symtab

type CacheOptions struct {
	PidCacheOptions      GCacheOptions
	BuildIDCacheOptions  GCacheOptions
	SameFileCacheOptions GCacheOptions
	Metrics              *Metrics // may be nil for tests
}

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

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 struct {
	SymbolsCount int    `river:"symbols_count,attr,optional"`
	File         string `river:"file,attr,optional"`
}

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

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

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

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"`
}

type GCacheOptions struct {
	Size       int
	KeepRounds int
}

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

type PidKey uint32

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
}

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
}

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

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 struct {
	Pid int
	ElfTableOptions
}

type Resource interface {
	Refresh()
	Cleanup()
}

type Stat struct {
	Dev   uint64
	Inode uint64
}

type Sym struct {
	Start uint64
	Name  string
}

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

type Symbol struct {
	Start  uint64
	Name   string
	Module string
}

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

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

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

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