Commit c1447efd authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'type-and-enum-value-relos' 

Andrii Nakryiko says:

====================
This patch set adds libbpf support for two new classes of CO-RE relocations:
type-based (TYPE_EXISTS/TYPE_SIZE/TYPE_ID_LOCAL/TYPE_ID_TARGET) and enum
value-vased (ENUMVAL_EXISTS/ENUMVAL_VALUE):
  - TYPE_EXISTS allows to detect presence in kernel BTF of a locally-recorded
    BTF type. Useful for feature detection (new functionality often comes with
    new internal kernel types), as well as handling type renames and bigger
    refactorings.
  - TYPE_SIZE allows to get the real size (in bytes) of a specified kernel
    type. Useful for dumping internal structure as-is through perfbuf or
    ringbuf.
  - TYPE_ID_LOCAL/TYPE_ID_TARGET allow to capture BTF type ID of a BTF type in
    program's BTF or kernel BTF, respectively. These could be used for
    high-performance and space-efficient generic data dumping/logging by
    relying on small and cheap BTF type ID as a data layout descriptor, for
    post-processing on user-space side.
  - ENUMVAL_EXISTS can be used for detecting the presence of enumerator value
    in kernel's enum type. Most direct application is to detect BPF helper
    support in kernel.
  - ENUMVAL_VALUE allows to relocate real integer value of kernel enumerator
    value, which is subject to change (e.g., always a potential issue for
    internal, non-UAPI, kernel enums).

I've indicated potential applications for these relocations, but relocations
themselves are generic and unassuming and are designed to work correctly even
in unintended applications. Furthermore, relocated values become constants,
known to the verifier and could and would be used for dead branch code
detection and elimination. This makes them ideal to do all sorts of feature
detection and guarding functionality that's not available on some older (but
still supported by BPF program) kernels, while having to compile and maintain
one unified source code.

Selftests are added for all the new features. Selftests utilizing new Clang
built-ins are designed such that they will compile with older Clangs and will
be skipped during test runs. So this shouldn't cause any build and test
failures on systems with slightly outdated Clang compiler.

LLVM patches adding these relocation in Clang:
  - __builtin_btf_type_id() ([0], [1], [2]);
  - __builtin_preserve_type_info(), __builtin_preserve_enum_value() ([3], [4]).

  [0] https://reviews.llvm.org/D74572
  [1] https://reviews.llvm.org/D74668
  [2] https://reviews.llvm.org/D85174
  [3] https://reviews.llvm.org/D83878
  [4] https://reviews.llvm.org/D83242



v2->v3:
  - fix feature detection for __builtin_btf_type_id() test (Yonghong);
  - fix extra empty lines at the end of files (Yonghong);

v1->v2:
  - selftests detect built-in support and are skipped if not found (Alexei).
====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents defcffeb 33574905

tools/lib/bpf/bpf_core_read.h

+79 −1
Original line number Diff line number Diff line
@@ -19,6 +19,24 @@ enum bpf_field_info_kind { 
	BPF_FIELD_RSHIFT_U64 = 5,

};



/* second argument to __builtin_btf_type_id() built-in */

enum bpf_type_id_kind {

	BPF_TYPE_ID_LOCAL = 0,		/* BTF type ID in local program */

	BPF_TYPE_ID_TARGET = 1,		/* BTF type ID in target kernel */

};



/* second argument to __builtin_preserve_type_info() built-in */

enum bpf_type_info_kind {

	BPF_TYPE_EXISTS = 0,		/* type existence in target kernel */

	BPF_TYPE_SIZE = 1,		/* type size in target kernel */

};



/* second argument to __builtin_preserve_enum_value() built-in */

enum bpf_enum_value_kind {

	BPF_ENUMVAL_EXISTS = 0,		/* enum value existence in kernel */

	BPF_ENUMVAL_VALUE = 1,		/* enum value value relocation */

};



#define __CORE_RELO(src, field, info)					      \

	__builtin_preserve_field_info((src)->field, BPF_FIELD_##info)
@@ -94,12 +112,72 @@ enum bpf_field_info_kind { 
	__builtin_preserve_field_info(field, BPF_FIELD_EXISTS)



/*

 * Convenience macro to get byte size of a field. Works for integers,

 * Convenience macro to get the byte size of a field. Works for integers,

 * struct/unions, pointers, arrays, and enums.

 */

#define bpf_core_field_size(field)					    \

	__builtin_preserve_field_info(field, BPF_FIELD_BYTE_SIZE)



/*

 * Convenience macro to get BTF type ID of a specified type, using a local BTF

 * information. Return 32-bit unsigned integer with type ID from program's own

 * BTF. Always succeeds.

 */

#define bpf_core_type_id_local(type)					    \

	__builtin_btf_type_id(*(typeof(type) *)0, BPF_TYPE_ID_LOCAL)



/*

 * Convenience macro to get BTF type ID of a target kernel's type that matches

 * specified local type.

 * Returns:

 *    - valid 32-bit unsigned type ID in kernel BTF;

 *    - 0, if no matching type was found in a target kernel BTF.

 */

#define bpf_core_type_id_kernel(type)					    \

	__builtin_btf_type_id(*(typeof(type) *)0, BPF_TYPE_ID_TARGET)



/*

 * Convenience macro to check that provided named type

 * (struct/union/enum/typedef) exists in a target kernel.

 * Returns:

 *    1, if such type is present in target kernel's BTF;

 *    0, if no matching type is found.

 */

#define bpf_core_type_exists(type)					    \

	__builtin_preserve_type_info(*(typeof(type) *)0, BPF_TYPE_EXISTS)



/*

 * Convenience macro to get the byte size of a provided named type

 * (struct/union/enum/typedef) in a target kernel.

 * Returns:

 *    >= 0 size (in bytes), if type is present in target kernel's BTF;

 *    0, if no matching type is found.

 */

#define bpf_core_type_size(type)					    \

	__builtin_preserve_type_info(*(typeof(type) *)0, BPF_TYPE_SIZE)



/*

 * Convenience macro to check that provided enumerator value is defined in

 * a target kernel.

 * Returns:

 *    1, if specified enum type and its enumerator value are present in target

 *    kernel's BTF;

 *    0, if no matching enum and/or enum value within that enum is found.

 */

#define bpf_core_enum_value_exists(enum_type, enum_value)		    \

	__builtin_preserve_enum_value(*(typeof(enum_type) *)enum_value, BPF_ENUMVAL_EXISTS)



/*

 * Convenience macro to get the integer value of an enumerator value in

 * a target kernel.

 * Returns:

 *    64-bit value, if specified enum type and its enumerator value are

 *    present in target kernel's BTF;

 *    0, if no matching enum and/or enum value within that enum is found.

 */

#define bpf_core_enum_value(enum_type, enum_value)			    \

	__builtin_preserve_enum_value(*(typeof(enum_type) *)enum_value, BPF_ENUMVAL_VALUE)



/*

 * bpf_core_read() abstracts away bpf_probe_read_kernel() call and captures

 * offset relocation for source address using __builtin_preserve_access_index()

tools/lib/bpf/libbpf.c

+348 −28

File changed.

Preview size limit exceeded, changes collapsed.

tools/lib/bpf/libbpf_internal.h

+6 −0
Original line number Diff line number Diff line
@@ -238,6 +238,12 @@ enum bpf_core_relo_kind { 
	BPF_FIELD_SIGNED = 3,		/* field signedness (0 - unsigned, 1 - signed) */

	BPF_FIELD_LSHIFT_U64 = 4,	/* bitfield-specific left bitshift */

	BPF_FIELD_RSHIFT_U64 = 5,	/* bitfield-specific right bitshift */

	BPF_TYPE_ID_LOCAL = 6,		/* type ID in local BPF object */

	BPF_TYPE_ID_TARGET = 7,		/* type ID in target kernel */

	BPF_TYPE_EXISTS = 8,		/* type existence in target kernel */

	BPF_TYPE_SIZE = 9,		/* type size in bytes */

	BPF_ENUMVAL_EXISTS = 10,	/* enum value existence in target kernel */

	BPF_ENUMVAL_VALUE = 11,		/* enum value integer value */

};



/* The minimum bpf_core_relo checked by the loader

tools/testing/selftests/bpf/prog_tests/core_reloc.c

+323 −26

File changed.

Preview size limit exceeded, changes collapsed.

tools/testing/selftests/bpf/progs/btf__core_reloc_enumval.c

0 → 100644
+3 −0
Original line number Diff line number Diff line 
#include "core_reloc_types.h"



void f(struct core_reloc_enumval x) {}

CRA Git | Maintained and supported by SUSTech CRA and CCSE