On Thu, Feb 14, 2019 at 6:01 AM Arnaldo Carvalho de Melo
<arnaldo.melo@xxxxxxxxx> wrote:
>
> Em Thu, Feb 14, 2019 at 10:20:29AM -0300, Arnaldo Carvalho de Melo escreveu:
> > Em Thu, Feb 14, 2019 at 10:11:56AM -0300, Arnaldo Carvalho de Melo escreveu:
> > > Em Thu, Feb 14, 2019 at 09:47:57AM -0300, Arnaldo Carvalho de Melo escreveu:
> > > > Em Wed, Feb 13, 2019 at 09:43:43PM -0800, Andrii Nakryiko escreveu:
> > > > > happy with it. So consider this email a solicitation for naming
> > > > > suggestion. Keep in mind, that all the pahole's functions of the form
> > > > > btf__xxx will be renamed as well for consistency. If you like
> > > > > btf_info, let me know as well, I'll just stick with it.
> > >
> > > > Can you try thinking if splitting this further into 'struct btf_loader',
> > > > 'struct btf_encoder' that would live in the pahole sources and that
> > > > refer to a 'struct btf' that lives in libbpf (or in libbtf, at some
> > > > point) is a move that eases your current needs?
I think pahole would be simpler by using struct btf for btf_loader and
separate struct btf_enc (or whatever name we come up with) to encode
BTF during DWARF->BTF conversion. See below about mutable vs immutable
BTF representations. For immutable parts libbpf's struct btf should be
enough, though pahole is dealing also with endianness issues, so we'll
need to resolve that somehow.
> > >
> > > So, the btf__new() in tools/lib/bpf/btf.c is basically a variant of
> > > btf__new() in the pahole sources, probably we should go ahead and make
> > > pahole use that btf__new() and do changes in tools/lib/bpf/btf.c to
> > > allow for it to access internal state that it needs to do its job?
> >
> > No, we can't, because tools/lib/btf/btf.c btf__new() is centered on
> > getting some BTF buffer no matter where it comes from and passing it to
> > the kernel.
Yes, libbpf's struct btf is immutable read-only view of .BTF section
that can come from either file or kernel. When I'll be adding BTF
writing (encoding) API, it probably will be done using something
similar to pahole's struct btf, that supports dynamic growth of types
and strings sections. Then, once application is done constructing BTF,
that modifyable struct can be "sealed" into read-only struct btf.
Whichever way we'll go about that, there should be minimal changes to
pahole to be able to reuse that functionality.
> >
> > So probably we should backtrack to my previous suggestion of having
> > pahole use 'struct btf_loader', or even more explicitely, 'struct
> > btf_elf' to make extra clear that this has nothing to do with the
> > kernel, its purely about loading/encoding the BTF info from/to a ELF
> > file.
>
> So, I have this in my private branch, please see if this helps get
> things moving forward:
Yes, this is exactly what I needed, thanks for doing this massive
renaming! See just one nit below about probably unintentional file
name change.
>
>
> commit 0233cc17568866f741af05ce2c8f4c2b1a4dc606
> Author: Arnaldo Carvalho de Melo <acme@xxxxxxxxxx>
> Date: Thu Feb 14 10:47:32 2019 -0300
>
> btf: Rename 'struct btf' to 'struct btf_elf'
>
> So that we don't clash with libbpf's 'struct btf', in time more internal
> state now in 'struct btf_elf' will refer to the equivalent internal
> state in libbpf's 'struct btf', as they have lots in common.
>
> Cc: Alexei Starovoitov <ast@xxxxxx>
> Cc: Martin Lau <kafai@xxxxxx>
> Cc: Yonghong Song <yhs@xxxxxx>
> To: Andrii Nakryiko <andrii.nakryiko@xxxxxxxxx>
> Signed-off-by: Arnaldo Carvalho de Melo <acme@xxxxxxxxxx>
>
> diff --git a/btf_encoder.c b/btf_encoder.c
> index 362c9ca39166..5ba8875107f2 100644
> --- a/btf_encoder.c
> +++ b/btf_encoder.c
> @@ -33,8 +33,7 @@ static int tag__check_id_drift(const struct tag *tag,
> return 0;
> }
>
> -static int32_t structure_type__encode(struct btf *btf, struct tag *tag,
> - uint32_t type_id_off)
> +static int32_t structure_type__encode(struct btf_elf *btfe, struct tag *tag, uint32_t type_id_off)
> {
> struct type *type = tag__type(tag);
> struct class_member *pos;
> @@ -63,9 +62,7 @@ static int32_t structure_type__encode(struct btf *btf, struct tag *tag,
> }
> }
>
> - type_id = btf__add_struct(btf, kind, type->namespace.name,
> - kind_flag,
> - type->size, type->nr_members);
> + type_id = btf_elf__add_struct(btfe, kind, type->namespace.name, kind_flag, type->size, type->nr_members);
> if (type_id < 0)
> return type_id;
>
> @@ -86,7 +83,7 @@ static int32_t structure_type__encode(struct btf *btf, struct tag *tag,
> * which corresponds to bits 2-3 from big endian
> * perspective.
> */
> - if (btf->is_big_endian || !pos->bitfield_size)
> + if (btfe->is_big_endian || !pos->bitfield_size)
> bit_offset = pos->bit_offset;
> else
> bit_offset = pos->byte_offset * 8 +
> @@ -94,10 +91,7 @@ static int32_t structure_type__encode(struct btf *btf, struct tag *tag,
> pos->bitfield_offset -
> pos->bitfield_size;
>
> - if (btf__add_member(btf, pos->name,
> - type_id_off + pos->tag.type,
> - kind_flag, pos->bitfield_size,
> - bit_offset))
> + if (btf_elf__add_member(btfe, pos->name, type_id_off + pos->tag.type, kind_flag, pos->bitfield_size, bit_offset))
> return -1;
> }
>
> @@ -116,7 +110,7 @@ static uint32_t array_type__nelems(struct tag *tag)
> return nelem;
> }
>
> -static int32_t enumeration_type__encode(struct btf *btf, struct tag *tag)
> +static int32_t enumeration_type__encode(struct btf_elf *btfe, struct tag *tag)
> {
> struct type *etype = tag__type(tag);
> struct enumerator *pos;
> @@ -128,22 +122,21 @@ static int32_t enumeration_type__encode(struct btf *btf, struct tag *tag)
>
> bt.bit_size = etype->size;
> bt.is_signed = true;
> - return btf__add_base_type(btf, &bt);
> + return btf_elf__add_base_type(btfe, &bt);
> }
>
> - type_id = btf__add_enum(btf, etype->namespace.name,
> - etype->size, etype->nr_members);
> + type_id = btf_elf__add_enum(btfe, etype->namespace.name, etype->size, etype->nr_members);
> if (type_id < 0)
> return type_id;
>
> type__for_each_enumerator(etype, pos)
> - if (btf__add_enum_val(btf, pos->name, pos->value))
> + if (btf_elf__add_enum_val(btfe, pos->name, pos->value))
> return -1;
>
> return type_id;
> }
>
> -static int tag__encode_btf(struct tag *tag, uint32_t core_id, struct btf *btf,
> +static int tag__encode_btf(struct tag *tag, uint32_t core_id, struct btf_elf *btfe,
> uint32_t array_index_id, uint32_t type_id_off)
> {
> /* single out type 0 as it represents special type "void" */
> @@ -151,37 +144,31 @@ static int tag__encode_btf(struct tag *tag, uint32_t core_id, struct btf *btf,
>
> switch (tag->tag) {
> case DW_TAG_base_type:
> - return btf__add_base_type(btf, tag__base_type(tag));
> + return btf_elf__add_base_type(btfe, tag__base_type(tag));
> case DW_TAG_const_type:
> - return btf__add_ref_type(btf, BTF_KIND_CONST, ref_type_id, 0, false);
> + return btf_elf__add_ref_type(btfe, BTF_KIND_CONST, ref_type_id, 0, false);
> case DW_TAG_pointer_type:
> - return btf__add_ref_type(btf, BTF_KIND_PTR, ref_type_id, 0, false);
> + return btf_elf__add_ref_type(btfe, BTF_KIND_PTR, ref_type_id, 0, false);
> case DW_TAG_restrict_type:
> - return btf__add_ref_type(btf, BTF_KIND_RESTRICT, ref_type_id, 0, false);
> + return btf_elf__add_ref_type(btfe, BTF_KIND_RESTRICT, ref_type_id, 0, false);
> case DW_TAG_volatile_type:
> - return btf__add_ref_type(btf, BTF_KIND_VOLATILE, ref_type_id, 0, false);
> + return btf_elf__add_ref_type(btfe, BTF_KIND_VOLATILE, ref_type_id, 0, false);
> case DW_TAG_typedef:
> - return btf__add_ref_type(btf, BTF_KIND_TYPEDEF, ref_type_id,
> - tag__namespace(tag)->name, false);
> + return btf_elf__add_ref_type(btfe, BTF_KIND_TYPEDEF, ref_type_id, tag__namespace(tag)->name, false);
> case DW_TAG_structure_type:
> case DW_TAG_union_type:
> case DW_TAG_class_type:
> if (tag__type(tag)->declaration)
> - return btf__add_ref_type(btf, BTF_KIND_FWD, 0,
> - tag__namespace(tag)->name,
> - tag->tag == DW_TAG_union_type);
> + return btf_elf__add_ref_type(btfe, BTF_KIND_FWD, 0, tag__namespace(tag)->name, tag->tag == DW_TAG_union_type);
> else
> - return structure_type__encode(btf, tag, type_id_off);
> + return structure_type__encode(btfe, tag, type_id_off);
> case DW_TAG_array_type:
> - return btf__add_array(btf, ref_type_id, array_index_id,
> - /*TODO: Encode one dimension
> - * at a time.
> - */
> - array_type__nelems(tag));
> + /* TODO: Encode one dimension at a time. */
> + return btf_elf__add_array(btfe, ref_type_id, array_index_id, array_type__nelems(tag));
> case DW_TAG_enumeration_type:
> - return enumeration_type__encode(btf, tag);
> + return enumeration_type__encode(btfe, tag);
> case DW_TAG_subroutine_type:
> - return btf__add_func_proto(btf, tag__ftype(tag), type_id_off);
> + return btf_elf__add_func_proto(btfe, tag__ftype(tag), type_id_off);
> default:
> fprintf(stderr, "Unsupported DW_TAG_%s(0x%x)\n",
> dwarf_tag_name(tag->tag), tag->tag);
> @@ -195,16 +182,16 @@ static int tag__encode_btf(struct tag *tag, uint32_t core_id, struct btf *btf,
> */
> extern struct strings *strings;
>
> -static struct btf *btf;
> +static struct btf_elf *btfe;
> static uint32_t array_index_id;
>
> int btf_encoder__encode()
> {
> int err;
>
> - err = btf__encode(btf, 0);
> - btf__free(btf);
> - btf = NULL;
> + err = btf_elf__encode(btfe, 0);
> + btf_elf__free(btfe);
> + btfe = NULL;
>
> return err;
> }
> @@ -217,7 +204,7 @@ int cu__encode_btf(struct cu *cu, int verbose)
> struct tag *pos;
> int err = 0;
>
> - if (btf && strcmp(btf->filename, cu->filename)) {
> + if (btfe && strcmp(btfe->filename, cu->filename)) {
> err = btf_encoder__encode();
> if (err)
> goto out;
> @@ -227,11 +214,11 @@ int cu__encode_btf(struct cu *cu, int verbose)
> printf("\n");
> }
>
> - if (!btf) {
> - btf = btf__new(cu->filename, cu->elf);
> - if (!btf)
> + if (!btfe) {
> + btfe = btf_elf__new(cu->filename, cu->elf);
> + if (!btfe)
> return -1;
> - btf__set_strings(btf, &strings->gb);
> + btf_elf__set_strings(btfe, &strings->gb);
>
> /* cu__find_base_type_by_name() takes "uint16_t *id" */
> uint16_t id;
> @@ -242,16 +229,14 @@ int cu__encode_btf(struct cu *cu, int verbose)
> array_index_id = id;
>
> if (verbose)
> - printf("File %s:\n", btf->filename);
> + printf("File %s:\n", btfe->filename);
> }
>
> - btf_verbose = verbose;
> - type_id_off = btf->type_index;
> + btf_elf__verbose = verbose;
> + type_id_off = btfe->type_index;
>
> cu__for_each_type(cu, core_id, pos) {
> - int32_t btf_type_id = tag__encode_btf(pos, core_id, btf,
> - array_index_id,
> - type_id_off);
> + int32_t btf_type_id = tag__encode_btf(pos, core_id, btfe, array_index_id, type_id_off);
>
> if (btf_type_id < 0 ||
> tag__check_id_drift(pos, core_id, btf_type_id, type_id_off)) {
> @@ -265,11 +250,11 @@ int cu__encode_btf(struct cu *cu, int verbose)
>
> bt.name = 0;
> bt.bit_size = 32;
> - btf__add_base_type(btf, &bt);
> + btf_elf__add_base_type(btfe, &bt);
> }
>
> out:
> if (err)
> - btf__free(btf);
> + btf_elf__free(btfe);
> return err;
> }
> diff --git a/btf_loader.c b/btf_loader.c
> index 8583cc8a7406..390f107595c2 100644
> --- a/btf_loader.c
> +++ b/btf_loader.c
> @@ -45,8 +45,8 @@ static void *tag__alloc(const size_t size)
> return tag;
> }
>
> -static int btf__load_ftype(struct btf *btf, struct ftype *proto, uint16_t tag,
> - uint32_t type, uint16_t vlen, struct btf_param *args, long id)
> +static int btf_elf__load_ftype(struct btf_elf *btfe, struct ftype *proto, uint16_t tag,
> + uint32_t type, uint16_t vlen, struct btf_param *args, long id)
> {
> int i;
>
> @@ -56,8 +56,8 @@ static int btf__load_ftype(struct btf *btf, struct ftype *proto, uint16_t tag,
>
> for (i = 0; i < vlen; ++i) {
> struct btf_param param = {
> - .name_off = btf__get32(btf, &args[i].name_off),
> - .type = btf__get32(btf, &args[i].type),
> + .name_off = btf_elf__get32(btfe, &args[i].name_off),
> + .type = btf_elf__get32(btfe, &args[i].type),
> };
>
> if (param.type == 0)
> @@ -75,11 +75,11 @@ static int btf__load_ftype(struct btf *btf, struct ftype *proto, uint16_t tag,
> }
>
> vlen *= sizeof(*args);
> - cu__add_tag(btf->priv, &proto->tag, &id);
> + cu__add_tag(btfe->priv, &proto->tag, &id);
>
> return vlen;
> out_free_parameters:
> - ftype__delete(proto, btf->priv);
> + ftype__delete(proto, btfe->priv);
> return -ENOMEM;
> }
>
> @@ -133,24 +133,24 @@ static struct class *class__new(strings_t name, size_t size)
> return class;
> }
>
> -static int create_new_base_type(struct btf *btf, void *ptr, struct btf_type *tp, long id)
> +static int create_new_base_type(struct btf_elf *btfe, void *ptr, struct btf_type *tp, long id)
> {
> uint32_t *enc = ptr;
> - uint32_t eval = btf__get32(btf, enc);
> + uint32_t eval = btf_elf__get32(btfe, enc);
> uint32_t attrs = BTF_INT_ENCODING(eval);
> - strings_t name = btf__get32(btf, &tp->name_off);
> + strings_t name = btf_elf__get32(btfe, &tp->name_off);
> struct base_type *base = base_type__new(name, attrs, 0,
> BTF_INT_BITS(eval));
> if (base == NULL)
> return -ENOMEM;
>
> base->tag.tag = DW_TAG_base_type;
> - cu__add_tag(btf->priv, &base->tag, &id);
> + cu__add_tag(btfe->priv, &base->tag, &id);
>
> return sizeof(*enc);
> }
>
> -static int create_new_array(struct btf *btf, void *ptr, long id)
> +static int create_new_array(struct btf_elf *btfe, void *ptr, long id)
> {
> struct btf_array *ap = ptr;
> struct array_type *array = tag__alloc(sizeof(*array));
> @@ -168,16 +168,16 @@ static int create_new_array(struct btf *btf, void *ptr, long id)
> return -ENOMEM;
> }
>
> - array->nr_entries[0] = btf__get32(btf, &ap->nelems);
> + array->nr_entries[0] = btf_elf__get32(btfe, &ap->nelems);
> array->tag.tag = DW_TAG_array_type;
> - array->tag.type = btf__get32(btf, &ap->type);
> + array->tag.type = btf_elf__get32(btfe, &ap->type);
>
> - cu__add_tag(btf->priv, &array->tag, &id);
> + cu__add_tag(btfe->priv, &array->tag, &id);
>
> return sizeof(*ap);
> }
>
> -static int create_members(struct btf *btf, void *ptr, int vlen, struct type *class,
> +static int create_members(struct btf_elf *btfe, void *ptr, int vlen, struct type *class,
> bool kflag)
> {
> struct btf_member *mp = ptr;
> @@ -191,9 +191,9 @@ static int create_members(struct btf *btf, void *ptr, int vlen, struct type *cla
> return -ENOMEM;
>
> member->tag.tag = DW_TAG_member;
> - member->tag.type = btf__get32(btf, &mp[i].type);
> - member->name = btf__get32(btf, &mp[i].name_off);
> - offset = btf__get32(btf, &mp[i].offset);
> + member->tag.type = btf_elf__get32(btfe, &mp[i].type);
> + member->name = btf_elf__get32(btfe, &mp[i].name_off);
> + offset = btf_elf__get32(btfe, &mp[i].offset);
> if (kflag) {
> member->bit_offset = BTF_MEMBER_BIT_OFFSET(offset);
> member->bitfield_size = BTF_MEMBER_BITFIELD_SIZE(offset);
> @@ -209,42 +209,42 @@ static int create_members(struct btf *btf, void *ptr, int vlen, struct type *cla
> return sizeof(*mp);
> }
>
> -static int create_new_class(struct btf *btf, void *ptr, int vlen,
> +static int create_new_class(struct btf_elf *btfe, void *ptr, int vlen,
> struct btf_type *tp, uint64_t size, long id,
> bool kflag)
> {
> - strings_t name = btf__get32(btf, &tp->name_off);
> + strings_t name = btf_elf__get32(btfe, &tp->name_off);
> struct class *class = class__new(name, size);
> - int member_size = create_members(btf, ptr, vlen, &class->type, kflag);
> + int member_size = create_members(btfe, ptr, vlen, &class->type, kflag);
>
> if (member_size < 0)
> goto out_free;
>
> - cu__add_tag(btf->priv, &class->type.namespace.tag, &id);
> + cu__add_tag(btfe->priv, &class->type.namespace.tag, &id);
>
> return (vlen * member_size);
> out_free:
> - class__delete(class, btf->priv);
> + class__delete(class, btfe->priv);
> return -ENOMEM;
> }
>
> -static int create_new_union(struct btf *btf, void *ptr,
> +static int create_new_union(struct btf_elf *btfe, void *ptr,
> int vlen, struct btf_type *tp,
> uint64_t size, long id,
> bool kflag)
> {
> - strings_t name = btf__get32(btf, &tp->name_off);
> + strings_t name = btf_elf__get32(btfe, &tp->name_off);
> struct type *un = type__new(DW_TAG_union_type, name, size);
> - int member_size = create_members(btf, ptr, vlen, un, kflag);
> + int member_size = create_members(btfe, ptr, vlen, un, kflag);
>
> if (member_size < 0)
> goto out_free;
>
> - cu__add_tag(btf->priv, &un->namespace.tag, &id);
> + cu__add_tag(btfe->priv, &un->namespace.tag, &id);
>
> return (vlen * member_size);
> out_free:
> - type__delete(un, btf->priv);
> + type__delete(un, btfe->priv);
> return -ENOMEM;
> }
>
> @@ -261,22 +261,22 @@ static struct enumerator *enumerator__new(strings_t name, uint32_t value)
> return en;
> }
>
> -static int create_new_enumeration(struct btf *btf, void *ptr,
> +static int create_new_enumeration(struct btf_elf *btfe, void *ptr,
> int vlen, struct btf_type *tp,
> uint16_t size, long id)
> {
> struct btf_enum *ep = ptr;
> uint16_t i;
> struct type *enumeration = type__new(DW_TAG_enumeration_type,
> - btf__get32(btf, &tp->name_off),
> + btf_elf__get32(btfe, &tp->name_off),
> size ? size * 8 : (sizeof(int) * 8));
>
> if (enumeration == NULL)
> return -ENOMEM;
>
> for (i = 0; i < vlen; i++) {
> - strings_t name = btf__get32(btf, &ep[i].name_off);
> - uint32_t value = btf__get32(btf, &ep[i].val);
> + strings_t name = btf_elf__get32(btfe, &ep[i].name_off);
> + uint32_t value = btf_elf__get32(btfe, &ep[i].val);
> struct enumerator *enumerator = enumerator__new(name, value);
>
> if (enumerator == NULL)
> @@ -285,61 +285,60 @@ static int create_new_enumeration(struct btf *btf, void *ptr,
> enumeration__add(enumeration, enumerator);
> }
>
> - cu__add_tag(btf->priv, &enumeration->namespace.tag, &id);
> + cu__add_tag(btfe->priv, &enumeration->namespace.tag, &id);
>
> return (vlen * sizeof(*ep));
> out_free:
> - enumeration__delete(enumeration, btf->priv);
> + enumeration__delete(enumeration, btfe->priv);
> return -ENOMEM;
> }
>
> -static int create_new_subroutine_type(struct btf *btf, void *ptr,
> +static int create_new_subroutine_type(struct btf_elf *btfe, void *ptr,
> int vlen, struct btf_type *tp,
> long id)
> {
> struct btf_param *args = ptr;
> - unsigned int type = btf__get32(btf, &tp->type);
> + unsigned int type = btf_elf__get32(btfe, &tp->type);
> struct ftype *proto = tag__alloc(sizeof(*proto));
>
> if (proto == NULL)
> return -ENOMEM;
>
> - vlen = btf__load_ftype(btf, proto, DW_TAG_subroutine_type,
> - type, vlen, args, id);
> + vlen = btf_elf__load_ftype(btfe, proto, DW_TAG_subroutine_type, type, vlen, args, id);
> return vlen < 0 ? -ENOMEM : vlen;
> }
>
> -static int create_new_forward_decl(struct btf *btf, struct btf_type *tp,
> +static int create_new_forward_decl(struct btf_elf *btfe, struct btf_type *tp,
> uint64_t size, long id)
> {
> - strings_t name = btf__get32(btf, &tp->name_off);
> + strings_t name = btf_elf__get32(btfe, &tp->name_off);
> struct class *fwd = class__new(name, size);
>
> if (fwd == NULL)
> return -ENOMEM;
> fwd->type.declaration = 1;
> - cu__add_tag(btf->priv, &fwd->type.namespace.tag, &id);
> + cu__add_tag(btfe->priv, &fwd->type.namespace.tag, &id);
> return 0;
> }
>
> -static int create_new_typedef(struct btf *btf, struct btf_type *tp, uint64_t size, long id)
> +static int create_new_typedef(struct btf_elf *btfe, struct btf_type *tp, uint64_t size, long id)
> {
> - strings_t name = btf__get32(btf, &tp->name_off);
> - unsigned int type_id = btf__get32(btf, &tp->type);
> + strings_t name = btf_elf__get32(btfe, &tp->name_off);
> + unsigned int type_id = btf_elf__get32(btfe, &tp->type);
> struct type *type = type__new(DW_TAG_typedef, name, size);
>
> if (type == NULL)
> return -ENOMEM;
>
> type->namespace.tag.type = type_id;
> - cu__add_tag(btf->priv, &type->namespace.tag, &id);
> + cu__add_tag(btfe->priv, &type->namespace.tag, &id);
>
> return 0;
> }
>
> -static int create_new_tag(struct btf *btf, int type, struct btf_type *tp, long id)
> +static int create_new_tag(struct btf_elf *btfe, int type, struct btf_type *tp, long id)
> {
> - unsigned int type_id = btf__get32(btf, &tp->type);
> + unsigned int type_id = btf_elf__get32(btfe, &tp->type);
> struct tag *tag = zalloc(sizeof(*tag));
>
> if (tag == NULL)
> @@ -356,70 +355,70 @@ static int create_new_tag(struct btf *btf, int type, struct btf_type *tp, long i
> }
>
> tag->type = type_id;
> - cu__add_tag(btf->priv, tag, &id);
> + cu__add_tag(btfe->priv, tag, &id);
>
> return 0;
> }
>
> -void *btf__get_buffer(struct btf *btf)
> +void *btf_elf__get_buffer(struct btf_elf *btfe)
> {
> - return btf->data;
> + return btfe->data;
> }
>
> -size_t btf__get_size(struct btf *btf)
> +size_t btf_elf__get_size(struct btf_elf *btfe)
> {
> - return btf->size;
> + return btfe->size;
> }
>
> -static int btf__load_types(struct btf *btf)
> +static int btf_elf__load_types(struct btf_elf *btfe)
> {
> - void *btf_buffer = btf__get_buffer(btf);
> + void *btf_buffer = btf_elf__get_buffer(btfe);
> struct btf_header *hp = btf_buffer;
> void *btf_contents = btf_buffer + sizeof(*hp),
> - *type_section = (btf_contents + btf__get32(btf, &hp->type_off)),
> - *strings_section = (btf_contents + btf__get32(btf, &hp->str_off));
> + *type_section = (btf_contents + btf_elf__get32(btfe, &hp->type_off)),
> + *strings_section = (btf_contents + btf_elf__get32(btfe, &hp->str_off));
> struct btf_type *type_ptr = type_section,
> *end = strings_section;
> unsigned int type_index = 0x0001;
>
> while (type_ptr < end) {
> - uint32_t val = btf__get32(btf, &type_ptr->info);
> + uint32_t val = btf_elf__get32(btfe, &type_ptr->info);
> uint32_t type = BTF_INFO_KIND(val);
> int vlen = BTF_INFO_VLEN(val);
> void *ptr = type_ptr;
> - uint32_t size = btf__get32(btf, &type_ptr->size);
> + uint32_t size = btf_elf__get32(btfe, &type_ptr->size);
> bool kflag = BTF_INFO_KFLAG(val);
>
> ptr += sizeof(struct btf_type);
>
> if (type == BTF_KIND_INT) {
> - vlen = create_new_base_type(btf, ptr, type_ptr, type_index);
> + vlen = create_new_base_type(btfe, ptr, type_ptr, type_index);
> } else if (type == BTF_KIND_ARRAY) {
> - vlen = create_new_array(btf, ptr, type_index);
> + vlen = create_new_array(btfe, ptr, type_index);
> } else if (type == BTF_KIND_STRUCT) {
> - vlen = create_new_class(btf, ptr, vlen, type_ptr, size, type_index, kflag);
> + vlen = create_new_class(btfe, ptr, vlen, type_ptr, size, type_index, kflag);
> } else if (type == BTF_KIND_UNION) {
> - vlen = create_new_union(btf, ptr, vlen, type_ptr, size, type_index, kflag);
> + vlen = create_new_union(btfe, ptr, vlen, type_ptr, size, type_index, kflag);
> } else if (type == BTF_KIND_ENUM) {
> - vlen = create_new_enumeration(btf, ptr, vlen, type_ptr, size, type_index);
> + vlen = create_new_enumeration(btfe, ptr, vlen, type_ptr, size, type_index);
> } else if (type == BTF_KIND_FWD) {
> - vlen = create_new_forward_decl(btf, type_ptr, size, type_index);
> + vlen = create_new_forward_decl(btfe, type_ptr, size, type_index);
> } else if (type == BTF_KIND_TYPEDEF) {
> - vlen = create_new_typedef(btf, type_ptr, size, type_index);
> + vlen = create_new_typedef(btfe, type_ptr, size, type_index);
> } else if (type == BTF_KIND_VOLATILE ||
> type == BTF_KIND_PTR ||
> type == BTF_KIND_CONST ||
> type == BTF_KIND_RESTRICT) {
> - vlen = create_new_tag(btf, type, type_ptr, type_index);
> + vlen = create_new_tag(btfe, type, type_ptr, type_index);
> } else if (type == BTF_KIND_UNKN) {
> - cu__table_nullify_type_entry(btf->priv, type_index);
> + cu__table_nullify_type_entry(btfe->priv, type_index);
> fprintf(stderr,
> "BTF: idx: %d, off: %zd, Unknown\n",
> type_index, ((void *)type_ptr) - type_section);
> fflush(stderr);
> vlen = 0;
> } else if (type == BTF_KIND_FUNC_PROTO) {
> - vlen = create_new_subroutine_type(btf, ptr, vlen, type_ptr, type_index);
> + vlen = create_new_subroutine_type(btfe, ptr, vlen, type_ptr, type_index);
> } else if (type == BTF_KIND_FUNC) {
> /* BTF_KIND_FUNC corresponding to a defined subprogram.
> * This is not really a type and it won't be referred by any other types
> @@ -428,7 +427,7 @@ static int btf__load_types(struct btf *btf)
> *
> * No warning here since BTF_KIND_FUNC is a legal entry in BTF.
> */
> - cu__table_nullify_type_entry(btf->priv, type_index);
> + cu__table_nullify_type_entry(btfe->priv, type_index);
> vlen = 0;
> } else {
> fprintf(stderr,
> @@ -447,12 +446,12 @@ static int btf__load_types(struct btf *btf)
> return 0;
> }
>
> -static int btf__load_sections(struct btf *btf)
> +static int btf_elf__load_sections(struct btf_elf *btfe)
> {
> - return btf__load_types(btf);
> + return btf_elf__load_types(btfe);
> }
>
> -static int class__fixup_btf_bitfields(struct tag *tag, struct cu *cu, struct btf *btf)
> +static int class__fixup_btf_bitfields(struct tag *tag, struct cu *cu, struct btf_elf *btfe)
> {
> struct class_member *pos;
> struct type *tag_type = tag__type(tag);
> @@ -510,7 +509,7 @@ static int class__fixup_btf_bitfields(struct tag *tag, struct cu *cu, struct btf
> }
>
> pos->bitfield_offset = pos->bit_offset % integral_bit_size;
> - if (!btf->is_big_endian)
> + if (!btfe->is_big_endian)
> pos->bitfield_offset = integral_bit_size - pos->bitfield_offset - pos->bitfield_size;
>
> pos->bit_size = type_bit_size;
> @@ -521,14 +520,14 @@ static int class__fixup_btf_bitfields(struct tag *tag, struct cu *cu, struct btf
> return 0;
> }
>
> -static int cu__fixup_btf_bitfields(struct cu *cu, struct btf *btf)
> +static int cu__fixup_btf_bitfields(struct cu *cu, struct btf_elf *btfe)
> {
> int err = 0;
> struct tag *pos;
>
> list_for_each_entry(pos, &cu->tags, node)
> if (tag__is_struct(pos) || tag__is_union(pos)) {
> - err = class__fixup_btf_bitfields(pos, cu, btf);
> + err = class__fixup_btf_bitfields(pos, cu, btfe);
> if (err)
> break;
> }
> @@ -536,48 +535,47 @@ static int cu__fixup_btf_bitfields(struct cu *cu, struct btf *btf)
> return err;
> }
>
> -static void btf__cu_delete(struct cu *cu)
> +static void btf_elf__cu_delete(struct cu *cu)
> {
> - btf__free(cu->priv);
> + btf_elf__free(cu->priv);
> cu->priv = NULL;
> }
>
> -static const char *btf__strings_ptr(const struct cu *cu, strings_t s)
> +static const char *btf_elf__strings_ptr(const struct cu *cu, strings_t s)
> {
> - return btf__string(cu->priv, s);
> + return btf_elf__string(cu->priv, s);
> }
>
> -struct debug_fmt_ops btf__ops;
> +struct debug_fmt_ops btf_elf__ops;
>
> -int btf__load_file(struct cus *cus, struct conf_load *conf,
> - const char *filename)
> +int btf_elf__load_file(struct cus *cus, struct conf_load *conf, const char *filename)
> {
> int err;
> - struct btf *state = btf__new(filename, NULL);
> + struct btf_elf *btfe = btf_elf__new(filename, NULL);
>
> - if (state == NULL)
> + if (btfe == NULL)
> return -1;
>
> - struct cu *cu = cu__new(filename, state->wordsize, NULL, 0, filename);
> + struct cu *cu = cu__new(filename, btfe->wordsize, NULL, 0, filename);
> if (cu == NULL)
> return -1;
>
> cu->language = LANG_C;
> cu->uses_global_strings = false;
> - cu->dfops = &btf__ops;
> - cu->priv = state;
> - state->priv = cu;
> - if (btf__load(state) != 0)
> + cu->dfops = &btf_elf__ops;
> + cu->priv = btfe;
> + btfe->priv = cu;
> + if (btf_elf__load(btfe) != 0)
> return -1;
>
> - err = btf__load_sections(state);
> + err = btf_elf__load_sections(btfe);
>
> if (err != 0) {
> cu__delete(cu);
> return err;
> }
>
> - err = cu__fixup_btf_bitfields(cu, state);
> + err = cu__fixup_btf_bitfields(cu, btfe);
> /*
> * The app stole this cu, possibly deleting it,
> * so forget about it
> @@ -589,9 +587,9 @@ int btf__load_file(struct cus *cus, struct conf_load *conf,
> return err;
> }
>
> -struct debug_fmt_ops btf__ops = {
> +struct debug_fmt_ops btf_elf__ops = {
> .name = "btf",
> - .load_file = btf__load_file,
> - .strings__ptr = btf__strings_ptr,
> - .cu__delete = btf__cu_delete,
> + .load_file = btf_elf__load_file,
> + .strings__ptr = btf_elf__strings_ptr,
> + .cu__delete = btf_elf__cu_delete,
> };
> diff --git a/dwarves.c b/dwarves.c
> index 250eaae61d75..093de117886b 100644
> --- a/dwarves.c
> +++ b/dwarves.c
> @@ -1457,12 +1457,12 @@ out:
> /*
> * This should really do demand loading of DSOs, STABS anyone? 8-)
> */
> -extern struct debug_fmt_ops dwarf__ops, ctf__ops, btf__ops;
> +extern struct debug_fmt_ops dwarf__ops, ctf__ops, btf_elf__ops;
>
> static struct debug_fmt_ops *debug_fmt_table[] = {
> &dwarf__ops,
> &ctf__ops,
> - &btf__ops,
> + &btf_elf__ops,
> NULL,
> };
>
> diff --git a/libbtf.c b/libbtf.c
> index 42da6a37de40..2d1ccf7af140 100644
> --- a/libbtf.c
> +++ b/libbtf.c
> @@ -41,13 +41,13 @@ struct btf_array_type {
> struct btf_array array;
> };
>
> -uint8_t btf_verbose;
> +uint8_t btf_elf__verbose;
>
> -uint32_t btf__get32(struct btf *btf, uint32_t *p)
> +uint32_t btf_elf__get32(struct btf_elf *btfe, uint32_t *p)
> {
> uint32_t val = *p;
>
> - if (btf->swapped)
> + if (btfe->swapped)
> val = ((val >> 24) |
> ((val >> 8) & 0x0000ff00) |
> ((val << 8) & 0x00ff0000) |
> @@ -55,11 +55,11 @@ uint32_t btf__get32(struct btf *btf, uint32_t *p)
> return val;
> }
>
> -int btf__load(struct btf *btf)
> +int btf_elf__load(struct btf_elf *btfe)
> {
> int err = -ENOTSUP;
> GElf_Shdr shdr;
> - Elf_Scn *sec = elf_section_by_name(btf->elf, &btf->ehdr, &shdr, ".BTF", NULL);
> + Elf_Scn *sec = elf_section_by_name(btfe->elf, &btfe->ehdr, &shdr, ".BTF", NULL);
>
> if (sec == NULL)
> return -ESRCH;
> @@ -78,15 +78,15 @@ int btf__load(struct btf *btf)
>
> err = -EINVAL;
> if (hp->magic == BTF_MAGIC)
> - btf->swapped = 0;
> + btfe->swapped = 0;
> else
> goto out;
>
> err = -ENOMEM;
> - btf->data = malloc(orig_size);
> - if (btf->data != NULL) {
> - memcpy(btf->data, hp, orig_size);
> - btf->size = orig_size;
> + btfe->data = malloc(orig_size);
> + if (btfe->data != NULL) {
> + memcpy(btfe->data, hp, orig_size);
> + btfe->size = orig_size;
> err = 0;
> }
> out:
> @@ -94,23 +94,23 @@ out:
> }
>
>
> -struct btf *btf__new(const char *filename, Elf *elf)
> +struct btf_elf *btf_elf__new(const char *filename, Elf *elf)
> {
> - struct btf *btf = zalloc(sizeof(*btf));
> + struct btf_elf *btfe = zalloc(sizeof(*btfe));
>
> - if (!btf)
> + if (!btfe)
> return NULL;
>
> - btf->in_fd = -1;
> - btf->filename = strdup(filename);
> - if (btf->filename == NULL)
> + btfe->in_fd = -1;
> + btfe->filename = strdup(filename);
> + if (btfe->filename == NULL)
> goto errout;
>
> if (elf != NULL) {
> - btf->elf = elf;
> + btfe->elf = elf;
> } else {
> - btf->in_fd = open(filename, O_RDONLY);
> - if (btf->in_fd < 0)
> + btfe->in_fd = open(filename, O_RDONLY);
> + if (btfe->in_fd < 0)
> goto errout;
>
> if (elf_version(EV_CURRENT) == EV_NONE) {
> @@ -119,82 +119,82 @@ struct btf *btf__new(const char *filename, Elf *elf)
> goto errout;
> }
>
> - btf->elf = elf_begin(btf->in_fd, ELF_C_READ_MMAP, NULL);
> - if (!btf->elf) {
> + btfe->elf = elf_begin(btfe->in_fd, ELF_C_READ_MMAP, NULL);
> + if (!btfe->elf) {
> fprintf(stderr, "%s: cannot read %s ELF file.\n",
> __func__, filename);
> goto errout;
> }
> }
>
> - if (gelf_getehdr(btf->elf, &btf->ehdr) == NULL) {
> + if (gelf_getehdr(btfe->elf, &btfe->ehdr) == NULL) {
> fprintf(stderr, "%s: cannot get elf header.\n", __func__);
> goto errout;
> }
>
> - switch (btf->ehdr.e_ident[EI_DATA]) {
> - case ELFDATA2LSB: btf->is_big_endian = false; break;
> - case ELFDATA2MSB: btf->is_big_endian = true; break;
> + switch (btfe->ehdr.e_ident[EI_DATA]) {
> + case ELFDATA2LSB: btfe->is_big_endian = false; break;
> + case ELFDATA2MSB: btfe->is_big_endian = true; break;
> default:
> fprintf(stderr, "%s: unknown elf endianness.\n", __func__);
> goto errout;
> }
>
> - switch (btf->ehdr.e_ident[EI_CLASS]) {
> - case ELFCLASS32: btf->wordsize = 4; break;
> - case ELFCLASS64: btf->wordsize = 8; break;
> - default: btf->wordsize = 0; break;
> + switch (btfe->ehdr.e_ident[EI_CLASS]) {
> + case ELFCLASS32: btfe->wordsize = 4; break;
> + case ELFCLASS64: btfe->wordsize = 8; break;
> + default: btfe->wordsize = 0; break;
> }
>
> - return btf;
> + return btfe;
>
> errout:
> - btf__free(btf);
> + btf_elf__free(btfe);
> return NULL;
> }
>
> -void btf__free(struct btf *btf)
> +void btf_elf__free(struct btf_elf *btfe)
> {
> - if (!btf)
> + if (!btfe)
> return;
>
> - if (btf->in_fd != -1) {
> - close(btf->in_fd);
> - if (btf->elf)
> - elf_end(btf->elf);
> + if (btfe->in_fd != -1) {
> + close(btfe->in_fd);
> + if (btfe->elf)
> + elf_end(btfe->elf);
> }
>
> - __gobuffer__delete(&btf->types);
> - free(btf->filename);
> - free(btf->data);
> - free(btf);
> + __gobuffer__delete(&btfe->types);
> + free(btfe->filename);
> + free(btfe->data);
> + free(btfe);
> }
>
> -char *btf__string(struct btf *btf, uint32_t ref)
> +char *btf_elf__string(struct btf_elf *btfe, uint32_t ref)
> {
> - struct btf_header *hp = btf->hdr;
> + struct btf_header *hp = btfe->hdr;
> uint32_t off = ref;
> char *name;
>
> - if (off >= btf__get32(btf, &hp->str_len))
> + if (off >= btf_elf__get32(btfe, &hp->str_len))
> return "(ref out-of-bounds)";
>
> - if ((off + btf__get32(btf, &hp->str_off)) >= btf->size)
> + if ((off + btf_elf__get32(btfe, &hp->str_off)) >= btfe->size)
> return "(string table truncated)";
>
> - name = ((char *)(hp + 1) + btf__get32(btf, &hp->str_off) + off);
> + name = ((char *)(hp + 1) + btf_elf__get32(btfe, &hp->str_off) + off);
>
> return name[0] == '\0' ? NULL : name;
> }
>
> -static void *btf__nohdr_data(struct btf *btf)
> +static void *btf_elf__nohdr_data(struct btf_elf *btfe)
> {
> - return btf->hdr + 1;
> + return btfe->hdr + 1;
> }
>
> -void btf__set_strings(struct btf *btf, struct gobuffer *strings)
> +void btf_elf__set_strings(struct btf_elf *btfe, struct gobuffer *strings)
> {
> - btf->strings = strings;
> + btfe->strings = strings;
> }
>
> #define BITS_PER_BYTE 8
> @@ -220,16 +220,15 @@ static const char * const btf_kind_str[NR_BTF_KINDS] = {
> [BTF_KIND_FUNC_PROTO] = "FUNC_PROTO",
> };
>
> -static const char *btf__name_in_gobuf(const struct btf *btf,
> - uint32_t offset)
> +static const char *btf_elf__name_in_gobuf(const struct btf_elf *btfe, uint32_t offset)
> {
> if (!offset)
> return "(anon)";
> else
> - return &btf->strings->entries[offset];
> + return &btfe->strings->entries[offset];
> }
>
> -static const char * btf__int_encoding_str(uint8_t encoding)
> +static const char * btf_elf__int_encoding_str(uint8_t encoding)
> {
> if (encoding == 0)
> return "(none)";
> @@ -244,21 +243,21 @@ static const char * btf__int_encoding_str(uint8_t encoding)
> }
>
> __attribute ((format (printf, 5, 6)))
> -static void btf__log_type(const struct btf *btf, const struct btf_type *t,
> - bool err, bool output_cr, const char *fmt, ...)
> +static void btf_elf__log_type(const struct btf_elf *btfe, const struct btf_type *t,
> + bool err, bool output_cr, const char *fmt, ...)
> {
> uint8_t kind;
> FILE *out;
>
> - if (!btf_verbose && !err)
> + if (!btf_elf__verbose && !err)
> return;
>
> kind = BTF_INFO_KIND(t->info);
> out = err ? stderr : stdout;
>
> fprintf(out, "[%u] %s %s",
> - btf->type_index, btf_kind_str[kind],
> - btf__name_in_gobuf(btf, t->name_off));
> + btfe->type_index, btf_kind_str[kind],
> + btf_elf__name_in_gobuf(btfe, t->name_off));
>
> if (fmt && *fmt) {
> va_list ap;
> @@ -274,26 +273,26 @@ static void btf__log_type(const struct btf *btf, const struct btf_type *t,
> }
>
> __attribute ((format (printf, 5, 6)))
> -static void btf_log_member(const struct btf *btf,
> +static void btf_log_member(const struct btf_elf *btfe,
> const struct btf_member *member,
> bool kind_flag, bool err, const char *fmt, ...)
> {
> FILE *out;
>
> - if (!btf_verbose && !err)
> + if (!btf_elf__verbose && !err)
> return;
>
> out = err ? stderr : stdout;
>
> if (kind_flag)
> fprintf(out, "\t%s type_id=%u bitfield_size=%u bits_offset=%u",
> - btf__name_in_gobuf(btf, member->name_off),
> + btf_elf__name_in_gobuf(btfe, member->name_off),
> member->type,
> BTF_MEMBER_BITFIELD_SIZE(member->offset),
> BTF_MEMBER_BIT_OFFSET(member->offset));
> else
> fprintf(out, "\t%s type_id=%u bits_offset=%u",
> - btf__name_in_gobuf(btf, member->name_off),
> + btf_elf__name_in_gobuf(btfe, member->name_off),
> member->type,
> member->offset);
>
> @@ -310,14 +309,14 @@ static void btf_log_member(const struct btf *btf,
> }
>
> __attribute ((format (printf, 6, 7)))
> -static void btf_log_func_param(const struct btf *btf,
> +static void btf_log_func_param(const struct btf_elf *btfe,
> uint32_t name_off, uint32_t type,
> bool err, bool is_last_param,
> const char *fmt, ...)
> {
> FILE *out;
>
> - if (!btf_verbose && !err)
> + if (!btf_elf__verbose && !err)
> return;
>
> out = err ? stderr : stdout;
> @@ -326,7 +325,7 @@ static void btf_log_func_param(const struct btf *btf,
> fprintf(out, "vararg)\n");
> else
> fprintf(out, "%u %s%s", type,
> - btf__name_in_gobuf(btf, name_off),
> + btf_elf__name_in_gobuf(btfe, name_off),
> is_last_param ? ")\n" : ", ");
>
> if (fmt && *fmt) {
> @@ -339,7 +338,7 @@ static void btf_log_func_param(const struct btf *btf,
> }
> }
>
> -int32_t btf__add_base_type(struct btf *btf, const struct base_type *bt)
> +int32_t btf_elf__add_base_type(struct btf_elf *btfe, const struct base_type *bt)
> {
> struct btf_int_type int_type;
> struct btf_type *t = &int_type.type;
> @@ -358,26 +357,26 @@ int32_t btf__add_base_type(struct btf *btf, const struct base_type *bt)
> }
> int_type.data = BTF_INT_ENCODE(encoding, 0, bt->bit_size);
>
> - ++btf->type_index;
> - if (gobuffer__add(&btf->types, &int_type, sizeof(int_type)) >= 0) {
> - btf__log_type(btf, t, false, true,
> + ++btfe->type_index;
> + if (gobuffer__add(&btfe->types, &int_type, sizeof(int_type)) >= 0) {
> + btf_elf__log_type(btfe, t, false, true,
> "size=%u bit_offset=%u nr_bits=%u encoding=%s",
> t->size, BTF_INT_OFFSET(int_type.data),
> BTF_INT_BITS(int_type.data),
> - btf__int_encoding_str(BTF_INT_ENCODING(int_type.data)));
> - return btf->type_index;
> + btf_elf__int_encoding_str(BTF_INT_ENCODING(int_type.data)));
> + return btfe->type_index;
> } else {
> - btf__log_type(btf, t, true, true,
> + btf_elf__log_type(btfe, t, true, true,
> "size=%u bit_offset=%u nr_bits=%u encoding=%s Error in adding gobuffer",
> t->size, BTF_INT_OFFSET(int_type.data),
> BTF_INT_BITS(int_type.data),
> - btf__int_encoding_str(BTF_INT_ENCODING(int_type.data)));
> + btf_elf__int_encoding_str(BTF_INT_ENCODING(int_type.data)));
> return -1;
> }
> }
>
> -int32_t btf__add_ref_type(struct btf *btf, uint16_t kind, uint32_t type,
> - uint32_t name, bool kind_flag)
> +int32_t btf_elf__add_ref_type(struct btf_elf *btfe, uint16_t kind, uint32_t type,
> + uint32_t name, bool kind_flag)
> {
> struct btf_type t;
>
> @@ -385,24 +384,22 @@ int32_t btf__add_ref_type(struct btf *btf, uint16_t kind, uint32_t type,
> t.info = BTF_INFO_ENCODE(kind, kind_flag, 0);
> t.type = type;
>
> - ++btf->type_index;
> - if (gobuffer__add(&btf->types, &t, sizeof(t)) >= 0) {
> + ++btfe->type_index;
> + if (gobuffer__add(&btfe->types, &t, sizeof(t)) >= 0) {
> if (kind == BTF_KIND_FWD)
> - btf__log_type(btf, &t, false, true, "%s",
> - kind_flag ? "union" : "struct");
> + btf_elf__log_type(btfe, &t, false, true, "%s", kind_flag ? "union" : "struct");
> else
> - btf__log_type(btf, &t, false, true, "type_id=%u", t.type);
> - return btf->type_index;
> + btf_elf__log_type(btfe, &t, false, true, "type_id=%u", t.type);
> + return btfe->type_index;
> } else {
> - btf__log_type(btf, &t, true, true,
> + btf_elf__log_type(btfe, &t, true, true,
> "kind_flag=%d type_id=%u Error in adding gobuffer",
> kind_flag, t.type);
> return -1;
> }
> }
>
> -int32_t btf__add_array(struct btf *btf, uint32_t type, uint32_t index_type,
> - uint32_t nelems)
> +int32_t btf_elf__add_array(struct btf_elf *btfe, uint32_t type, uint32_t index_type, uint32_t nelems)
> {
> struct btf_array_type array_type;
> struct btf_type *t = &array_type.type;
> @@ -416,22 +413,22 @@ int32_t btf__add_array(struct btf *btf, uint32_t type, uint32_t index_type,
> array->index_type = index_type;
> array->nelems = nelems;
>
> - ++btf->type_index;
> - if (gobuffer__add(&btf->types, &array_type, sizeof(array_type)) >= 0) {
> - btf__log_type(btf, t, false, true,
> + ++btfe->type_index;
> + if (gobuffer__add(&btfe->types, &array_type, sizeof(array_type)) >= 0) {
> + btf_elf__log_type(btfe, t, false, true,
> "type_id=%u index_type_id=%u nr_elems=%u",
> array->type, array->index_type, array->nelems);
> - return btf->type_index;
> + return btfe->type_index;
> } else {
> - btf__log_type(btf, t, true, true,
> + btf_elf__log_type(btfe, t, true, true,
> "type_id=%u index_type_id=%u nr_elems=%u Error in adding gobuffer",
> array->type, array->index_type, array->nelems);
> return -1;
> }
> }
>
> -int btf__add_member(struct btf *btf, uint32_t name, uint32_t type, bool kind_flag,
> - uint32_t bitfield_size, uint32_t offset)
> +int btf_elf__add_member(struct btf_elf *btfe, uint32_t name, uint32_t type, bool kind_flag,
> + uint32_t bitfield_size, uint32_t offset)
> {
> struct btf_member member = {
> .name_off = name,
> @@ -439,17 +436,17 @@ int btf__add_member(struct btf *btf, uint32_t name, uint32_t type, bool kind_fla
> .offset = kind_flag ? (bitfield_size << 24 | offset) : offset,
> };
>
> - if (gobuffer__add(&btf->types, &member, sizeof(member)) >= 0) {
> - btf_log_member(btf, &member, kind_flag, false, NULL);
> + if (gobuffer__add(&btfe->types, &member, sizeof(member)) >= 0) {
> + btf_log_member(btfe, &member, kind_flag, false, NULL);
> return 0;
> } else {
> - btf_log_member(btf, &member, kind_flag, true, "Error in adding gobuffer");
> + btf_log_member(btfe, &member, kind_flag, true, "Error in adding gobuffer");
> return -1;
> }
> }
>
> -int32_t btf__add_struct(struct btf *btf, uint8_t kind, uint32_t name,
> - bool kind_flag, uint32_t size, uint16_t nr_members)
> +int32_t btf_elf__add_struct(struct btf_elf *btfe, uint8_t kind, uint32_t name,
> + bool kind_flag, uint32_t size, uint16_t nr_members)
> {
> struct btf_type t;
>
> @@ -457,21 +454,20 @@ int32_t btf__add_struct(struct btf *btf, uint8_t kind, uint32_t name,
> t.info = BTF_INFO_ENCODE(kind, kind_flag, nr_members);
> t.size = size;
>
> - ++btf->type_index;
> - if (gobuffer__add(&btf->types, &t, sizeof(t)) >= 0) {
> - btf__log_type(btf, &t, false, true, "kind_flag=%d size=%u vlen=%u",
> + ++btfe->type_index;
> + if (gobuffer__add(&btfe->types, &t, sizeof(t)) >= 0) {
> + btf_elf__log_type(btfe, &t, false, true, "kind_flag=%d size=%u vlen=%u",
> kind_flag, t.size, BTF_INFO_VLEN(t.info));
> - return btf->type_index;
> + return btfe->type_index;
> } else {
> - btf__log_type(btf, &t, true, true,
> + btf_elf__log_type(btfe, &t, true, true,
> "kind_flag=%d size=%u vlen=%u Error in adding gobuffer",
> kind_flag, t.size, BTF_INFO_VLEN(t.info));
> return -1;
> }
> }
>
> -int32_t btf__add_enum(struct btf *btf, uint32_t name, uint32_t bit_size,
> - uint16_t nr_entries)
> +int32_t btf_elf__add_enum(struct btf_elf *btfe, uint32_t name, uint32_t bit_size, uint16_t nr_entries)
> {
> struct btf_type t;
>
> @@ -479,57 +475,55 @@ int32_t btf__add_enum(struct btf *btf, uint32_t name, uint32_t bit_size,
> t.info = BTF_INFO_ENCODE(BTF_KIND_ENUM, 0, nr_entries);
> t.size = BITS_ROUNDUP_BYTES(bit_size);
>
> - ++btf->type_index;
> - if (gobuffer__add(&btf->types, &t, sizeof(t)) >= 0) {
> - btf__log_type(btf, &t, false, true, "size=%u vlen=%u",
> - t.size, BTF_INFO_VLEN(t.info));
> - return btf->type_index;
> + ++btfe->type_index;
> + if (gobuffer__add(&btfe->types, &t, sizeof(t)) >= 0) {
> + btf_elf__log_type(btfe, &t, false, true, "size=%u vlen=%u", t.size, BTF_INFO_VLEN(t.info));
> + return btfe->type_index;
> } else {
> - btf__log_type(btf, &t, true, true,
> + btf_elf__log_type(btfe, &t, true, true,
> "size=%u vlen=%u Error in adding gobuffer",
> t.size, BTF_INFO_VLEN(t.info));
> return -1;
> }
> }
>
> -int btf__add_enum_val(struct btf *btf, uint32_t name, int32_t value)
> +int btf_elf__add_enum_val(struct btf_elf *btfe, uint32_t name, int32_t value)
> {
> struct btf_enum e = {
> .name_off = name,
> .val = value,
> };
>
> - if (gobuffer__add(&btf->types, &e, sizeof(e)) < 0) {
> + if (gobuffer__add(&btfe->types, &e, sizeof(e)) < 0) {
> fprintf(stderr, "\t%s val=%d Error in adding gobuffer\n",
> - btf__name_in_gobuf(btf, e.name_off), e.val);
> + btf_elf__name_in_gobuf(btfe, e.name_off), e.val);
> return -1;
> - } else if (btf_verbose)
> - printf("\t%s val=%d\n", btf__name_in_gobuf(btf, e.name_off),
> + } else if (btf_elf__verbose)
> + printf("\t%s val=%d\n", btf_elf__name_in_gobuf(btfe, e.name_off),
> e.val);
>
> return 0;
> }
>
> -static int32_t btf__add_func_proto_param(struct btf *btf, uint32_t name,
> - uint32_t type, bool is_last_param)
> +static int32_t btf_elf__add_func_proto_param(struct btf_elf *btfe, uint32_t name,
> + uint32_t type, bool is_last_param)
> {
> struct btf_param param;
>
> param.name_off = name;
> param.type = type;
>
> - if (gobuffer__add(&btf->types, ¶m, sizeof(param)) >= 0) {
> - btf_log_func_param(btf, name, type, false, is_last_param, NULL);
> + if (gobuffer__add(&btfe->types, ¶m, sizeof(param)) >= 0) {
> + btf_log_func_param(btfe, name, type, false, is_last_param, NULL);
> return 0;
> } else {
> - btf_log_func_param(btf, name, type, true, is_last_param,
> + btf_log_func_param(btfe, name, type, true, is_last_param,
> "Error in adding gobuffer");
> return -1;
> }
> }
>
> -int32_t btf__add_func_proto(struct btf *btf, struct ftype *ftype,
> - uint32_t type_id_off)
> +int32_t btf_elf__add_func_proto(struct btf_elf *btfe, struct ftype *ftype, uint32_t type_id_off)
> {
> uint16_t nr_params, param_idx;
> struct parameter *param;
> @@ -543,13 +537,13 @@ int32_t btf__add_func_proto(struct btf *btf, struct ftype *ftype,
> t.info = BTF_INFO_ENCODE(BTF_KIND_FUNC_PROTO, 0, nr_params);
> t.type = ftype->tag.type == 0 ? 0 : type_id_off + ftype->tag.type;
>
> - ++btf->type_index;
> - if (gobuffer__add(&btf->types, &t, sizeof(t)) >= 0) {
> - btf__log_type(btf, &t, false, false, "return=%u args=(%s",
> + ++btfe->type_index;
> + if (gobuffer__add(&btfe->types, &t, sizeof(t)) >= 0) {
> + btf_elf__log_type(btfe, &t, false, false, "return=%u args=(%s",
> t.type, !nr_params ? "void)\n" : "");
> - type_id = btf->type_index;
> + type_id = btfe->type_index;
> } else {
> - btf__log_type(btf, &t, true, true,
> + btf_elf__log_type(btfe, &t, true, true,
> "return=%u vlen=%u Error in adding gobuffer",
> t.type, BTF_INFO_VLEN(t.info));
> return -1;
> @@ -560,22 +554,19 @@ int32_t btf__add_func_proto(struct btf *btf, struct ftype *ftype,
> ftype__for_each_parameter(ftype, param) {
> uint32_t param_type_id = param->tag.type == 0 ? 0 : type_id_off + param->tag.type;
> ++param_idx;
> - if (btf__add_func_proto_param(btf, param->name,
> - param_type_id,
> - param_idx == nr_params))
> + if (btf_elf__add_func_proto_param(btfe, param->name, param_type_id, param_idx == nr_params))
> return -1;
> }
>
> ++param_idx;
> if (ftype->unspec_parms)
> - if (btf__add_func_proto_param(btf, 0, 0,
> - param_idx == nr_params))
> + if (btf_elf__add_func_proto_param(btfe, 0, 0, param_idx == nr_params))
> return -1;
>
> return type_id;
> }
>
> -static int btf__write_elf(struct btf *btf)
> +static int btf_elf__write(struct btf_elf *btfe)
> {
> GElf_Shdr shdr_mem, *shdr;
> GElf_Ehdr ehdr_mem, *ehdr;
> @@ -585,9 +576,9 @@ static int btf__write_elf(struct btf *btf)
> int fd, err = -1;
> size_t strndx;
>
> - fd = open(btf->filename, O_RDWR);
> + fd = open(btfe->filename, O_RDWR);
> if (fd < 0) {
> - fprintf(stderr, "Cannot open %s\n", btf->filename);
> + fprintf(stderr, "Cannot open %s\n", btfe->filename);
> return -1;
> }
>
> @@ -628,8 +619,8 @@ static int btf__write_elf(struct btf *btf)
>
> if (btf_elf) {
> /* Exisiting .BTF section found */
> - btf_elf->d_buf = btf->data;
> - btf_elf->d_size = btf->size;
> + btf_elf->d_buf = btfe->data;
> + btf_elf->d_size = btfe->size;
> elf_flagdata(btf_elf, ELF_C_SET, ELF_F_DIRTY);
>
> if (elf_update(elf, ELF_C_NULL) >= 0 &&
> @@ -645,7 +636,7 @@ static int btf__write_elf(struct btf *btf)
> llvm_objcopy = "llvm-objcopy";
>
> /* Use objcopy to add a .BTF section */
> - snprintf(tmp_fn, sizeof(tmp_fn), "%s.btf", btf->filename);
> + snprintf(tmp_fn, sizeof(tmp_fn), "%s.btfe", btfe->filename);
This is probably unintentional change, though not a problem per se.
> close(fd);
> fd = creat(tmp_fn, S_IRUSR | S_IWUSR);
> if (fd == -1) {
> @@ -655,9 +646,9 @@ static int btf__write_elf(struct btf *btf)
> }
>
> snprintf(cmd, sizeof(cmd), "%s --add-section .BTF=%s %s",
> - llvm_objcopy, tmp_fn, btf->filename);
> + llvm_objcopy, tmp_fn, btfe->filename);
>
> - if (write(fd, btf->data, btf->size) == btf->size &&
> + if (write(fd, btfe->data, btfe->size) == btfe->size &&
> !system(cmd))
> err = 0;
>
> @@ -672,39 +663,37 @@ out:
> return err;
> }
>
> -int btf__encode(struct btf *btf, uint8_t flags)
> +int btf_elf__encode(struct btf_elf *btfe, uint8_t flags)
> {
> struct btf_header *hdr;
>
> /* Empty file, nothing to do, so... done! */
> - if (gobuffer__size(&btf->types) == 0)
> + if (gobuffer__size(&btfe->types) == 0)
> return 0;
>
> - btf->size = sizeof(*hdr) +
> - (gobuffer__size(&btf->types) +
> - gobuffer__size(btf->strings));
> - btf->data = zalloc(btf->size);
> + btfe->size = sizeof(*hdr) + (gobuffer__size(&btfe->types) + gobuffer__size(btfe->strings));
> + btfe->data = zalloc(btfe->size);
>
> - if (btf->data == NULL) {
> + if (btfe->data == NULL) {
> fprintf(stderr, "%s: malloc failed!\n", __func__);
> return -1;
> }
>
> - hdr = btf->hdr;
> + hdr = btfe->hdr;
> hdr->magic = BTF_MAGIC;
> hdr->version = 1;
> hdr->flags = flags;
> hdr->hdr_len = sizeof(*hdr);
>
> hdr->type_off = 0;
> - hdr->type_len = gobuffer__size(&btf->types);
> + hdr->type_len = gobuffer__size(&btfe->types);
> hdr->str_off = hdr->type_len;
> - hdr->str_len = gobuffer__size(btf->strings);
> + hdr->str_len = gobuffer__size(btfe->strings);
>
> - gobuffer__copy(&btf->types, btf__nohdr_data(btf) + hdr->type_off);
> - gobuffer__copy(btf->strings, btf__nohdr_data(btf) + hdr->str_off);
> + gobuffer__copy(&btfe->types, btf_elf__nohdr_data(btfe) + hdr->type_off);
> + gobuffer__copy(btfe->strings, btf_elf__nohdr_data(btfe) + hdr->str_off);
>
> - *(char *)(btf__nohdr_data(btf) + hdr->str_off) = '\0';
> + *(char *)(btf_elf__nohdr_data(btfe) + hdr->str_off) = '\0';
>
> - return btf__write_elf(btf);
> + return btf_elf__write(btfe);
> }
> diff --git a/libbtf.h b/libbtf.h
> index 780f3ec888d7..3388a6fb30fd 100644
> --- a/libbtf.h
> +++ b/libbtf.h
> @@ -12,7 +12,7 @@
> #include <stdbool.h>
> #include <stdint.h>
>
> -struct btf {
> +struct btf_elf {
> union {
> struct btf_header *hdr;
> void *data;
> @@ -31,39 +31,39 @@ struct btf {
> uint32_t type_index;
> };
>
> -extern uint8_t btf_verbose;
> -#define btf_verbose_log(fmt, ...) { if (btf_verbose) printf(fmt, __VA_ARGS__); }
> +extern uint8_t btf_elf__verbose;
> +#define btf_elf__verbose_log(fmt, ...) { if (btf_elf__verbose) printf(fmt, __VA_ARGS__); }
>
> struct base_type;
> struct ftype;
>
> -struct btf *btf__new(const char *filename, Elf *elf);
> -void btf__free(struct btf *btf);
> +struct btf_elf *btf_elf__new(const char *filename, Elf *elf);
> +void btf_elf__free(struct btf_elf *btf);
>
> -int32_t btf__add_base_type(struct btf *btf, const struct base_type *bt);
> -int32_t btf__add_ref_type(struct btf *btf, uint16_t kind, uint32_t type,
> - uint32_t name, bool kind_flag);
> -int btf__add_member(struct btf *btf, uint32_t name, uint32_t type, bool kind_flag,
> - uint32_t bitfield_size, uint32_t bit_offset);
> -int32_t btf__add_struct(struct btf *btf, uint8_t kind, uint32_t name,
> - bool kind_flag, uint32_t size, uint16_t nr_members);
> -int32_t btf__add_array(struct btf *btf, uint32_t type, uint32_t index_type,
> - uint32_t nelems);
> -int32_t btf__add_enum(struct btf *btf, uint32_t name, uint32_t size,
> - uint16_t nr_entries);
> -int btf__add_enum_val(struct btf *btf, uint32_t name, int32_t value);
> -int32_t btf__add_func_proto(struct btf *btf, struct ftype *ftype,
> - uint32_t type_id_off);
> -void btf__set_strings(struct btf *btf, struct gobuffer *strings);
> -int btf__encode(struct btf *btf, uint8_t flags);
> +int32_t btf_elf__add_base_type(struct btf_elf *btf, const struct base_type *bt);
> +int32_t btf_elf__add_ref_type(struct btf_elf *btf, uint16_t kind, uint32_t type,
> + uint32_t name, bool kind_flag);
> +int btf_elf__add_member(struct btf_elf *btf, uint32_t name, uint32_t type, bool kind_flag,
> + uint32_t bitfield_size, uint32_t bit_offset);
> +int32_t btf_elf__add_struct(struct btf_elf *btf, uint8_t kind, uint32_t name,
> + bool kind_flag, uint32_t size, uint16_t nr_members);
> +int32_t btf_elf__add_array(struct btf_elf *btf, uint32_t type, uint32_t index_type,
> + uint32_t nelems);
> +int32_t btf_elf__add_enum(struct btf_elf *btf, uint32_t name, uint32_t size,
> + uint16_t nr_entries);
> +int btf_elf__add_enum_val(struct btf_elf *btf, uint32_t name, int32_t value);
> +int32_t btf_elf__add_func_proto(struct btf_elf *btf, struct ftype *ftype,
> + uint32_t type_id_off);
> +void btf_elf__set_strings(struct btf_elf *btf, struct gobuffer *strings);
> +int btf_elf__encode(struct btf_elf *btf, uint8_t flags);
>
> -char *btf__string(struct btf *btf, uint32_t ref);
> -int btf__load(struct btf *btf);
> +char *btf_elf__string(struct btf_elf *btf, uint32_t ref);
> +int btf_elf__load(struct btf_elf *btf);
>
> -uint32_t btf__get32(struct btf *btf, uint32_t *p);
> +uint32_t btf_elf__get32(struct btf_elf *btf, uint32_t *p);
>
> -void *btf__get_buffer(struct btf *btf);
> +void *btf_elf__get_buffer(struct btf_elf *btf);
>
> -size_t btf__get_size(struct btf *btf);
> +size_t btf_elf__get_size(struct btf_elf *btf);
>
> #endif /* _LIBBTF_H */
