opensnitch/daemon/procmon/ebpf/cache.go
Gustavo Iñiguez Goia feafe87604
migrated ebpf lib from gobpf to cilium
Up until now we've been using https://github.com/iovisor/gobpf/ for
intercepting events from the kernel, and it has worked very well.

Unfortunately it's deprecated since 2021 (iovisor/gobpf#304), which means
that some of the known issues and limitations won't be fixed.

After evaluating some options, I've migrated the code from gobpf to
github.com/cilium/ebpf.

More info: #1222, #1312
2025-04-09 00:15:38 +02:00

127 lines
2.3 KiB
Go

package ebpf
import (
"sync"
"time"
)
type ebpfCacheItem struct {
Key []byte
LastSeen int64
Pid int
UID int
}
type ebpfCacheType struct {
Items map[interface{}]*ebpfCacheItem
mu *sync.RWMutex
}
var (
// TODO: allow to configure these options
maxTTL = 40 // Seconds
maxCacheItems = 5000
ebpfCache *ebpfCacheType
ebpfCacheTicker *time.Ticker
)
// NewEbpfCacheItem creates a new cache item.
func NewEbpfCacheItem(key []byte, pid, uid int) *ebpfCacheItem {
return &ebpfCacheItem{
Key: key,
Pid: pid,
UID: uid,
LastSeen: time.Now().UnixNano(),
}
}
func (i *ebpfCacheItem) isValid() bool {
lastSeen := time.Now().Sub(
time.Unix(0, i.LastSeen),
)
return int(lastSeen.Seconds()) < maxTTL
}
// NewEbpfCache creates a new cache store.
func NewEbpfCache() *ebpfCacheType {
ebpfCacheTicker = time.NewTicker(1 * time.Minute)
return &ebpfCacheType{
Items: make(map[interface{}]*ebpfCacheItem, 500),
mu: &sync.RWMutex{},
}
}
func (e *ebpfCacheType) addNewItem(key interface{}, itemKey []byte, pid, uid int) {
e.mu.Lock()
e.Items[key] = NewEbpfCacheItem(itemKey, pid, uid)
e.mu.Unlock()
}
func (e *ebpfCacheType) isInCache(key interface{}) (item *ebpfCacheItem, found bool) {
leng := e.Len()
e.mu.Lock()
item, found = e.Items[key]
if found {
if item.isValid() {
e.update(key, item)
} else {
found = false
delete(e.Items, key)
}
}
e.mu.Unlock()
if leng > maxCacheItems {
e.DeleteOldItems()
}
return
}
func (e *ebpfCacheType) update(key interface{}, item *ebpfCacheItem) {
item.LastSeen = time.Now().UnixNano()
e.Items[key] = item
}
func (e *ebpfCacheType) Len() int {
e.mu.RLock()
defer e.mu.RUnlock()
return len(e.Items)
}
func (e *ebpfCacheType) DeleteOldItems() {
length := e.Len()
e.mu.Lock()
defer e.mu.Unlock()
for k, item := range e.Items {
if length > maxCacheItems || (item != nil && !item.isValid()) {
delete(e.Items, k)
}
}
}
func (e *ebpfCacheType) delete(key interface{}) {
e.mu.Lock()
defer e.mu.Unlock()
if key, found := e.Items[key]; found {
delete(e.Items, key)
}
}
func (e *ebpfCacheType) clear() {
if e == nil {
return
}
e.mu.Lock()
defer e.mu.Unlock()
for k := range e.Items {
delete(e.Items, k)
}
if ebpfCacheTicker != nil {
ebpfCacheTicker.Stop()
}
}