symtab

Jul 30, 2024

Changes in this version

+ type Sym struct

+ Name string

+ Start uint64

+ type SymTab struct

+ Symbols []Sym

+ func NewSymTab(symbols []Sym) *SymTab

+ func (t *SymTab) Length() int

+ func (t *SymTab) Rebase(base uint64)

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

Jul 22, 2024

Changes in this version

+ var DefaultSymbolOptions = &SymbolOptions

+ type CacheOptions struct

+ BuildIDCacheOptions GCacheOptions

+ PidCacheOptions GCacheOptions

+ SameFileCacheOptions GCacheOptions

+ type ElfCache struct

+ BuildIDCache *GCache[elf.BuildID, SymbolNameResolver]

+ SameFileCache *GCache[Stat, SymbolNameResolver]

+ 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 struct

+ BuildIDCache GCacheDebugInfo[elf.SymTabDebugInfo]

+ SameFileCache GCacheDebugInfo[elf.SymTabDebugInfo]

+ type ElfDebugInfo struct

+ File string

+ SymbolsCount int

+ type ElfTable struct

+ 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 struct

+ ElfCache *ElfCache

+ Metrics *metrics.SymtabMetrics

+ SymbolOptions *SymbolOptions

+ type GCache struct

+ 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, round int))

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

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

+ 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 struct

+ CurrentRound int

+ LRUDump []T

+ LRUSize int

+ RoundDump []T

+ RoundSize int

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

+ type GCacheOptions struct

+ KeepRounds int

+ Size int

+ type PidKey uint32

+ type ProcMap struct

+ Dev uint64

+ EndAddr uint64

+ Inode uint64

+ Offset int64

+ Pathname string

+ Perms *ProcMapPermissions

+ StartAddr uint64

+ func FindLastRXMap(maps []*ProcMap) *ProcMap

+ func FindReadableMap(maps []*ProcMap) *ProcMap

+ func ParseProcMapLine(line []byte, executableOnly bool) (*ProcMap, error)

+ func ParseProcMapsExecutableModules(procMaps []byte, executableOnly bool) ([]*ProcMap, error)

+ func (p *ProcMap) String() string

+ type ProcMapPermissions struct

+ Execute bool

+ Private bool

+ Read bool

+ Shared bool

+ Write bool

+ func (p *ProcMapPermissions) String() string

+ type ProcMaps []*ProcMap

+ func (p ProcMaps) String() string

+ type ProcTable struct

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

+ func (p *ProcTable) Cleanup()

+ func (p *ProcTable) DebugInfo() ProcTableDebugInfo

+ func (p *ProcTable) Error() error

+ func (p *ProcTable) Pid() int

+ func (p *ProcTable) Refresh()

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

+ type ProcTableDebugInfo struct

+ ElfTables map[string]elf.SymTabDebugInfo

+ LastUsedRound int

+ Pid int

+ Size int

+ type ProcTableOptions struct

+ Pid int

+ type Resource interface

+ Cleanup func()

+ Refresh func()

+ type Stat struct

+ Dev uint64

+ Ino uint64

+ Inode uint64

+ type Symbol struct

+ Module string

+ Name string

+ Start uint64

+ type SymbolCache struct

+ func NewSymbolCache(logger log.Logger, options CacheOptions, metrics *metrics.SymtabMetrics) (*SymbolCache, error)

+ func (sc *SymbolCache) Cleanup()

+ func (sc *SymbolCache) ElfCacheDebugInfo() ElfCacheDebugInfo

+ func (sc *SymbolCache) GetKallsyms() SymbolTable

+ func (sc *SymbolCache) GetProcTableCached(pid PidKey) *ProcTable

+ func (sc *SymbolCache) NewProcTable(pid PidKey, symbolOptions *SymbolOptions) *ProcTable

+ func (sc *SymbolCache) NextRound()

+ func (sc *SymbolCache) PidCacheDebugInfo() GCacheDebugInfo[ProcTableDebugInfo]

+ func (sc *SymbolCache) RemoveDeadPID(pid PidKey)

+ func (sc *SymbolCache) UpdateOptions(options CacheOptions)

+ type SymbolNameResolver interface

+ Cleanup func()

+ DebugInfo func() elf.SymTabDebugInfo

+ IsDead func() bool

+ Refresh func()

+ Resolve func(addr uint64) string

+ type SymbolOptions struct

+ DemangleOptions []demangle.Option

+ GoTableFallback bool

+ PythonFullFilePath bool

+ type SymbolTab struct

+ func NewKallsyms() (*SymbolTab, error)

+ func NewKallsymsFromData(kallsyms []byte) (*SymbolTab, error)

+ func NewKallsymsFromFile(f string) (*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 interface

+ Cleanup func()

+ Refresh func()

+ Resolve func(addr uint64) Symbol