bpf

package
v1.6.8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 25, 2020 License: Apache-2.0 Imports: 37 Imported by: 0

Documentation

Overview

Package bpf provides functions that allow golang programs to interact with bpf maps. +groupName=pkg

Index

Constants

View Source 
const (
	// BPF map type constants. Must match enum bpf_map_type from linux/bpf.h
	BPF_MAP_TYPE_UNSPEC              = 0
	BPF_MAP_TYPE_HASH                = 1
	BPF_MAP_TYPE_ARRAY               = 2
	BPF_MAP_TYPE_PROG_ARRAY          = 3
	BPF_MAP_TYPE_PERF_EVENT_ARRAY    = 4
	BPF_MAP_TYPE_PERCPU_HASH         = 5
	BPF_MAP_TYPE_PERCPU_ARRAY        = 6
	BPF_MAP_TYPE_STACK_TRACE         = 7
	BPF_MAP_TYPE_CGROUP_ARRAY        = 8
	BPF_MAP_TYPE_LRU_HASH            = 9
	BPF_MAP_TYPE_LRU_PERCPU_HASH     = 10
	BPF_MAP_TYPE_LPM_TRIE            = 11
	BPF_MAP_TYPE_ARRAY_OF_MAPS       = 12
	BPF_MAP_TYPE_HASH_OF_MAPS        = 13
	BPF_MAP_TYPE_DEVMAP              = 14
	BPF_MAP_TYPE_SOCKMAP             = 15
	BPF_MAP_TYPE_CPUMAP              = 16
	BPF_MAP_TYPE_XSKMAP              = 17
	BPF_MAP_TYPE_SOCKHASH            = 18
	BPF_MAP_TYPE_CGROUP_STORAGE      = 19
	BPF_MAP_TYPE_REUSEPORT_SOCKARRAY = 20

	// BPF syscall command constants. Must match enum bpf_cmd from linux/bpf.h
	BPF_MAP_CREATE          = 0
	BPF_MAP_LOOKUP_ELEM     = 1
	BPF_MAP_UPDATE_ELEM     = 2
	BPF_MAP_DELETE_ELEM     = 3
	BPF_MAP_GET_NEXT_KEY    = 4
	BPF_PROG_LOAD           = 5
	BPF_OBJ_PIN             = 6
	BPF_OBJ_GET             = 7
	BPF_PROG_ATTACH         = 8
	BPF_PROG_DETACH         = 9
	BPF_PROG_TEST_RUN       = 10
	BPF_PROG_GET_NEXT_ID    = 11
	BPF_MAP_GET_NEXT_ID     = 12
	BPF_PROG_GET_FD_BY_ID   = 13
	BPF_MAP_GET_FD_BY_ID    = 14
	BPF_OBJ_GET_INFO_BY_FD  = 15
	BPF_PROG_QUERY          = 16
	BPF_RAW_TRACEPOINT_OPEN = 17
	BPF_BTF_LOAD            = 18
	BPF_BTF_GET_FD_BY_ID    = 19
	BPF_TASK_FD_QUERY       = 20

	// BPF syscall attach types
	BPF_CGROUP_INET_INGRESS     = 0
	BPF_CGROUP_INET_EGRESS      = 1
	BPF_CGROUP_INET_SOCK_CREATE = 2
	BPF_CGROUP_SOCK_OPS         = 3
	BPF_SK_SKB_STREAM_PARSER    = 4
	BPF_SK_SKB_STREAM_VERDICT   = 5
	BPF_CGROUP_DEVICE           = 6
	BPF_SK_MSG_VERDICT          = 7
	BPF_CGROUP_INET4_BIND       = 8
	BPF_CGROUP_INET6_BIND       = 9
	BPF_CGROUP_INET4_CONNECT    = 10
	BPF_CGROUP_INET6_CONNECT    = 11
	BPF_CGROUP_INET4_POST_BIND  = 12
	BPF_CGROUP_INET6_POST_BIND  = 13
	BPF_CGROUP_UDP4_SENDMSG     = 14
	BPF_CGROUP_UDP6_SENDMSG     = 15
	BPF_LIRC_MODE2              = 16
	BPF_FLOW_DISSECTOR          = 17
	BPF_CGROUP_SYSCTL           = 18
	BPF_CGROUP_UDP4_RECVMSG     = 19
	BPF_CGROUP_UDP6_RECVMSG     = 20

	// Flags for BPF_MAP_UPDATE_ELEM. Must match values from linux/bpf.h
	BPF_ANY     = 0
	BPF_NOEXIST = 1
	BPF_EXIST   = 2

	// Flags for BPF_MAP_CREATE. Must match values from linux/bpf.h
	BPF_F_NO_PREALLOC   = 1 << 0
	BPF_F_NO_COMMON_LRU = 1 << 1
	BPF_F_NUMA_NODE     = 1 << 2

	// Flags for BPF_PROG_QUERY
	BPF_F_QUERY_EFFECTVE = 1 << 0

	// Flags for accessing BPF object
	BPF_F_RDONLY = 1 << 3
	BPF_F_WRONLY = 1 << 4

	// Flag for stack_map, store build_id+offset instead of pointer
	BPF_F_STACK_BUILD_ID = 1 << 5
)
View Source 
const (
	EndpointKeyIPv4 uint8 = 1
	EndpointKeyIPv6 uint8 = 2
)

Must be in sync with ENDPOINT_KEY_* in <bpf/lib/common.h>

View Source 
const (
	EventsMapName = "cilium_events"

	PERF_TYPE_HARDWARE   = 0
	PERF_TYPE_SOFTWARE   = 1
	PERF_TYPE_TRACEPOINT = 2
	PERF_TYPE_HW_CACHE   = 3
	PERF_TYPE_RAW        = 4
	PERF_TYPE_BREAKPOINT = 5

	PERF_SAMPLE_IP           = 1 << 0
	PERF_SAMPLE_TID          = 1 << 1
	PERF_SAMPLE_TIME         = 1 << 2
	PERF_SAMPLE_ADDR         = 1 << 3
	PERF_SAMPLE_READ         = 1 << 4
	PERF_SAMPLE_CALLCHAIN    = 1 << 5
	PERF_SAMPLE_ID           = 1 << 6
	PERF_SAMPLE_CPU          = 1 << 7
	PERF_SAMPLE_PERIOD       = 1 << 8
	PERF_SAMPLE_STREAM_ID    = 1 << 9
	PERF_SAMPLE_RAW          = 1 << 10
	PERF_SAMPLE_BRANCH_STACK = 1 << 11
	PERF_SAMPLE_REGS_USER    = 1 << 12
	PERF_SAMPLE_STACK_USER   = 1 << 13
	PERF_SAMPLE_WEIGHT       = 1 << 14
	PERF_SAMPLE_DATA_SRC     = 1 << 15
	PERF_SAMPLE_IDENTIFIER   = 1 << 16
	PERF_SAMPLE_TRANSACTION  = 1 << 17
	PERF_SAMPLE_REGS_INTR    = 1 << 18

	PERF_COUNT_SW_BPF_OUTPUT = 10
)
View Source 
const (
	MAX_POLL_EVENTS = 32
)

Variables

This section is empty.

Functions

func CheckOrMountFS added in v1.5.0 

func CheckOrMountFS(bpfRoot string)

CheckOrMountFS checks or mounts the BPF filesystem and then opens/creates/deletes all maps which have previously been scheduled to be opened/created/deleted.

func ConfigureResourceLimits added in v1.6.0 

func ConfigureResourceLimits() error

ConfigureResourceLimits configures the memory resource limits for the process to allow BPF syscall interactions.

func ConvertKeyValue added in v1.5.0 

func ConvertKeyValue(bKey []byte, bValue []byte, key MapKey, value MapValue) (MapKey, MapValue, error)

ConvertKeyValue converts key and value from bytes to given Golang struct pointers.

func CreateMap 

func CreateMap(mapType int, keySize, valueSize, maxEntries, flags, innerID uint32, path string) (int, error)

CreateMap creates a Map of type mapType, with key size keySize, a value size of valueSize and the maximum amount of entries of maxEntries. mapType should be one of the bpf_map_type in "uapi/linux/bpf.h" When mapType is the type HASH_OF_MAPS an innerID is required to point at a map fd which has the same type/keySize/valueSize/maxEntries as expected map entries. For all other mapTypes innerID is ignored and should be zeroed.

func DeleteElement 

func DeleteElement(fd int, key unsafe.Pointer) error

DeleteElement deletes the map element with the given key.

func DisableMapPreAllocation added in v1.5.0 

func DisableMapPreAllocation()

DisableMapPreAllocation disables BPF map pre-allocation as a default setting. Some map types enforces pre-alloc strategy so this does not take effect in that case. Also note that this does not take effect on existing map although could be recreated later when objCheck() runs.

func EnableMapPreAllocation added in v1.5.0 

func EnableMapPreAllocation()

EnableMapPreAllocation enables BPF map pre-allocation on map types that support it. This does not take effect on existing map although some map types could be recreated later when objCheck() runs.

func Environment added in v1.5.0 

func Environment() []string

Environment returns a list of environment variables which are needed to make BPF programs and tc aware of the actual BPFFS mount path.

func GetFirstKey added in v1.6.0 

func GetFirstKey(fd int, nextKey unsafe.Pointer) error

GetFirstKey fetches the first key in the map.

func GetMapPrefix 

func GetMapPrefix() string

func GetMapRoot 

func GetMapRoot() string

func GetMtime added in v0.9.0 

func GetMtime() (uint64, error)

GetMtime returns monotonic time that can be used to compare values with ktime_get_ns() BPF helper, e.g. needed to check the timeout in sec for BPF entries. We return the raw nsec, although that is not quite usable for comparison. Go has runtime.nanotime() but doesn't expose it as API.

func GetNextKey 

func GetNextKey(fd int, key, nextKey unsafe.Pointer) error

GetNextKey stores, in nextKey, the next key after the key of the map in fd. Deprecated, use GetNextKeyFromPointers

func GetNextKeyFromPointers added in v1.5.1 

func GetNextKeyFromPointers(fd int, structPtr unsafe.Pointer, sizeOfStruct uintptr) error

GetNextKeyFromPointers stores, in nextKey, the next key after the key of the map in fd.

func GetOpenMaps added in v1.5.0 

func GetOpenMaps() []*models.BPFMap

GetOpenMaps returns a slice of all open BPF maps. This is identical to calling GetMap() on all open maps.

func GetPreAllocateMapFlags added in v1.5.0 

func GetPreAllocateMapFlags(t MapType) uint32

GetPreAllocateMapFlags returns the map flags for map which use conditional pre-allocation.

func LocalMapName added in v1.5.0 

func LocalMapName(name string, id uint16) string

LocalMapName returns the name for a BPF map that is local to the specified ID.

func LocalMapPath added in v1.5.0 

func LocalMapPath(name string, id uint16) string

LocalMapPath returns the path for a BPF map that is local to the specified ID.

func LookupElement 

func LookupElement(fd int, key, value unsafe.Pointer) error

LookupElement looks up for the map value stored in fd with the given key. The value is stored in the value unsafe.Pointer. Deprecated, use LookupElementFromPointers

func LookupElementFromPointers added in v1.5.1 

func LookupElementFromPointers(fd int, structPtr unsafe.Pointer, sizeOfStruct uintptr) error

LookupElement looks up for the map value stored in fd with the given key. The value is stored in the value unsafe.Pointer.

func MapFdFromID added in v1.5.0 

func MapFdFromID(id int) (int, error)

MapFdFromID retrieves a file descriptor based on a map ID.

func MapPath 

func MapPath(name string) string

MapPath returns a path for a BPF map with a given name.

func MapPrefixPath 

func MapPrefixPath() string

func ObjClose added in v0.9.0 

func ObjClose(fd int) error

ObjClose closes the map's fd.

func ObjGet 

func ObjGet(pathname string) (int, error)

ObjGet reads the pathname and returns the map's fd read.

func ObjPin 

func ObjPin(fd int, pathname string) error

ObjPin stores the map's fd in pathname.

func OpenOrCreateMap 

func OpenOrCreateMap(path string, mapType int, keySize, valueSize, maxEntries, flags uint32, innerID uint32, pin bool) (int, bool, error)

func ReadFeatureProbes added in v1.5.0 

func ReadFeatureProbes(filename string)

ReadFeatureProbes reads the bpf_features.h file at the specified path (as generated by bpf/run_probes.sh), and stores the results of the kernel feature probing.

func SetMapPrefix 

func SetMapPrefix(path string)

func SetMapRoot 

func SetMapRoot(path string)

func TestDummyProg added in v1.6.0 

func TestDummyProg(progType ProgType, attachType uint32) error

TestDummyProg loads a minimal BPF program into the kernel and probes whether it succeeds in doing so. This can be used to bail out early in the daemon when a given type is not supported.

func UpdateElement 

func UpdateElement(fd int, key, value unsafe.Pointer, flags uint64) error

UpdateElement updates the map in fd with the given value in the given key. The flags can have the following values: bpf.BPF_ANY to create new element or update existing; bpf.BPF_NOEXIST to create new element if it didn't exist; bpf.BPF_EXIST to update existing element. Deprecated, use UpdateElementFromPointers

func UpdateElementFromPointers added in v1.5.1 

func UpdateElementFromPointers(fd int, structPtr unsafe.Pointer, sizeOfStruct uintptr) error

UpdateElementFromPointers updates the map in fd with the given value in the given key. The flags can have the following values: bpf.BPF_ANY to create new element or update existing; bpf.BPF_NOEXIST to create new element if it didn't exist; bpf.BPF_EXIST to update existing element.

Types

type DesiredAction added in v1.5.0 

type DesiredAction int

DesiredAction is the action to be performed on the BPF map 

const (
	// OK indicates that to further action is required and the entry is in
	// sync
	OK DesiredAction = iota

	// Insert indicates that the entry needs to be created or updated
	Insert

	// Delete indicates that the entry needs to be deleted
	Delete
)

func (DesiredAction) String added in v1.5.0 

func (d DesiredAction) String() string

type DumpCallback 

type DumpCallback func(key MapKey, value MapValue)

type DumpParser 

type DumpParser func(key []byte, value []byte, mapKey MapKey, mapValue MapValue) (MapKey, MapValue, error)

type DumpStats added in v1.5.0 

type DumpStats struct {
	// Started is the timestamp when the gc run was started.
	Started time.Time

	// Finished is the timestamp when the gc run completed.
	Finished time.Time

	// Lookup is the number of key lookups performed.
	Lookup uint32

	// LookupFailed is the number of key lookups that failed.
	LookupFailed uint32

	// PrevKeyUnavailable is the number of times the previous key was not
	// available.
	PrevKeyUnavailable uint32

	// KeyFallback is the number of times the current key became invalid
	// while traversing and we had to fall back to the previous key.
	KeyFallback uint32

	// MaxEntries is the maximum number of entries in the gc table.
	MaxEntries uint32

	// Interrupted is the number of times the gc run was interrupted and
	// had to start from scratch.
	Interrupted uint32

	// Completed is true when the gc run has been completed.
	Completed bool
}

DumpStats tracks statistics over the dump of a map.

func NewDumpStats added in v1.5.0 

func NewDumpStats(m *Map) *DumpStats

NewDumpStats returns a new stats structure for collecting dump statistics.

func (*DumpStats) Duration added in v1.5.0 

func (d *DumpStats) Duration() time.Duration

Duration returns the duration of the dump.

type EPoll 

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

func (*EPoll) AddFD 

func (ep *EPoll) AddFD(fd int, events uint32) error

func (*EPoll) Close 

func (ep *EPoll) Close()

func (*EPoll) Poll 

func (ep *EPoll) Poll(timeout int) (int, error)

type EndpointKey added in v1.5.0 

type EndpointKey struct {
	// represents both IPv6 and IPv4 (in the lowest four bytes)
	IP     types.IPv6 `align:"$union0"`
	Family uint8      `align:"family"`
	Key    uint8      `align:"key"`
	Pad2   uint16     `align:"pad5"`
}

EndpointKey represents the key value of the endpoints BPF map

Must be in sync with struct endpoint_key in <bpf/lib/common.h> +k8s:deepcopy-gen=true

func NewEndpointKey added in v1.5.0 

func NewEndpointKey(ip net.IP) EndpointKey

NewEndpointKey returns an EndpointKey based on the provided IP address. The address family is automatically detected.

func (*EndpointKey) DeepCopy added in v1.5.1 

func (in *EndpointKey) DeepCopy() *EndpointKey

DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new EndpointKey.

func (*EndpointKey) DeepCopyInto added in v1.5.1 

func (in *EndpointKey) DeepCopyInto(out *EndpointKey)

DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil.

func (*EndpointKey) GetKeyPtr added in v1.5.0 

func (k *EndpointKey) GetKeyPtr() unsafe.Pointer

GetKeyPtr returns the unsafe pointer to the BPF key

func (*EndpointKey) GetValuePtr added in v1.5.0 

func (k *EndpointKey) GetValuePtr() unsafe.Pointer

GetValuePtr returns the unsafe pointer to the BPF key for users that use EndpointKey as a value in bpf maps

func (EndpointKey) String added in v1.5.0 

func (k EndpointKey) String() string

String provides a string representation of the EndpointKey.

func (EndpointKey) ToIP added in v1.5.0 

func (k EndpointKey) ToIP() net.IP

ToIP converts the EndpointKey into a net.IP structure.

type ErrorFunc added in v1.5.0 

type ErrorFunc func(msg *PerfEvent)

ErrorFunc is run when reading PerfEvent results in an error

type EventMap 

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

func (*EventMap) Close 

func (e *EventMap) Close()

func (*EventMap) Update 

func (e *EventMap) Update(fd int, ubaPtr unsafe.Pointer, sizeOf uintptr) error

type LostFunc 

type LostFunc func(msg *PerfEventLost, cpu int)

type Map 

type Map struct {
	MapInfo

	// NonPersistent is true if the map does not contain persistent data
	// and should be removed on startup.
	NonPersistent bool
	// contains filtered or unexported fields
}

func GetMap added in v1.5.0 

func GetMap(name string) *Map

GetMap returns the registered map with the given name or absolute path

func NewMap 

func NewMap(name string, mapType MapType, mapKey MapKey, keySize int, mapValue MapValue, valueSize, maxEntries int, flags uint32, innerID uint32, dumpParser DumpParser) *Map

NewMap creates a new Map instance - object representing a BPF map

func NewPerCPUHashMap added in v1.6.0 

func NewPerCPUHashMap(name string, mapKey MapKey, keySize int, mapValue MapValue, valueSize, cpus, maxEntries int, flags uint32, innerID uint32, dumpParser DumpParser) *Map

NewPerCPUHashMap creates a new Map type of "per CPU hash" - object representing a BPF map The number of cpus is used to have the size representation of a value when a lookup is made on this map types.

func OpenMap 

func OpenMap(name string) (*Map, error)

OpenMap opens the given bpf map and generates the Map info based in the information stored in the bpf map. *Warning*: Calling this function requires the caller to properly setup the MapInfo.MapKey and MapInfo.MapValues fields as those structures are not stored in the bpf map.

func (*Map) CheckAndUpgrade added in v1.5.0 

func (m *Map) CheckAndUpgrade(desired *MapInfo) bool

CheckAndUpgrade checks the received map's properties (for the map currently loaded into the kernel) against the desired properties, and if they do not match, deletes the map.

Returns true if the map was upgraded.

func (*Map) Close 

func (m *Map) Close() error

func (*Map) DeepEquals added in v1.5.0 

func (m *Map) DeepEquals(other *Map) bool

DeepEquals compares the current map against another map to see that the attributes of the two maps are the same.

func (*Map) Delete 

func (m *Map) Delete(key MapKey) error

func (*Map) DeleteAll 

func (m *Map) DeleteAll() error

DeleteAll deletes all entries of a map by traversing the map and deleting individual entries. Note that if entries are added while the taversal is in progress, such entries may survive the deletion process.

func (*Map) DeleteWithErrno added in v1.5.0 

func (m *Map) DeleteWithErrno(key MapKey) (error, syscall.Errno)

func (*Map) Dump 

func (m *Map) Dump(hash map[string][]string) error

Dump returns the map (type map[string][]string) which contains all data stored in BPF map.

func (*Map) DumpIfExists added in v1.5.0 

func (m *Map) DumpIfExists(hash map[string][]string) error

DumpIfExists dumps the contents of the map into hash via Dump() if the map file exists

func (*Map) DumpReliablyWithCallback added in v1.5.0 

func (m *Map) DumpReliablyWithCallback(cb DumpCallback, stats *DumpStats) error

DumpReliablyWithCallback is similar to DumpWithCallback, but performs additional tracking of the current and recently seen keys, so that if an element is removed from the underlying kernel map during the dump, the dump can continue from a recently seen key rather than restarting from scratch. In addition, it caps the maximum number of map entry iterations by the maximum size of the map.

The caller must provide a callback for handling each entry, and a stats object initialized via a call to NewDumpStats().

func (*Map) DumpWithCallback added in v1.5.0 

func (m *Map) DumpWithCallback(cb DumpCallback) error

DumpWithCallback iterates over the Map and calls the given callback function on each iteration. That callback function is receiving the actual key and value. The callback function should consider creating a deepcopy of the key and value on between each iterations to avoid memory corruption.

func (*Map) DumpWithCallbackIfExists added in v1.5.0 

func (m *Map) DumpWithCallbackIfExists(cb DumpCallback) error

DumpWithCallbackIfExists is similar to DumpWithCallback, but returns earlier if the given map does not exist.

func (*Map) EndParallelMode added in v1.5.0 

func (m *Map) EndParallelMode()

EndParallelMode ends the parallel mode of a map

func (*Map) GetFd 

func (m *Map) GetFd() int

func (*Map) GetModel added in v1.5.0 

func (m *Map) GetModel() *models.BPFMap

GetModel returns a BPF map in the representation served via the API

func (*Map) GetNextKey added in v0.9.0 

func (m *Map) GetNextKey(key MapKey, nextKey MapKey) error

GetNextKey returns the next key in the Map after key.

func (*Map) Lookup 

func (m *Map) Lookup(key MapKey) (MapValue, error)

func (*Map) Name added in v1.5.0 

func (m *Map) Name() string

Name returns the basename of this map.

func (*Map) Open 

func (m *Map) Open() error

func (*Map) OpenOrCreate 

func (m *Map) OpenOrCreate() (bool, error)

OpenOrCreate attempts to open the Map, or if it does not yet exist, create the Map. If the existing map's attributes such as map type, key/value size, capacity, etc. do not match the Map's attributes, then the map will be deleted and reopened without any attempt to retain its previous contents. If the map is marked as non-persistent, it will always be recreated.

If the map type is MapTypeLRUHash or MapTypeLPMTrie and the kernel lacks support for this map type, then the map will be opened as MapTypeHash instead. Note that the BPF code that interacts with this map *MUST* be structured in such a way that the map is declared as the same type based on the same probe logic (eg HAVE_LRU_MAP_TYPE, HAVE_LPM_MAP_TYPE).

For code that uses an LPMTrie, the BPF code must also use macros to retain the "longest prefix match" behaviour on top of the hash maps, for example via LPM_LOOKUP_FN() (see bpf/lib/maps.h).

To detect map type support properly, this function must be called after a call to ReadFeatureProbes(); failure to do so will result in LPM or LRU map types being unconditionally opened as hash maps.

Returns whether the map was deleted and recreated, or an optional error.

func (*Map) OpenOrCreateUnpinned added in v1.6.4 

func (m *Map) OpenOrCreateUnpinned() (bool, error)

OpenOrCreateUnpinned is similar to OpenOrCreate (see above) but without pinning the map to the file system if it had to be created.

func (*Map) OpenParallel added in v1.5.0 

func (m *Map) OpenParallel() (bool, error)

OpenParallel is similar to OpenOrCreate() but prepares the existing map to be faded out while a new map is taking over. This can be used if a map is shared between multiple consumers and the context of the shared map is changing. Any update to the shared map would impact all consumers and consumers can only be updated one by one. Parallel mode allows for consumers to continue using the old version of the map until the consumer is updated to use the new version.

func (*Map) Path added in v1.5.0 

func (m *Map) Path() (string, error)

Path returns the path to this map on the filesystem.

func (*Map) Reopen added in v1.5.0 

func (m *Map) Reopen() error

Reopen attempts to close and re-open the received map.

func (*Map) Unpin added in v1.5.0 

func (m *Map) Unpin() error

Unpin attempts to unpin (remove) the map from the filesystem.

func (*Map) UnpinIfExists added in v1.5.0 

func (m *Map) UnpinIfExists() error

UnpinIfExists tries to unpin (remove) the map only if it exists.

func (*Map) Update 

func (m *Map) Update(key MapKey, value MapValue) error

func (*Map) WithCache added in v1.5.0 

func (m *Map) WithCache() *Map

WithCache enables use of a cache. This will store all entries inserted from user space in a local cache (map) and will indicate the status of each individual entry.

func (*Map) WithNonPersistent added in v0.10.0 

func (m *Map) WithNonPersistent() *Map

WithNonPersistent turns the map non-persistent and returns the map

type MapInfo 

type MapInfo struct {
	MapType  MapType
	MapKey   MapKey
	KeySize  uint32
	MapValue MapValue
	// ReadValueSize is the value size that is used to read from the BPF maps
	// this value an the ValueSize values can be different for BPF_MAP_TYPE_PERCPU_HASH
	// for example.
	ReadValueSize uint32
	ValueSize     uint32
	MaxEntries    uint32
	Flags         uint32
	InnerID       uint32
	OwnerProgType ProgType
}

func GetMapInfo 

func GetMapInfo(pid int, fd int) (*MapInfo, error)

type MapKey 

type MapKey interface {
	fmt.Stringer

	// Returns pointer to start of key
	GetKeyPtr() unsafe.Pointer

	// Allocates a new value matching the key type
	NewValue() MapValue

	// DeepCopyMapKey returns a deep copy of the map key
	DeepCopyMapKey() MapKey
}

type MapType 

type MapType int

MapType is an enumeration for valid BPF map types 

const (
	MapTypeUnspec MapType = iota
	MapTypeHash
	MapTypeArray
	MapTypeProgArray
	MapTypePerfEventArray
	MapTypePerCPUHash
	MapTypePerCPUArray
	MapTypeStackTrace
	MapTypeCgroupArray
	MapTypeLRUHash
	MapTypeLRUPerCPUHash
	MapTypeLPMTrie
	MapTypeArrayOfMaps
	MapTypeHashOfMaps
	MapTypeDevMap
	MapTypeSockMap
	MapTypeCPUMap
	MapTypeXSKMap
	MapTypeSockHash
	// MapTypeMaximum is the maximum supported known map type.
	MapTypeMaximum
)

This enumeration must be in sync with enum bpf_prog_type in <linux/bpf.h>

func GetMapType added in v1.5.0 

func GetMapType(t MapType) MapType

GetMapType determines whether the specified map type is supported by the kernel (as determined by ReadFeatureProbes()), and if the map type is not supported, returns a more primitive map type that may be used to implement the map on older implementations. Otherwise, returns the specified map type.

func (MapType) String 

func (t MapType) String() string

type MapValidator added in v1.5.0 

type MapValidator func(path string) (bool, error)

type MapValue 

type MapValue interface {
	fmt.Stringer

	// Returns pointer to start of value
	GetValuePtr() unsafe.Pointer

	// DeepCopyMapValue returns a deep copy of the map value
	DeepCopyMapValue() MapValue
}

type PerCpuEvents 

type PerCpuEvents struct {
	Cpus     int
	Npages   int
	Pagesize int
	// contains filtered or unexported fields
}

func NewPerCpuEvents 

func NewPerCpuEvents(config *PerfEventConfig) (*PerCpuEvents, error)

func (*PerCpuEvents) CloseAll 

func (e *PerCpuEvents) CloseAll() error

func (*PerCpuEvents) Mute added in v1.6.4 

func (e *PerCpuEvents) Mute()

Mute removes the perf event fd(s) from the perf event BPF map. This has the effect that no new events are pushed into the ring buffer.

func (*PerCpuEvents) Poll 

func (e *PerCpuEvents) Poll(timeout int) (int, error)

func (*PerCpuEvents) ReadAll 

func (e *PerCpuEvents) ReadAll(receive ReceiveFunc, lost LostFunc, handleError ErrorFunc) error

ReadAll reads perf events

func (*PerCpuEvents) Stats 

func (e *PerCpuEvents) Stats() (uint64, uint64, uint64)

func (*PerCpuEvents) Unmute added in v1.6.4 

func (e *PerCpuEvents) Unmute() error

Unmute adds the perf event fd(s) to the perf event BPF map. This has the effect that events can now be pushed into the ring buffer.

type PerfEvent 

type PerfEvent struct {
	Fd int
	// contains filtered or unexported fields
}

func PerfEventFromMemory added in v1.5.0 

func PerfEventFromMemory(page *PerfEventMmapPage, buf []byte) *PerfEvent

PerfEventFromMemory creates an in-memory PerfEvent object for testing and analysis purposes. No kernel interaction is made.

The caller MUST eventually call Disable() to free event resources.

func PerfEventOpen 

func PerfEventOpen(config *PerfEventConfig, pid int, cpu int, groupFD int, flags int) (*PerfEvent, error)

func (*PerfEvent) Close 

func (e *PerfEvent) Close()

func (*PerfEvent) Debug added in v1.5.0 

func (e *PerfEvent) Debug() string

Debug returns string with internal information about PerfEvent

func (*PerfEvent) DebugDump added in v1.5.0 

func (e *PerfEvent) DebugDump() string

func (*PerfEvent) Disable 

func (e *PerfEvent) Disable() error

func (*PerfEvent) Enable 

func (e *PerfEvent) Enable() error

func (*PerfEvent) Mmap 

func (e *PerfEvent) Mmap(pagesize int, npages int) error

func (*PerfEvent) Munmap added in v1.5.0 

func (e *PerfEvent) Munmap() error

func (*PerfEvent) Read 

func (e *PerfEvent) Read(receive ReceiveFunc, lostFn LostFunc, err ErrorFunc)

Read attempts to read all events from the perf event buffer, calling one of the receive / lost functions for each event. receiveFn is called when the event is a valid sample; lostFn is called when the kernel has attempted to write an event into the ringbuffer but ran out of space for the event.

If all events are not read within a time period (default 20s), it will call errFn() and stop reading events.

type PerfEventConfig 

type PerfEventConfig struct {
	NumCpus      int
	NumPages     int
	MapName      string
	Type         int
	Config       int
	SampleType   int
	WakeupEvents int
}

func DefaultPerfEventConfig 

func DefaultPerfEventConfig() *PerfEventConfig

type PerfEventHeader 

type PerfEventHeader struct {
	Type      uint32
	Misc      uint16
	TotalSize uint16
}

PerfEventHeader must match 'struct perf_event_header in <linux/perf_event.h>.

type PerfEventLost 

type PerfEventLost struct {
	PerfEventHeader
	Id   uint64
	Lost uint64
}

PerfEventLost must match 'struct perf_event_lost in kernel sources.

type PerfEventMmapPage added in v1.5.0 

type PerfEventMmapPage struct {
	Version       uint32 // version number of this structure
	CompatVersion uint32 // lowest version this is compat with

	Lock        uint32 // seqlock for synchronization
	Index       uint32 // hardware event identifier
	Offset      int64  // add to hardware event value
	TimeEnabled uint64 // time event active
	TimeRunning uint64 // time event on cpu
	//union {
	Capabilities uint64

	//		cap_user_rdpmc		: 1, /* The RDPMC instruction can be used to read counts */
	//		cap_user_time		: 1, /* The time_* fields are used */
	//		cap_user_time_zero	: 1, /* The time_zero field is used */
	//		cap_____res		: 59;
	//};
	//};
	PmcWidth uint16

	TimeShift  uint16
	TimeMult   uint32
	TimeOffset uint64
	TimeZero   uint64
	Size       uint32

	Reserved [118*8 + 4]uint8 // align to 1k.

	DataHead   uint64 // head in the data section
	DataTail   uint64 // user-space written tail
	DataOffset uint64 // where the buffer starts
	DataSize   uint64 // data buffer size

	AuxHead   uint64
	AuxTail   uint64
	AuxOffset uint64
	AuxSize   uint64
}

PerfEventMmapPage reflects the Linux 'struct perf_event_mmap_page'

func (*PerfEventMmapPage) Decode added in v1.5.0 

func (p *PerfEventMmapPage) Decode(reader io.ReadSeeker) error

Decode populates 'p' base on the bytes read from the specified reader.

This function should not be used from performance-sensitive code.

type PerfEventSample 

type PerfEventSample struct {
	PerfEventHeader
	Size uint32
	// contains filtered or unexported fields
}

PerfEventSample must match 'struct perf_event_sample in kernel sources.

func (*PerfEventSample) DataCopy 

func (e *PerfEventSample) DataCopy() []byte

func (*PerfEventSample) DataDirect 

func (e *PerfEventSample) DataDirect() []byte

type ProgType added in v0.10.0 

type ProgType int

ProgType is an enumeration for valid BPF program types 

const (
	ProgTypeUnspec ProgType = iota
	ProgTypeSocketFilter
	ProgTypeKprobe
	ProgTypeSchedCls
	ProgTypeSchedAct
	ProgTypeTracepoint
	ProgTypeXdp
	ProgTypePerfEvent
	ProgTypeCgroupSkb
	ProgTypeCgroupSock
	ProgTypeLwtIn
	ProgTypeLwtOut
	ProgTypeLwtXmit
	ProgTypeSockOps
	ProgTypeSkSkb
	ProgTypeCgroupDevice
	ProgTypeSkMsg
	ProgTypeRawTracepoint
	ProgTypeCgroupSockAddr
	ProgTypeLwtSeg6Local
	ProgTypeLircMode2
	ProgTypeSkReusePort
)

This enumeration must be in sync with enum bpf_prog_type in <linux/bpf.h>

func (ProgType) String added in v0.10.0 

func (t ProgType) String() string

type ReadState added in v1.5.0 

type ReadState struct {
	Base     uint64 // Actually a pointer
	RawSize  uint64
	LastSize uint64
}

ReadState is a golang reflection of C.struct_read_state{}

func (*ReadState) Decode added in v1.5.0 

func (r *ReadState) Decode(reader io.ReadSeeker) error

Decode populates 'r' based on the bytes read from the specified reader.

This function should not be used from performance-sensitive code.

type ReceiveFunc 

type ReceiveFunc func(msg *PerfEventSample, cpu int)

Source Files

View all Source files

Directories

Path Synopsis
Package binary is a fork of the upstream golang library.
 Package binary is a fork of the upstream golang library.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.