symtab

Documentation

Index

• type ElfCache
  • func NewElfCache(buildIDCacheOptions GCacheOptions, sameFileCacheOptions GCacheOptions) (*ElfCache, error)
  • func (e *ElfCache) CacheByBuildID(buildID elf.BuildID, v SymbolNameResolver)
  • func (e *ElfCache) CacheByStat(s Stat, v SymbolNameResolver)
  • func (e *ElfCache) Cleanup()
  • func (e *ElfCache) DebugInfo() ElfCacheDebugInfo
  • func (e *ElfCache) GetSymbolsByBuildID(buildID elf.BuildID) SymbolNameResolver
  • func (e *ElfCache) GetSymbolsByStat(s Stat) SymbolNameResolver
  • func (e *ElfCache) NextRound()
  • func (e *ElfCache) Update(buildIDCacheOptions GCacheOptions, sameFileCacheOptions GCacheOptions)
• type ElfCacheDebugInfo
• type ElfDebugInfo
• type ElfTable
  • func NewElfTable(logger log.Logger, procMap *ProcMap, fs string, elfFilePath string, ...) *ElfTable
  • func (et *ElfTable) Cleanup()
  • func (et *ElfTable) DebugInfo() elf2.SymTabDebugInfo
  • func (et *ElfTable) Resolve(pc uint64) string
• type ElfTableOptions
• type GCache
  • func NewGCache[K comparable, V Resource](options GCacheOptions) (*GCache[K, V], error)
  • func (g *GCache[K, V]) Cache(k K, v V)
  • func (g *GCache[K, V]) Cleanup()
  • func (g *GCache[K, V]) Each(f func(k K, v V))
  • func (g *GCache[K, V]) EachLRU(f func(k K, v V))
  • func (g *GCache[K, V]) EachRound(f func(k K, v V))
  • func (g *GCache[K, V]) Get(k K) V
  • func (g *GCache[K, V]) LRUSize() int
  • func (g *GCache[K, V]) NextRound()
  • func (g *GCache[K, V]) Remove(k K)
  • func (g *GCache[K, V]) RoundSize() int
  • func (g *GCache[K, V]) Update(options GCacheOptions)
• type GCacheDebugInfo
  • func DebugInfo[K comparable, V Resource, D any](g *GCache[K, V], ff func(K, V) D) GCacheDebugInfo[D]
• type GCacheOptions
• type Metrics
  • func NewMetrics(reg prometheus.Registerer) *Metrics
• type ProcMap
• type ProcMapPermissions
• type ProcTable
  • func NewProcTable(logger log.Logger, options ProcTableOptions) *ProcTable
  • func (p *ProcTable) Cleanup()
  • func (p *ProcTable) DebugInfo() ProcTableDebugInfo
  • func (p *ProcTable) Refresh()
  • func (p *ProcTable) Resolve(pc uint64) Symbol
• type ProcTableDebugInfo
• type ProcTableOptions
• type Resource
• type Stat
• type Sym
• type SymTab
  • func NewSymTab(symbols []Sym) *SymTab
  • func (t *SymTab) Length() int
  • func (t *SymTab) Rebase(base uint64)
  • func (t *SymTab) Resolve(addr uint64) *Sym
• type Symbol
• type SymbolNameResolver
• type SymbolTab
  • func NewKallsyms(kallsyms []byte) (*SymbolTab, error)
  • func NewSymbolTab(symbols []Symbol) *SymbolTab
  • func (t *SymbolTab) Cleanup()
  • func (t *SymbolTab) DebugString() string
  • func (t *SymbolTab) Rebase(base uint64)
  • func (t *SymbolTab) Refresh()
  • func (t *SymbolTab) Resolve(addr uint64) Symbol
• type SymbolTable

Types

type ElfCache

type ElfCache struct {
	BuildIDCache  *GCache[elf.BuildID, SymbolNameResolver]
	SameFileCache *GCache[Stat, SymbolNameResolver]
}

func NewElfCache

func NewElfCache(buildIDCacheOptions GCacheOptions, sameFileCacheOptions GCacheOptions) (*ElfCache, error)

func (*ElfCache) CacheByBuildID

func (e *ElfCache) CacheByBuildID(buildID elf.BuildID, v SymbolNameResolver)

func (*ElfCache) CacheByStat

func (e *ElfCache) CacheByStat(s Stat, v SymbolNameResolver)

func (*ElfCache) Cleanup

func (e *ElfCache) Cleanup()

func (*ElfCache) DebugInfo

func (e *ElfCache) DebugInfo() ElfCacheDebugInfo

func (*ElfCache) GetSymbolsByBuildID

func (e *ElfCache) GetSymbolsByBuildID(buildID elf.BuildID) SymbolNameResolver

func (*ElfCache) GetSymbolsByStat

func (e *ElfCache) GetSymbolsByStat(s Stat) SymbolNameResolver

func (*ElfCache) NextRound

func (e *ElfCache) NextRound()

func (*ElfCache) Update

func (e *ElfCache) Update(buildIDCacheOptions GCacheOptions, sameFileCacheOptions GCacheOptions)

type ElfCacheDebugInfo

type ElfCacheDebugInfo struct {
	BuildIDCache  GCacheDebugInfo[elf.SymTabDebugInfo] `river:"build_id_cache,attr,optional"`
	SameFileCache GCacheDebugInfo[elf.SymTabDebugInfo] `river:"same_file_cache,attr,optional"`
}

type ElfDebugInfo

type ElfDebugInfo struct {
	SymbolsCount int    `river:"symbols_count,attr,optional"`
	File         string `river:"file,attr,optional"`
}

type ElfTable

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

func NewElfTable

func NewElfTable(logger log.Logger, procMap *ProcMap, fs string, elfFilePath string, options ElfTableOptions) *ElfTable

func (*ElfTable) Cleanup

func (et *ElfTable) Cleanup()

func (*ElfTable) DebugInfo

func (et *ElfTable) DebugInfo() elf2.SymTabDebugInfo

func (*ElfTable) Resolve

func (et *ElfTable) Resolve(pc uint64) string

type ElfTableOptions

type ElfTableOptions struct {
	ElfCache *ElfCache
	Metrics  *Metrics // may be nil for tests
}

type GCache

type GCache[K comparable, V Resource] struct {
	// contains filtered or unexported fields
}

func NewGCache

func NewGCache[K comparable, V Resource](options GCacheOptions) (*GCache[K, V], error)

func (*GCache[K, V]) Cache

func (g *GCache[K, V]) Cache(k K, v V)

func (*GCache[K, V]) Cleanup

func (g *GCache[K, V]) Cleanup()

func (*GCache[K, V]) Each

func (g *GCache[K, V]) Each(f func(k K, v V))

func (*GCache[K, V]) EachLRU

func (g *GCache[K, V]) EachLRU(f func(k K, v V))

func (*GCache[K, V]) EachRound

func (g *GCache[K, V]) EachRound(f func(k K, v V))

func (*GCache[K, V]) Get

func (g *GCache[K, V]) Get(k K) V

func (*GCache[K, V]) LRUSize

func (g *GCache[K, V]) LRUSize() int

func (*GCache[K, V]) NextRound

func (g *GCache[K, V]) NextRound()

func (*GCache[K, V]) Remove

func (g *GCache[K, V]) Remove(k K)

func (*GCache[K, V]) RoundSize

func (g *GCache[K, V]) RoundSize() int

func (*GCache[K, V]) Update

func (g *GCache[K, V]) Update(options GCacheOptions)

type GCacheDebugInfo

type GCacheDebugInfo[T any] struct {
	LRUSize   int `river:"lru_size,attr,optional"`
	RoundSize int `river:"round_size,attr,optional"`
	LRU       []T `river:"lru_dump,block,optional"`
	Round     []T `river:"round_dump,block,optional"`
}

func DebugInfo

func DebugInfo[K comparable, V Resource, D any](g *GCache[K, V], ff func(K, V) D) GCacheDebugInfo[D]

type GCacheOptions

type GCacheOptions struct {
	Size       int
	KeepRounds int
}

type Metrics

type Metrics struct {
	ElfErrors      *prometheus.CounterVec
	ProcErrors     *prometheus.CounterVec
	KnownSymbols   *prometheus.CounterVec
	UnknownSymbols *prometheus.CounterVec
	UnknownModules *prometheus.CounterVec
	UnknownStacks  *prometheus.CounterVec
}

func NewMetrics

func NewMetrics(reg prometheus.Registerer) *Metrics

type ProcMap

type ProcMap struct {
	// The start address of current mapping.
	StartAddr uint64
	// The end address of the current mapping
	EndAddr uint64
	// The permissions for this mapping
	Perms *ProcMapPermissions
	// The current offset into the file/fd (e.g., shared libs)
	Offset int64
	// Device owner of this mapping (major:minor) in Mkdev format.
	Dev uint64
	// The inode of the device above
	Inode uint64
	// The file or psuedofile (or empty==anonymous)
	Pathname string
}

ProcMap contains the process memory-mappings of the process read from `/proc/[pid]/maps`.

type ProcMapPermissions

type ProcMapPermissions struct {
	// mapping has the [R]ead flag set
	Read bool
	// mapping has the [W]rite flag set
	Write bool
	// mapping has the [X]ecutable flag set
	Execute bool
	// mapping has the [S]hared flag set
	Shared bool
	// mapping is marked as [P]rivate (copy on write)
	Private bool
}

ProcMapPermissions contains permission settings read from `/proc/[pid]/maps`.

type ProcTable

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

func NewProcTable

func NewProcTable(logger log.Logger, options ProcTableOptions) *ProcTable

func (*ProcTable) Cleanup

func (p *ProcTable) Cleanup()

func (*ProcTable) DebugInfo

func (p *ProcTable) DebugInfo() ProcTableDebugInfo

func (*ProcTable) Refresh

func (p *ProcTable) Refresh()

func (*ProcTable) Resolve

func (p *ProcTable) Resolve(pc uint64) Symbol

type ProcTableDebugInfo

type ProcTableDebugInfo struct {
	ElfTables map[string]elf.SymTabDebugInfo `river:"elfs,block,optional"`
	Size      int                            `river:"size,attr,optional"`
	Pid       int                            `river:"pid,attr,optional"`
}

type ProcTableOptions

type ProcTableOptions struct {
	Pid int
	ElfTableOptions
}

type Resource

type Resource interface {
	Refresh()
	Cleanup()
}

type Stat

type Stat struct {
	Dev uint64
	Ino uint64
}

type Sym

type Sym struct {
	Start uint64
	Name  string
}

type SymTab

type SymTab struct {
	Symbols []Sym
	// contains filtered or unexported fields
}

func NewSymTab

func NewSymTab(symbols []Sym) *SymTab

func (*SymTab) Length

func (t *SymTab) Length() int

func (*SymTab) Rebase

func (t *SymTab) Rebase(base uint64)

func (*SymTab) Resolve

func (t *SymTab) Resolve(addr uint64) *Sym

type Symbol

type Symbol struct {
	Start  uint64
	Name   string
	Module string
}

type SymbolNameResolver

type SymbolNameResolver interface {
	Refresh()
	Cleanup()
	DebugInfo() elf.SymTabDebugInfo
	IsDead() bool
	Resolve(addr uint64) string
}

type SymbolTab

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

func NewKallsyms

func NewKallsyms(kallsyms []byte) (*SymbolTab, error)

func NewSymbolTab

func NewSymbolTab(symbols []Symbol) *SymbolTab

func (*SymbolTab) Cleanup

func (t *SymbolTab) Cleanup()

func (*SymbolTab) DebugString

func (t *SymbolTab) DebugString() string

func (*SymbolTab) Rebase

func (t *SymbolTab) Rebase(base uint64)

func (*SymbolTab) Refresh

func (t *SymbolTab) Refresh()

func (*SymbolTab) Resolve

func (t *SymbolTab) Resolve(addr uint64) Symbol

type SymbolTable

type SymbolTable interface {
	Refresh()
	Cleanup()
	Resolve(addr uint64) Symbol
}