feat: add ability to get individual controller stats

This adds methods to retrieve statistics for individual cgroup controllers
(CPU, memory, pids, IO, hugetlb, rdma, misc) instead of requiring all
stats to be fetched at once. This enables tools like cadvisor to collect
specific metrics with different housekeeping intervals, reducing
computational overhead.

Fixes: #44

Signed-off-by: Sambhav Jain <jnsmbhv@gmail.com>

Author: sambhav-jain-16

cgroups.go

@@ -44,6 +44,27 @@ type Manager interface {
 	// GetStats returns cgroups statistics.
 	GetStats() (*Stats, error)
 
+	// AddCpuStats adds cpu statistics to the provided stats object.
+	AddCpuStats(stats *Stats) error
+
+	// AddMemoryStats adds memory statistics to the provided stats object.
+	AddMemoryStats(stats *Stats) error
+
+	// AddPidsStats adds pids statistics to the provided stats object.
+	AddPidsStats(stats *Stats) error
+
+	// AddIoStats adds io statistics to the provided stats object.
+	AddIoStats(stats *Stats) error
+
+	// AddHugetlbStats adds hugetlb statistics to the provided stats object.
+	AddHugetlbStats(stats *Stats) error
+
+	// AddRdmaStats adds rdma statistics to the provided stats object.
+	AddRdmaStats(stats *Stats) error
+
+	// AddMiscStats adds misc statistics to the provided stats object.
+	AddMiscStats(stats *Stats) error
+
 	// Freeze sets the freezer cgroup to the specified state.
 	Freeze(state FreezerState) error
 

fs/fs.go

@@ -14,6 +14,10 @@ import (
 	"github.com/opencontainers/cgroups/fscommon"
 )
 
+const (
+	ErrStatsNil = "stats must not be nil"
+)
+
 var subsystems = []subsystem{
 	&CpusetGroup{},
 	&DevicesGroup{},
@@ -196,6 +200,138 @@ func (m *Manager) GetStats() (*cgroups.Stats, error) {
 	return stats, nil
 }
 
+func (m *Manager) AddCpuStats(stats *cgroups.Stats) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if stats == nil {
+		return errors.New(ErrStatsNil)
+	}
+
+	cpuGroup := &CpuGroup{}
+	if path := m.paths["cpu"]; path != "" {
+		if err := cpuGroup.GetStats(path, stats); err != nil {
+			return err
+		}
+	}
+
+	cpuacctGroup := &CpuacctGroup{}
+	if path := m.paths["cpuacct"]; path != "" {
+		if err := cpuacctGroup.GetStats(path, stats); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *Manager) AddMemoryStats(stats *cgroups.Stats) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if stats == nil {
+		return errors.New(ErrStatsNil)
+	}
+	if stats.MemoryStats.Stats == nil {
+		return errors.New("stats.MemoryStats.Stats must not be nil")
+	}
+
+	memoryGroup := &MemoryGroup{}
+	if path := m.paths["memory"]; path != "" {
+		if err := memoryGroup.GetStats(path, stats); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *Manager) AddPidsStats(stats *cgroups.Stats) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if stats == nil {
+		return errors.New(ErrStatsNil)
+	}
+
+	pidsGroup := &PidsGroup{}
+	if path := m.paths["pids"]; path != "" {
+		if err := pidsGroup.GetStats(path, stats); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *Manager) AddIoStats(stats *cgroups.Stats) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if stats == nil {
+		return errors.New(ErrStatsNil)
+	}
+
+	blkioGroup := &BlkioGroup{}
+	if path := m.paths["blkio"]; path != "" {
+		if err := blkioGroup.GetStats(path, stats); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *Manager) AddHugetlbStats(stats *cgroups.Stats) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if stats == nil {
+		return errors.New(ErrStatsNil)
+	}
+	if stats.HugetlbStats == nil {
+		return errors.New("stats.HugetlbStats must not be nil")
+	}
+
+	hugetlbGroup := &HugetlbGroup{}
+	if path := m.paths["hugetlb"]; path != "" {
+		if err := hugetlbGroup.GetStats(path, stats); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *Manager) AddRdmaStats(stats *cgroups.Stats) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if stats == nil {
+		return errors.New(ErrStatsNil)
+	}
+
+	rdmaGroup := &RdmaGroup{}
+	if path := m.paths["rdma"]; path != "" {
+		if err := rdmaGroup.GetStats(path, stats); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (m *Manager) AddMiscStats(stats *cgroups.Stats) error {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	if stats == nil {
+		return errors.New(ErrStatsNil)
+	}
+
+	return nil
+}
+
 func (m *Manager) Set(r *cgroups.Resources) error {
 	if r == nil {
 		return nil