btf

type Array ¶

type Array struct {
	TypeID
	Type   Type
	Nelems uint32
}

Array is an array with a fixed number of elements.

type Const ¶

type Const struct {
	TypeID
	Type Type
}

Const is a qualifier.

type Datasec ¶

type Datasec struct {
	TypeID
	Name
	Size uint32
	Vars []VarSecinfo
}

Datasec is a global program section containing data.

type Enum ¶

type Enum struct {
	TypeID
	Name
	Values []EnumValue
}

Enum lists possible values.

type EnumValue ¶

type EnumValue struct {
	Name
	Value int32
}

EnumValue is part of an Enum

Is is not a valid Type

type Func ¶

type Func struct {
	TypeID
	Name
	Type Type
}

Func is a function definition.

type FuncParam ¶

type FuncParam struct {
	Name
	Type Type
}

type FuncProto ¶

type FuncProto struct {
	TypeID
	Return Type
	Params []FuncParam
}

FuncProto is a function declaration.

type Fwd ¶

type Fwd struct {
	TypeID
	Name
}

Fwd is a forward declaration of a Type.

type Handle ¶

type Handle struct {
	// contains filtered or unexported fields
}

Handle is a reference to BTF loaded into the kernel.

func NewHandle(spec *Spec) (*Handle, error)

func (h *Handle) Close() error

func (h *Handle) FD() int

type Int ¶

type Int struct {
	TypeID
	Name

	// The size of the integer in bytes.
	Size     uint32
	Encoding IntEncoding
	// Offset is the starting bit offset. Currently always 0.
	// See https://www.kernel.org/doc/html/latest/bpf/btf.html#btf-kind-int
	Offset uint32
	Bits   byte
}

Int is an integer of a given length.

type IntEncoding ¶

type IntEncoding byte

const (
	Signed IntEncoding = 1 << iota
	Char
	Bool
)

type Map ¶

type Map struct {
	// contains filtered or unexported fields
}

Map is the BTF for a map.

type Member ¶

type Member struct {
	Name
	Type Type
	// Offset is the bit offset of this member
	Offset       uint32
	BitfieldSize uint32
}

Member is part of a Struct or Union.

It is not a valid Type.

type Name ¶

type Name string

Name identifies a type.

Anonymous types have an empty name.

type Pointer ¶

type Pointer struct {
	TypeID
	Target Type
}

Pointer is a pointer to another type.

type Program ¶

type Program struct {
	// contains filtered or unexported fields
}

Program is the BTF information for a stream of instructions.

type Restrict ¶

type Restrict struct {
	TypeID
	Type Type
}

Restrict is a qualifier.

type Spec ¶

type Spec struct {
	// contains filtered or unexported fields
}

Spec represents decoded BTF.

func LoadKernelSpec() (*Spec, error)

func LoadSpecFromReader(rd io.ReaderAt) (*Spec, error)

func MapSpec(m *Map) *Spec

func ProgramSpec(s *Program) *Spec

func (s *Spec) Datasec(name string) (*Map, error)

func (s *Spec) FindType(name string, typ Type) error

// Acquire a Spec via one of its constructors.
spec := new(Spec)

// Declare a variable of the desired type
var foo Struct

if err := spec.FindType("foo", &foo); err != nil {
	// There is no struct with name foo, or there
	// are multiple possibilities.
}

// We've found struct foo
fmt.Println(foo.Name)

func (s *Spec) Map(name string) (*Map, []Member, error)

func (s *Spec) Program(name string, length uint64) (*Program, error)

type Struct ¶

type Struct struct {
	TypeID
	Name
	// The size of the struct including padding, in bytes
	Size    uint32
	Members []Member
}

Struct is a compound type of consecutive members.

type Type ¶

type Type interface {
	ID() TypeID
	// contains filtered or unexported methods
}

Type represents a type described by BTF.

var t Type
t = &Void{}
t = &Int{}
t = &Pointer{}
t = &Array{}
t = &Struct{}
t = &Union{}
t = &Enum{}
t = &Fwd{}
t = &Typedef{}
t = &Volatile{}
t = &Const{}
t = &Restrict{}
t = &Func{}
t = &FuncProto{}
t = &Var{}
t = &Datasec{}
_ = t

func MapKey(m *Map) Type

func MapValue(m *Map) Type

type TypeID ¶

type TypeID uint32

TypeID identifies a type in a BTF section.

func (tid TypeID) ID() TypeID

type Typedef ¶

type Typedef struct {
	TypeID
	Name
	Type Type
}

Typedef is an alias of a Type.

type Union ¶

type Union struct {
	TypeID
	Name
	// The size of the union including padding, in bytes.
	Size    uint32
	Members []Member
}

Union is a compound type where members occupy the same memory.

type Var ¶

type Var struct {
	TypeID
	Name
	Type Type
}

Var is a global variable.

type VarSecinfo ¶

type VarSecinfo struct {
	Type   Type
	Offset uint32
	Size   uint32
}

VarSecinfo describes variable in a Datasec

type Void ¶

type Void struct{}

Void is the unit type of BTF.

func (v *Void) ID() TypeID

type Volatile ¶

type Volatile struct {
	TypeID
	Type Type
}

Volatile is a qualifier.