symtab

type CacheOptions struct {
	PidCacheOptions      GCacheOptions
	BuildIDCacheOptions  GCacheOptions
	SameFileCacheOptions GCacheOptions
}

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

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

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

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

type ElfTableOptions struct {
	ElfCache      *ElfCache
	Metrics       *metrics.SymtabMetrics
	SymbolOptions *SymbolOptions
}

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

type GCacheDebugInfo[T any] struct {
	LRUSize      int `alloy:"lru_size,attr,optional" river:"lru_size,attr,optional"`
	RoundSize    int `alloy:"round_size,attr,optional" river:"round_size,attr,optional"`
	CurrentRound int `alloy:"current_round,attr,optional" river:"current_round,attr,optional"`
	LRUDump      []T `alloy:"lru_dump,block,optional" river:"lru_dump,block,optional"`
	RoundDump    []T `alloy:"round_dump,block,optional" river:"round_dump,block,optional"`
}

type GCacheOptions struct {
	Size       int
	KeepRounds int
}

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 ProcMaps []*ProcMap

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

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

type ProcTableOptions struct {
	Pid int
	ElfTableOptions
}

type Resource interface {
	Refresh()
	Cleanup()
}

type Stat struct {
	Dev   uint64
	Inode uint64
}

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 SymbolOptions struct {
	GoTableFallback    bool
	PythonFullFilePath bool
	DemangleOptions    []demangle.Option
}

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

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