前回はLinuxの namespace(名前空間) についてCプログラムやツールを使っていろいろと確認できましたので、今回は cgroups についても調べます。
namespaceは生成したプロセスに対してリソース体系を割り当てる(隔離空間を作る)のに対して、cgroupsは指定したプロセスのグループに対してリソース制限をかけます。似ているようで全然別の機能ですね。
環境
* CentOS 7.2 (kernel-3.10.0-327.4.5.el7.x86_64)
* Ubuntu 14.04 (3.13.0-77-generic)
* Docker 1.9.1
cgroups
Control Groups provide a mechanism for aggregating/partitioning sets of
tasks, and all their future children, into hierarchical groups with
specialized behaviour.
cgroupsは control groups の略でタスクをグループ化したり、そのグループ内のタスクに対して様々なリソース制御を行うための仕組みです。namespaceではホスト名やPID空間などのカーネル/OSが扱うリソースを制御(隔離)しますが、cgroupsで制御するのはCPUやメモリといった物理的なリソースです。
/sys/fs/cgroup 以下に仮想的なファイルシステムとしてのインタフェースが提供されています。今回の作業環境も上述の通りCentOSとUbuntuの両方で確認していますが、CentOSの場合はsystemd経由でcgroupsを操作するのに対して、Ubuntuの場合は直接 /sys/fs/cgroup を書き換えています。Ubuntu 15.04からはUpstartからsystemdに置き換わるらしいですが、ディレクトリ以下の構造は基本的には変わりません。
実際に /sys/fs/cgroup の中身を見てみるとcpuやmemoryといったわかりやすい名前のサブディレクトリが見えます。
[bash]
# CentOSの場合
$ ls -l /sys/fs/cgroup
drwxr-xr-x 2 root root 0 2月 6 16:07 blkio/
lrwxrwxrwx 1 root root 11 2月 6 16:07 cpu -> cpu,cpuacct/
drwxr-xr-x 2 root root 0 2月 6 16:07 cpu,cpuacct/
lrwxrwxrwx 1 root root 11 2月 6 16:07 cpuacct -> cpu,cpuacct/
drwxr-xr-x 2 root root 0 2月 6 16:07 cpuset/
drwxr-xr-x 2 root root 0 2月 6 16:07 devices/
drwxr-xr-x 2 root root 0 2月 6 16:07 freezer/
drwxr-xr-x 2 root root 0 2月 6 16:07 hugetlb/
drwxr-xr-x 2 root root 0 2月 6 16:07 memory/
drwxr-xr-x 2 root root 0 2月 6 16:07 net_cls/
drwxr-xr-x 2 root root 0 2月 6 16:07 perf_event/
drwxr-xr-x 4 root root 0 2月 6 16:07 systemd/
# Ubuntuの場合
$ ls -l /sys/fs/cgroup
drwxr-xr-x 3 root root 0 4月 28 11:02 blkio/
drwxr-xr-x 3 root root 0 4月 28 11:02 cpu/
drwxr-xr-x 3 root root 0 4月 28 11:02 cpuacct/
drwxr-xr-x 3 root root 0 4月 28 11:02 cpuset/
drwxr-xr-x 3 root root 0 4月 28 11:02 devices/
drwxr-xr-x 3 root root 0 4月 28 11:02 freezer/
drwxr-xr-x 3 root root 0 4月 28 11:02 hugetlb/
drwxr-xr-x 3 root root 0 4月 28 11:02 memory/
drwxr-xr-x 3 root root 0 4月 28 11:02 perf_event/
drwxr-xr-x 3 root root 0 4月 28 11:02 systemd/
[/bash]
仮想的なファイルシステムと前述した通り、ここでファイル/ディレクトリ操作をすることで様々なリソース制御を行います。これらはサブシステムと呼ばれています。
[bash]
## 使用可能なサブシステムは/proc/cgroupsで確認できる
$ cat /proc/cgroups
#subsys_name hierarchy num_cgroups enabled
cpuset 2 10 1
cpu 3 10 1
cpuacct 4 10 1
memory 5 10 1
devices 6 10 1
freezer 7 10 1
blkio 8 10 1
perf_event 9 10 1
hugetlb 10 10 1
## OSブート時にcgroupが初期化されていることを確認
$ dmesg | grep cgroup
[ 0.000000] Initializing cgroup subsys cpuset
[ 0.000000] Initializing cgroup subsys cpu
[ 0.000000] Initializing cgroup subsys cpuacct
[ 0.000000] allocated 33554432 bytes of page_cgroup
[ 0.000000] please try ‘cgroup_disable=memory’ option if you don’t want memory cgroups
[ 0.002301] Initializing cgroup subsys memory
[ 0.002305] Initializing cgroup subsys devices
[ 0.002306] Initializing cgroup subsys freezer
[ 0.002307] Initializing cgroup subsys blkio
[ 0.002308] Initializing cgroup subsys perf_event
[ 0.002310] Initializing cgroup subsys hugetlb
## include/linux/cgroup_subsys.h 内にマクロで列挙されている
$ cat include/linux/cgroup_subsys.h | grep ‘SUBSYS(‘
SUBSYS(cpuset)
SUBSYS(debug)
SUBSYS(cpu_cgroup)
SUBSYS(cpuacct)
SUBSYS(mem_cgroup)
SUBSYS(devices)
SUBSYS(freezer)
SUBSYS(net_cls)
SUBSYS(blkio)
SUBSYS(perf)
SUBSYS(net_prio)
SUBSYS(hugetlb)
[/bash]
| サブシステム | 概要 |
|---|---|
| blkio | ブロックデバイスの入出力 |
| cpu | CPUリソースの割り当て・制限 |
| cpuacct | タスクが消費するCPU時間をレポート |
| cpuset | グループへのCPU，メモリノードの割り当て |
| devices | デバイスへのアクセス制限 |
| freezer | グループに属するプロセスの一時停止/再開 |
| hugetlb | cgroupからのhugetlbの使用 |
| memory | タスクが消費するメモリリソースのレポートと制限 |
| perf_event | cgroup単位でのperfツールの使用 |
cgroupsによってタスクをグループ化しますが、そのグループは各々ヒエラルキー(hierarchy:階層)構造を持ち、上記のサブシステムによるリソース制限を受けます。そのヒエラルキー構造は仮想ファイルシステム上で表現されます。
ここではいくつかのサブシステムをピックアップしていろいろ調べてみます。
cpuset/cpu/memoryサブシステム
まずは挙動がわかりやすいcpuset/cpu/memoryサブシステムについて。dockerコンテナを作成する際の以下のオプションに関係してきます。オプション名はDockerのバージョンによって変わることがあるので注意してください(その際はdeprecatedメッセージが出力されます)。
| –cpuset-cpus | 使用するCPUコアを指定 (cpusetサブシステム) |
| –cpu-shares | CPU時間の割り当てを相対比率で指定、デフォルト 1024 (cpuサブシステム) |
| -m | –memory | 使用メモリの上限 (memoryサブシステム) |
上記dockerオプションはcpuset,cpu,memoryサブシステムの以下のファイルを操作してリソース制限を行います。ここではUbuntu上で動作確認していますが、/sys/fs/cgourps/cpuset,cpu,memoryディレクトリに以下のファイルがあります。
- cpuset.cpus
- cpu.shares
- memory.limit_in_bytes
まずはcpusetサブシステムの動作確認のために適当なdockerコンテナを作って起動し、CPU1のみを利用するように --cpuset-cpus オプションで指定してddコマンドを実行し続けます。
[bash]
$ sudo docker run -itd –cpuset-cpus 1 centos dd if=/dev/zero of=/dev/null
46532188bbd17503d9ceca0d57d72c5783d25e2f5648af4c89c5111e3a847a10
## topコマンドでCPU使用率を確認
$ top
top – 23:11:40 up 9:56, 1 user, load average: 0.99, 0.58, 0.27
Tasks: 158 total, 2 running, 156 sleeping, 0 stopped, 0 zombie
%Cpu0 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
%Cpu1 : 26.3 us, 73.7 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st ## 1コアのみ利用されている
%Cpu2 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
%Cpu3 : 0.3 us, 0.0 sy, 0.0 ni, 99.7 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem: 8071336 total, 1041000 used, 7030336 free, 124388 buffers
KiB Swap: 16670716 total, 0 used, 16670716 free. 599068 cached Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
7146 root 20 0 4356 360 284 R 99.8 0.0 4:13.35 dd
… 省略
[/bash]
dockerではコンテナを起動すると各サブシステムに docker/{コンテナID} 名のディレクトリを作成します。上記のコンテナで指定した --cpuset-cpus の値を確認してみます。
[bash]
## cpuset.cpusファイルに1が書き込まれている
$ cat /sys/fs/cgroup/cpuset/docker/46532188bbd17503d9ceca0d57d72c5783d25e2f5648af4c89c5111e3a847a10/cpuset.cpus
1
[/bash]
次はcpuサブシステムが関係する --cpu-shares の挙動を確認してみます。2つめのコンテナを以下のオプションで起動します。--cpu-shares 2048 と指定していますが、これは同じCPUコアで複数のコンテナのプロセスが実行される場合に、どちらのコンテナを優先的に実行するかを相対的な重みで指定するオプションです。デフォルト値が1024なので、ここではその2倍の値を指定しています。その結果、2つめのコンテナは2倍の優先度でCPU時間が割り当てられることになります。
[bash]
$ sudo docker run -itd –cpuset-cpus 1 –cpu-shares 2048 centos dd if=/dev/zero of=/dev/null
2b8096a07c04892d9882615a70f5cf58882de3af1434e45a931bf587ba9f2015
## 同様にtopコマンドでCPU使用率を確認
top – 23:38:30 up 10:23, 1 user, load average: 1.99, 1.32, 0.79
Tasks: 159 total, 3 running, 156 sleeping, 0 stopped, 0 zombie
%Cpu0 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
%Cpu1 : 25.0 us, 75.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st ## 1コアのみ利用
%Cpu2 : 0.0 us, 0.3 sy, 0.0 ni, 99.7 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
%Cpu3 : 0.0 us, 0.0 sy, 0.0 ni,100.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
KiB Mem: 8071336 total, 1050296 used, 7021040 free, 125476 buffers
KiB Swap: 16670716 total, 0 used, 16670716 free. 600564 cached Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
7794 root 20 0 4356 356 284 R 66.6 0.0 2:02.05 dd ## 2つめのコンテナでのdd
7670 root 20 0 4356 360 284 R 33.6 0.0 2:05.72 dd ## 1つめのコンテナでのdd
… 省略
[/bash]
2つのコンテナでのddコマンドのCPU使用率が綺麗に1対2に分かれています。確認のため cpu.shares ファイルの中身も見てみます。
[bash]
## cpu.sharesファイルに2048が書き込まれている
$ cat /sys/fs/cgroup/cpu/docker/2b8096a07c04892d9882615a70f5cf58882de3af1434e45a931bf587ba9f2015/cpu.shares
2048
[/bash]
次はmemoryサブシステムが関係する --memory オプションの挙動を確認します。コンテナから使用できるメモリの上限値を指定するオプションで、数値の後ろにmを付ければMB(メガバイト)指定ができます。
[bash]
$ sudo docker run -itd –memory 128m centos /bin/bash
6077df1a5a396b729256871482942d033aa9f0897f3bf9753e1e90e23029eb48
## memory.limit_in_bytesファイルに指定した値がバイト単位で書き込まれている
$ cat /sys/fs/cgroup/memory/docker/6077df1a5a396b729256871482942d033aa9f0897f3bf9753e1e90e23029eb48/memory.limit_in_bytes
134217728 ## 128MB
[/bash]
--memory オプションを指定しない場合(デフォルト)だと、memory.limit_in_bytesファイルには 18446744073709551615 (bytes)と書かれていました。スワップ領域の容量も同じサイズに制限されるため、128mと指定した場合はプロセスは物理メモリ128MB + スワップ128MBまで使用できます。そのサイズを超えるとOOM Killerが発動してコンテナ内のプロセスが強制終了させられます。
また、以下のファイルの中身を見るとコンテナ内でのメモリ使用状況を確認することができます。
[bash]
## コンテナ内のプロセスの現在のメモリ使用量
$ cat /sys/fs/cgroup/memory/docker/6077df1a5a396b729256871482942d033aa9f0897f3bf9753e1e90e23029eb48/memory.usage_in_bytes
2453504
## コンテナ内のプロセスのメモリ使用量の最大値
$ cat /sys/fs/cgroup/memory/docker/6077df1a5a396b729256871482942d033aa9f0897f3bf9753e1e90e23029eb48/memory.max_usage_in_bytes
134217728 ## コンテナ作成時にオプションで指定した値 128MB
## コンテナ内のプロセスのメモリ使用量が上限値に達した回数
$ cat /sys/fs/cgroup/memory/docker/6077df1a5a396b729256871482942d033aa9f0897f3bf9753e1e90e23029eb48/memory.failcnt
84491
[/bash]
ここまで紹介した各ファイル内の値を直接書き換えることでもコンテナ内のリソースを任意に制限をすることができます。まぁdockerを使っているなら素直にdockerのコマンドから指定した方が良いですね。
devicesサブシステム
次にdevicesサブシステムについていろいろ確認してみます。devicesはグループに所属するプロセスがアクセス可能なデバイスを制限するサブシステムです。例えばコンテナ内から直接ネットワークやディスクのデバイスにアクセスさせないように設定できます。
[bash]
$ ls -l /sys/fs/cgroup/devices
-rw-r–r– 1 root root 0 4月 28 11:02 cgroup.clone_children
–w–w–w- 1 root root 0 4月 28 11:02 cgroup.event_control
-rw-r–r– 1 root root 0 4月 28 11:02 cgroup.procs
-r–r–r– 1 root root 0 4月 28 11:02 cgroup.sane_behavior
–w——- 1 root root 0 4月 28 11:02 devices.allow
–w——- 1 root root 0 4月 28 11:02 devices.deny
-r–r–r– 1 root root 0 4月 28 11:02 devices.list
drwxr-xr-x 3 root root 0 4月 28 11:09 docker/
-rw-r–r– 1 root root 0 4月 28 11:02 notify_on_release
-rw-r–r– 1 root root 0 4月 28 11:02 release_agent
-rw-r–r– 1 root root 0 4月 28 11:02 tasks
drwxr-xr-x 4 root root 0 4月 28 11:02 user/
[/bash]
cgroupから始まっているファイルは他のサブシステムと共通のファイル、devicesから始まっているファイルはdevicesサブシステム専用のファイルとなっています。それ以外の tasks、notify_on_release、release_agent の3つはどうやら歴史的な理由でプレフィックスが付いていないようです。これらに頼るのなら焼かれる覚悟をしておけって書いてありますけど、怖すぎるんですが。
[cpp]
/*
* Historical crazy stuff. These don’t have “cgroup.” prefix and
* don’t exist if sane_behavior. If you’re depending on these, be
* prepared to be burned.
*/
{
.name = “tasks”,
.flags = CFTYPE_INSANE, /* use “procs” instead */
.seq_start = cgroup_pidlist_start,
.seq_next = cgroup_pidlist_next,
.seq_stop = cgroup_pidlist_stop,
.seq_show = cgroup_pidlist_show,
.private = CGROUP_FILE_TASKS,
.write_u64 = cgroup_tasks_write,
.mode = S_IRUGO | S_IWUSR,
},
{
.name = “notify_on_release”,
.flags = CFTYPE_INSANE,
.read_u64 = cgroup_read_notify_on_release,
.write_u64 = cgroup_write_notify_on_release,
},
{
.name = “release_agent”,
.flags = CFTYPE_INSANE | CFTYPE_ONLY_ON_ROOT,
.seq_show = cgroup_release_agent_show,
.write_string = cgroup_release_agent_write,
.max_write_len = PATH_MAX,
},
{ } /* terminate */
};
[/cpp]
前述のdevicesプレフィックスが付いた3つのファイルを使って各種アクセス制御を行います。
| devices.allow | アクセスを許可するデバイスを追加 |
| devices.deny | アクセスを禁止するデバイスを追加 |
| devices.list | 現在のアクセス許可されているデバイスの状態を表示 |
Linux Kernel Updates Vol 2014.08の内容に沿ってこちらの環境でも動作確認してみます。まずはdevices.listの中身を見て現在のデバイスの状態を確認しておきます。
[bash]
$ cat /sys/fs/cgroup/devices/devices.list
a *:* rwm ## 全てのデバイスにアクセス可能であることを示している、具体的な読み方は後述
[/bash]
dockerコンテナの内部ではどうなっているでしょう。
[bash]
## dockerコンテナ起動前
$ ls /sys/fs/cgroup/devices/docker/
cgroup.clone_children cgroup.event_control cgroup.procs devices.allow devices.deny devices.list notify_on_release tasks
## コンテナ起動
$ sudo docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a4557c514ddc centos “/bin/bash” 9 weeks ago Exited (137) 4 seconds ago clever_hawking
$ sudo docker start clever_hawking
clever_hawking
## dockerコンテナ起動時に /sys/fs/cgroup/{サブシステム}/docker/{コンテナID} ディレクトリが作成される
$ ls /sys/fs/cgroup/devices/docker/
a4557c514ddc3c3668030fe9b1aac13b7ba8c5ea3fdaed70e345eb7991df364c/ cgroup.clone_children cgroup.event_control cgroup.procs devices.allow devices.deny devices.list notify_on_release tasks
## 同様にdevices.listの中身を見る
$ cat /sys/fs/cgroup/devices/docker/a4557c514ddc3c3668030fe9b1aac13b7ba8c5ea3fdaed70e345eb7991df364c/devices.list
c *:* m
b *:* m
c 5:1 rwm
c 4:0 rwm
c 4:1 rwm
c 136:* rwm
c 5:2 rwm
c 10:200 rwm
c 1:3 rwm
c 1:5 rwm
c 1:7 rwm
c 5:0 rwm
c 1:9 rwm
c 1:8 rwm
[/bash]
なにやらいろいろと制限されているようです。以下に読み方を整理します。
- 先頭のアルファベット a: 全てのデバイス、b: ブロックデバイス、c: キャラクタデバイス
- n:m (n:mはメジャー番号:マイナー番号 or ワイルドカード)は/devのノード番号
- 末尾のアルファベット3つ r: 読み込み可能、w: 書き込み可能、m: 新規作成可能
となっています。つまり a *:* rwm は全てのデバイスへの操作が可能であることを示しています。そして上記の内容を読み解くと、まずは全てのキャラクタデバイスとブロックデバイスへの読み書きを禁止した後に、個々のキャラクタデバイスに必要に応じて権限を与えていることが読み取れます。/devのノード番号だけみてもわかりにくいですが、例えば 1:3 は /dev/null 、1:8 は /dev/random を差しています。このように各デバイスへの操作を制限することによってdockerコンテナ内のセキュリティを担保しているのですが、ここでは試しにその制限を解除してみます。
[bash]
## 適当なdockerコンテナを作る
$ sudo docker run -it centos /bin/bash
## dockerコンテナ内のcgroupsの設定を確認
$ cat /sys/fs/cgroup/devices/docker/a3cdbc51ba62665e056fc438390dcf7e0ee3deae6e39312dfa41071d9cde2946/cgroup.procs
7811 ## 起動しているプロセスIDが表示される
$ ps 7811
PID TTY STAT TIME COMMAND
7811 pts/20 Ss+ 0:00 /bin/bash ## PID 7811はbashプロセス
## コンテナ内のbashプロセスから/dev/kmsgへの書き込みが制限されていることを確認
# mknod /dev/kmsg c 1 11
# echo aiueo > /dev/kmsg
bash: /dev/kmsg: Operation not permitted ## この時点では書き込みできない
## 制限を解除するには、ホストから別のcgroupにコンテナ内のプロセスを移す
$ cd /sys/fs/cgroup/devices
$ echo 7811 | sudo tee cgroup.procs
7811
## もう一度コンテナ内から/dev/kmsgに書き込みを試すと
# echo aiueo > /dev/kmsg ## 今度は成功
## ホストからカーネルバッファを確認
$ dmesg | tail -n 1
[ 6563.293512] aiueo ## コンテナ側から書き込んだ文字列が記録されている
[/bash]
また、devices.allowに明示的に/dev/kmsgへの読み書きを許可することもできます。
[bash]
$ echo ‘c 1:11 rwm’ | sudo tee /sys/fs/cgroup/devices/docker/a3cdbc51ba62665e056fc438390dcf7e0ee3deae6e39312dfa41071d9cde2946/devices.allow
c 1:11 rwm
[/bash]
devicesサブシステムの動作確認ができました。他にもサブシステムはありますが動作確認はこれくらいにして、カーネルのソースコードも少しだけ見ておきたいと思います。
カーネルの実装
task_struct 構造体(Linuxプロセスを表現するデータ構造)のメンバに css_set というcgroupを管理するための構造体があります。
[cpp]
## include/linux/sched.h
#ifdef CONFIG_CGROUPS
/* Control Group info protected by css_set_lock */
struct css_set __rcu *cgroups;
/* cg_list protected by css_set_lock and tsk->alloc_lock */
struct list_head cg_list;
#endif
[/cpp]
また、list_head 構造体はわかりやすいのでカーネルを読むときはこの辺りから慣れていくとと良いかもしれません。Doubly linked listの実装でカーネル内のあちこちに登場してきますので。css_set の中身は以下のようになっており、全てのタスクはこの css_set に対する参照カウント(のポインタ)を保持しています。
[cpp]
struct css_set {
/* Reference count */
atomic_t refcount;
/*
* List running through all cgroup groups in the same hash
* slot. Protected by css_set_lock
*/
struct hlist_node hlist;
/*
* List running through all tasks using this cgroup
* group. Protected by css_set_lock
*/
struct list_head tasks;
/*
* List of cg_cgroup_link objects on link chains from
* cgroups referenced from this css_set. Protected by
* css_set_lock
*/
struct list_head cg_links;
/*
* Set of subsystem states, one for each subsystem. This array
* is immutable after creation apart from the init_css_set
* during subsystem registration (at boot time) and modular subsystem
* loading/unloading.
*/
struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
/* For RCU-protected deletion */
struct rcu_head rcu_head;
};
[/cpp]
css_set はcgroup_subsys_stateという構造体の集合を保持していることがわかります。cssというのはcgroup_subysys_stateを略なんでしょう。tasks は前述の task_struct 構造体メンバの cg_list と(連結リストとして)繋がっており、これを辿ればcgroupsに属する全てタスクにアクセスできるようになっています。
[cpp]
/* Per-subsystem/per-cgroup state maintained by the system. */
struct cgroup_subsys_state {
/* the cgroup that this css is attached to */
struct cgroup *cgroup;
/* the cgroup subsystem that this css is attached to */
struct cgroup_subsys *ss;
/* reference count – access via css_[try]get() and css_put() */
struct percpu_ref refcnt;
/* the parent css */
struct cgroup_subsys_state *parent;
unsigned long flags;
/* percpu_ref killing and RCU release */
struct rcu_head rcu_head;
struct work_struct destroy_work;
};
// cgroup 構造体の一部
struct cgroup {
unsigned long flags; /* “unsigned long” so bitops work */
/*
* count users of this cgroup. >0 means busy, but doesn’t
* necessarily indicate the number of tasks in the cgroup
*/
atomic_t count;
int id; /* ida allocated in-hierarchy ID */
/*
* We link our ‘sibling’ struct into our parent’s ‘children’.
* Our children link their ‘sibling’ into our ‘children’.
*/
struct list_head sibling; /* my parent’s children */
struct list_head children; /* my children */
struct list_head files; /* my files */
struct cgroup *parent; /* my parent */
struct dentry *dentry; /* cgroup fs entry, RCU protected */
… 長いので省略
[/cpp]
cgroup_subsys_state 単体だけを見てもよくわかりませんが、css_set からコメント文も読みつつ cgroups 構造体まで辿ってくるとなんとなく構造が見えてきます。ここまでに前述した list_head がたくさん登場していますが、これを使ってcgroupsのヒエラルキー構造を表現していることが読めます。ちなみにRCUというのは排他制御機構 Read-Copy-Update の実装ですが、cgroupsでも多くの場所で活用されているようです。詳細はWikipediaが詳しいです。
ここまではcgroups自体の実装に関する部分で、サブシステムの実装はどうなっているのかわかりません。ここでは例としてdevicesサブシステムを少し覗いてみます。
[cpp]
/* security/device_cgroup.c */
// デバイスへのアクセス可否(ファイルパーミッション)をチェックする関数
static int __devcgroup_check_permission(short type, u32 major, u32 minor,
short access)
{
struct dev_cgroup *dev_cgroup;
struct dev_exception_item ex;
int rc;
memset(&ex, 0, sizeof(ex));
ex.type = type;
ex.major = major;
ex.minor = minor;
ex.access = access;
rcu_read_lock();
dev_cgroup = task_devcgroup(current);
rc = may_access(dev_cgroup, &ex, dev_cgroup->behavior);
rcu_read_unlock();
if (!rc)
return -EPERM;
return 0;
}
// dev_cgroup 構造体
struct dev_cgroup {
struct cgroup_subsys_state css;
struct list_head exceptions;
enum devcg_behavior behavior;
/* temporary list for pending propagation operations */
struct list_head propagate_pending;
};
// dev_exception_item 構造体
struct dev_exception_item {
u32 major, minor;
short type;
short access;
struct list_head list;
struct rcu_head rcu;
};
[/cpp]
現在のタスク(プロセス)が所属するcgroupを取得(task_devcgroup関数)、前述したデバイスタイプと番号(c 5:1 とか)を指定してパーミッションのチェックを行っています(may_access関数)。
cgroup.h/cにはサブシステム自体の実装は含まれておらず、cpuサブシステムならkernel/sched/ 、memoryサブシステムならmm/以下にあり、タスクスケジューラやメモリ管理などカーネルの主機能の中にサブシステムの実装も含まれている形です。
サブシステムの実装詳細については今後も興味のあるものから少しずつ読み進めていくつもりです。今回は前回調べたnamespaceに続いて、Dockerコンテナを作成するために必要な技術要素であるcgroupsについて概要を整理しました。
参考
- cgroups documentation – The Linux Kernel Archives
- 第1章 コントロールグループについて (cgroup)
- Linux Containers Basic Concepts (PDF)
- Linux Kernel Updates Vol 2014.08 (Kindle)
おまけ: Cscopeについて
効率良くLinuxカーネルのコードリーディングするためにCscopeというツールを利用しています。
Cscope is a developer’s tool for browsing source code. It has an impeccable Unix pedigree, having been originally developed at Bell Labs back in the days of the PDP-11. Cscope was part of the official AT&T Unix distribution for many years, and has been used to manage projects involving 20 million lines of code!
[bash]
## installation
## CentOS
$ sudo yum install cscope
## Ubuntu
$ sudo apt-get install cscope
[/bash]
使い方は以下のエントリーを参考にさせてもらいました。Linuxカーネルのソースコードは規模が大きいので、cscopeのデータベースは必ず転置インデックス付きで作成しておきましょう。また、Emacs使いであればhelmインタフェースからも利用できます。