Merge pull request #565 from dqminh/cgroup_id

Support for BPF_MAP_CGRP_STORAGE type

Author: bobrik

.vscode/config-schema.yaml

@@ -77,6 +77,10 @@ properties:
     properties:
       name:
         type: string
+      type:
+        enum:
+          - hash
+          - cgrp_storage
       regexps:
         type: array
         items:

config/config.go

@@ -50,10 +50,24 @@ type Histogram struct {
 // The cgroups that match the provided regexps will be available to the bpf program
 // as a shared map with provided name.
 type CgroupIDMap struct {
-	Name    string   `yaml:"name"`
-	Regexps []string `yaml:"regexps"`
+	Name    string          `yaml:"name"`
+	Type    CgroupIDMapType `yaml:"type"`
+	Regexps []string        `yaml:"regexps"`
 }
 
+// CgroupIDMapType describes the map type that stores the cgroups that the bpf
+// programs are interested in.
+type CgroupIDMapType string
+
+const (
+	// CgroupIDMapHashType is normal hash map such as BPF_MAP_TYPE_LRU_HASH
+	CgroupIDMapHashType CgroupIDMapType = "hash"
+	// CgroupIDMapCgrpStorageType is specialized BPF_MAP_TYPE_CGRP_STORAGE map
+	// with data keyed on a cgroup. When a group is deleted, data is automatically
+	// removed.
+	CgroupIDMapCgrpStorageType CgroupIDMapType = "cgrp_storage"
+)
+
 // Tracing is a collection of spans attached to a program
 type Tracing struct {
 	Spans []Span `yaml:"spans"`

examples/cgroup_id_map.yaml

@@ -20,5 +20,6 @@ metrics:
 
 cgroup_id_map:
   name: cgroup_id_map
+  type: hash
   regexps:
     - ^.*(system.slice/.*)$

examples/cgroup_id_map_cgrp_storage.bpf.c

@@ -0,0 +1,45 @@
+#include <vmlinux.h>
+#include <bpf/bpf_tracing.h>
+#include <bpf/bpf_core_read.h>
+#include "maps.bpf.h"
+
+struct {
+    __uint(type, BPF_MAP_TYPE_LRU_HASH);
+    __uint(max_entries, 1024);
+    __type(key, u64);
+    __type(value, u64);
+} cgroup_cgrp_storage_sched_migrations_total SEC(".maps");
+
+struct {
+    __uint(type, BPF_MAP_TYPE_LRU_HASH);
+    __uint(max_entries, 1024);
+    __type(key, u64);
+    __type(value, u64);
+} cgroup_cgrp_storage_sched_migrations_not_match_total SEC(".maps");
+
+struct {
+    __uint(type, BPF_MAP_TYPE_CGRP_STORAGE);
+    __uint(map_flags, BPF_F_NO_PREALLOC);
+    __type(key, u32);
+    __type(value, u64);
+} cgroup_id_map_cgrp_storage SEC(".maps");
+
+SEC("tp_btf/sched_migrate_task")
+int BPF_PROG(sched_migrate_task, struct task_struct *task, int dest_cpu)
+{
+    u64 *ok;
+    struct cgroup *cgrp = task->cgroups->dfl_cgrp;
+    ok = bpf_cgrp_storage_get(&cgroup_id_map_cgrp_storage, cgrp, 0, BPF_LOCAL_STORAGE_GET_F_CREATE);
+    if (!ok) {
+        return 1;
+    }
+    u64 cgroup_id = BPF_CORE_READ(cgrp, kn, id);
+    if (*ok) {
+        increment_map(&cgroup_cgrp_storage_sched_migrations_total, &cgroup_id, 1);
+    } else {
+        increment_map(&cgroup_cgrp_storage_sched_migrations_not_match_total, &cgroup_id, 1);
+    }
+    return 0;
+}
+
+char LICENSE[] SEC("license") = "GPL";

examples/cgroup_id_map_cgrp_storage.yaml

@@ -0,0 +1,25 @@
+metrics:
+  counters:
+    - name: cgroup_cgrp_storage_sched_migrations_total
+      help: Number of sched:sched_migrate_task events per cgroup
+      labels:
+        - name: cgroup
+          size: 8
+          decoders:
+            - name: uint
+            - name: cgroup
+
+    - name: cgroup_cgrp_storage_sched_migrations_not_match_total
+      help: Number of sched:sched_migrate_task events per cgroup not match cgroup id map
+      labels:
+        - name: cgroup
+          size: 8
+          decoders:
+            - name: uint
+            - name: cgroup
+
+cgroup_id_map:
+  name: cgroup_id_map_cgrp_storage
+  type: cgrp_storage
+  regexps:
+    - ^.*(system.slice/.*)$

exporter/cgroup_id_map.go

@@ -1,8 +1,11 @@
 package exporter
 
 import (
+	"errors"
 	"fmt"
+	"io/fs"
 	"log"
+	"os"
 	"regexp"
 	"unsafe"
 
@@ -13,9 +16,10 @@ import (
 
 // CgroupIDMap synchronises cgroup changes with the shared bpf map.
 type CgroupIDMap struct {
-	bpfMap *libbpfgo.BPFMap
-	ch     chan cgroup.ChangeNotification
-	cache  map[string]*regexp.Regexp
+	bpfMap     *libbpfgo.BPFMap
+	bpfMapType config.CgroupIDMapType
+	ch         chan cgroup.ChangeNotification
+	cache      map[string]*regexp.Regexp
 }
 
 func newCgroupIDMap(module *libbpfgo.Module, cfg config.Config) (*CgroupIDMap, error) {
@@ -25,18 +29,26 @@ func newCgroupIDMap(module *libbpfgo.Module, cfg config.Config) (*CgroupIDMap, e
 	}
 
 	keySize := m.KeySize()
-	if keySize != 8 {
-		return nil, fmt.Errorf("key size for map %q is not expected 8 bytes (u64), it is %d bytes", cfg.CgroupIDMap.Name, keySize)
+	var expectedKeySize int
+	switch cfg.CgroupIDMap.Type {
+	case config.CgroupIDMapHashType:
+		expectedKeySize = 8
+	case config.CgroupIDMapCgrpStorageType:
+		expectedKeySize = 4
+	}
+	if keySize != expectedKeySize {
+		return nil, fmt.Errorf("key size for map %q is not expected %d bytes for map type %s, it is %d bytes", cfg.CgroupIDMap.Name, expectedKeySize, cfg.CgroupIDMap.Type, keySize)
 	}
 	valueSize := m.ValueSize()
 	if valueSize != 8 {
 		return nil, fmt.Errorf("value size for map %q is not expected 8 bytes (u64), it is %d bytes", cfg.CgroupIDMap.Name, valueSize)
 	}
 
 	c := &CgroupIDMap{
-		bpfMap: m,
-		ch:     make(chan cgroup.ChangeNotification, 10),
-		cache:  map[string]*regexp.Regexp{},
+		bpfMap:     m,
+		bpfMapType: cfg.CgroupIDMap.Type,
+		ch:         make(chan cgroup.ChangeNotification, 10),
+		cache:      map[string]*regexp.Regexp{},
 	}
 
 	for _, expr := range cfg.CgroupIDMap.Regexps {
@@ -59,20 +71,57 @@ func (c *CgroupIDMap) subscribe(m *cgroup.Monitor) error {
 func (c *CgroupIDMap) runLoop() {
 	for update := range c.ch {
 		if update.Remove {
-			key := uint64(update.ID)
-			err := c.bpfMap.DeleteKey(unsafe.Pointer(&key))
-			log.Printf("Error deleting key from CgroupIDMap: %v", err)
+			err := c.removeCgroup(uint64(update.ID))
+			if err != nil {
+				log.Printf("Error deleting key from CgroupIDMap %s: %v", c.bpfMap.Name(), err)
+			}
 		} else {
-			key := uint64(update.ID)
-			value := uint64(1)
-			if c.checkMatch(update.Path) {
-				err := c.bpfMap.Update(unsafe.Pointer(&key), unsafe.Pointer(&value))
+			err := c.updateCgroup(uint64(update.ID), update.Path)
+			if err != nil {
 				log.Printf("Error updating CgroupIDMap: %v", err)
 			}
 		}
 	}
 }
 
+func (c *CgroupIDMap) removeCgroup(id uint64) error {
+	// we only need to delete cgroup id for normal hash map
+	if c.bpfMapType == config.CgroupIDMapCgrpStorageType {
+		return nil
+	}
+	err := c.bpfMap.DeleteKey(unsafe.Pointer(&id))
+	if errors.Is(err, fs.ErrNotExist) {
+		return nil
+	}
+	return err
+}
+
+func (c *CgroupIDMap) updateCgroup(id uint64, cgroupPath string) error {
+	if !c.checkMatch(cgroupPath) {
+		return nil
+	}
+	value := uint64(1)
+	var err error
+	switch c.bpfMapType {
+	case config.CgroupIDMapHashType:
+		err = c.bpfMap.Update(unsafe.Pointer(&id), unsafe.Pointer(&value))
+	case config.CgroupIDMapCgrpStorageType:
+		var cgroupFile *os.File
+		// https://docs.kernel.org/bpf/map_cgrp_storage.html
+		// we need an open cgroup fd to update cgroup map
+		cgroupFile, err = os.Open(cgroupPath)
+		if err != nil {
+			log.Printf("Error opening cgroup path %s: %v", cgroupPath, err)
+		} else {
+			fd := cgroupFile.Fd()
+			err = c.bpfMap.Update(unsafe.Pointer(&fd), unsafe.Pointer(&value))
+			cgroupFile.Close()
+		}
+	}
+
+	return err
+}
+
 func (c *CgroupIDMap) checkMatch(path string) bool {
 	for _, compiled := range c.cache {
 		if compiled.MatchString(path) {