feat: Add some toolkits

lib/cgroup/host_cgroup_test.go

+package cgroup
+
+import (
+	"os"
+	"testing"
+
+	"linkfog.com/public/option"
+)
+
+func TestSetHostCgroup(t *testing.T) {
+	// init test env
+	option.HostProc = "/proc/"
+
+	if err := SetHostCgroup(); err != nil {
+		t.Fatal(err)
+	}
+
+	cgroup, err := GetCgroup(os.Getpid())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if IsContainerCgroup(cgroup) {
+		t.Fatalf("unexpected: unit test is container cgroup\nhost cgroup:\n%s\nproc cgroup:\n%s\n",
+			HostCgroupCfg, cgroup)
+	}
+}

lib/cgroup/limit/cpu.go

+package limit
+
+import (
+	"linkfog.com/public/lib/cgroup"
+	"linkfog.com/public/lib/cgroup/fs"
+	"linkfog.com/public/lib/cgroup/fs2"
+	"linkfog.com/public/lib/l"
+)
+
+var (
+	DefaultCPULimit = float64(2)
+)
+
+func GetSelfCPULimit(defaultLimit float64) float64 {
+	return GetCPULimit(-1, defaultLimit)
+}
+
+func GetCPULimit(pid int, defaultLimit float64) float64 {
+	cgroupDir, err := cgroup.GetContainerCPUCgroupPath(pid)
+	if err != nil {
+		l.Errorf("read self cgroup cpuacct path error:%v, use default value", err)
+		return defaultLimit
+	}
+
+	if cgroup.IsCgroup2() {
+		return fs2.GetCPULimit(cgroupDir, defaultLimit)
+	} else {
+		return fs.GetCPULimit(cgroupDir, defaultLimit)
+	}
+}

lib/cgroup/limit/io.go

+package limit
+
+import (
+	"io/ioutil"
+	"strconv"
+	"strings"
+
+	"linkfog.com/public/lib/cgroup"
+	"linkfog.com/public/lib/cgroup/fs"
+	"linkfog.com/public/lib/cgroup/fs2"
+	"linkfog.com/public/lib/cgroup/types"
+)
+
+func SetSelfIORWLimit(rlimit, wlimit uint64) (map[string]*types.DevLimit, error) {
+	return SetIORWLimit(-1, rlimit, wlimit)
+}
+
+func SetIORWLimit(pid int, rlimit, wlimit uint64) (map[string]*types.DevLimit, error) {
+	cgroupDir, err := cgroup.GetContainerIOCgroupPath(pid)
+	if err != nil {
+		return nil, err
+	}
+
+	devinfos, err := getDevInfos("/proc/diskstats")
+	if err != nil {
+		return nil, err
+	}
+
+	if cgroup.IsCgroup2() {
+		return fs2.SetIORWLimit(cgroupDir, devinfos, rlimit, wlimit)
+	} else {
+		return fs.SetIORWLimit(cgroupDir, devinfos, rlimit, wlimit)
+	}
+}
+
+func getDevInfos(file string) ([]types.DevInfo, error) {
+	devinfos := make([]types.DevInfo, 0)
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		return devinfos, err
+	}
+
+	for _, line := range strings.Split(string(data), "\n") {
+		line = strings.TrimSpace(line)
+		fields := strings.Fields(line)
+		if len(fields) >= 3 {
+			_, err := strconv.Atoi(fields[0])
+			if err != nil {
+				continue
+			}
+			_, err = strconv.Atoi(fields[1])
+			if err != nil {
+				continue
+			}
+			devinfos = append(devinfos, types.DevInfo{Major: fields[0], Minor: fields[1], Name: fields[2]})
+		}
+	}
+
+	return devinfos, nil
+}

lib/cgroup/limit/memory.go

+package limit
+
+import (
+	"linkfog.com/public/lib/cgroup"
+	"linkfog.com/public/lib/cgroup/fs"
+	"linkfog.com/public/lib/cgroup/fs2"
+	"linkfog.com/public/lib/l"
+)
+
+var (
+	DefaultMemLimit = float64(3 * 1024 * 1024 * 1024)
+)
+
+func GetSelfMemoryLimit(defaultLimit float64) float64 {
+	return GetMemoryLimit(-1, defaultLimit)
+}
+
+func GetMemoryLimit(pid int, defaultLimit float64) float64 {
+	cgroupDir, err := cgroup.GetContainerMemoryCgroupPath(pid)
+	if err != nil {
+		l.Errorf("read self cgroup memory path error:%v, use default value", err)
+		return defaultLimit
+	}
+
+	if cgroup.IsCgroup2() {
+		return fs2.GetMemoryLimit(cgroupDir, defaultLimit)
+	} else {
+		return fs.GetMemoryLimit(cgroupDir, defaultLimit)
+	}
+}

lib/cgroup/stats/cpu.go

+package stats
+
+import (
+	"time"
+
+	"linkfog.com/public/lib/cgroup"
+	"linkfog.com/public/lib/cgroup/fs"
+	"linkfog.com/public/lib/cgroup/fs2"
+	"linkfog.com/public/lib/cgroup/types"
+)
+
+func GetCPUTotalUsage(cgroupDir string) (usage float64, err error) {
+	var cpuStats types.CPUStats
+	cpuStats, err = GetCPUStats(cgroupDir)
+	if err != nil {
+		return
+	}
+
+	usage = float64(cpuStats.TotalUsage)
+	return
+}
+
+func GetCPUStats(cgroupDir string) (stats types.CPUStats, err error) {
+	var totalUsage uint64
+	var perCPUUsage []uint64
+
+	if cgroup.IsCgroup2() {
+		totalUsage, err = fs2.GetCPUUsage(cgroupDir)
+	} else {
+		totalUsage, perCPUUsage, err = fs.GetCPUUsage(cgroupDir)
+	}
+	if err != nil {
+		return
+	}
+
+	stats.TotalUsage = totalUsage
+	stats.PerCPUUsage = perCPUUsage
+	stats.Timestamp = time.Now()
+	return
+}

lib/cgroup/stats/io.go

+package stats
+
+import (
+	"time"
+
+	"linkfog.com/public/lib/cgroup"
+	"linkfog.com/public/lib/cgroup/fs"
+	"linkfog.com/public/lib/cgroup/fs2"
+	"linkfog.com/public/lib/cgroup/types"
+)
+
+func GetIOStats(cgroupDir string) (*types.IOStats, error) {
+	var stats map[string]*types.IOStat
+	var err error
+
+	if cgroup.IsCgroup2() {
+		stats, err = fs2.GetAllDevIOStat(cgroupDir)
+	} else {
+		stats, err = fs.GetAllDevIOStat(cgroupDir)
+	}
+	if err != nil {
+		return nil, err
+	}
+	return &types.IOStats{Stats: stats, Timestamp: time.Now()}, nil
+}

lib/cgroup/stats/memory.go

+package stats
+
+import (
+	"path/filepath"
+	"time"
+
+	"linkfog.com/public/lib/cgroup"
+	"linkfog.com/public/lib/cgroup/fs"
+	"linkfog.com/public/lib/cgroup/fs2"
+	"linkfog.com/public/lib/cgroup/types"
+)
+
+// GetMemoryWorkingSet return memory.usage_in_bytes - total_inactive_file
+func GetMemoryWorkingSet(cgroupDir string) (usage float64, err error) {
+	var memStats types.MemoryStats
+	memStats, err = GetMemoryStats(cgroupDir)
+	if err != nil {
+		return
+	}
+
+	usage = float64(memStats.WorkingSet)
+	return
+}
+
+// GetMemoryUsage return memory.usage_in_bytes
+func GetMemoryUsage(cgroupDir string) (usage float64, err error) {
+	var memStats types.MemoryStats
+	memStats, err = GetMemoryStats(cgroupDir)
+	if err != nil {
+		return
+	}
+
+	usage = float64(memStats.Usage)
+	return
+}
+
+func GetMemoryStats(cgroupDir string) (stats types.MemoryStats, err error) {
+	if cgroup.IsCgroup2() {
+		stats.Usage, stats.WorkingSet, err = fs2.GetMemoryUsage(cgroupDir)
+	} else {
+		stats.Usage, stats.WorkingSet, err = fs.GetMemoryUsage(cgroupDir)
+	}
+	if err != nil {
+		return
+	}
+
+	stats.Timestamp = time.Now()
+	return
+}
+
+func GetKernelMemoryUsage(cgroupDir string) (usage float64, err error) {
+	var kmemUsage uint64
+	if cgroup.IsCgroup2() {
+		kmemUsage, err = fs2.GetKernelMemoryUsage(cgroupDir)
+	} else {
+		kmemUsage, err = fs.GetKernelMemoryUsage(cgroupDir)
+	}
+	if err != nil {
+		return
+	}
+
+	usage = float64(kmemUsage)
+	return
+}
+
+func GetMemoryStatFields(cgroupDir string) (activeFile, inactiveFile, activeAnon, inactiveAnon uint64, err error) {
+	var stats map[string]uint64
+	stats, err = fs.ParseMemoryStat(filepath.Join(cgroupDir, "memory.stat"))
+	if err != nil {
+		return
+	}
+
+	if cgroup.IsCgroup2() {
+		if v, ok := stats["active_file"]; ok {
+			activeFile = v
+		}
+		if v, ok := stats["inactive_file"]; ok {
+			inactiveFile = v
+		}
+		if v, ok := stats["active_anon"]; ok {
+			activeAnon = v
+		}
+		if v, ok := stats["inactive_anon"]; ok {
+			inactiveAnon = v
+		}
+	} else {
+		if v, ok := stats["total_active_file"]; ok {
+			activeFile = v
+		}
+		if v, ok := stats["total_inactive_file"]; ok {
+			inactiveFile = v
+		}
+		if v, ok := stats["total_active_anon"]; ok {
+			activeAnon = v
+		}
+		if v, ok := stats["total_inactive_anon"]; ok {
+			inactiveAnon = v
+		}
+	}
+	return
+}
+
+func GetKernelMemorySlabInfo(cgroupDir string) (slabInfo fs.SlabInfo, err error) {
+	if cgroup.IsCgroup2() {
+		return fs2.GetKernelMemorySlabInfo(cgroupDir)
+	} else {
+		return fs.GetKernelMemorySlabInfo(cgroupDir)
+	}
+}

lib/cgroup/stats/metric.go

+package stats
+
+type metric struct {
+	value float64
+	ts    int64
+}
+
+func calculateRate(v1, v2 metric) float64 {
+	diff := v2.value - v1.value
+	interval := float64(v2.ts - v1.ts)
+	if diff <= float64(0) || interval <= float64(0) {
+		return float64(0)
+	}
+	return diff / interval
+}

lib/cgroup/stats/metric_test.go

+package stats
+
+import (
+	"testing"
+	"time"
+)
+
+func TestCalculateRate(t *testing.T) {
+	ts1 := time.Now().Unix()
+	time.Sleep(1 * time.Second)
+	ts2 := time.Now().Unix()
+
+	v1 := metric{value: 1, ts: ts1}
+	v2 := metric{value: 0, ts: ts1}
+	result := calculateRate(v1, v2)
+	t.Log("v1.Value > v2.Value && v1.Timestamp == v2.Timestamp, result:", result)
+	if result != 0 {
+		t.Fatal("unexpected result")
+	}
+
+	v1 = metric{value: 1, ts: ts1}
+	v2 = metric{value: 1, ts: ts1}
+	result = calculateRate(v1, v2)
+	t.Log("v1.Value == v2.Value && v1.Timestamp == v2.Timestamp, result:", result)
+	if result != 0 {
+		t.Fatal("unexpected result")
+	}
+
+	v1 = metric{value: 1, ts: ts1}
+	v2 = metric{value: 2, ts: ts1}
+	result = calculateRate(v1, v2)
+	t.Log("v1.Value < v2.Value && v1.Timestamp == v2.Timestamp, result:", result)
+	if result != 0 {
+		t.Fatal("unexpected result")
+	}
+
+	v1 = metric{value: 1, ts: ts2}
+	v2 = metric{value: 2, ts: ts1}
+	result = calculateRate(v1, v2)
+	t.Log("v1.Value < v2.Value && v1.Timestamp > v2.Timestamp, result:", result)
+	if result != 0 {
+		t.Fatal("unexpected result")
+	}
+
+	v1 = metric{value: 1, ts: ts1}
+	v2 = metric{value: 2, ts: ts2}
+	result = calculateRate(v1, v2)
+	t.Log("v1.Value < v2.Value && v1.Timestamp < v2.Timestamp, result:", result)
+	if result == 0 {
+		t.Fatal("unexpected result")
+	}
+
+	v1 = metric{value: 1024, ts: ts1}
+	v2 = metric{value: 2048, ts: ts2}
+	result = calculateRate(v1, v2)
+	t.Log("rate is", result)
+	if result != 1024 {
+		t.Fatal("unexpected result")
+	}
+}

lib/cgroup/stats/stats.go

+package stats
+
+import (
+	"fmt"
+	"math"
+	"time"
+
+	"linkfog.com/public/lib/cgroup"
+	"linkfog.com/public/lib/cgroup/types"
+	"linkfog.com/public/lib/common"
+)
+
+type Stats struct {
+	pid        int
+	memDir     string
+	cpuDir     string
+	ioDir      string
+	fifo       *common.Fifo   // for cpu stats
+	preIoStats *types.IOStats // for io stats
+}
+
+func NewStats(pid int, refreshDura, cpuRateRange time.Duration) *Stats {
+	poolLen := math.Ceil(float64(cpuRateRange.Nanoseconds())/float64(refreshDura)) + 1
+	if poolLen <= 1 {
+		poolLen = 2
+	}
+	return NewStatsWithPoolLen(pid, int(poolLen))
+}
+
+func NewStatsWithPoolLen(pid int, poolLen int) *Stats {
+	stats := &Stats{
+		pid:  pid,
+		fifo: common.NewFifo(poolLen),
+	}
+	return stats
+}
+
+func (s *Stats) TryCgroupPath() error {
+	var err error
+	s.memDir, err = cgroup.GetContainerMemoryCgroupPath(s.pid)
+	if err != nil {
+		return fmt.Errorf("get container (pid:%d) mem cgroup path err:%v", s.pid, err)
+	}
+	s.cpuDir, err = cgroup.GetContainerCPUCgroupPath(s.pid)
+	if err != nil {
+		return fmt.Errorf("get container (pid:%d) cpu cgroup path err:%v", s.pid, err)
+	}
+	s.ioDir, err = cgroup.GetContainerIOCgroupPath(s.pid)
+	if err != nil {
+		return fmt.Errorf("get container (pid:%d) io cgroup path err:%v", s.pid, err)
+	}
+	return nil
+}
+
+func (s *Stats) GetMemoryWorkingSet() (usage float64, err error) {
+	var memStats types.MemoryStats
+	memStats, err = GetMemoryStats(s.memDir)
+	if err != nil {
+		return
+	}
+
+	usage = float64(memStats.WorkingSet)
+	return
+}
+
+func (s *Stats) GetCPUUsage() (usage float64, err error) {
+	var cpuStats types.CPUStats
+	cpuStats, err = GetCPUStats(s.cpuDir)
+	if err != nil {
+		return
+	}
+
+	s.fifo.Push(cpuStats)
+	if s.fifo.Len() >= s.fifo.MaxLen() {
+		frontStats := s.fifo.Front().Value.(types.CPUStats)
+		backStats := s.fifo.Back().Value.(types.CPUStats)
+		front := metric{
+			value: float64(frontStats.TotalUsage) / float64(time.Second),
+			ts:    frontStats.Timestamp.Unix(),
+		}
+		back := metric{
+			value: float64(backStats.TotalUsage) / float64(time.Second),
+			ts:    backStats.Timestamp.Unix(),
+		}
+		usage = calculateRate(front, back)
+	}
+	return
+}
+
+func (s *Stats) GetIOUsage() (map[string]*types.IOUsage, error) {
+	curIoStats, err := GetIOStats(s.ioDir)
+	if err != nil {
+		return nil, err
+	}
+
+	ioUsage := make(map[string]*types.IOUsage, 0)
+	if s.preIoStats != nil {
+		for dev, curIoStat := range curIoStats.Stats {
+			ioUsage[dev] = &types.IOUsage{}
+			if preIoStat, ok := s.preIoStats.Stats[dev]; ok {
+				if curIoStat.Read != 0 {
+					pre := metric{value: float64(preIoStat.Read), ts: s.preIoStats.Timestamp.Unix()}
+					cur := metric{value: float64(curIoStat.Read), ts: curIoStats.Timestamp.Unix()}
+					ioUsage[dev].Read = calculateRate(pre, cur)
+				}
+				if curIoStat.Write != 0 {
+					pre := metric{value: float64(preIoStat.Write), ts: s.preIoStats.Timestamp.Unix()}
+					cur := metric{value: float64(curIoStat.Write), ts: curIoStats.Timestamp.Unix()}
+					ioUsage[dev].Write = calculateRate(pre, cur)
+				}
+			}
+		}
+	}
+	s.preIoStats = curIoStats
+	return ioUsage, nil
+}
+
+func (s *Stats) GetMemoryDir() string {
+	return s.memDir
+}
+
+func (s *Stats) GetCPUDir() string {
+	return s.cpuDir
+}
+
+func (s *Stats) GetIODir() string {
+	return s.ioDir
+}

lib/cgroup/stats/stats_test.go

+package stats
+
+import (
+	"testing"
+	"time"
+)
+
+func TestNewStats(t *testing.T) {
+	dura := 1 * time.Second
+	rateRange := 1 * time.Second
+	stats := NewStats(-1, dura, rateRange)
+	err := stats.TryCgroupPath()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	for i := 1; i <= 2; i++ {
+		memoryUsage, err := stats.GetMemoryWorkingSet()
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Log(i, "memory usage", memoryUsage)
+
+		cpuUsage, err := stats.GetCPUUsage()
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Log(i, "cpu usage", cpuUsage)
+
+		ioUsage, err := stats.GetIOUsage()
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Log(i, "io usage", ioUsage)
+
+		time.Sleep(time.Second)
+	}
+}

lib/cgroup/testdata/cg1_memory/memory.kmem.slabinfo

+slabinfo - version: 2.1
+# name            <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab> : tunables <limit> <batchcount> <sharedfactor> : slabdata <active_slabs> <num_slabs> <sharedavail>
+fsnotify_mark_connector    850    850     24  170    1 : tunables    0    0    0 : slabdata      5      5      0
+Acpi-State           408    408     80   51    1 : tunables    0    0    0 : slabdata      8      8      0
+nf_conntrack_ffffffff94111640   2193   2193    320   51    4 : tunables    0    0    0 : slabdata     43     43      0
+UDP                   30     30   1088   30    8 : tunables    0    0    0 : slabdata      1      1      0
+user_namespace       408    408    480   68    8 : tunables    0    0    0 : slabdata      6      6      0
+TCPv6                 15     15   2112   15    8 : tunables    0    0    0 : slabdata      1      1      0
+xfs_efd_item         507    507    416   39    4 : tunables    0    0    0 : slabdata     13     13      0
+TCP                   96     96   1984   16    8 : tunables    0    0    0 : slabdata      6      6      0
+buffer_head         1677   1677    104   39    1 : tunables    0    0    0 : slabdata     43     43      0
+bio-2                306    306    320   51    4 : tunables    0    0    0 : slabdata      6      6      0
+blkdev_ioc           234    234    104   39    1 : tunables    0    0    0 : slabdata      6      6      0
+kmalloc-8192          24     24   8192    4    8 : tunables    0    0    0 : slabdata      6      6      0
+taskstats            294    294    328   49    4 : tunables    0    0    0 : slabdata      6      6      0
+xfs_ili              288    288    168   48    2 : tunables    0    0    0 : slabdata      6      6      0
+radix_tree_node      560    560    584   56    8 : tunables    0    0    0 : slabdata     10     10      0
+xfs_inode            204    204    960   34    8 : tunables    0    0    0 : slabdata      6      6      0
+posix_timers_cache    396    396    248   66    4 : tunables    0    0    0 : slabdata      6      6      0
+xfs_log_ticket       264    264    184   44    2 : tunables    0    0    0 : slabdata      6      6      0
+shmem_inode_cache    144    144    680   48    8 : tunables    0    0    0 : slabdata      3      3      0
+ovl_inode            336    336    680   48    8 : tunables    0    0    0 : slabdata      7      7      0
+avc_node             336    336     72   56    1 : tunables    0    0    0 : slabdata      6      6      0
+inode_cache          330    330    592   55    8 : tunables    0    0    0 : slabdata      6      6      0
+sigqueue             306    306    160   51    2 : tunables    0    0    0 : slabdata      6      6      0
+selinux_inode_security    612    612     40  102    1 : tunables    0    0    0 : slabdata      6      6      0
+kmalloc-8           3072   3072      8  512    1 : tunables    0    0    0 : slabdata      6      6      0
+mnt_cache            884    924    384   42    4 : tunables    0    0    0 : slabdata     22     22      0
+idr_layer_cache       60     60   2112   15    8 : tunables    0    0    0 : slabdata      4      4      0
+kmalloc-96           462    462     96   42    1 : tunables    0    0    0 : slabdata     11     11      0
+shared_policy_node    170    170     48   85    1 : tunables    0    0    0 : slabdata      2      2      0
+signal_cache         168    168   1152   28    8 : tunables    0    0    0 : slabdata      6      6      0
+sighand_cache         90     90   2112   15    8 : tunables    0    0    0 : slabdata      6      6      0
+files_cache          306    306    640   51    8 : tunables    0    0    0 : slabdata      6      6      0
+task_delay_info      216    216    112   36    1 : tunables    0    0    0 : slabdata      6      6      0
+task_xstate          780    780    832   39    8 : tunables    0    0    0 : slabdata     20     20      0
+task_struct           98     98   4160    7    8 : tunables    0    0    0 : slabdata     14     14      0
+sock_inode_cache     306    306    640   51    8 : tunables    0    0    0 : slabdata      6      6      0
+kmalloc-512          512    512    512   64    8 : tunables    0    0    0 : slabdata      8      8      0
+kmalloc-32           768    768     32  128    1 : tunables    0    0    0 : slabdata      6      6      0
+kmalloc-1024         352    352   1024   32    8 : tunables    0    0    0 : slabdata     11     11      0
+kmalloc-128         3648   3648    128   64    2 : tunables    0    0    0 : slabdata     57     57      0
+anon_vma             459    459     80   51    1 : tunables    0    0    0 : slabdata      9      9      0
+kmalloc-64          1792   1792     64   64    1 : tunables    0    0    0 : slabdata     28     28      0
+vm_area_struct      2375   2479    216   37    2 : tunables    0    0    0 : slabdata     67     67      0
+mm_struct            120    120   1600   20    8 : tunables    0    0    0 : slabdata      6      6      0
+proc_inode_cache    7072   7742    656   49    8 : tunables    0    0    0 : slabdata    158    158      0
+dentry              8270   8904    192   42    2 : tunables    0    0    0 : slabdata    212    212      0
+kmalloc-16          1536   1536     16  256    1 : tunables    0    0    0 : slabdata      6      6      0
+kmalloc-192         3402   3402    192   42    2 : tunables    0    0    0 : slabdata     81     81      0
+kmalloc-256         2854   3200    256   64    4 : tunables    0    0    0 : slabdata     50     50      0
+kmalloc-2048         236    256   2048   16    8 : tunables    0    0    0 : slabdata     16     16      0
+kmalloc-4096          73    120   4096    8    8 : tunables    0    0    0 : slabdata     15     15      0
\ No newline at end of file

lib/cgroup/testdata/cg1_memory/memory.kmem.usage_in_bytes

+10240000
\ No newline at end of file

lib/cgroup/testdata/cg1_memory/memory.stat

+cache 13672448
+rss 226430976
+rss_huge 0
+mapped_file 8921088
+swap 0
+pgpgin 18082270
+pgpgout 18023651
+pgfault 69828799
+pgmajfault 220
+inactive_anon 0
+active_anon 226430976
+inactive_file 6828032
+active_file 6844416
+unevictable 0
+hierarchical_memory_limit 3221225472
+hierarchical_memsw_limit 3221225472
+total_cache 13672448
+total_rss 226430976
+total_rss_huge 0
+total_mapped_file 8921088
+total_swap 0
+total_pgpgin 18082270
+total_pgpgout 18023651
+total_pgfault 69828799
+total_pgmajfault 220
+total_inactive_anon 0
+total_active_anon 22643097
+total_inactive_file 2400000
+total_active_file 6844416
+total_unevictable 0
\ No newline at end of file

lib/cgroup/testdata/cg1_memory/memory.usage_in_bytes

+102400000
\ No newline at end of file

lib/cgroup/testdata/cg2/memory.current

+102400001
\ No newline at end of file

lib/cgroup/testdata/cg2/memory.stat

+anon 121929728
+file 2021380096
+kernel_stack 1806336
+slab 314105856
+sock 196608
+shmem 1241088
+file_mapped 105160704
+file_dirty 1081344
+file_writeback 135168
+anon_thp 0
+inactive_anon 52580352
+active_anon 56909824
+inactive_file 2400000
+active_file 912285696
+unevictable 13516800
+slab_reclaimable 290246656
+slab_unreclaimable 23859200
+pgfault 38792189
+pgmajfault 1991
+workingset_refault 7649
+workingset_activate 5416
+workingset_nodereclaim 9075
+pgrefill 224452
+pgscan 338134
+pgsteal 325178
+pgactivate 8118
+pgdeactivate 219141
+pglazyfree 4693
+pglazyfreed 891
+thp_fault_alloc 0
+thp_collapse_alloc 0
\ No newline at end of file

lib/cgroup/testdata/cgroup_v1

+11:perf_event:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+10:memory:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+9:blkio:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+8:cpuacct,cpu:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+7:devices:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+6:hugetlb:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+5:freezer:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+4:cpuset:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+3:pids:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+2:net_prio,net_cls:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
+1:name=systemd:/kubepods/besteffort/pod30d45881-d876-4898-a212-f8c95e1b08db/b5209b0109b0fc07d889f4f7878354670c8fbc6a977201be3a6f6aa389187f1b
\ No newline at end of file

lib/cgroup/testdata/cgroup_v2_docker

+0::/system.slice/docker-1654a9da9950616391265776d0c38f1ab55c95afbc5581ed9f7ff0c370b25ebf.scope
\ No newline at end of file

lib/cgroup/testdata/cgroup_v2_k8s

+0::/kubepods.slice/kubepods-burstable.slice/xxxxxxxxxx-1654a9da9950616391265776d0c38f1ab55c95afbc5581ed9f7ff0c370b25ebf.scope
\ No newline at end of file