/*
SPDX-License-Identifier: GPL-2.0-only
Copyright (C) 2019 Facebook
*/
#include <fcntl.h>
#include <gelf.h>
#include <limits.h>
#include <malloc.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <stdarg.h>
#include "libbtf.h"
#include "lib/bpf/include/uapi/linux/btf.h"
#include "lib/bpf/include/linux/err.h"
#include "lib/bpf/src/btf.h"
#include "lib/bpf/src/libbpf.h"
#include "dutil.h"
#include "gobuffer.h"
#include "dwarves.h"
#include "elf_symtab.h"
struct btf *base_btf;
uint8_t btf_elf__verbose;
uint8_t btf_elf__force;
static int btf_var_secinfo_cmp(const void *a, const void *b)
{
const struct btf_var_secinfo *av = a;
const struct btf_var_secinfo *bv = b;
return av->offset - bv->offset;
}
static int libbpf_log(enum libbpf_print_level level, const char *format, va_list args)
{
return vfprintf(stderr, format, args);
}
int btf_elf__load(struct btf_elf *btfe)
{
int err;
libbpf_set_print(libbpf_log);
/* free initial empty BTF */
btf__free(btfe->btf);
if (btfe->raw_btf)
btfe->btf = btf__parse_raw_split(btfe->filename, btfe->base_btf);
else
btfe->btf = btf__parse_elf_split(btfe->filename, btfe->base_btf);
err = libbpf_get_error(btfe->btf);
if (err)
return err;
return 0;
}
struct btf_elf *btf_elf__new(const char *filename, Elf *elf, struct btf *base_btf)
{
struct btf_elf *btfe = zalloc(sizeof(*btfe));
GElf_Shdr shdr;
Elf_Scn *sec;
if (!btfe)
return NULL;
btfe->in_fd = -1;
btfe->filename = strdup(filename);
if (btfe->filename == NULL)
goto errout;
btfe->base_btf = base_btf;
btfe->btf = btf__new_empty_split(base_btf);
if (libbpf_get_error(btfe->btf)) {
fprintf(stderr, "%s: failed to create empty BTF.\n", __func__);
goto errout;
}
if (strstarts(filename, "/sys/kernel/btf/")) {
try_as_raw_btf:
btfe->raw_btf = true;
btfe->wordsize = sizeof(long);
btfe->is_big_endian = BYTE_ORDER == BIG_ENDIAN;
btf__set_endianness(btfe->btf,
btfe->is_big_endian ? BTF_BIG_ENDIAN : BTF_LITTLE_ENDIAN);
return btfe;
}
if (elf != NULL) {
btfe->elf = elf;
} else {
btfe->in_fd = open(filename, O_RDONLY);
if (btfe->in_fd < 0)
goto errout;
if (elf_version(EV_CURRENT) == EV_NONE) {
fprintf(stderr, "%s: cannot set libelf version.\n",
__func__);
goto errout;
}
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(btfe->elf, &btfe->ehdr) == NULL) {
struct btf_header hdr;
if (lseek(btfe->in_fd, 0, SEEK_SET) == 0 &&
read(btfe->in_fd, &hdr, sizeof(hdr)) == sizeof(hdr) &&
hdr.magic == BTF_MAGIC) {
close(btfe->in_fd);
elf_end(btfe->elf);
btfe->in_fd = -1;
goto try_as_raw_btf;
}
if (btf_elf__verbose)
fprintf(stderr, "%s: cannot get elf header.\n", __func__);
goto errout;
}
switch (btfe->ehdr.e_ident[EI_DATA]) {
case ELFDATA2LSB:
btfe->is_big_endian = false;
btf__set_endianness(btfe->btf, BTF_LITTLE_ENDIAN);
break;
case ELFDATA2MSB:
btfe->is_big_endian = true;
btf__set_endianness(btfe->btf, BTF_BIG_ENDIAN);
break;
default:
fprintf(stderr, "%s: unknown elf endianness.\n", __func__);
goto errout;
}
switch (btfe->ehdr.e_ident[EI_CLASS]) {
case ELFCLASS32: btfe->wordsize = 4; break;
case ELFCLASS64: btfe->wordsize = 8; break;
default: btfe->wordsize = 0; break;
}
btfe->symtab = elf_symtab__new(NULL, btfe->elf, &btfe->ehdr);
if (!btfe->symtab) {
if (btf_elf__verbose)
printf("%s: '%s' doesn't have symtab.\n", __func__,
btfe->filename);
return btfe;
}
/* find percpu section's shndx */
sec = elf_section_by_name(btfe->elf, &btfe->ehdr, &shdr, PERCPU_SECTION,
NULL);
if (!sec) {
if (btf_elf__verbose)
printf("%s: '%s' doesn't have '%s' section\n", __func__,
btfe->filename, PERCPU_SECTION);
return btfe;
}
btfe->percpu_shndx = elf_ndxscn(sec);
btfe->percpu_base_addr = shdr.sh_addr;
return btfe;
errout:
btf_elf__delete(btfe);
return NULL;
}
void btf_elf__delete(struct btf_elf *btfe)
{
if (!btfe)
return;
if (btfe->in_fd != -1) {
close(btfe->in_fd);
if (btfe->elf)
elf_end(btfe->elf);
}
elf_symtab__delete(btfe->symtab);
__gobuffer__delete(&btfe->percpu_secinfo);
btf__free(btfe->btf);
free(btfe->filename);
free(btfe);
}
const char *btf_elf__string(struct btf_elf *btfe, uint32_t ref)
{
const char *s = btf__str_by_offset(btfe->btf, ref);
return s && s[0] == '\0' ? NULL : s;
}
#define BITS_PER_BYTE 8
#define BITS_PER_BYTE_MASK (BITS_PER_BYTE - 1)
#define BITS_PER_BYTE_MASKED(bits) ((bits) & BITS_PER_BYTE_MASK)
#define BITS_ROUNDDOWN_BYTES(bits) ((bits) >> 3)
#define BITS_ROUNDUP_BYTES(bits) (BITS_ROUNDDOWN_BYTES(bits) + !!BITS_PER_BYTE_MASKED(bits))
static const char * const btf_kind_str[NR_BTF_KINDS] = {
[BTF_KIND_UNKN] = "UNKNOWN",
[BTF_KIND_INT] = "INT",
[BTF_KIND_PTR] = "PTR",
[BTF_KIND_ARRAY] = "ARRAY",
[BTF_KIND_STRUCT] = "STRUCT",
[BTF_KIND_UNION] = "UNION",
[BTF_KIND_ENUM] = "ENUM",
[BTF_KIND_FWD] = "FWD",
[BTF_KIND_TYPEDEF] = "TYPEDEF",
[BTF_KIND_VOLATILE] = "VOLATILE",
[BTF_KIND_CONST] = "CONST",
[BTF_KIND_RESTRICT] = "RESTRICT",
[BTF_KIND_FUNC] = "FUNC",
[BTF_KIND_FUNC_PROTO] = "FUNC_PROTO",
[BTF_KIND_VAR] = "VAR",
[BTF_KIND_DATASEC] = "DATASEC",
};
static const char *btf_elf__printable_name(const struct btf_elf *btfe, uint32_t offset)
{
if (!offset)
return "(anon)";
else
return btf__str_by_offset(btfe->btf, offset);
}
static const char * btf_elf__int_encoding_str(uint8_t encoding)
{
if (encoding == 0)
return "(none)";
else if (encoding == BTF_INT_SIGNED)
return "SIGNED";
else if (encoding == BTF_INT_CHAR)
return "CHAR";
else if (encoding == BTF_INT_BOOL)
return "BOOL";
else
return "UNKN";
}
__attribute ((format (printf, 5, 6)))
static void btf_elf__log_err(const struct btf_elf *btfe, int kind, const char *name,
bool output_cr, const char *fmt, ...)
{
fprintf(stderr, "[%u] %s %s", btf__get_nr_types(btfe->btf) + 1,
btf_kind_str[kind], name ?: "(anon)");
if (fmt && *fmt) {
va_list ap;
fprintf(stderr, " ");
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
}
if (output_cr)
fprintf(stderr, "\n");
}
__attribute ((format (printf, 5, 6)))
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_elf__verbose && !err)
return;
kind = BTF_INFO_KIND(t->info);
out = err ? stderr : stdout;
fprintf(out, "[%u] %s %s",
btf__get_nr_types(btfe->btf), btf_kind_str[kind],
btf_elf__printable_name(btfe, t->name_off));
if (fmt && *fmt) {
va_list ap;
fprintf(out, " ");
va_start(ap, fmt);
vfprintf(out, fmt, ap);
va_end(ap);
}
if (output_cr)
fprintf(out, "\n");
}
__attribute ((format (printf, 5, 6)))
static void btf_log_member(const struct btf_elf *btfe,
const struct btf_type *t,
const struct btf_member *member,
bool err, const char *fmt, ...)
{
FILE *out;
if (!btf_elf__verbose && !err)
return;
out = err ? stderr : stdout;
if (btf_kflag(t))
fprintf(out, "\t%s type_id=%u bitfield_size=%u bits_offset=%u",
btf_elf__printable_name(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_elf__printable_name(btfe, member->name_off),
member->type,
member->offset);
if (fmt && *fmt) {
va_list ap;
fprintf(out, " ");
va_start(ap, fmt);
vfprintf(out, fmt, ap);
va_end(ap);
}
fprintf(out, "\n");
}
__attribute ((format (printf, 6, 7)))
static void btf_log_func_param(const struct btf_elf *btfe,
const char *name, uint32_t type,
bool err, bool is_last_param,
const char *fmt, ...)
{
FILE *out;
if (!btf_elf__verbose && !err)
return;
out = err ? stderr : stdout;
if (is_last_param && !type)
fprintf(out, "vararg)\n");
else
fprintf(out, "%u %s%s", type, name, is_last_param ? ")\n" : ", ");
if (fmt && *fmt) {
va_list ap;
fprintf(out, " ");
va_start(ap, fmt);
vfprintf(out, fmt, ap);
va_end(ap);
}
}
int32_t btf_elf__add_base_type(struct btf_elf *btfe, const struct base_type *bt,
const char *name)
{
struct btf *btf = btfe->btf;
const struct btf_type *t;
uint8_t encoding = 0;
int32_t id;
if (bt->is_signed) {
encoding = BTF_INT_SIGNED;
} else if (bt->is_bool) {
encoding = BTF_INT_BOOL;
} else if (bt->float_type) {
fprintf(stderr, "float_type is not supported\n");
return -1;
}
id = btf__add_int(btf, name, BITS_ROUNDUP_BYTES(bt->bit_size), encoding);
if (id < 0) {
btf_elf__log_err(btfe, BTF_KIND_INT, name, true, "Error emitting BTF type");
} else {
t = btf__type_by_id(btf, id);
btf_elf__log_type(btfe, t, false, true,
"size=%u nr_bits=%u encoding=%s%s",
t->size, bt->bit_size,
btf_elf__int_encoding_str(encoding),
id < 0 ? " Error in emitting BTF" : "" );
}
return id;
}
int32_t btf_elf__add_ref_type(struct btf_elf *btfe, uint16_t kind, uint32_t type,
const char *name, bool kind_flag)
{
struct btf *btf = btfe->btf;
const struct btf_type *t;
int32_t id;
switch (kind) {
case BTF_KIND_PTR:
id = btf__add_ptr(btf, type);
break;
case BTF_KIND_VOLATILE:
id = btf__add_volatile(btf, type);
break;
case BTF_KIND_CONST:
id = btf__add_const(btf, type);
break;
case BTF_KIND_RESTRICT:
id = btf__add_const(btf, type);
break;
case BTF_KIND_TYPEDEF:
id = btf__add_typedef(btf, name, type);
break;
case BTF_KIND_FWD:
id = btf__add_fwd(btf, name, kind_flag);
break;
case BTF_KIND_FUNC:
id = btf__add_func(btf, name, BTF_FUNC_STATIC, type);
break;
default:
btf_elf__log_err(btfe, kind, name, true, "Unexpected kind for reference");
return -1;
}
if (id > 0) {
t = btf__type_by_id(btf, id);
if (kind == BTF_KIND_FWD)
btf_elf__log_type(btfe, t, false, true, "%s", kind_flag ? "union" : "struct");
else
btf_elf__log_type(btfe, t, false, true, "type_id=%u", t->type);
} else {
btf_elf__log_err(btfe, kind, name, true, "Error emitting BTF type");
}
return id;
}
int32_t btf_elf__add_array(struct btf_elf *btfe, uint32_t type, uint32_t index_type, uint32_t nelems)
{
struct btf *btf = btfe->btf;
const struct btf_type *t;
const struct btf_array *array;
int32_t id;
id = btf__add_array(btf, index_type, type, nelems);
if (id > 0) {
t = btf__type_by_id(btf, id);
array = btf_array(t);
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);
} else {
btf_elf__log_err(btfe, BTF_KIND_ARRAY, NULL, true,
"type_id=%u index_type_id=%u nr_elems=%u Error emitting BTF type",
type, index_type, nelems);
}
return id;
}
int btf_elf__add_member(struct btf_elf *btfe, const char *name, uint32_t type,
uint32_t bitfield_size, uint32_t offset)
{
struct btf *btf = btfe->btf;
const struct btf_type *t;
const struct btf_member *m;
int err;
err = btf__add_field(btf, name, type, offset, bitfield_size);
t = btf__type_by_id(btf, btf__get_nr_types(btf));
if (err) {
fprintf(stderr, "[%u] %s %s's field '%s' offset=%u bit_size=%u type=%u Error emitting field\n",
btf__get_nr_types(btf), btf_kind_str[btf_kind(t)],
btf_elf__printable_name(btfe, t->name_off),
name, offset, bitfield_size, type);
} else {
m = &btf_members(t)[btf_vlen(t) - 1];
btf_log_member(btfe, t, m, false, NULL);
}
return err;
}
int32_t btf_elf__add_struct(struct btf_elf *btfe, uint8_t kind, const char *name, uint32_t size)
{
struct btf *btf = btfe->btf;
const struct btf_type *t;
int32_t id;
switch (kind) {
case BTF_KIND_STRUCT:
id = btf__add_struct(btf, name, size);
break;
case BTF_KIND_UNION:
id = btf__add_union(btf, name, size);
break;
default:
btf_elf__log_err(btfe, kind, name, true, "Unexpected kind of struct");
return -1;
}
if (id < 0) {
btf_elf__log_err(btfe, kind, name, true, "Error emitting BTF type");
} else {
t = btf__type_by_id(btf, id);
btf_elf__log_type(btfe, t, false, true, "size=%u", t->size);
}
return id;
}
int32_t btf_elf__add_enum(struct btf_elf *btfe, const char *name, uint32_t bit_size)
{
struct btf *btf = btfe->btf;
const struct btf_type *t;
int32_t id, size;
size = BITS_ROUNDUP_BYTES(bit_size);
id = btf__add_enum(btf, name, size);
if (id > 0) {
t = btf__type_by_id(btf, id);
btf_elf__log_type(btfe, t, false, true, "size=%u", t->size);
} else {
btf_elf__log_err(btfe, BTF_KIND_ENUM, name, true,
"size=%u Error emitting BTF type", size);
}
return id;
}
int btf_elf__add_enum_val(struct btf_elf *btfe, const char *name, int32_t value)
{
struct btf *btf = btfe->btf;
int err;
err = btf__add_enum_value(btf, name, value);
if (!err) {
if (btf_elf__verbose)
printf("\t%s val=%d\n", name, value);
} else {
fprintf(stderr, "\t%s val=%d Error emitting BTF enum value\n",
name, value);
}
return err;
}
static int32_t btf_elf__add_func_proto_param(struct btf_elf *btfe, const char *name,
uint32_t type, bool is_last_param)
{
int err;
err = btf__add_func_param(btfe->btf, name, type);
if (!err) {
btf_log_func_param(btfe, name, type, false, is_last_param, NULL);
return 0;
} else {
btf_log_func_param(btfe, name, type, true, is_last_param,
"Error adding func param");
return -1;
}
}
extern struct debug_fmt_ops *dwarves__active_loader;
int32_t btf_elf__add_func_proto(struct btf_elf *btfe, struct cu *cu, struct ftype *ftype, uint32_t type_id_off)
{
struct btf *btf = btfe->btf;
const struct btf_type *t;
struct parameter *param;
uint16_t nr_params, param_idx;
int32_t id, type_id;
/* add btf_type for func_proto */
nr_params = ftype->nr_parms + (ftype->unspec_parms ? 1 : 0);
type_id = ftype->tag.type == 0 ? 0 : type_id_off + ftype->tag.type;
id = btf__add_func_proto(btf, type_id);
if (id > 0) {
t = btf__type_by_id(btf, id);
btf_elf__log_type(btfe, t, false, false, "return=%u args=(%s",
t->type, !nr_params ? "void)\n" : "");
} else {
btf_elf__log_err(btfe, BTF_KIND_FUNC_PROTO, NULL, true,
"return=%u vlen=%u Error emitting BTF type",
type_id, nr_params);
return id;
}
/* add parameters */
param_idx = 0;
ftype__for_each_parameter(ftype, param) {
const char *name = dwarves__active_loader->strings__ptr(cu, param->name);
type_id = param->tag.type == 0 ? 0 : type_id_off + param->tag.type;
++param_idx;
if (btf_elf__add_func_proto_param(btfe, name, type_id, param_idx == nr_params))
return -1;
}
++param_idx;
if (ftype->unspec_parms)
if (btf_elf__add_func_proto_param(btfe, NULL, 0, param_idx == nr_params))
return -1;
return id;
}
int32_t btf_elf__add_var_type(struct btf_elf *btfe, uint32_t type, const char *name,
uint32_t linkage)
{
struct btf *btf = btfe->btf;
const struct btf_type *t;
int32_t id;
id = btf__add_var(btf, name, linkage, type);
if (id > 0) {
t = btf__type_by_id(btf, id);
btf_elf__log_type(btfe, t, false, true, "type=%u linkage=%u",
t->type, btf_var(t)->linkage);
} else {
btf_elf__log_err(btfe, BTF_KIND_VAR, name, true,
"type=%u linkage=%u Error emitting BTF type",
type, linkage);
}
return id;
}
int32_t btf_elf__add_var_secinfo(struct gobuffer *buf, uint32_t type,
uint32_t offset, uint32_t size)
{
struct btf_var_secinfo si = {
.type = type,
.offset = offset,
.size = size,
};
return gobuffer__add(buf, &si, sizeof(si));
}
int32_t btf_elf__add_datasec_type(struct btf_elf *btfe, const char *section_name,
struct gobuffer *var_secinfo_buf)
{
struct btf *btf = btfe->btf;
size_t sz = gobuffer__size(var_secinfo_buf);
uint16_t nr_var_secinfo = sz / sizeof(struct btf_var_secinfo);
struct btf_var_secinfo *last_vsi, *vsi;
const struct btf_type *t;
uint32_t datasec_sz;
int32_t err, id, i;
qsort(var_secinfo_buf->entries, nr_var_secinfo,
sizeof(struct btf_var_secinfo), btf_var_secinfo_cmp);
last_vsi = (struct btf_var_secinfo *)var_secinfo_buf->entries + nr_var_secinfo - 1;
datasec_sz = last_vsi->offset + last_vsi->size;
id = btf__add_datasec(btf, section_name, datasec_sz);
if (id < 0) {
btf_elf__log_err(btfe, BTF_KIND_DATASEC, section_name, true,
"size=%u vlen=%u Error emitting BTF type",
datasec_sz, nr_var_secinfo);
} else {
t = btf__type_by_id(btf, id);
btf_elf__log_type(btfe, t, false, true, "size=%u vlen=%u",
t->size, nr_var_secinfo);
}
for (i = 0; i < nr_var_secinfo; i++) {
vsi = (struct btf_var_secinfo *)var_secinfo_buf->entries + i;
err = btf__add_datasec_var_info(btf, vsi->type, vsi->offset, vsi->size);
if (!err) {
if (btf_elf__verbose)
printf("\ttype=%u offset=%u size=%u\n",
vsi->type, vsi->offset, vsi->size);
} else {
fprintf(stderr, "\ttype=%u offset=%u size=%u Error emitting BTF datasec var info\n",
vsi->type, vsi->offset, vsi->size);
return -1;
}
}
return id;
}
static int btf_elf__write(const char *filename, struct btf *btf)
{
GElf_Shdr shdr_mem, *shdr;
GElf_Ehdr ehdr_mem, *ehdr;
Elf_Data *btf_data = NULL;
Elf_Scn *scn = NULL;
Elf *elf = NULL;
const void *raw_btf_data;
uint32_t raw_btf_size;
int fd, err = -1;
size_t strndx;
fd = open(filename, O_RDWR);
if (fd < 0) {
fprintf(stderr, "Cannot open %s\n", filename);
return -1;
}
if (elf_version(EV_CURRENT) == EV_NONE) {
fprintf(stderr, "Cannot set libelf version.\n");
goto out;
}
elf = elf_begin(fd, ELF_C_RDWR, NULL);
if (elf == NULL) {
fprintf(stderr, "Cannot update ELF file.\n");
goto out;
}
elf_flagelf(elf, ELF_C_SET, ELF_F_DIRTY);
ehdr = gelf_getehdr(elf, &ehdr_mem);
if (ehdr == NULL) {
fprintf(stderr, "%s: elf_getehdr failed.\n", __func__);
goto out;
}
switch (ehdr_mem.e_ident[EI_DATA]) {
case ELFDATA2LSB:
btf__set_endianness(btf, BTF_LITTLE_ENDIAN);
break;
case ELFDATA2MSB:
btf__set_endianness(btf, BTF_BIG_ENDIAN);
break;
default:
fprintf(stderr, "%s: unknown elf endianness.\n", __func__);
goto out;
}
/*
* First we look if there was already a .BTF section to overwrite.
*/
elf_getshdrstrndx(elf, &strndx);
while ((scn = elf_nextscn(elf, scn)) != NULL) {
shdr = gelf_getshdr(scn, &shdr_mem);
if (shdr == NULL)
continue;
char *secname = elf_strptr(elf, strndx, shdr->sh_name);
if (strcmp(secname, ".BTF") == 0) {
btf_data = elf_getdata(scn, btf_data);
break;
}
}
raw_btf_data = btf__get_raw_data(btf, &raw_btf_size);
if (btf_data) {
/* Exisiting .BTF section found */
btf_data->d_buf = (void *)raw_btf_data;
btf_data->d_size = raw_btf_size;
elf_flagdata(btf_data, ELF_C_SET, ELF_F_DIRTY);
if (elf_update(elf, ELF_C_NULL) >= 0 &&
elf_update(elf, ELF_C_WRITE) >= 0)
err = 0;
} else {
const char *llvm_objcopy;
char tmp_fn[PATH_MAX];
char cmd[PATH_MAX * 2];
llvm_objcopy = getenv("LLVM_OBJCOPY");
if (!llvm_objcopy)
llvm_objcopy = "llvm-objcopy";
/* Use objcopy to add a .BTF section */
snprintf(tmp_fn, sizeof(tmp_fn), "%s.btf", filename);
close(fd);
fd = creat(tmp_fn, S_IRUSR | S_IWUSR);
if (fd == -1) {
fprintf(stderr, "%s: open(%s) failed!\n", __func__,
tmp_fn);
goto out;
}
if (write(fd, raw_btf_data, raw_btf_size) != raw_btf_size) {
fprintf(stderr, "%s: write of %d bytes to '%s' failed: %d!\n",
__func__, raw_btf_size, tmp_fn, errno);
goto out;
}
snprintf(cmd, sizeof(cmd), "%s --add-section .BTF=%s %s",
llvm_objcopy, tmp_fn, filename);
if (system(cmd)) {
fprintf(stderr, "%s: failed to add .BTF section to '%s': %d!\n",
__func__, tmp_fn, errno);
goto out;
}
err = 0;
unlink(tmp_fn);
}
out:
if (fd != -1)
close(fd);
if (elf)
elf_end(elf);
return err;
}
int btf_elf__encode(struct btf_elf *btfe, uint8_t flags)
{
struct btf *btf = btfe->btf;
/* Empty file, nothing to do, so... done! */
if (btf__get_nr_types(btf) == 0)
return 0;
if (btf__dedup(btf, NULL, NULL)) {
fprintf(stderr, "%s: btf__dedup failed!\n", __func__);
return -1;
}
return btf_elf__write(btfe->filename, btf);
}