
# cgroup v1与cgroup v2接口对比
#### 背景信息
目前cgroup有两个主要版本：cgroup v1和cgroup v2。cgroup v1与cgroup v2之间存在较多差异，如果从cgroup v1切换到cgroup v2需要参考接口资料进行适配。本文介绍cgroup v1与cgroup v2接口的主要区别。
#### 框架接口
表1cgroup v1框架接口 
| cgroup v1接口           | 作用                                                                                                                                                                                         | 是否自研 | 对应cgroup v2接口  | 备注                                                                                                                                                                                                                                                                             |
|:---|:---|:---|:---|:---|
| cgroup.procs          | 可读可写。 设置/查看cgroup组中运行的线程群组。如果向procs接口写入一个TGID，那么此线程组群将被移至新的cgroup中。显示的TGID列表中，TGID不一定是有序排列的，且可能存在重复的TGID。                                                      | 否    | cgroup.procs   | - cgroup v2版本中为杜绝子cgroup与父节点内部进程竞争资源的情况，启用了层级结构控制器后，进程只能出现在叶子节点（根 cgroup 不受此限制）。  - cgroup v2版本中的cgroup.procs不对进程排序输出。   |
| tasks                 | 可读可写。 设置/查看cgroup组中运行的线程。如果向tasks接口写入一个TID，但该线程已经在另一个cgroup中，那么它将从原来的cgroup中移除，并被添加到新的cgroup中。显示的TID列表中，TID不一定是有序排列的，且可能存在重复的TID。                           | 否    | cgroup.threads | cgroup v2版本中的cgroup.threads不对线程排序输出，且是否使能线程化cgroup与控制器cgroup.type有关。                                                                                                                                                                                                           |
| notify_on_release     | 可读可写。 默认值为0。设置/查看是否启动和禁用release_agent的指令。对于所有非root cgroup，它们将从其父cgroup继承notify_on_release的值。当notify_on_release启用，且cgroup不再包含任何任务时，kernel会执行release_agent中的指令。 | 否    | NA             | cgroup v2版本中的cgroup.events可以监听到cgroup有无进程的状态变化，实现类似功能。                                                                                                                                                                                                                         |
| release_agent         | 可读可写。 默认为空。设置/查看当"notify on release"被触发时要执行的指令。                                                                                                               | 否    | NA             | cgroup v2版本中的cgroup.events可以监听到cgroup有无进程的状态变化，实现类似功能。                                                                                                                                                                                                                         |
| cgroup.clone_children | 可读可写。 默认值为0。只影响cpuset控制器。若在某个 cgroup 中启用了clone_children标志（设为 1），则新的cpuset cgroup在初始化期间将从其父级复制配置。                                                             | 否    | NA             |                                                                                                                                                                                                                                                                                |
   
表2cgroup v2框架接口 
| cgroup v2接口            | 作用                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 是否自研 | 对应cgroup v1接口   | 备注                                                                                                                                                                                                                                                                              |
|:---|:---|:---|:---|:---|
| cgroup.controllers     | 只读。 存在于所有cgroup上的文件，以空格分隔的值。它显示了一个以空格分隔的可用于该cgroup的所有控制器的列表。控制器的顺序不固定。                                                                                                                                                                                                                                                                                                                                                                                                                        | 否    | NA              |                                                                                                                                                                                                                                                                                 |
| cgroup.events          | 只读。 非根cgroup都有一个cgroup.events文件，包含以下字段： - populated：如果该cgroup或其子cgroup包含任何活动进程，则为1；否则为0。  - frozen：如果该cgroup已冻结，则为1；否则为0。                                                                                                                                                                            | 否    | NA              | - cgroup v1版本中的notify_on_release和release_agent可以监听到cgroup释放，实现类似功能。  - cgroup v1版本中的freezer.state也可以获取当前cgroup的冻结状态。            |
| cgroup.freeze          | 可读可写。 默认值为0。一个存在于非根cgroup上的单值文件。允许的值为0和1。向该文件写入1会导致该cgroup及其所有子cgroup被冻结。这意味着所有属于该cgroup的任务将被停止，并且直到显式解冻该cgroup之前将不会运行。                                                                                                                                                                                                                                                                                                                                                                          | 否    | freezer.state   | - cgroup v2的cgroup.freeze字段：写1/0表示冻结/解冻。  - cgroup v1的freezer.state字段：FROZEN表示冻结，THAWED表示解冻。                       |
| cgroup.kill            | 只写。 一个存在于非根cgroup上的单值文件。唯一允许的值是1。向该文件写入1会导致该cgroup及其所有子cgroup被终止。这意味着位于受影响cgroup树中的所有进程将通过SIGKILL信号被终止。                                                                                                                                                                                                                                                                                                                                                                                         | 否    | NA              |                                                                                                                                                                                                                                                                                 |
| cgroup.max.depth       | 可读可写。 默认值为max。范围（0，max\]。当前cgroup下允许的最大子层次深度。如果实际的子层次深度相等或更大，则尝试创建新的子cgroup将失败。                                                                                                                                                                                                                                                                                                                                                                                                                | 否    | NA              |                                                                                                                                                                                                                                                                                 |
| cgroup.max.descendants | 可读可写。 默认值为max。范围（0，max\]。允许的最大子cgroup数量。如果实际的子cgroup数量相等或更大，则尝试在层次结构中创建新的cgroup将失败。                                                                                                                                                                                                                                                                                                                                                                                                             | 否    | NA              |                                                                                                                                                                                                                                                                                 |
| cgroup.procs           | 可读可写。 一个存在于所有cgroup上的文件，值以换行符分隔。当读取时，它逐行列出属于该cgroup的所有进程的PID。PID的顺序不固定，并且如果进程被移动到另一个cgroup然后再返回，或者在读取时PID被重新分配，同一个PID可能会出现多次。                                                                                                                                                                                                                                                                                                                                                                  | 否    | cgroup.procs    | - cgroup v2版本中为杜绝子cgroup与父节点内部进程竞争资源的情况，启用了层级结构控制器后，进程只能出现在叶子节点（根 cgroup 不受此限制）。  - cgroup v2版本中的cgroup.procs不对进程排序输出。   |
| cgroup.stat            | 只读。 包含以下字段： - nr_descendants：可见的子cgroup的总数。  - nr_dying_descendants：垂死的子cgroup的总数。当用户删除一个cgroup后，该cgroup将变为垂死状态。在完全销毁之前，垂死的cgroup将保持一段时间的未定义时间。                                                                                                                                                                     | 否    | NA              |                                                                                                                                                                                                                                                                                 |
| cgroup.subtree_control | 可读可写。 一个存在于所有cgroup上的文件，以空格分隔的值。初始为空。当读取时，它显示了一个以空格分隔的列表，其中包含启用用于从当前cgroup指定给其子cgroup的资源分配的控制器。可以写入以"+"或"-"为前缀的以空格分隔的控制器列表，以启用或禁用控制器。以"+"为前缀的控制器名称表示启用该控制器，"-"表示禁用。                                                                                                                                                                                                                                                                                                                             | 否    | NA              |                                                                                                                                                                                                                                                                                 |
| cgroup.threads         | 可读可写。 一个存在于所有cgroup上的文件，值以换行符分隔。当读取时，它逐行列出属于该cgroup的所有线程的TID。TID的顺序不固定，并且如果线程被移动到另一个cgroup然后再返回，或者在读取时TID被重新分配，同一个TID可能会出现多次。可以将TID写入该文件，以将与该TID关联的线程迁移到目标cgroup。                                                                                                                                                                                                                                                                                                                            | 否    | tasks           | cgroup v2版本中的cgroup.threads不对线程排序输出，且是否使能线程化cgroup与控制器cgroup.type有关。                                                                                                                                                                                                            |
| cgroup.type            | 可读可写。 表示当前cgroup的类型，cgroup类型包括： - domain：默认类型。  - domain threaded：作为threaded类型cgroup的根节点。  - domain invalid：无效状态cgroup。  - threaded：threaded类型的cgoup组。   设置的输入只能：threaded。 | 否    | NA              |                                                                                                                                                                                                                                                                                 |
| cpu.stat               | 只读。 用于查看CPU及限流相关的统计数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 否    | NA              |                                                                                                                                                                                                                                                                                 |
| cpu.stat.local         | 只读。 用于本cgroup CPU限流相关的统计数据，字段如下： - throttled_usec：任务被限流的总时间。                                                                                                                                                                                                                                                                                                       | 否    | NA              |                                                                                                                                                                                                                                                                                 |
| io.pressure            | 可读可写。 监控io相关的压力指标（需要使能全局PSI）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 否    | io.pressure     | cgroup v1 PSI的接口位于cpuacct子系统所在目录下。                                                                                                                                                                                                                                              |
| memory.pressure        | 可读可写。 监控内存相关的压力指标（需要使能全局PSI）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 否    | memory.pressure | cgroup v1 PSI的接口位于cpuacct子系统所在目录下。                                                                                                                                                                                                                                              |
| cpu.pressure           | 可读可写。 监控CPU相关的压力指标（需要使能全局PSI）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 否    | cpu.pressure    | cgroup v1 PSI的接口位于cpuacct子系统所在目录下。                                                                                                                                                                                                                                              |
   
#### memory接口
表3cgroup v1 memory接口 
| cgroup v1接口                              | 作用                                                                                                                                                                                                                                                                                        | 是否自研 | 对应cgroup v2接口           | 备注                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|:---|:---|:---|:---|:---|
| memory.usage_in_bytes                    | 只读。 用于查看cgroup组中当前所有进程使用的内存（memory）资源总量，单位为字节。                                                                                                                                                                                                               | 否    | memory.current          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.memsw.usage_in_bytes              | 只读。 用于查看cgroup组中所有进程当前使用"内存资源（memory）+ 交换分区资源（swap）"的总量，单位为字节。                                                                                                                                                                                                | 否    | memory.swap.current     | cgroup v1：memory.memsw.usage_in_bytes统计的是内存与swap一共使用了多少。cgroup v2：memory.swap.current单独统计swap的使用。 注意：memory.memsw.usage_in_bytes统计使用内存资源(memory)+交换分区资源(swap)的总量，但是并非v2中memory.current和memory.swap.current严格意义上的二者之和。 存在一种情况：v1在换入的时候，swap数据没有删除，内存也有数据，memory.memsw.usage_in_bytes只统计一次，即换入后memory.memsw.usage_in_bytes不变。但是在v2是分开统计的，所以memory.swap.current不变，memory.current增加。 |
| memory.limit_in_bytes                    | 可读可写。 用于设置/查看cgroup组可使用内存(memory)资源的限额值，单位为字节。                                                                                                                                                                                                             | 否    | memory.max              |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.memsw.limit_in_bytes              | 可读可写。 用于设置/查看cgroup组可使用"内存资源（memory）+ 交换分区资源（swap）"的限额值，单位为字节。                                                                                                                                                                                               | 否    | memory.swap.max         | cgroup v1的memory.memsw.limit_in_bytes是使用内存资源(memory)+交换分区资源(swap)的限额值，因此对应v2中memory.max和memory.swap.max二者之和。                                                                                                                                                                                                                                                                                                                              |
| memory.failcnt                           | 可读可写。 用于设置/查看cgroup中所有进程使用内存资源的总量达到 memory.limit_in_bytes 的次数。                                                                                                                                                                                               | 否    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.memsw.failcnt                     | 可读可写。 用于设置/查看cgroup中所有进程使用"内存资源（memory）+ 交换分区资源（swap）"的总量达到memory.memsw.limit_in_bytes的次数。                                                                                                                                                                 | 否    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.max_usage_in_bytes                | 可读可写。 用于查看cgroup创建以来使用内存(memory)资源的的峰值，单位为字节。                                                                                                                                                                                                               | 否    | memory.peak             | cgroup v1的memory.max_usage_in_bytes可读写，cgroup v2的memory.peak是只读的。                                                                                                                                                                                                                                                                                                                                                                         |
| memory.memsw.max_usage_in_bytes          | 可读可写。 用于记录cgroup创建以来使用"内存资源（memory）+ 交换分区资源（swap）"总和的峰值，单位为字节。                                                                                                                                                                                              | 否    | memory.swap.peak        | - cgroup v1的memory.memsw.max_usage_in_bytes可读写，cgroup v2的memory.swap.peak是只读的。  - memory.memsw.max_usage_in_bytes统计内存+swap使用的峰值，memory.swap.peak只统计swap使用的峰值。                                                                                                                     |
| memory.soft_limit_in_bytes               | 可读可写。 用于设置/查看内存资源的软限制的限额值，单位为字节。                                                                                                                                                                                                                           | 否    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.stat                              | 只读。 用于查看当前cgroup组的内存资源的详细统计数据。                                                                                                                                                                                                                              | 否    | memory.stat             | 字段存在差异。                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| memory.use_hierarchy                     | 可读可写。 默认值为1，表示子cgroup中的内存会统计到父cgroup中。用于设置/查看是否将子cgroup的内存使用情况统计到当前cgroup里面。该文件内容为0时，表示不使用继承，即父子cgroup之间没有关系；当该文件内容为1时，子cgroup所占用的内存会统计到所有祖先cgroup中。                                                                                                       | 否    | NA                      | 该接口在6.6 kernel的cgroup v1已经被弃用了，只支持true。cgroup v2相当于true。                                                                                                                                                                                                                                                                                                                                                                                  |
| memory.force_empty                       | 只写。 用于触发强制内存页回收操作。当设置为0时，cgroup中所有任务使用的内存页会被回收，只有在cgroup中没有进程时才会生效。                                                                                                                                                                                           | 否    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.pressure_level                    | 不支持命令行直接读写操作该文件，这个文件主要用来监控当前cgroup的内存压力，当cgroup组内存使用量达到某种压力状态的时候，内核可以通过eventfd的机制来通知用户程序，这个通知是通过cgroup.event_control和memory.pressure_level来实现。                                                                                                                                            | 否    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| cgroup.event_control                     | 可写。 用于配置cgroup的事件通知，允许cgroup的变更状态通知被发送。                                                                                                                                                                                                                       | 否    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.swappiness                        | 可读可写。 默认值为60，用于设置/查看控制换出运行时内存到交换分区（swap）的相对权重。值越小，表示让内核交换越少内存页到交换空间，值越大，表示让内核更多地使用交换空间。                                                                                                                                                                     | 否    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.move_charge_at_immigrate          | 可读可写。 默认值为1，用于设置/查看当移动cgroup中的进程到其它cgroup组时，是否同时移动该进程使用内存页的统计信息。当memory.move_charge_at_immigrate文件的值设置为0的时候表示关闭这个功能，相当于不累计之前的信息，进程进入的新cgroup中记录的内存使用量是重新从0累计；当memory.move_charge_at_immigrate文件的值为1时，迁移的时候要在新的cgroup中累积（charge）原来信息，并把旧group中的信息给uncharge掉。 | 否    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.oom_control                       | 可读可写。 用于设置/查看cgroup组内存超限之后oom相关的处理行为。                                                                                                                                                                                                                      | 否    | NA                      | cgroup v1查询memory.oom_control中的oom_kill字段可以在cgroup v2的memory.events中获取。                                                                                                                                                                                                                                                                                                                                                                   |
| memory.numa_stat                         | 只读。 用于查看NUMA内存节点相关的内存统计信息。                                                                                                                                                                                                                                   | 否    | memory.numa_stat        |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.high                              | 可读可写。 设置、查看cgroup可使用内存资源的软限制，默认值为max，单位为字节。更多信息请参考：[内核memory的多级内存回收策略](https://support.huaweicloud.com/usermanual-hce/hce_02_0072.html)。                                                                                                                    | 是    | memory.high             |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.low                               | 可读可写。 设置、查看cgroup内存资源的软保护阈值，默认值为0，单位为字节。更多信息请参考：[内核memory的多级内存回收策略](https://support.huaweicloud.com/usermanual-hce/hce_02_0072.html)。                                                                                                                      | 是    | memory.low              |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.min                               | 可读可写。 设置、查看cgroup内存资源的硬保护阈值，默认值为0，单位为字节。更多信息请参考：[内核memory的多级内存回收策略](https://support.huaweicloud.com/usermanual-hce/hce_02_0072.html)。                                                                                                                      | 是    | memory.min              |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.high_async_ratio                  | 可读可写。 异步内存回收功能中配合memory.high一起使用，表示cgroup的警戒水位线与安全水位线的值。更多信息请参考：[cgroup异步内存回收](https://support.huaweicloud.com/usermanual-hce/hce_02_0073.html)。                                                                                                          | 是    | memory.high_async_ratio |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.reclaim                           | 只写。 触发一次内存回收，回收目标值是设置值。                                                                                                                                                                                                                                    | 是    | memory.reclaim          |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.wb_blkio_ino                      | 可读可写。 表示cgroup回写功能memcg与blkio的绑定关系。                                                                                                                                                                                                                            | 是    | NA                      | cgroup v2支持cgroup回写功能。                                                                                                                                                                                                                                                                                                                                                                                                                    |
| memory.ksm                               | 可读可写。 存在于非root memcg中。写该接口时控制memcg的KSM使能，默认不使能。                                                                                                                                                                                                             | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.memfs_files_info                  | 只读。 支持OOM时统计文件内存占用。查询记账到该memcg的rootfs和tmpfs文件的信息。需要用户向/sys/kernel/mm/memcg_memfs_info/enable接口写入1，使能该特性。只打印占用内存大于/sys/kernel/mm/memcg_memfs_info/size_threshold的文件。                                                                                           | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.qos_level                         | 可读可写。 混合部署场景下使用，配置cgroup的内存资源优先级。更多信息请参考：[内核memory的OOM进程控制策略](https://support.huaweicloud.com/usermanual-hce/hce_02_0071.html)。                                                                                                                             | 是    | memory.qos_level        |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.skip_reclaim_exec_threshold_in_mb | 可读可写。 用于设置在内存回收过程中跳过内存回收操作的阈值。                                                                                                                                                                                                                              | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| memory.zram_usage_in_bytes               | 只读。 显示绑定到该memcg上的zram设备占用的内存大小。                                                                                                                                                                                                                              | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| swap_ahead.delay_enable_msec             | 可读可写。 用于配置开启内存压缩功能后，延时一段时间后进行扫描。                                                                                                                                                                                                                             | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| swap_ahead.enable                        | 可读可写。 swap增强功能开关，0表示关闭，1表示开启。                                                                                                                                                                                                                               | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| swap_ahead.enable_swap_default           | 可读可写。 配置memcg下拉起的进程默认是否允许swap，配置为0时，该memcg下拉起进程的/proc/\<pid\>/enable_swap为0，表示该进程使用的内存不能swap。                                                                                                                                                              | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| swap_ahead.scan_cpu_limit                | 可读可写。 swap增强功能cpu使用率上限（包括zram压缩使用的cpu在内），单位为1%vcpu。比如配置为3代表限制本功能cpu使用率在3%以下。设置为0表示不进行扫描。                                                                                                                                                                      | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| swap_ahead.scan_interval_msec            | 可读可写。 swap增强功能扫描LRU链表间隔时间，代表两次扫描LRU链表之间间隔的时间，单位为毫秒。                                                                                                                                                                                                         | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| swap_ahead.scan_len_ratio                | 可读可写。 用于配置swap增强功能单次扫描LRU链表长度，配置的数值为每次扫描长度占LRU链表总长度比例的倒数。                                                                                                                                                                                                    | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| swap_ahead.scan_task                     | 只读。 用于读取当前memcg下swap_memcg扫描线程的pid。                                                                                                                                                                                                                          | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| swap_ahead.scan_trigger_ratio            | 可读可写。 swap增强功能使能的内存比例阈值。                                                                                                                                                                                                                                    | 是    | NA                      |                                                                                                                                                                                                                                                                                                                                                                                                                                           |
   
表4cgroup v2 memory接口 
| cgroup v2接口             | 作用                                                                                                                                                                              | 是否自研 | 对应cgroup v1接口                   | 备注                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|:---|:---|:---|:---|:---|
| memory.current          | 只读。 用于查看cgroup中当前所有进程使用的内存资源总量，单位为字节。                                                                                                               | 否    | memory.usage_in_bytes           |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.swap.current     | 只读。 用于查看cgroup中当前所有进程使用的交换分区资源总量，单位为字节。                                                                                                           | 否    | memory.memsw.usage_in_bytes     | cgroup v1：memory.memsw.usage_in_bytes统计的是内存与swap一共使用了多少。cgroup v2：memory.swap.current单独统计swap的使用。 注意：memory.memsw.usage_in_bytes统计使用内存资源(memory)+交换分区资源(swap)的总量，但是并非v2中memory.current和memory.swap.current严格意义上的二者之和。 存在一种情况：v1在换入的时候，swap数据没有删除，内存也有数据，memory.memsw.usage_in_bytes只统计一次，即换入后memory.memsw.usage_in_bytes不变。但是在v2是分开统计的，所以memory.swap.current不变，memory.current增加。 |
| memory.max              | 可读可写。 用于设置、查看cgroup可使用内存资源的限额值，默认值为max，单位为字节。cgroup使用的内存资源达到限额值后，会触发内存回收，如果无可回收内存，将触发OOM Killer。                                                  | 否    | memory.limit_in_bytes           |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.swap.max         | 可读可写。 用于设置、查看cgroup可使用交换分区资源的限额值，默认值为max，单位为字节。                                                                                                   | 否    | memory.memsw.limit_in_bytes     | cgroup v1的memory.memsw.limit_in_bytes是使用内存资源(memory)+交换分区资源(swap)的限额值，因此对应v2中memory.max和memory.swap.max二者之和。                                                                                                                                                                                                                                                                                                                               |
| memory.min              | 可读可写。 设置、查看cgroup内存资源的硬保护阈值，默认值为0，单位为字节。更多信息请参考：[内核memory的多级内存回收策略](https://support.huaweicloud.com/usermanual-hce/hce_02_0072.html)。           | 否    | memory.min                      |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.low              | 可读可写。 设置、查看cgroup内存资源的软保护阈值，默认值为0，单位为字节。更多信息请参考：[内核memory的多级内存回收策略](https://support.huaweicloud.com/usermanual-hce/hce_02_0072.html)。             | 否    | memory.low                      |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.high             | 可读可写。 设置、查看cgroup可使用内存资源的软限制，默认值为max，单位为字节。更多信息请参考：[内核memory的多级内存回收策略](https://support.huaweicloud.com/usermanual-hce/hce_02_0072.html)。           | 否    | memory.high                     |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.swap.high        | 可读可写。 设置、查看cgroup可使用交换分区资源的软限制，默认值为max，单位为字节。当cgroup的交换分区资源使用量到达high后，触发本次记账的进程会触发短暂阻塞。                                                           | 否    | NA                              |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.reclaim          | 只写。 用于回收cgroup中指定大小的内存资源，单位为字节。                                                                                                                   | 否    | memory.reclaim                  |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.peak             | 只读。 用于查看cgroup自从创建以来最大的内存资源使用量，单位为字节。                                                                                                           | 否    | memory.max_usage_in_bytes       | cgroup v1的memory.max_usage_in_bytes可读写，cgroup v2的memory.peak是只读的。                                                                                                                                                                                                                                                                                                                                                                          |
| memory.swap.peak        | 只读。 用于查看cgroup自从创建以来最大的交换分区资源使用量，单位为字节。                                                                                                           | 否    | memory.memsw.max_usage_in_bytes | - cgroup v1的memory.memsw.max_usage_in_bytes可读写，cgroup v2的memory.swap.peak是只读的。  - memory.memsw.max_usage_in_bytes统计内存+swap使用的峰值，memory.swap.peak只统计swap使用的峰值。                                                                                                                              |
| memory.events           | 只读。 用于查询cgroup及子cgroup的内存资源使用事件的发生次数。                                                                                                              | 否    | memory.events                   | cgroup v1查询memory.oom_control中的oom_kill字段可以在cgroup v2的memory.events中获取。                                                                                                                                                                                                                                                                                                                                                                    |
| memory.events.local     | 只读。 类似memory.events，但只统计当前cgroup的事件，不统计子cgroup的事件。                                                                                                  | 否    | memory.events.local             |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.swap.events      | 只读。 用于查询cgroup及子cgroup的交换分区资源使用事件的发生次数。                                                                                                              | 否    | NA                              |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.oom.group        | 可读可写。 用于查看/设置cgroup是否启用group OOM，默认不开启。当cgroup开启group OOM后，如果cgroup中的任何一个进程因OOM被杀死，cgroup中的全部进程都被杀死。                                               | 否    | NA                              |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.stat             | 只读。 用于查看cgroup的内存资源使用的详细统计数据，统计数据包含该cgroup及其子cgroup。                                                                                              | 否    | memory.stat                     | 字段差异较大。                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| memory.numa_stat        | 只读。 用于查看cgroup的各NUMA Node的内存资源使用的详细统计数据，统计数据包含该cgroup及其子cgroup。                                                                                   | 否    | memory.numa_stat                |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.high_async_ratio | 可读可写。 异步内存回收功能中配合memory.high一起使用，表示cgroup的警戒水位线与安全水位线的值。更多信息请参考：[cgroup异步内存回收](https://support.huaweicloud.com/usermanual-hce/hce_02_0073.html)。 | 是    | memory.high_async_ratio         |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| memory.qos_level        | 可读可写。 混部场景使用，配置cgroup的内存资源优先级。更多信息请参考：[内核memory的OOM进程控制策略](https://support.huaweicloud.com/usermanual-hce/hce_02_0071.html)。                    | 是    | memory.qos_level                |                                                                                                                                                                                                                                                                                                                                                                                                                                            |
   
#### cpu/cpuacct接口
表5cgroup v1 cpu/cpuacct接口 
| cgroup v1接口                     | 作用                                                                                                                                                                          | 是否自研 | 对应cgroup v2接口               | 备注                                                                                                              |
|:---|:---|:---|:---|:---|
| cpu.cfs_quota_us                | 可读可写。 只对CFS调度器调度的进程有效。默认值为-1，表示CPU使用时间不受cgroup限制，单位为微秒。进程在设置的时间周期长度内，可以使用的CPU时间上限。                                                              | 否    | cpu.max                     | cgroup v2版本中cpu.max一个接口可以同时设置quota和period。                                                                      |
| cpu.cfs_period_us               | 可读可写。 只对CFS调度器调度的进程有效。默认值为100ms，表示重新分配CPU资源的时间周期长度，单位为us。                                                                                      | 否    | cpu.max                     | cgroup v2版本中cpu.max一个接口可以同时设置quota和period。                                                                      |
| cpu.cfs_burst_us                | 可读可写。 只对CFS调度器调度的进程有效。表示上一个cfs_period周期中未被使用完的份额可以累计到下一个cfs_period周期中使用的最大值，默认为0，表示不开启cpu burst的功能。                                           | 否    | cpu.max.burst               |                                                                                                                 |
| cpu.shares                      | 可读可写。 设置cgroup组中进程在CPU资源竞争时的相对权重。                                                                                                            | 否    | cpu.weight                  | cgroup v1和v2权重的取值范围不一样。cgroup v1：cpu.shares默认值为1024，值范围\[2,262144\]；cgroup v2：cpu.weight默认值为100，值范围\[1,10000\]。 |
| cpu.rt_runtime_us               | 可读可写。 只对RT调度器调度的进程有效。表示cgroup组中实时进程在设置的时间周期长度内，可连续使用的cpu时间上限，单位为微秒，默认值为0，表示不做限制。                                                               | 否    | NA                          | cgroup v2没有对应接口。可以通过/proc/sys/kernel/sched_rt_runtime_us设置。                                                     |
| cpu.rt_period_us                | 可读可写。 只对RT调度器调度的进程有效。表示重新分配CPU资源的时间周期长度，单位为微秒，只对实时调度进程有效，默认值为1000000微秒。                                                                      | 否    | NA                          | cgroup v2没有对应接口。可以通过/proc/sys/kernel/sched_rt_period_us设置。                                                      |
| cpu.stat                        | 只读。 显示关于CPU使用情况的统计信息。                                                                                                                           | 否    | cpu.stat                    |                                                                                                                 |
| cpu.qos_level                   | 可读可写。 混合部署场景下使用，配置CPU资源优先级。更多信息请参考：[内核cpu cgroup的多级混部调度](https://support.huaweicloud.com/usermanual-hce/hce_02_0074.html)。                     | 是    | cpu.qos_level               | cgroup v1接口将任务调度级别扩展到5个级别；cgroup v2目前只支持-1和0两级优先级。                                                              |
| cpuacct.usage                   | 可读可写。 此cgroup中（包括子cgroup）中所有进程使用的cpu总时间，单位是纳秒。                                                                                                  | 否    | cpu.stat                    | cgroup v2版本中cpu.stat的 usage_usec字段，单位为us；cgroup v1 cpuacct.usage中的时间则以ns为单位。                                    |
| cpuacct.usage_sys               | 只读。 统计此cgroup中（包括子cgroup）所有进程在内核态使用cpu资源的总时间，单位为纳秒。                                                                                             | 否    | cpu.stat                    |                                                                                                                 |
| cpuacct.usage_user              | 只读。 统计此cgroup中（包括子cgroup）所有进程在用户态使用cpu资源的总时间，单位为纳秒。                                                                                         | 否    | cpu.stat                    |                                                                                                                 |
| cpuacct.usage_percpu            | 只读。 统计此cgroup中（包括子cgroup）所有进程在每个CPU使用CPU的时间，单位为纳秒。                                                                                          | 否    | NA                          | cgroup v2不再统计单个cpu的数据。                                                                                          |
| cpuacct.usage_percpu_sys        | 只读。 统计此cgroup中（包括子cgroup）所有进程在每个CPU在内核态使用CPU的时间，单位为纳秒。                                                                                       | 否    | NA                          | cgroup v2不再统计单个cpu的数据。                                                                                          |
| cpuacct.usage_percpu_user       | 只读。 统计此cgroup中（包括子cgroup）所有进程在每个CPU在用户态使用CPU的时间，单位为纳秒。                                                                                         | 否    | NA                          | cgroup v2不再统计单个cpu的数据。                                                                                          |
| cpuacct.usage_all               | 只读。 查看每个CPU在用户态和内核态各自消耗的时间。                                                                                                                  | 否    | NA                          | cgroup v2不再统计单个cpu的数据。                                                                                          |
| cpuacct.stat                    | 只读。 显示用户态和内核态的 CPU 时间统计。                                                                                                                       | 否    | cpu.stat                    | cgroup v2 cpu.stat中的user_usec和system_usec字段单位为us。cgroup v1 cpuacct.stat中的时间则以USER_HZ为单位。                        |
| cpuacct.normalize_usage         | 只读。 算力归一化场景下使用。统计cgroup级别的任务归一化的CPU运行时间。                                                                                                      | 是    | NA                          |                                                                                                                 |
| cpuacct.nr_select_allowed_cpus  | 只读。 CPU软绑定功能开启时，统计cgroup组内的任务在唤醒选核时，选择共享核的次数。更多信息请参考：[CPU软绑定](https://support.huaweicloud.com/usermanual-hce/hce_02_0090.html)。              | 是    | cpu.nr_select_allowed_cpus  |                                                                                                                 |
| cpuacct.nr_select_prefer_cpus   | 只读。 CPU软绑定功能开启时，统计cgroup组内的任务在唤醒选核时，选择优先核的次数。更多信息请参考：[CPU软绑定](https://support.huaweicloud.com/usermanual-hce/hce_02_0090.html)。                 | 是    | cpu.nr_select_prefer_cpus   |                                                                                                                 |
| cpuacct.nr_smoothed_prefer_cpus | 只读。 CPU软绑定功能开启时，统计cgroup组内的任务在唤醒选核时，由于平滑算法没有从优先核切换到共享核的次数。更多信息请参考：[CPU软绑定](https://support.huaweicloud.com/usermanual-hce/hce_02_0090.html)。 | 是    | cpu.nr_smoothed_prefer_cpus |                                                                                                                 |
| io.pressure                     | 可读可写。 监控io相关的压力指标（需要使能全局PSI和cgroupv1 PSI）                                                                                                     | 是    | io.pressure                 | cgroup v2 PSI的接口位于通用框架目录下。                                                                                      |
| memory.pressure                 | 可读可写。 监控内存相关的压力指标（需要使能全局PSI和cgroupv1 PSI）                                                                                                    | 是    | memory.pressure             | cgroup v2 PSI的接口位于通用框架目录下。                                                                                      |
| cpu.pressure                    | 可读可写。 监控CPU相关的压力指标（需要使能全局PSI和cgroupv1 PSI）                                                                                                    | 是    | cpu.pressure                | cgroup v2 PSI的接口位于通用框架目录下。                                                                                      |
   
表6cgroup v2 cpu接口 
| cgroup v2接口                 | 作用                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 是否自研 | 对应cgroup v1接口                      | 备注                                                                                                              |
|:---|:---|:---|:---|:---|
| cpu.max                     | 可读可写。 只对CFS调度器调度的进程有效。存在于非根cgroup中，用于限制cgroup中的进程使用cpu带宽，默认值为 "max 100000"，单位为微秒，表示cpu的时间周期为100000微秒，且使用时间不受限制。 参数格式：${quota} ${period} - ${quota}：表示进程在设置的时间周期内，可以使用的cpu带宽的上限，默认值为max，表示不受限制。  - ${period}：表示分配cpu资源的时间周期长度，默认值为100000，单位为微秒。   可以仅设置一个值，此时表示对"${quota}"参数进行修改。 | 否    | cpu.cfs_quota_us和cpu.cfs_period_us |                                                                                                                 |
| cpu.max.burst               | 可读可写。 只对CFS调度器调度的进程有效。存在于非根cgroup中，表示上一个cfs_period周期中未被使用完的cpu份额可以累计到下一个cfs_period周期中使用的最大值，默认值为0，表示不开启该功能。                                                                                                                                                                                                                                                                                                                                                                                                 | 否    | cpu.cfs_burst_us                   |                                                                                                                 |
| cpu.weight                  | 可读可写。 只对CFS调度器调度的进程有效。存在于非根cgroup中，表示cgroup中进程可以使用的cpu时间份额，默认值为100。                                                                                                                                                                                                                                                                                                                                                                                                                                           | 否    | cpu.shares                         | cgroup v1和v2权重的取值范围不一样。cgroup v1：cpu.shares默认值为1024，值范围\[2,262144\]；cgroup v2：cpu.weight默认值为100，值范围\[1,10000\]。 |
| cpu.idle                    | 可读可写。 存在于非根cgroup中，默认值为0。设置该值为1时，表示其优先级较低，被分配的时间片较少，易被普通任务抢占。                                                                                                                                                                                                                                                                                                                                                                                                                                               | 否    | NA                                 |                                                                                                                 |
| cpu.qos_level               | 可读可写。 混合部署场景下使用，配置CPU资源优先级。更多信息请参考：[内核cpu cgroup的多级混部调度](https://support.huaweicloud.com/usermanual-hce/hce_02_0074.html)。                                                                                                                                                                                                                                                                                                                                                                                    | 是    | cpu.qos_level                      | cgroup v1接口将任务调度级别扩展到5个级别；cgroup v2目前只支持-1和0两级优先级。                                                              |
| cpu.nr_select_allowed_cpus  | 只读。 CPU软绑定功能开启时，统计cgroup组内的任务在唤醒选核时，选择共享核的次数。更多信息请参考：[CPU软绑定](https://support.huaweicloud.com/usermanual-hce/hce_02_0090.html)。                                                                                                                                                                                                                                                                                                                                                                            | 是    | cpuacct.nr_select_allowed_cpus     |                                                                                                                 |
| cpu.nr_select_prefer_cpus   | 只读。 CPU软绑定功能开启时，统计cgroup组内的任务在唤醒选核时，选择优先核的次数。更多信息请参考：[CPU软绑定](https://support.huaweicloud.com/usermanual-hce/hce_02_0090.html)。                                                                                                                                                                                                                                                                                                                                                                             | 是    | cpuacct.nr_select_prefer_cpus      |                                                                                                                 |
| cpu.nr_smoothed_prefer_cpus | 只读。 CPU软绑定功能开启时，统计cgroup组内的任务在唤醒选核时，由于平滑算法没有从优先核切换到共享核的次数。更多信息请参考：[CPU软绑定](https://support.huaweicloud.com/usermanual-hce/hce_02_0090.html)。                                                                                                                                                                                                                                                                                                                                                                | 是    | cpuacct.nr_smoothed_prefer_cpus    |                                                                                                                 |
   
#### cpuset接口
表7cgroup v1 cpuset接口 
| cgroup v1接口                     | 作用                                                                                                                                                                                                                      | 是否自研 | 对应cgroup v2接口         | 备注                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|:---|:---|
| cpuset.cpus                     | 可读可写。 设定该cgroup任务可以访问的CPU。                                                                                                                                                                 | 否    | cpuset.cpus           | cgroup v1: - 不会自动继承父节点的节点；  - 如果下线，再上线，对应的cpu不会出现在cpus；  - 如果要迁入进程，首先需要配置cpus mems，否则迁入失败。  - 如果cgroup组cpu全部下线，对应的cgroup任务会被迁移至可用的父节点。往里面迁移不可迁移。   cgroup v2: - 如果不设置，默认继承最近祖先的节点。  - 下线的仍然在cpus显示，effective不会显示。  - 如果没有配置cpus，迁入进程是可以的，使用的最近祖先的有效配置。   |
| cpuset.mems                     | 可读可写。 设定该cgroup中任务可以访问的NUMA内存节点。                                                                                                                                                            | 否    | cpuset.mems           | cpuset.mems规则与cpuset.cpus类似。 注意：内存迁移有一定的消耗，迁移有可能是不完整，有些内存也可能还在原节点上。所以一般在cgroup迁入进程之前，应该把内存节点配置好。避免做迁移。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| cpuset.effective_cpus           | 只读。 表示实际可使用的cpus。                                                                                                                                                                         | 否    | cpuset.cpus.effective | cgroup v1： - 如果设置了cpuset.cpus，但是当前cgroup设置在cpuset.cpus的cpu都下线了，则cpuset.effective_cpus为空；   例如：cg2的cpuset.cpus为0-1，当CPU 0-1下线后，cg2的cpuset.effective_cpus将显示空。 cgroup v2： - 显示最终有效的cpus。如果设置了cpuset.cpus，但是当前cgroup设置在cpuset.cpus的cpu都下线了，则cpuset.cpus.effective显示不是当前cgroup cpuset.cpus子集，而是当前cgroup继承父节点的、有效的cpus。   例如：cg1的cpuset.cpus为0-3，cg2的cpuset.cpus为0-1，cg1是cg2的父节点，当CPU 0-1下线后，cg2的cpuset.cpus.effective将显示2-3。                                                                                                  |
| cpuset.effective_mems           | 只读。 表示有效的NUMA内存节点（正常情况下等于cpuset.mems，不同的是该接口感知内存热插拔事件，会显示实际的有效内存节点）。                                                                                                                     | 否    | cpuset.mems.effective | 与cpuset.effective_cpus规则类似。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| cpuset.cpu_exclusive            | 可读可写。 值为0或者1。设置其它cpuset及其父、子cpuset是否可共享该cpuset.cpus的特定CPU。默认情况下（0），CPU不会专门分配给某个cpuset。                                                                                                    | 否    | cpuset.cpus.exclusive | - 都是表示独占，但设置方法不一样。cgroup v1表示是否独占；cgroup v2设置独占编号。   cgroup v1： echo 1 \> cpuset.cpu_exclusive表示独占cpus，echo 0 \> cpuset.cpu_exclusive表示非独占cpus，不能设置编号。 cgroup v2： echo 0-1 \> cpuset.cpus.exclusive表示该cgroup独占0-1核。 - cgroup v2的cpuset.cpus.exclusive需要需要与cpuset.cpus.partition配合使用。                                                                                                                                                                                                                   |
| cpuset.mem_exclusive            | 可读可写。 值为0或者1。设置其它cpuset是否可共享该cpuset的特定内存节点。默认情况下（0），内存节点不会专门分配给某个cpuset。设置1表示为某个cpuset保留其专用内存节点。                                                                                          | 否    | NA                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| cpuset.mem_hardwall             | 可读可写。 值为0或者1，表示kernel分配内存页和缓冲数据的是否受到cpuset指定的内存节点限制。默认情况下（0），cpuset.mems 只限制用户态内存申请，内核态内存申请不受其限制，但如果设置了mem_hardwall，内核态的内存申请也会受到限制。                                                         | 否    | NA                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| cpuset.sched_load_balance       | 可读可写。 值为0或者1。表示是否在cgroup做负载均衡。默认情况下 1，kernel将超载CPU中的进程移动到负载较低的CPU中以便平衡负载。                                                                                                                 | 否    | NA                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| cpuset.sched_relax_domain_level | 可读可写。 它代表kernel应尝试平衡负载的CPU宽度范围。必须cpuset.sched_load_balance设置为1才有意义。                                                                                                                        | 否    | NA                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| cpuset.memory_migrate           | 可读可写。 值为0或者1。用来指定当cpuset.mems的值更改时，是否应该将内存中的页迁移到新节点。默认情况下（0）禁止内存迁移，并且页就保留在原来分配的节点中，即使此节点不再是cpuset.mems指定的节点。如果启用（1），系统会将页迁移到cpuset.mems指定的新参数的内存节点中，如果可能的话会保留其相对位置。                          | 否    | NA                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| cpuset.memory_pressure          | 只读。 包含该cpuset进程生成的运行平均"内存压力"，用于衡量cpuset中的任务试图释放节点上正在使用的内存的速率，以满足额外的内存请求。                                                                                                                  | 否    | NA                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| cpuset.memory_pressure_enabled  | 可读可写。 值为0或者1。设定系统是否计算该cgroup进程生成的"内存压力"。计算出的值会输出到cpuset.memory_pressure，代表进程试图释放被占用内存的速率，报告值为：每秒尝试回收内存的整数值再乘以1000。                                                                        | 否    | NA                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| cpuset.memory_spread_page       | 可读可写。 值为0或者1。设定内存页面是否应在该cpuset的内存节点中均匀分布。默认情况下0，系统不会平均分配内存页面，优先在生成它们的进程所运行的同一节点中分配。                                                                                                       | 否    | NA                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| cpuset.memory_spread_slab       | 可读可写。 值为0或者1。设定是否在cpuset中平均分配slab对象。默认情况下0，slab对象不被平均分配，slab对象被置于生成它们的进程所运行的同一节点中。                                                                                                         | 否    | NA                    |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| cpuset.preferred_cpus           | 可读可写。 默认为空。设置cgroup优先使用的CPU范围。根据负载大小动态调节使用CPU范围。具体来说，当负载低于阈值时，调度preferred_cpus集上，负载高时调度到cpuset.cpus范围上。更多信息请参考：[CPU软绑定](https://support.huaweicloud.com/usermanual-hce/hce_02_0090.html)。 | 是    | cpuset.preferred_cpus |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
   
表8cgroup v2 cpuset接口 
| cgroup v2接口           | 作用                                                                                                                                                                                                                                                    | 是否自研 | 对应cgroup v1接口         | 备注                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|:---|:---|:---|
| cpuset.cpus           | 可读可写。 在非根cgroup。描述了这个cgroup进程申请的CPU列表，逗号隔开：范围是\[0,cpu个数)。但是最终真正分配给这个cgroup的CPU列表，可能不同于申请的列表， 因为还要受parent的限制（比如申请了CPU 4但是parent列表里没有4）。这个文件为空时，表示这个cgroup使用离它最近的、非空的祖先cgroup的配置； 如果所有的祖先都为空，那就意味着使用所有可用的CPU。热插拔不影响这个值。 | 否    | cpuset.cpus           | cgroup v1: - 不会自动继承父节点的节点；  - 如果下线，再上线，对应的cpu不会出现在cpus；  - 如果要迁入进程，首先需要配置cpus mems，否则迁入失败。  - 如果cgroup组cpu全部下线，对应的cgroup任务会被迁移至可用的父节点。往里面迁移不可迁移。   cgroup v2: - 如果不设置，默认继承最近祖先的节点。  - 下线的仍然在cpus显示，effective不会显示。  - 如果没有配置cpus，迁入进程是可以的，使用的最近祖先的有效配置。   |
| cpuset.cpus.effective | 只读。 列出了所有parent分配给cgroup的且在线的有效cpu。如果cpuset.cpus是空，那么列出所有parent的可用的cpus。cpuset.cpus不为空，cpuset.cpus.effective必须是它的子集。热插拔影响这个值。                                                                                           | 否    | cpuset.effective_cpus | cgroup v1： - 如果设置了cpuset.cpus，但是当前cgroup设置在cpuset.cpus的cpu都下线了，则cpuset.effective_cpus为空。   例如：cg2的cpuset.cpus为0-1，当CPU 0-1下线后，cg2的cpuset.effective_cpus将显示空。 cgroup v2： - 显示最终有效的cpus。如果设置了cpuset.cpus，但是当前cgroup设置在cpuset.cpus的cpu都下线了，则cpuset.cpus.effective显示不是当前cgroup cpuset.cpus子集，而是当前cgroup继承父节点的、有效的cpus。   例如：cg1的cpuset.cpus为0-3，cg2的cpuset.cpus为0-1，cg1是cg2的父节点，当CPU 0-1下线后，cg2的cpuset.cpus.effective将显示2-3。                                                                                                                            |
| cpuset.mems           | 可读可写。 在在非根cgroup。描述了这个cgroup进程申请的mem列表，逗号隔开，有效值\[0,mem节点个数）。这个文件为空时，表示这个cgroup使用离它最近的、非空的祖先mem的配置； 如果所有的祖先都为空，那就意味着使用所有可用的mem。热插拔不影响这个值。                                                                                | 否    | cpuset.mems           | cpuset.mems规则与cpuset.cpus类似。 注意：内存迁移有一定的消耗，迁移有可能是不完整，有些内存也可能还在原节点上。所以一般在cgroup迁入进程之前，应该把内存节点配置好。避免做迁移。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| cpuset.mems.effective | 只读。 列出了所有parent分配给cgroup的切在线的有效mem。如果cpuset.mems是空，那么列出所有parent的可用的mems。cpuset.mems不为空，cpuset.mems.effective必须是它的子集。                                                                                                      | 否    | cpuset.effective_mems | 与cpuset.cpus.effective规则类似。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| cpuset.cpus.exclusive | 可读可写。 存在于非根cpuset的多值文件。它列出了所有允许用于创建新的cpuset分区的独占CPU。除非cgroup成为一个有效的分区根，否则它的值不会被使用。有关cpuset分区的描述，需要与cpuset.cpus.partition配合使用。                                                                                              | 否    | cpuset.cpu_exclusive  | - 都是表示独占，但设置方法不一样。cgroup v1表示是否独占；cgroup v2设置独占编号。   cgroup v1： echo 1 \> cpuset.cpu_exclusive表示独占cpus，echo 0 \> cpuset.cpu_exclusive表示非独占cpus，不能设置编号。 cgroup v2： echo 0-1 \> cpuset.cpus.exclusive表示该cgroup独占0-1核。 - cgroup v2的cpuset.cpus.exclusive需要需要与cpuset.cpus.partition配合使用。                                                                                                                                                                                                                                   |
| cpuset.preferred_cpus | 可读可写。 默认为空，设置cgroup优先使用的CPU范围。根据负载大小动态调节使用CPU范围。具体来说，当负载低于阈值时，调度preferred_cpus集上，负载高时调度到cpuset.cpus范围上。更多信息请参考：[CPU软绑定](https://support.huaweicloud.com/usermanual-hce/hce_02_0090.html)。                                 | 是    | cpuset.preferred_cpus |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
   
#### io接口
表9cgroup v1 io接口 
| cgroup v1接口                               | 作用                                                                                                          | 是否自研 | 对应cgroup v2接口 | 备注                                                                                                                                                                                                                                                                                                                                                                                             |
|:---|:---|:---|:---|:---|
| blkio.bfq.weight                          | 可读可写。 默认值为100，在没有单独指定设备权重覆盖的情况下，这是所有设备上该组策略的默认权重，仅存在于非root cgroup。           | 否    | io.bfq.weight |                                                                                                                                                                                                                                                                                                                                                                                                |
| blkio.bfq.weight_device                   | 可读可写。 默认值为100，指定cgroup在每个设备的权重。这些权重覆盖由blkio.bfq.weight指定的组权重，仅存在于非root cgroup。 | 否    | io.bfq.weight |                                                                                                                                                                                                                                                                                                                                                                                                |
| blkio.throttle.read_bps_device            | 可读可写。 默认值为空，设置cgroup从设备读取的最大字节速度。                                              | 否    | io.max        | 对应cgroup v2的io.max接口中rbps字段。                                                                                                                                                                                                                                                                                                                                                                   |
| blkio.throttle.write_bps_device           | 可读可写。 默认值为空，设置cgroup向设备写入的最大字节速度。                                            | 否    | io.max        | 对应cgroup v2的io.max接口中wbps字段。                                                                                                                                                                                                                                                                                                                                                                   |
| blkio.throttle.read_iops_device           | 可读可写。 默认值为空，设置cgroup从设备读操作的每秒最大操作次数。                                          | 否    | io.max        | 对应cgroup v2的io.max接口中riops字段。                                                                                                                                                                                                                                                                                                                                                                  |
| blkio.throttle.write_iops_device          | 可读可写。 默认值为空，设置cgroup向设备写操作的每秒最大操作次数。                                           | 否    | io.max        | 对应cgroup v2的io.max接口中wiops字段。                                                                                                                                                                                                                                                                                                                                                                  |
| blkio.throttle.io_service_bytes           | 只读。 查看cgroup在设备中传送的字节数。                                                         | 否    | NA            | 参考blkio.throttle.io_service_bytes_recursive，cgroup v2设计的cgroup只有叶子cgroup对任务起作用，因此中间cgroup节点不再单独统计io.stat，直接包含了所有子目录cgroup的统计总和。                                                                                                                                                                                                                                                                |
| blkio.throttle.io_service_bytes_recursive | 只读。 查看本cgroup及所有子cgroup在设备中传送的字节数。                                              | 否    | io.stat       | - cgroup v2的每个目录下io.stat统计值包含了子目录下的io.stat，相当于v1的blkio.throttle.io_service_bytes_recursive。  - cgroup v1的blkio.throttle.io_service_bytes_recursive中的total字段在v2中没有统计，但是可以根据v2的io.stat的数据进行累积计算得到；另外，v2的io.stat中没有区分sync/async。   |
| blkio.throttle.io_serviced                | 只读。 查看cgroup在设备中执行 I/O 请求的数量。                                                 | 否    | NA            | 参考blkio.throttle.io_serviced_recursive，cgroup v2设计的cgroup只有叶子cgroup对任务起作用，因此中间cgroup节点不再单独统计io.stat，直接包含了所有子目录cgroup的统计总和。                                                                                                                                                                                                                                                                     |
| blkio.throttle.io_serviced_recursive      | 只读。 查看本cgroup及所有子cgroup在设备中执行 I/O 请求的数量。                                        | 否    | io.stat       | - cgroup v2的每个目录下io.stat统计值包含了子目录下的io.stat综合，相当于v1的blkio.throttle.io_serviced_recursive。  - cgroup v1的blkio.throttle.io_serviced_recursive中的total字段在v2中没有统计，但是可以根据v2的io.stat的数据进行累积计算得到；另外，v2的io.stat中没有区分sync/async。           |
| blkio.cost.model                          | 可读可写。 设置指定磁盘的设备模型，只在根cgroup设置。                                                | 是    | io.cost.model |                                                                                                                                                                                                                                                                                                                                                                                                |
| blkio.cost.qos                            | 可读可写。 设置指定磁盘的QOS（Quality of Service）参数，只在根cgroup设置。                            | 是    | io.cost.qos   |                                                                                                                                                                                                                                                                                                                                                                                                |
| blkio.cost.weight                         | 可读可写。 设置cgroup的IO下发权重，默认值为100。                                              | 是    | io.weight     |                                                                                                                                                                                                                                                                                                                                                                                                |
| blkio.reset_stats                         | 只写。 向这个文件写入一个整数会导致重置cgroup所有I/O相关统计信息。                                        | 否    | NA            |                                                                                                                                                                                                                                                                                                                                                                                                |
| blkio.bfq.io_service_bytes                | 只读。 按设备显示BFQ调度器的I/O服务字节数。                                                    | 否    | NA            | cgroup v2只统计cgroup相关的IO，不区分控制策略。                                                                                                                                                                                                                                                                                                                                                               |
| blkio.bfq.io_service_bytes_recursive      | 只读。 查看本cgroup及所有子cgroup的BFQ I/O服务字节数。                                         | 否    | NA            | cgroup v2只统计cgroup相关的IO，不区分控制策略。                                                                                                                                                                                                                                                                                                                                                               |
| blkio.bfq.io_serviced                     | 只读。 查看BFQ调度器的I/O操作次数。                                                          | 否    | NA            | cgroup v2只统计cgroup相关的IO，不区分控制策略。                                                                                                                                                                                                                                                                                                                                                               |
| blkio.bfq.io_serviced_recursive           | 只读。 查看本cgroup及所有子cgroup的BFQ I/O操作次数。                                          | 否    | NA            | cgroup v2只统计cgroup相关的IO，不区分控制策略。                                                                                                                                                                                                                                                                                                                                                               |
   
表10cgroup v2 io接口 
| cgroup v2接口   | 作用                                                                               | 是否自研 | 对应cgroup v1接口                                                                                                                                                                                                               | 备注 |
|:---|:---|:---|:---|:---|
| io.max        | 可读可写。 设置读写最大值，包括读写字节数和读写IO数，默认为空。                   | 否    | blkio.throttle.read_bps_device blkio.throttle.read_iops_device blkio.throttle.write_bps_device blkio.throttle.write_iops_device |    |
| io.weight     | 可读可写。 设置cgroup的IO下发权重，默认值为100。                    | 否    | blkio.cost.weight                                                                                                                                                                                                           |    |
| io.stat       | 只读。 当前cgroup的io统计。                                | 否    | blkio.throttle.io_service_bytes_recursive blkio.throttle.io_serviced_recursive                                                                                                              |    |
| io.cost.qos   | 可读可写。 设置指定磁盘的QOS（Quality of Service）参数，只在根cgroup设置。 | 否    | blkio.cost.qos                                                                                                                                                                                                              |    |
| io.cost.model | 可读可写。 设置指定磁盘的设备模型，只在根cgroup设置。                      | 否    | blkio.cost.model                                                                                                                                                                                                            |    |
| io.bfq.weight | 可读可写。 设置基于bfq的IO下发权重。                              | 否    | blkio.bfq.weight_device                                                                                                                                                                                                     |    |
   
#### hugetlb接口
表11cgroup v1 hugetlb接口 
| cgroup v1接口                                      | 作用                                                                                                         | 是否自研 | 对应cgroup v2接口                         | 备注 |
|:---|:---|:---|:---|:---|
| hugetlb.\<hugepagesize\>.limit_in_bytes          | 可读可写。 设置和查看此cgroup可使用的hugepagesize类型大页内存资源的大小，单位为字节。                       | 否    | hugetlb.\<hugepagesize\>.max          |    |
| hugetlb.\<hugepagesize\>.max_usage_in_bytes      | 可读可写。 记录此cgroup创建以来hugepagesize类型大页内存资源使用的峰值，默认值为0，单位为字节。                    | 否    | NA                                    |    |
| hugetlb.\<hugepagesize\>.usage_in_bytes          | 只读。 查看此cgroup组中当前使用的hugepagesize类型大页内存资源总量大小，单位为字节。                          | 否    | hugetlb.\<hugepagesize\>.current      |    |
| hugetlb.\<hugepagesize\>.failcnt                 | 可读可写。 设置/查看此cgroup中所有进程使用内存资源的总量达到 hugetlb.\<hugepagesize\>.limit_in_bytes的次数。 | 否    | hugetlb.\<hugepagesize\>.events       |    |
| hugetlb.\<hugepagesize\>.rsvd.limit_in_bytes     | 可读可写。 设置和查看此cgroup可预留的hugepagesize类型大页内存资源的限额值，单位为字节。                        | 否    | hugetlb.\<hugepagesize\>.rsvd.max     |    |
| hugetlb.\<hugepagesize\>.rsvd.max_usage_in_bytes | 可读可写。 记录此cgroup创建以来预留的hugepagesize类型大页内存资源的峰值，默认值为0，单位为字节。                   | 否    | NA                                    |    |
| hugetlb.\<hugepagesize\>.rsvd.usage_in_bytes     | 只读。 查看cgroup中当前预留的hugepagesize类型大页内存资源总量，单位为字节。                             | 否    | hugetlb.\<hugepagesize\>.rsvd.current |    |
| hugetlb.\<hugepagesize\>.rsvd.failcnt            | 可读可写。 记录由于HugeTLB预留限制导致大页内存分配失败的次数。                                          | 否    | NA                                    |    |
   
表12cgroup v2 hugetlb接口 
| cgroup v2接口                           | 作用                                                                                                 | 是否自研 | 对应cgroup v1接口                                | 备注 |
|:---|:---|:---|:---|:---|
| hugetlb.\<hugepagesize\>.current      | 只读。 用于查看cgroup中当前使用的hugepagesize类型大页内存资源总量，单位为字节。                     | 否    | hugetlb.\<hugepagesize\>.usage_in_bytes      |    |
| hugetlb.\<hugepagesize\>.events       | 只读。 当前只有max一项事件。max事件用于查看cgroup中hugepagesize类型大页内存由于限制而分配失败的次数，单位为次数。 | 否    | hugetlb.\<hugepagesize\>.failcnt             |    |
| hugetlb.\<hugepagesize\>.max          | 可读可写。 用于设置、查看cgroup可使用的hugepagesize类型大页内存资源的限额值，单位为字节。               | 否    | hugetlb.\<hugepagesize\>.limit_in_bytes      |    |
| hugetlb.\<hugepagesize\>.rsvd.current | 只读。 用于查看cgroup中当前预留的hugepagesize类型大页内存资源总量，单位为字节。                    | 否    | hugetlb.\<hugepagesize\>.rsvd.usage_in_bytes |    |
| hugetlb.\<hugepagesize\>.rsvd.max     | 可读可写。 用于设置、查看cgroup可预留的hugepagesize类型大页内存资源的限额值，单位为字节。                | 否    | hugetlb.\<hugepagesize\>.rsvd.limit_in_bytes |    |
   
#### freezer接口
表13cgroup v1 freezer接口 
| cgroup v1接口             | 作用                                                                                            | 是否自研 | 对应cgroup v2接口 | 备注                                                                                                                                                                                                                                                          |
|:---|:---|:---|:---|:---|
| freezer.state           | 可读可写。 表示当前 freezer 子系统的状态。可以通过读取该文件来获取当前的冻结状态，也可以通过写入特定的值来改变状态。 | 否    | cgroup.freeze | - cgroup v2的cgroup.freeze字段：写1/0表示冻结/解冻。  - cgroup v1的freezer.state字段：FROZEN表示冻结，THAWED表示解冻。   |
| freezer.self_freezing   | 只读。 查看该cgroup是否自身被显式设置为冻结状态。                                    | 否    | NA            |                                                                                                                                                                                                                                                             |
| freezer.parent_freezing | 只读。 查看当前cgroup的父cgroup 是否处于冻结状态。                                  | 否    | NA            |                                                                                                                                                                                                                                                             |
   
#### pids接口
cgroup pids子系统可以限制cgroup及其所有子孙cgroup里面能创建的task数总量。目前cgroup v1和v2的pids接口没有差别。
表14cgroup pids接口 
| cgroup 接口    | 作用                                                                   | 是否自研 |
|:---|:---|:---|
| pids.current | 只读。 当前cgroup的任务个数。                      | 否    |
| pids.events  | 只读。 显示触发超过max被限制次数。                   | 否    |
| pids.max     | 可读可写。 设置cgroup最大的任务个数,默认值为max，表示不限制。 | 否    |
   
#### net_cls,net_prio接口
cgroup v2中移除了net_cls,net_prio相关的接口文件， 建议使用ebpf对流量进行过滤和整形。
表15cgroup v1 net_cls,net_prio接口 
| cgroup v1接口        | 作用                                                                   | 是否自研 | 对应cgroup v2接口 | 备注 |
|:---|:---|:---|:---|:---|
| net_cls.classid    | 可读可写。 为 cgroup 中的网络流量设置分类标识符（classid）。 | 否    | NA            |    |
| net_prio.prioidx   | 只读。 显示 cgroup 的优先级索引号，为只读索引，用于内核内部管理。   | 否    | NA            |    |
| net_prio.ifpriomap | 可读可写。 用于设置或查看网络接口的优先级映射。             | 否    | NA            |    |
   
#### devices接口
cgroup v2中devices控制器不再提供传统接口文件，而是基于 cgroup BPF 机制实现。
表16cgroup v1 devices接口 
| cgroup v1接口   | 作用                                                          | 是否自研 | 对应cgroup v2接口 | 备注 |
|:---|:---|:---|:---|:---|
| devices.allow | 只写。 设置允许 cgroup 中的进程访问特定的设备。 | 否    | NA            |    |
| devices.list  | 只读。 列出 cgroup 中的进程当前可以访问的所有设备。 | 否    | NA            |    |
| devices.deny  | 只写。 设置拒绝 cgroup 中的进程访问特定的设备。 | 否    | NA            |    |
   
#### misc接口
使用misc子系统可以对多种杂项资源进行资源限制和跟踪，在使用之前需要确保已将资源添加到控制器并设置了资源容量。例如：在HCE 3.0系统中增加启动参数filecg_misc，可以对cgroup中进程打开的文件句柄数进行控制，接口中用于对文件句柄的限制是fd开头的。目前cgroup v1和v2的misc接口没有差别。
表17 
| cgroup 接口    | 作用                                                                | 是否自研 |
|:---|:---|:---|
| misc.max     | 可读可写。 设置cgroup最大的资源数量。               | 否    |
| misc.current | 只读。 当前cgroup使用的资源数量。                | 否    |
| misc.events  | 只读。 存在非根目录下。目前只定义了max事件，表示超过资源限制的次数。 | 否    |
   
