#!/usr/bin/env python3
# Ad-hoc script to print BTF file in a readable format.
# Follows the same printing conventions as bpftool with format 'raw'.
# Usage:
#
# ./print_btf.py <btf_file>
#
# Parameters:
#
# <btf_file> :: a file name or '-' to read from stdin.
#
# Intended usage:
#
# llvm-objcopy --dump-section .BTF=- <input> | ./print_btf.py -
#
# Kernel documentation contains detailed format description:
# https://www.kernel.org/doc/html/latest/bpf/btf.html
import struct
import ctypes
import sys
class SafeDict(dict):
def __getitem__(self, key):
try:
return dict.__getitem__(self, key)
except KeyError:
return f"<BAD_KEY: {key}>"
KINDS = SafeDict(
{
0: "UNKN",
1: "INT",
2: "PTR",
3: "ARRAY",
4: "STRUCT",
5: "UNION",
6: "ENUM",
7: "FWD",
8: "TYPEDEF",
9: "VOLATILE",
10: "CONST",
11: "RESTRICT",
12: "FUNC",
13: "FUNC_PROTO",
14: "VAR",
15: "DATASEC",
16: "FLOAT",
17: "DECL_TAG",
18: "TYPE_TAG",
19: "ENUM64",
}
)
INT_ENCODING = SafeDict(
{0 << 0: "(none)", 1 << 0: "SIGNED", 1 << 1: "CHAR", 1 << 2: "BOOL"}
)
ENUM_ENCODING = SafeDict({0: "UNSIGNED", 1: "SIGNED"})
FUNC_LINKAGE = SafeDict({0: "static", 1: "global", 2: "extern"})
VAR_LINKAGE = SafeDict({0: "static", 1: "global", 2: "extern"})
FWD_KIND = SafeDict(
{
0: "struct",
1: "union",
}
)
for val, name in KINDS.items():
globals()["BTF_KIND_" + name] = val
def warn(message):
print(message, file=sys.stderr)
def print_btf(filename):
if filename == "-":
buf = sys.stdin.buffer.read()
else:
with open(filename, "rb") as file:
buf = file.read()
fmt_cache = {}
endian_pfx = ">" # big endian
off = 0
def unpack(fmt):
nonlocal off, endian_pfx
fmt = endian_pfx + fmt
if fmt not in fmt_cache:
fmt_cache[fmt] = struct.Struct(fmt)
st = fmt_cache[fmt]
r = st.unpack_from(buf, off)
off += st.size
return r
# Use magic number at the header start to determine endianness
(magic,) = unpack("H")
if magic == 0xEB9F:
endian_pfx = ">" # big endian
elif magic == 0x9FEB:
endian_pfx = "<" # little endian
else:
warn(f"Unexpected BTF magic: {magic:02x}")
return
# Rest of the header
version, flags, hdr_len = unpack("BBI")
type_off, type_len, str_off, str_len = unpack("IIII")
# Offsets in the header are relative to the end of a header
type_off += hdr_len
str_off += hdr_len
off = hdr_len
type_end = type_off + type_len
def string(rel_off):
try:
start = str_off + rel_off
end = buf.index(b"\0", start)
if start == end:
return "(anon)"
return buf[start:end].decode("utf8")
except ValueError as e:
warn(f"Can't get string at offset {str_off} + {rel_off}: {e}")
return f"<BAD_STRING {rel_off}>"
idx = 1
while off < type_end:
name_off, info, size = unpack("III")
kind = (info >> 24) & 0x1F
vlen = info & 0xFFFF
kflag = info >> 31
kind_name = KINDS[kind]
name = string(name_off)
def warn_nonzero(val, name):
nonlocal idx
if val != 0:
warn(f"<{idx}> {name} should be 0 but is {val}")
if kind == BTF_KIND_INT:
(info,) = unpack("I")
encoding = (info & 0x0F000000) >> 24
offset = (info & 0x00FF0000) >> 16
bits = info & 0x000000FF
enc_name = INT_ENCODING[encoding]
print(
f"[{idx}] {kind_name} '{name}' size={size} "
f"bits_offset={offset} "
f"nr_bits={bits} encoding={enc_name}"
)
warn_nonzero(kflag, "kflag")
warn_nonzero(vlen, "vlen")
elif kind in [
BTF_KIND_PTR,
BTF_KIND_CONST,
BTF_KIND_VOLATILE,
BTF_KIND_RESTRICT,
]:
print(f"[{idx}] {kind_name} '{name}' type_id={size}")
warn_nonzero(name_off, "name_off")
warn_nonzero(kflag, "kflag")
warn_nonzero(vlen, "vlen")
elif kind == BTF_KIND_ARRAY:
warn_nonzero(name_off, "name_off")
warn_nonzero(kflag, "kflag")
warn_nonzero(vlen, "vlen")
warn_nonzero(size, "size")
type, index_type, nelems = unpack("III")
print(
f"[{idx}] {kind_name} '{name}' type_id={type} "
f"index_type_id={index_type} nr_elems={nelems}"
)
elif kind in [BTF_KIND_STRUCT, BTF_KIND_UNION]:
print(f"[{idx}] {kind_name} '{name}' size={size} vlen={vlen}")
if kflag not in [0, 1]:
warn(f"<{idx}> kflag should 0 or 1: {kflag}")
for _ in range(0, vlen):
name_off, type, offset = unpack("III")
if kflag == 0:
print(
f"\t'{string(name_off)}' type_id={type} "
f"bits_offset={offset}"
)
else:
bits_offset = offset & 0xFFFFFF
bitfield_size = offset >> 24
print(
f"\t'{string(name_off)}' type_id={type} "
f"bits_offset={bits_offset} "
f"bitfield_size={bitfield_size}"
)
elif kind == BTF_KIND_ENUM:
encoding = ENUM_ENCODING[kflag]
print(
f"[{idx}] {kind_name} '{name}' encoding={encoding} "
f"size={size} vlen={vlen}"
)
for _ in range(0, vlen):
(name_off,) = unpack("I")
(val,) = unpack("i" if kflag == 1 else "I")
print(f"\t'{string(name_off)}' val={val}")
elif kind == BTF_KIND_ENUM64:
encoding = ENUM_ENCODING[kflag]
print(
f"[{idx}] {kind_name} '{name}' encoding={encoding} "
f"size={size} vlen={vlen}"
)
for _ in range(0, vlen):
name_off, lo, hi = unpack("III")
val = hi << 32 | lo
if kflag == 1:
val = ctypes.c_long(val).value
print(f"\t'{string(name_off)}' val={val}LL")
elif kind == BTF_KIND_FWD:
print(f"[{idx}] {kind_name} '{name}' fwd_kind={FWD_KIND[kflag]}")
warn_nonzero(vlen, "vlen")
warn_nonzero(size, "size")
elif kind in [BTF_KIND_TYPEDEF, BTF_KIND_TYPE_TAG]:
print(f"[{idx}] {kind_name} '{name}' type_id={size}")
warn_nonzero(kflag, "kflag")
warn_nonzero(kflag, "vlen")
elif kind == BTF_KIND_FUNC:
linkage = FUNC_LINKAGE[vlen]
print(f"[{idx}] {kind_name} '{name}' type_id={size} " f"linkage={linkage}")
warn_nonzero(kflag, "kflag")
elif kind == BTF_KIND_FUNC_PROTO:
print(f"[{idx}] {kind_name} '{name}' ret_type_id={size} " f"vlen={vlen}")
warn_nonzero(name_off, "name_off")
warn_nonzero(kflag, "kflag")
for _ in range(0, vlen):
name_off, type = unpack("II")
print(f"\t'{string(name_off)}' type_id={type}")
elif kind == BTF_KIND_VAR:
(linkage,) = unpack("I")
linkage = VAR_LINKAGE[linkage]
print(f"[{idx}] {kind_name} '{name}' type_id={size}, " f"linkage={linkage}")
warn_nonzero(kflag, "kflag")
warn_nonzero(vlen, "vlen")
elif kind == BTF_KIND_DATASEC:
print(f"[{idx}] {kind_name} '{name}' size={size} vlen={vlen}")
warn_nonzero(kflag, "kflag")
warn_nonzero(size, "size")
for _ in range(0, vlen):
type, offset, size = unpack("III")
print(f"\ttype_id={type} offset={offset} size={size}")
elif kind == BTF_KIND_FLOAT:
print(f"[{idx}] {kind_name} '{name}' size={size}")
warn_nonzero(kflag, "kflag")
warn_nonzero(vlen, "vlen")
elif kind == BTF_KIND_DECL_TAG:
(component_idx,) = unpack("i")
print(
f"[{idx}] {kind_name} '{name}' type_id={size} "
+ f"component_idx={component_idx}"
)
warn_nonzero(kflag, "kflag")
warn_nonzero(vlen, "vlen")
else:
warn(
f"<{idx}> Unexpected entry: kind={kind_name} "
f"name_off={name_off} "
f"vlen={vlen} kflag={kflag} size={size}"
)
idx += 1
if __name__ == "__main__":
if len(sys.argv) != 2:
warn(f"Usage: {sys.argv[0]} <btf_file>")
sys.exit(1)
print_btf(sys.argv[1])
Codebase Browser
llvm