switch from perf maps to ring buffer

2 files changed, 43 insertions, 33 deletions

diff --git a/internal/flags/flags.go b/internal/flags/flags.go
index 1ba9d60..ac7abd4 100644
--- a/internal/flags/flags.go
+++ b/internal/flags/flags.go
@@ -9,15 +9,13 @@ import (
 )
 
 type Flags struct {
-	UidFilter        int
-	FdEventMapSize   int
-	OpenEventMapSize int
+	UidFilter    int
+	EventMapSize int
 }
 
 func New() (flags Flags) {
 	flag.IntVar(&flags.UidFilter, "uid", 0, "Filter for processes with UID")
-	flag.IntVar(&flags.FdEventMapSize, "fdMapSize", 4096, "BPF FD event map size")
-	flag.IntVar(&flags.OpenEventMapSize, "openMapSize", 1024, "BPF open event map size")
+	flag.IntVar(&flags.EventMapSize, "mapSize", 4096, "BPF FD event ring buffer map size")
 	flag.Parse()
 	return flags
 }
@@ -39,17 +37,14 @@ func (flags Flags) SetBPF(bpfModule *bpf.Module) error {
 }
 
 func (flags Flags) ResizeBPFMaps(bpfModule *bpf.Module) error {
-	if err := resizeBPFMap(bpfModule, "open_event_map", uint32(flags.OpenEventMapSize)); err != nil {
-		return err
-	}
-	if err := resizeBPFMap(bpfModule, "fd_event_map", uint32(flags.FdEventMapSize)); err != nil {
-		return err
+	if err := resizeBPFMap(bpfModule, "event_map", uint32(flags.EventMapSize)); err != nil {
+		return fmt.Errorf("event_map: %w", err)
 	}
 	return nil
 }
 
 func resizeBPFMap(module *bpf.Module, name string, size uint32) error {
-	m, err := module.GetMap("open_event_map")
+	m, err := module.GetMap(name)
 	if err != nil {
 		return err
 	}
@@ -59,7 +54,7 @@ func resizeBPFMap(module *bpf.Module, name string, size uint32) error {
 	}
 
 	if actual := m.MaxEntries(); actual != size {
-		return fmt.Errorf("map resize failed, expected %v, actual %v", size, actual)
+		return fmt.Errorf("map resize to %d failed, expected %v, actual %v", size, size, actual)
 	}
 
 	return nil
diff --git a/internal/ioriotng.go b/internal/ioriotng.go
index d840ea5..f368c09 100644
--- a/internal/ioriotng.go
+++ b/internal/ioriotng.go
@@ -6,15 +6,12 @@ import (
 	"bytes"
 	"context"
 	"encoding/binary"
-	"fmt"
 	"log"
 	"runtime"
-	"sync"
 
 	"ioriotng/internal/debugfs"
 	"ioriotng/internal/flags"
 	"ioriotng/internal/tracepoints"
-	"ioriotng/internal/types"
 
 	bpf "github.com/aquasecurity/libbpfgo"
 )
@@ -50,25 +47,43 @@ func Run(flags flags.Flags) {
 		log.Fatal(err)
 	}
 
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-	var wg sync.WaitGroup
-	wg.Add(2)
+	ch := make(chan []byte)
+	rb, err := bpfModule.InitRingBuf("event_map", ch)
+	if err != nil {
+		log.Fatal(err)
+	}
+	rb.Poll(300)
 
-	go func() {
-		defer wg.Done()
-		for ev := range listenToEvents[types.FdEvent](ctx, bpfModule, "fd_event_map") {
-			fmt.Println(ev)
-		}
-	}()
-	go func() {
-		defer wg.Done()
-		for ev := range listenToEvents[types.OpenEvent](ctx, bpfModule, "open_event_map") {
-			fmt.Println(ev)
-		}
-	}()
+	for b := range ch {
+		/*
+			if binary.LittleEndian.Uint32(b) != 2021 {
+				log.Fatal("invalid data retrieved", len(b), b)
+			}
+		*/
+		log.Println("Ringbuf data received", len(b), b)
+	}
+
+	/*
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+		var wg sync.WaitGroup
+		wg.Add(2)
+
+			go func() {
+				defer wg.Done()
+				for ev := range listenToEvents[types.FdEvent](ctx, bpfModule, "fd_event_map") {
+					fmt.Println(ev)
+				}
+			}()
+		go func() {
+			defer wg.Done()
+			for ev := range listenToEvents[types.OpenEvent](ctx, bpfModule, "open_event_map") {
+				fmt.Println(ev)
+			}
+		}()
 
-	wg.Wait()
+		wg.Wait()
+	*/
 	log.Println("Good bye")
 }
 
@@ -77,7 +92,7 @@ func listenToEvents[T BpfMapper](ctx context.Context, bpfModule *bpf.Module, map
 	rawLostCh := make(chan uint64) // TODO: Of any use this channel?
 	eventsCh := make(chan T)
 
-	pb, err := bpfModule.InitPerfBuf(mapName, rawEventsCh, rawLostCh, 4096)
+	pb, err := bpfModule.InitPerfBuf(mapName, rawEventsCh, rawLostCh, 1024)
 	if err != nil {
 		log.Fatal(err)
 	}