Commit 7d3c1077 authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'BPF static linker: support externs' 

Andrii Nakryiko says:

====================

Add BPF static linker support for extern resolution of global variables,
functions, and BTF-defined maps.

This patch set consists of 4 parts:
  - few patches are extending bpftool to simplify working with BTF dump;
  - libbpf object loading logic is extended to support __hidden functions and
    overriden (unused) __weak functions; also BTF-defined map parsing logic is
    refactored to be re-used by linker;
  - the crux of the patch set is BPF static linker logic extension to perform
    extern resolution for three categories: global variables, BPF
    sub-programs, BTF-defined maps;
  - a set of selftests that validate that all the combinations of
    extern/weak/__hidden are working as expected.

See respective patches for more details.

One aspect hasn't been addressed yet and is going to be resolved in the next
patch set, but is worth mentioning. With BPF static linking of multiple .o
files, dealing with static everything becomes more problematic for BPF
skeleton and in general for any by name look up APIs. This is due to static
entities are allowed to have non-unique name. Historically this was never
a problem due to BPF programs were always confined to a single C file. That
changes now and needs to be addressed. The thinking so far is for BPF static
linker to prepend filename to each static variable and static map (which is
currently not supported by libbpf, btw), so that they can be unambiguously
resolved by (mostly) unique name. Mostly, because even filenames can be
duplicated, but that should be rare and easy to address by wiser choice of
filenames by users. Fortunately, static BPF subprograms don't suffer from this
issues, as they are not independent entities and are neither exposed in BPF
skeleton, nor is lookup-able by any of libbpf APIs (and there is little reason
to do that anyways).

This and few other things will be the topic of the next set of patches.

Some tests rely on Clang fix ([0]), so need latest Clang built from main.

  [0] https://reviews.llvm.org/D100362



v2->v3:
  - allow only STV_DEFAULT and STV_HIDDEN ELF symbol visibility (Yonghong);
  - update selftests' README for required Clang 13 fix dependency (Alexei);
  - comments, typos, slight code changes (Yonghong, Alexei);

v1->v2:
  - make map externs support full attribute list, adjust linked_maps selftest
    to demonstrate that typedef works now (though no shared header file was
    added to simplicity sake) (Alexei);
  - remove commented out parts from selftests and fix few minor code style
    issues;
  - special __weak map definition semantics not yet implemented and will be
    addressed in a follow up.
====================

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

tools/bpf/bpftool/btf.c

+21 −9
Original line number Diff line number Diff line
@@ -71,7 +71,9 @@ static const char *btf_var_linkage_str(__u32 linkage) 
	case BTF_VAR_STATIC:

		return "static";

	case BTF_VAR_GLOBAL_ALLOCATED:

		return "global-alloc";

		return "global";

	case BTF_VAR_GLOBAL_EXTERN:

		return "extern";

	default:

		return "(unknown)";

	}
@@ -98,26 +100,28 @@ static const char *btf_str(const struct btf *btf, __u32 off) 
	return btf__name_by_offset(btf, off) ? : "(invalid)";

}



static int btf_kind_safe(int kind)

{

	return kind <= BTF_KIND_MAX ? kind : BTF_KIND_UNKN;

}



static int dump_btf_type(const struct btf *btf, __u32 id,

			 const struct btf_type *t)

{

	json_writer_t *w = json_wtr;

	int kind, safe_kind;



	kind = BTF_INFO_KIND(t->info);

	safe_kind = kind <= BTF_KIND_MAX ? kind : BTF_KIND_UNKN;

	int kind = btf_kind(t);



	if (json_output) {

		jsonw_start_object(w);

		jsonw_uint_field(w, "id", id);

		jsonw_string_field(w, "kind", btf_kind_str[safe_kind]);

		jsonw_string_field(w, "kind", btf_kind_str[btf_kind_safe(kind)]);

		jsonw_string_field(w, "name", btf_str(btf, t->name_off));

	} else {

		printf("[%u] %s '%s'", id, btf_kind_str[safe_kind],

		printf("[%u] %s '%s'", id, btf_kind_str[btf_kind_safe(kind)],

		       btf_str(btf, t->name_off));

	}



	switch (BTF_INFO_KIND(t->info)) {

	switch (kind) {

	case BTF_KIND_INT: {

		__u32 v = *(__u32 *)(t + 1);

		const char *enc;
@@ -301,6 +305,7 @@ static int dump_btf_type(const struct btf *btf, __u32 id, 
	}

	case BTF_KIND_DATASEC: {

		const struct btf_var_secinfo *v = (const void *)(t + 1);

		const struct btf_type *vt;

		__u16 vlen = BTF_INFO_VLEN(t->info);

		int i;
@@ -322,6 +327,13 @@ static int dump_btf_type(const struct btf *btf, __u32 id, 
			} else {

				printf("\n\ttype_id=%u offset=%u size=%u",

				       v->type, v->offset, v->size);



				if (v->type <= btf__get_nr_types(btf)) {

					vt = btf__type_by_id(btf, v->type);

					printf(" (%s '%s')",

					       btf_kind_str[btf_kind_safe(btf_kind(vt))],

					       btf_str(btf, vt->name_off));

				}

			}

		}

		if (json_output)

tools/lib/bpf/bpf_helpers.h

+17 −2
Original line number Diff line number Diff line
@@ -25,9 +25,16 @@ 
/*

 * Helper macro to place programs, maps, license in

 * different sections in elf_bpf file. Section names

 * are interpreted by elf_bpf loader

 * are interpreted by libbpf depending on the context (BPF programs, BPF maps,

 * extern variables, etc).

 * To allow use of SEC() with externs (e.g., for extern .maps declarations),

 * make sure __attribute__((unused)) doesn't trigger compilation warning.

 */

#define SEC(NAME) __attribute__((section(NAME), used))

#define SEC(name) \

	_Pragma("GCC diagnostic push")					    \

	_Pragma("GCC diagnostic ignored \"-Wignored-attributes\"")	    \

	__attribute__((section(name), used))				    \

	_Pragma("GCC diagnostic pop")					    \



/* Avoid 'linux/stddef.h' definition of '__always_inline'. */

#undef __always_inline
@@ -40,6 +47,14 @@ 
#define __weak __attribute__((weak))

#endif



/*

 * Use __hidden attribute to mark a non-static BPF subprogram effectively

 * static for BPF verifier's verification algorithm purposes, allowing more

 * extensive and permissive BPF verification process, taking into account

 * subprogram's caller context.

 */

#define __hidden __attribute__((visibility("hidden")))



/* When utilizing vmlinux.h with BPF CO-RE, user BPF programs can't include

 * any system-level headers (such as stddef.h, linux/version.h, etc), and

 * commonly-used macros like NULL and KERNEL_VERSION aren't available through

tools/lib/bpf/btf.c

+0 −5
Original line number Diff line number Diff line
@@ -1605,11 +1605,6 @@ static void *btf_add_type_mem(struct btf *btf, size_t add_sz) 
			      btf->hdr->type_len, UINT_MAX, add_sz);

}



static __u32 btf_type_info(int kind, int vlen, int kflag)

{

	return (kflag << 31) | (kind << 24) | vlen;

}



static void btf_type_inc_vlen(struct btf_type *t)

{

	t->info = btf_type_info(btf_kind(t), btf_vlen(t) + 1, btf_kflag(t));

tools/lib/bpf/libbpf.c

+215 −158

File changed.

Preview size limit exceeded, changes collapsed.

tools/lib/bpf/libbpf_internal.h

+45 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
#pragma GCC poison reallocarray



#include "libbpf.h"

#include "btf.h"



#ifndef EM_BPF

#define EM_BPF 247
@@ -131,6 +132,50 @@ struct btf; 
struct btf_type;



struct btf_type *btf_type_by_id(struct btf *btf, __u32 type_id);

const char *btf_kind_str(const struct btf_type *t);

const struct btf_type *skip_mods_and_typedefs(const struct btf *btf, __u32 id, __u32 *res_id);



static inline enum btf_func_linkage btf_func_linkage(const struct btf_type *t)

{

	return (enum btf_func_linkage)(int)btf_vlen(t);

}



static inline __u32 btf_type_info(int kind, int vlen, int kflag)

{

	return (kflag << 31) | (kind << 24) | vlen;

}



enum map_def_parts {

	MAP_DEF_MAP_TYPE	= 0x001,

	MAP_DEF_KEY_TYPE	= 0x002,

	MAP_DEF_KEY_SIZE	= 0x004,

	MAP_DEF_VALUE_TYPE	= 0x008,

	MAP_DEF_VALUE_SIZE	= 0x010,

	MAP_DEF_MAX_ENTRIES	= 0x020,

	MAP_DEF_MAP_FLAGS	= 0x040,

	MAP_DEF_NUMA_NODE	= 0x080,

	MAP_DEF_PINNING		= 0x100,

	MAP_DEF_INNER_MAP	= 0x200,



	MAP_DEF_ALL		= 0x3ff, /* combination of all above */

};



struct btf_map_def {

	enum map_def_parts parts;

	__u32 map_type;

	__u32 key_type_id;

	__u32 key_size;

	__u32 value_type_id;

	__u32 value_size;

	__u32 max_entries;

	__u32 map_flags;

	__u32 numa_node;

	__u32 pinning;

};



int parse_btf_map_def(const char *map_name, struct btf *btf,

		      const struct btf_type *def_t, bool strict,

		      struct btf_map_def *map_def, struct btf_map_def *inner_def);



void *libbpf_add_mem(void **data, size_t *cap_cnt, size_t elem_sz,

		     size_t cur_cnt, size_t max_cnt, size_t add_cnt);