Correctness and robustness improvements across multiple subsystems

- cgroup: initialize map eagerly, fix swallowed error in cGroupWalk, add
  blank line before lock call for readability, declare err in var block
- main: defer signal.Stop to clean up signal channel on exit
- map: guard duration with 1ns floor to prevent division-by-zero in
  bitrate calculation; simplify checkBatchMapSupport return expression;
  add minDuration constant with explanatory comment
- output: fix bitrate unit thresholds to use unit boundaries instead of
  10x multiples; handle json.Encoder.Encode error instead of discarding
- probe: warn when no KProbes were attached so output-is-empty is diagnosable
- tui: replace func-pointer sort selector with atomic.Int32 index into a
  fixed sortFuncs array for safe concurrent access; introduce done channel
  so updateStatsTable goroutine exits cleanly when the app stops

Author: dkorunic

cgroup.go

@@ -41,7 +41,7 @@ const (
 )
 
 var (
-	cGroupCache     map[uint64]string
+	cGroupCache     = make(map[uint64]string)
 	cGroupCacheLock sync.RWMutex
 	cGroupInitOnce  sync.Once
 )
@@ -131,6 +131,8 @@ func cGroupWalk(dir string, mapping map[uint64]string) error {
 			if errors.Is(err, fs.ErrNotExist) {
 				return nil
 			}
+
+			return err
 		}
 
 		if !d.IsDir() {
@@ -181,9 +183,11 @@ func cGroupWatcher(objs cgroupObjects) (*perf.Reader, error) {
 	}
 
 	go func() {
-		var event cgroupCgroupevent
-
-		var r perf.Record
+		var (
+			event cgroupCgroupevent
+			r     perf.Record
+			err   error
+		)
 
 		for {
 			r, err = rd.Read()
@@ -201,6 +205,7 @@ func cGroupWatcher(objs cgroupObjects) (*perf.Reader, error) {
 			}
 
 			path := bsliceToString(event.Path[:])
+
 			cGroupCacheLock.Lock()
 			cGroupCache[event.Cgroupid] = strings.TrimPrefix(path, CGroupRootPath)
 			cGroupCacheLock.Unlock()

main.go

@@ -144,7 +144,9 @@ func main() {
 		drawTUI(objsCounter, startTime)
 	} else {
 		signalCh := make(chan os.Signal, 1)
+
 		signal.Notify(signalCh, os.Interrupt, syscall.SIGTERM, syscall.SIGINT)
+		defer signal.Stop(signalCh)
 
 		go func() {
 			s := <-signalCh

map.go

@@ -29,7 +29,10 @@ import (
 	"github.com/cilium/ebpf"
 )
 
-const batchSize = 4096
+const (
+	batchSize   = 4096
+	minDuration = 1e-9 // 1 nanosecond floor to avoid division by zero in bitrate
+)
 
 type batchBuffers struct {
 	keys   []counterStatkey
@@ -67,11 +70,7 @@ func checkBatchMapSupport(m *ebpf.Map) bool {
 	// BPF_MAP_LOOKUP_BATCH support requires v5.6 kernel
 	_, err := m.BatchLookup(&cursor, keys, values, nil)
 
-	if err != nil && errors.Is(err, ebpf.ErrNotSupported) {
-		return false
-	}
-
-	return true
+	return !errors.Is(err, ebpf.ErrNotSupported)
 }
 
 // listMap lists all the entries in the given ebpf.Map, converting the counter
@@ -112,6 +111,10 @@ func listMapBatch(m *ebpf.Map, start time.Time) ([]statEntry, error) {
 	values := buf.values
 
 	dur := time.Since(start).Seconds()
+	if dur < minDuration {
+		dur = minDuration
+	}
+
 	stats := make([]statEntry, 0, m.MaxEntries())
 
 	var cursor ebpf.MapBatchCursor
@@ -156,6 +159,10 @@ func listMapIterate(m *ebpf.Map, start time.Time) ([]statEntry, error) {
 	)
 
 	dur := time.Since(start).Seconds()
+	if dur < minDuration {
+		dur = minDuration
+	}
+
 	stats := make([]statEntry, 0, m.MaxEntries())
 
 	iter := m.Iterate()

output.go

@@ -25,6 +25,7 @@ import (
 	"bytes"
 	"cmp"
 	"encoding/json"
+	"fmt"
 	"os"
 	"slices"
 	"strconv"
@@ -124,14 +125,12 @@ func formatBitrate(b float64) string {
 	switch {
 	case b < Kbps:
 		return strconv.FormatFloat(b, 'f', 2, 64) + " bps"
-	case b < 10*Kbps:
+	case b < Mbps:
 		return strconv.FormatFloat(b/Kbps, 'f', 2, 64) + " Kbps"
-	case b < 10*Mbps:
+	case b < Gbps:
 		return strconv.FormatFloat(b/Mbps, 'f', 2, 64) + " Mbps"
-	case b < 10*Gbps:
+	case b < Tbps:
 		return strconv.FormatFloat(b/Gbps, 'f', 2, 64) + " Gbps"
-	case b < 10*Tbps:
-		return strconv.FormatFloat(b/Tbps, 'f', 2, 64) + " Tbps"
 	}
 
 	return strconv.FormatFloat(b/Tbps, 'f', 2, 64) + " Tbps"
@@ -230,7 +229,10 @@ func outputPlain(m []statEntry) string {
 func outputJSON(m []statEntry) {
 	enc := json.NewEncoder(os.Stdout)
 	enc.SetEscapeHTML(false)
-	_ = enc.Encode(m)
+
+	if err := enc.Encode(m); err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "Error encoding JSON output: %v\n", err)
+	}
 }
 
 // bsliceToString converts a slice of int8 values to a string by first

probe.go

@@ -67,6 +67,8 @@ func startKProbes(hooks []kprobeHook, links []link.Link) []link.Link {
 
 	links = slices.Grow(links, len(hooks))
 
+	initialLen := len(links)
+
 	for _, kp := range hooks {
 		l, err = link.Kprobe(kp.kprobe, kp.prog, nil)
 		if err != nil {
@@ -78,6 +80,10 @@ func startKProbes(hooks []kprobeHook, links []link.Link) []link.Link {
 		links = append(links, l)
 	}
 
+	if len(links) == initialLen {
+		log.Printf("Warning: no KProbes were successfully attached; output will be empty")
+	}
+
 	log.Printf("Using KProbes mode w/ PID/comm tracking")
 
 	return links

tui.go

@@ -25,6 +25,7 @@ package main
 import (
 	"fmt"
 	"strconv"
+	"sync/atomic"
 	"time"
 
 	"github.com/gdamore/tcell/v2"
@@ -54,9 +55,19 @@ const (
 // The TUI is interactive: pressing 'q' or 'x' will exit the program,
 // pressing 'r' or 'l' will redraw the TUI, and pressing any other key will
 // do nothing.
+// sortFuncs maps the atomic sort index to the corresponding sort function.
+var sortFuncs = [...]func([]statEntry){
+	bitrateSort, // 0
+	packetSort,  // 1
+	bytesSort,   // 2
+	srcIPSort,   // 3
+	dstIPSort,   // 4
+}
+
 func drawTUI(objs counterObjects, startTime time.Time) {
 	app := tview.NewApplication()
-	tableSort := bitrateSort
+
+	var tableSortIdx atomic.Int32 // 0 = bitrateSort (default)
 
 	// packet statistics
 	statsTable := tview.NewTable().
@@ -72,23 +83,23 @@ func drawTUI(objs counterObjects, startTime time.Time) {
 	statsTable.SetInputCapture(func(event *tcell.EventKey) *tcell.EventKey {
 		switch event.Rune() {
 		case '0':
-			tableSort = bitrateSort
+			tableSortIdx.Store(0)
 
 			statsTable.Select(0, 0)
 		case '1':
-			tableSort = packetSort
+			tableSortIdx.Store(1)
 
 			statsTable.Select(0, 0)
 		case '2':
-			tableSort = bytesSort
+			tableSortIdx.Store(2)
 
 			statsTable.Select(0, 0)
 		case '3':
-			tableSort = srcIPSort
+			tableSortIdx.Store(3)
 
 			statsTable.Select(0, 0)
 		case '4':
-			tableSort = dstIPSort
+			tableSortIdx.Store(4)
 
 			statsTable.Select(0, 0)
 		case 'q', 'x', 'Q', 'X':
@@ -131,12 +142,17 @@ func drawTUI(objs counterObjects, startTime time.Time) {
 		AddItem(statsTable, 1, 0, 1, 1, 0, 0, true).
 		AddItem(naviView, 2, 0, 1, 1, 0, 0, false)
 
-	// start the update loop
-	go updateStatsTable(app, statsTable, &tableSort, objs, startTime)
+	// start the update loop; done is closed when app.Run() returns so the
+	// goroutine can exit instead of blocking on a stopped application.
+	done := make(chan struct{})
+
+	go updateStatsTable(app, statsTable, &tableSortIdx, objs, startTime, done)
 
 	_ = app.SetRoot(grid, true).
 		SetFocus(statsTable).
 		Run()
+
+	close(done)
 }
 
 // updateStatsTable starts an infinite loop that updates the given table with
@@ -159,8 +175,8 @@ func drawTUI(objs counterObjects, startTime time.Time) {
 //
 // Note that the table is cleared and recreated on each iteration, so any cell
 // attributes are lost on each iteration.
-func updateStatsTable(app *tview.Application, table *tview.Table, tableSort *func(stats []statEntry),
-	objs counterObjects, startTime time.Time,
+func updateStatsTable(app *tview.Application, table *tview.Table, tableSortIdx *atomic.Int32,
+	objs counterObjects, startTime time.Time, done <-chan struct{},
 ) {
 	ticker := time.NewTicker(*refresh)
 	defer ticker.Stop()
@@ -186,7 +202,7 @@ func updateStatsTable(app *tview.Application, table *tview.Table, tableSort *fun
 
 	for {
 		// read eBPF map outside the draw closure so the UI goroutine is not blocked on the syscall
-		snapshot, _ := processMap(objs.PktCount, startTime, *tableSort)
+		snapshot, _ := processMap(objs.PktCount, startTime, sortFuncs[tableSortIdx.Load()])
 
 		app.QueueUpdateDraw(func() {
 			table.Clear()
@@ -273,6 +289,10 @@ func updateStatsTable(app *tview.Application, table *tview.Table, tableSort *fun
 			}
 		})
 
-		<-ticker.C
+		select {
+		case <-ticker.C:
+		case <-done:
+			return
+		}
 	}
 }