Reduce lock contention in cgroup cache rebuild and simplify BPF map update

Walk the cgroup filesystem outside any lock and swap in the fresh cache
under a brief write lock, eliminating the upgrade-to-write-lock pattern
that blocked all readers during the walk.

Extract the inline map lookup/update logic in process_eth() into the
existing update_val() helper to reduce code duplication across hook types.

Author: dkorunic

bpf/counter_common.h

@@ -350,17 +350,7 @@ process_eth(void *data, void *data_end, __u64 pkt_len) {
     return;
   }
 
-  // lookup value in hash
-  statvalue *val = (statvalue *)bpf_map_lookup_elem(&pkt_count, &key);
-  if (val) {
-    // atomic XADD, doesn't need bpf_spin_lock()
-    __sync_fetch_and_add(&val->packets, 1);
-    __sync_fetch_and_add(&val->bytes, pkt_len);
-  } else {
-    statvalue initval = {.packets = 1, .bytes = pkt_len};
-
-    bpf_map_update_elem(&pkt_count, &key, &initval, BPF_NOEXIST);
-  }
+  update_val(&key, pkt_len);
 }
 
 /**

cgroup.go

@@ -74,23 +74,22 @@ func cGroupToPath(id uint64) string {
 		return p
 	}
 
-	// Upgrade to write lock; re-check to avoid redundant WalkDir from concurrent misses.
-	cGroupCacheLock.Lock()
-	defer cGroupCacheLock.Unlock()
-
-	if p, ok = cGroupCache[id]; ok {
-		return p
-	}
-
-	// ID genuinely absent: rebuild cache from filesystem.
-	_ = cGroupWalk(CGroupRootPath, cGroupCache)
+	// Build a fresh cache outside any lock to avoid blocking readers during
+	// the filesystem walk, then swap it in under a brief write lock.
+	fresh := make(map[uint64]string)
+	_ = cGroupWalk(CGroupRootPath, fresh)
 
-	// Create negative cache entry if still missing after walk.
-	if p, ok = cGroupCache[id]; !ok {
+	// Synthesise a negative cache entry if still missing after the walk.
+	p, ok = fresh[id]
+	if !ok {
 		p = "cgroup-id: " + strconv.FormatUint(id, 10)
-		cGroupCache[id] = p
+		fresh[id] = p
 	}
 
+	cGroupCacheLock.Lock()
+	cGroupCache = fresh
+	cGroupCacheLock.Unlock()
+
 	return p
 }