阅读计划-Linux Cgroup

Posted by 聪少 on 2019-05-30

Cgroups是control groups的缩写,是Linux内核提供的一种可以限制、记录、隔离进程组(process groups)所使用的物理资源(CPU、Memory、IO、Net等等)的机制。

基础概念

hierarchy(层级)

一个层级就是一组相关的cgroup,结构类似于进程层级结构,分父cgroup和子cgroup,一个系统内可以有多个层级。

cgroup(控制组)

组成层级(hierarchy)的最小单位,注意本文中复数词态cgroups,一般代指整个软件,单数词态代指的是单个控制组。

task(任务)

这里说的任务就是进程,每个控制组(cgroup)都可以包含若干任务。

subsystem(子系统)

可以理解为资源分类,一个子系统往往对应一种资源(如cpu、memory等)。每个子系统必须绑定到一个层级(hierarchy)上才能发挥作用。通过子系统的接口可以对某个具体的控制组(cgroup)设置资源限制。

规则

  • 一个subsystem只能附加到一个hierarchy中。
  • 一个hierarchy可以附加一个或者多个subsystem。
  • 一个操作系统可以包含多个hierarchy,每个hierarchy创建后,都会有一个root cgroup,当前系统内的所有任务都自动加入到root cgroup中。
  • 一个任务可以属于多个cgroup,这多个cgroup必须属于不同的hierarchy,即如果一个task成为同一hierarchy中第二个cgroup的成员,就会自动将其从第一个cgroup中删除。
  • 子进程(task)会自动加入到父进程所在的cgroup,但之后可以将子进程从当前cgroup中移走。

subsystem

subsystem是一组资源控制的模块,包括如下:

blkio

设置对块设备输入输出的访问控制权限。(硬盘等)

cpu

cpu设置cgroup中进程的cpu被调度策略。

cpuacct

cpuacct统计cgroup中进程的cpu占用。

cpuset

cpuset在多核机器中设置cgroup中进程可有使用cpu和内存(此处内存仅使用鱼NUMA架构)。

devices

devices用于控制cgroup中进程对设备对访问。

freezer

freezer用于挂起(suspend)和恢复(resume)cgroup中对进程。

memory

memory用于控制cgroup中进程的内存占用。

net_cls

net_cls用于将cgroup中进程产生的网络包分类,以便Linux的traffic controller可以根据分类区分出来自某个cgroup的包并做限流或者监控。

net_prio

net_prio设置cgroup中进程产生的网络流量的优先级。

ns

ns的作用是使cgroup中的进程在新的Namespace中fork新进程时,创建一个新的cgroup,这个cgroup包含新的Namespace中的新进程。

每个subsystem会关联到定义了相应限制的cgroup上,并对这个cgroup中的进程做相应的限制和控制。

查看支持的subsystem

1
2
3
4
5
6
7
8
9
10
11
12
13
# 安装工具包
[root@tyy ~]# yum install -y libcgroup-tools.x86_64
[root@tyy ~]# lssubsys -a
cpuset
cpu,cpuacct
memory
devices
freezer
net_cls,net_prio
blkio
perf_event
hugetlb
pids

hierarchy把一组cgroup串成一个树状的结构,一个树便是一个hierarchy。通过这种树状结构,cgroup可以做到继承。

再介绍

Cgroup中的hierarchy是一种树状的组织结构,kernel为了使Cgroups的配置更直观,通过一个树状文件系统配置Cgroups的。
通俗的讲Linux把Cgroup实现成了一个文件系统,如果使用他可以通过mount的方式。
可以使用下面的指令来查看:

1
2
mount -t cgroup
lssubsys -m
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
[root@tyy ~]# mount -t cgroup
cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,hugetlb)
cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpuacct,cpu)
cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)
cgroup on /sys/fs/cgroup/net_cls,net_prio type cgroup (rw,nosuid,nodev,noexec,relatime,net_prio,net_cls)
cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)
cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)
cgroup on /sys/fs/cgroup/pids type cgroup (rw,nosuid,nodev,noexec,relatime,pids)
cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)
cgroup-test on /root/cgroup-test type cgroup (rw,relatime,name=cgroup-test)
[root@tyy ~]# lssubsys -m
cpuset /sys/fs/cgroup/cpuset
cpu,cpuacct /sys/fs/cgroup/cpu,cpuacct
memory /sys/fs/cgroup/memory
devices /sys/fs/cgroup/devices
freezer /sys/fs/cgroup/freezer
net_cls,net_prio /sys/fs/cgroup/net_cls,net_prio
blkio /sys/fs/cgroup/blkio
perf_event /sys/fs/cgroup/perf_event
hugetlb /sys/fs/cgroup/hugetlb
pids /sys/fs/cgroup/pids

可以看到在/sys/fs有一个cgroup的目录,这个目录下有很多子目录,这些子目录都是cgroup的子系统。
如果你不能通过上述指令查看,那么你也可以使用mount的方式去查看, 如下操作:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 创建一个挂载点
[root@tyy ~]# mkdir cgroup-test
[root@tyy ~]# ll
总用量 124952
drwxr-xr-x 2 root root 4096 6月 3 22:37 cgroup-test
[root@tyy ~]# mount -t cgroup -o none,name=cgroup-test cgroup-test ./cgroup-test/
# 一个hierarchy
[root@tyy ~]# ll cgroup-test/
总用量 0
# cpuset的subsystem会读取这个配置文件
-rw-r--r-- 1 root root 0 6月 3 22:37 cgroup.clone_children
--w--w--w- 1 root root 0 6月 3 22:37 cgroup.
# 当前节点的cgroup中的进程组ID
-rw-r--r-- 1 root root 0 6月 3 22:37 cgroup.procs
-r--r--r-- 1 root root 0 6月 3 22:37 cgroup.sane_behavior
# 标识这个Cgroup最后一个进程退出的时候是否执行了release_agent
-rw-r--r-- 1 root root 0 6月 3 22:37 notify_on_release
-rw-r--r-- 1 root root 0 6月 3 22:37 release_agent
# 该cgroup下面的进程ID,如果将一个进程ID写到这个tasks文件中,便会将相应的进程加入到这个cgroup中.
-rw-r--r-- 1 root root 0 6月 3 22:37 tasks

资源限制演示

CPU

用下面的程序将cpu跑满

1
2
3
4
5
int main(void) {
int i = 0;
for(;;) i++;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 编译代码
[root@tyy deadloop]# gcc -o deadloop deadloop.c
# 后台执行
[root@tyy cgroup]# nohup ./deadloop 1>/dev/null 2>/dev/null &
[2] 8798
# 在cgroup的cpu限制中查看是有该进程的,这里默认是没有限制的,所以下面使用top是可以看到cpu被跑满.
[root@tyy deadloop]# top
top - 13:21:25 up 29 days, 22:46, 1 user, load average: 1.64, 0.80, 0.36
Tasks: 66 total, 3 running, 63 sleeping, 0 stopped, 0 zombie
%Cpu(s): 99.5 us, 0.5 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 1883492 total, 126760 free, 78108 used, 1678624 buff/cache
KiB Swap: 0 total, 0 free, 0 used. 1605904 avail Mem

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
8798 root 20 0 4164 348 272 R 99.6 0.0 1:22.61 deadloop
794 root 20 0 562388 18604 5880 S 0.4 1.0 4:32.86 tuned
[root@tyy cpu]# cd /sys/fs/cgroup/cpu
[root@tyy cpu]# cat tasks | grep 8798
8798
# 创建一个cgroup
[root@tyy cpu]# mkdir deadloop
[root@tyy cpu]# cd deadloop/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 添加限制只能使用20%的量
[root@tyy deadloop]# echo 20000 > cpu.cfs_quota_us
# 将进程ID输入进去
[root@tyy deadloop]# echo 8798 > tasks
# cpu瞬间降了下来.
[root@tyy deadloop]# top
top - 13:21:50 up 29 days, 22:47, 1 user, load average: 1.41, 0.81, 0.38
Tasks: 66 total, 3 running, 63 sleeping, 0 stopped, 0 zombie
%Cpu(s): 20.9 us, 0.0 sy, 0.0 ni, 79.1 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem : 1883492 total, 126868 free, 77984 used, 1678640 buff/cache
KiB Swap: 0 total, 0 free, 0 used. 1606028 avail Mem

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
8798 root 20 0 4164 348 272 R 20.7 0.0 1:43.81 deadloop

内存限制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
[root@tyy ~]# cd /sys/fs/cgroup/memory
[root@tyy memory]# mkdir deadloop
[root@tyy memory]# cd deadloop/
[root@tyy deadloop]# ls
cgroup.clone_children memory.kmem.tcp.max_usage_in_bytes memory.oom_control
cgroup.event_control memory.kmem.tcp.usage_in_bytes memory.pressure_level
cgroup.procs memory.kmem.usage_in_bytes memory.soft_limit_in_bytes
memory.failcnt memory.limit_in_bytes memory.stat
memory.force_empty memory.max_usage_in_bytes memory.swappiness
memory.kmem.failcnt memory.memsw.failcnt memory.usage_in_bytes
memory.kmem.limit_in_bytes memory.memsw.limit_in_bytes memory.use_hierarchy
memory.kmem.max_usage_in_bytes memory.memsw.max_usage_in_bytes notify_on_release
memory.kmem.slabinfo memory.memsw.usage_in_bytes tasks
memory.kmem.tcp.failcnt memory.move_charge_at_immigrate
memory.kmem.tcp.limit_in_bytes memory.numa_stat
[root@tyy deadloop]# echo 64k > memory.limit_in_bytes
[root@tyy deadloop]# echo 你的PID > tasks

写一个疯狂分配内存的程序,将pid写入tasks,如果超过64k的话就会被系统杀死。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>

int main(void) {
int size = 0;
int chunk_size = 1024;
void *p = NULL;
while(1) {

if ((p = malloc(p, chunk_size)) == NULL) {
printf("out of memory!!\n");
break;
}
memset(p, 1, chunk_size);
size += chunk_size;
printf("[%d] - memory is allocated [%8d] bytes \n", getpid(), size);
sleep(1);
}
return 0;
}

删除

删除限制的话需要tasks里面的pid全部清空才行,下面就是我删除的过程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[root@tyy cpu]# ps -ef | grep deadloop
root 8798 8724 27 13:19 pts/0 00:04:45 ./deadloop
root 8856 8724 0 13:37 pts/0 00:00:00 grep --color=auto deadloop
[root@tyy cpu]# kill -9 8798
[root@tyy cpu]#
[2]+ 已杀死 nohup ./deadloop > /dev/null 2> /dev/null(工作目录:~/gowork/src/cwork/cgroup)
(当前工作目录:/sys/fs/cgroup/cpu)
[root@tyy cpu]#
[root@tyy cpu]# rmdir deadloop
rmdir: 删除 "deadloop" 失败: 设备或资源忙
[root@tyy deadloop]# cat tasks
8724
8865
[root@tyy deadloop]# ps -ef | grep 8724
root 8724 8722 0 13:02 pts/0 00:00:00 -bash
root 8868 8724 0 13:38 pts/0 00:00:00 ps -ef
root 8869 8724 0 13:38 pts/0 00:00:00 grep --color=auto 8724
[root@tyy deadloop]# cd ..
[root@tyy cpu]# ps -ef | grep 8724
root 8724 8722 0 13:02 pts/0 00:00:00 -bash
root 8870 8724 0 13:38 pts/0 00:00:00 ps -ef
root 8871 8724 0 13:38 pts/0 00:00:00 grep --color=auto 8724
[root@tyy cpu]# kill -9 8724

我的情况是直接退出登录了,子进程也都退出了,所以清空干净了。个人要以场景而定,总之清空tasks内容即可。

1
2
3
4
5
6
7
8
9
[root@tyy ~]# cd /sys/fs/cgroup/cpu
[root@tyy cpu]# cat deadloop/tasks
[root@tyy cpu]# rmdir deadloop
[root@tyy cpu]# ls
cgroup.clone_children container cpu.cfs_period_us cpu.shares tasks
cgroup.event_control cpuacct.stat cpu.cfs_quota_us cpu.stat
cgroup.procs cpuacct.usage cpu.rt_period_us notify_on_release
cgroup.sane_behavior cpuacct.usage_percpu cpu.rt_runtime_us release_agent
[root@tyy cpu]#

golang的例子
malloc.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package main

import (
"fmt"
"os"
"runtime"
"time"
)

const (
MB = 1024 * 1024
)

func main() {
blocks := make([][MB]byte, 0)
fmt.Println("Child pid is", os.Getpid())

for i := 0; ; i++ {
blocks = append(blocks, [MB]byte{})
printMemUsage()
time.Sleep(time.Second)
}
}

func printMemUsage() {
var m runtime.MemStats
runtime.ReadMemStats(&m)
fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
fmt.Printf("\tSys = %v MiB \n", bToMb(m.Sys))
}

func bToMb(b uint64) uint64 {
return b / MB
}

climits.go

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
package main

import (
"flag"
"fmt"
"io/ioutil"
"log"
"os"
"os/exec"
"os/signal"
"path/filepath"
"syscall"
)

var (
rssLimit int
cgroupRoot string
)

const (
procsFile = "cgroup.procs"
memoryLimitFile = "memory.limit_in_bytes"
swapLimitFile = "memory.swappiness"
)

func init() {
flag.IntVar(&rssLimit, "memory", 10, "memory limit with MB.")
flag.StringVar(&cgroupRoot, "root", "/sys/fs/cgroup/memory/climits", "cgroup root path")
}

func main() {
flag.Parse()

// set memory limit
mPath := filepath.Join(cgroupRoot, memoryLimitFile)
// 写入限制内存的大小
whiteFile(mPath, rssLimit*1024*1024)

// set swap memory limit to zero
sPath := filepath.Join(cgroupRoot, swapLimitFile)
whiteFile(sPath, 0)

go startCmd("./malloc")

// 阻塞
c := make(chan os.Signal, 1)
signal.Notify(c, os.Interrupt)
s := <-c
fmt.Println("Got signal:", s)
}

func whiteFile(path string, value int) {
if err := ioutil.WriteFile(path, []byte(fmt.Sprintf("%d", value)), 0755); err != nil {
log.Panic(err)
}
}

type ExitStatus struct {
Signal os.Signal
Code int
}

func startCmd(command string) {
// 重启信号channel
restart := make(chan ExitStatus, 1)
runner := func() {
cmd := exec.Cmd{
Path: command,
}
cmd.Stdout = os.Stdout
// start app
if err := cmd.Start(); err != nil {
log.Panic(err)
}

fmt.Println("add pid", cmd.Process.Pid, "to file cgroup.procs")

// set cgroup procs id
pPath := filepath.Join(cgroupRoot, procsFile)
whiteFile(pPath, cmd.Process.Pid)

if err := cmd.Wait(); err != nil {
fmt.Println("cmd return with error:", err)
}
// 当内存超过一定限制后,进程 48189 会被 Kill 掉,守护程序收到 Kill 信号后,会先关闭老进程,再重启新进程
status := cmd.ProcessState.Sys().(syscall.WaitStatus)
options := ExitStatus{
Code: status.ExitStatus(),
}
if status.Signaled() {
options.Signal = status.Signal()
}

cmd.Process.Kill()

// 重启信号
restart <- options
}
// 第一次启动
go runner()

// 守护
for {
status := <-restart
switch status.Signal {
case os.Kill:
fmt.Println("app is killed by system")
default:
fmt.Println("app exit with code:", status.Code)
return
}
fmt.Println("restart app..")
go runner()
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
[root@tyy cgroup]# mkdir /sys/fs/cgroup/memory/climits
[root@tyy cgroup]# go build -o malloc malloc.go
[root@tyy cgroup]# go build -o climits climits.go
[root@tyy cgroup]# ./climits memory 6
add pid 9234 to file cgroup.procs
Child pid is 9234
Alloc = 1 MiB Sys = 66 MiB
Alloc = 3 MiB Sys = 66 MiB
Alloc = 7 MiB Sys = 66 MiB
Alloc = 4 MiB Sys = 66 MiB
cmd return with error: signal: killed
app is killed by system
restart app..
add pid 9238 to file cgroup.procs
Child pid is 9238
Alloc = 1 MiB Sys = 66 MiB
Alloc = 3 MiB Sys = 66 MiB
Alloc = 7 MiB Sys = 66 MiB
Alloc = 4 MiB Sys = 66 MiB
^CGot signal: interrupt
[root@tyy cgroup]#