Merge pull request #89 from Tim-Zhang/release-0.2.11

release: v0.2.11

.github/workflows/bvt.yaml

@@ -1,20 +1,22 @@
 name: BVT
 on: [pull_request]
+env:
+  RUST_VERSION: 1.52
 jobs:
   build:
     name: Build
     runs-on: ubuntu-latest
     steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-      - name: Build
-        run: make debug
+      - uses: actions/checkout@v2
+      - run: rustup install ${{ env.RUST_VERSION }} && rustup default ${{ env.RUST_VERSION }}
+      - run: make debug
 
   fmt:
     name: Format Check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - run: rustup install ${{ env.RUST_VERSION }} && rustup default ${{ env.RUST_VERSION }}
       - run: rustup component add rustfmt
       - run: make fmt
   clippy:
@@ -22,6 +24,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - run: rustup install ${{ env.RUST_VERSION }} && rustup default ${{ env.RUST_VERSION }}
       - run: rustup component add clippy
       - run: make clippy
   test:
@@ -29,6 +32,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - run: rustup install ${{ env.RUST_VERSION }} && rustup default ${{ env.RUST_VERSION }}
       - run: make test
 
 

.github/workflows/commit-message-check.yaml

@@ -48,6 +48,6 @@ jobs:
       uses: tim-actions/commit-message-checker-with-regex@v0.3.1
       with:
         commits: ${{ steps.get-pr-commits.outputs.commits }}
-        pattern: '^.+(\n.{0,72})*$|^.+\n\s*[^a-zA-Z\s\n]|^.+\n\S+$'
+        pattern: '^.+(\n([a-zA-Z].{0,149}|[^a-zA-Z\n].*|Signed-off-by:.*|))+$'
         error: 'Body line too long (max 72)'
         post_error: ${{ env.error_msg }}

Cargo.toml

@@ -5,7 +5,7 @@ repository = "https://github.com/kata-containers/cgroups-rs"
 keywords = ["linux", "cgroup", "containers", "isolation"]
 categories = ["os", "api-bindings", "os::unix-apis"]
 license = "MIT OR Apache-2.0"
-version = "0.2.6"
+version = "0.2.11"
 authors = ["The Kata Containers community <kata-dev@lists.katacontainers.io>", "Levente Kurusa <lkurusa@acm.org>", "Sam Wilson <tecywiz121@hotmail.com>"]
 edition = "2018"
 homepage = "https://github.com/kata-containers/cgroups-rs"
@@ -14,8 +14,12 @@ readme = "README.md"
 [dependencies]
 log = "0.4"
 regex = "1.1"
-nix = "0.20.0"
+nix = { version = "0.24", default-features = false, features = ["event", "fs", "process"] }
 libc = "0.2"
+serde = { version = "1.0", features = ["derive"], optional = true }
 
 [dev-dependencies]
 libc = "0.2.76"
+
+[features]
+default = []

src/blkio.rs

@@ -16,7 +16,8 @@ use crate::error::*;
 
 use crate::{read_string_from, read_u64_from};
 use crate::{
-    BlkIoResources, ControllIdentifier, ControllerInternal, Controllers, Resources, Subsystem,
+    BlkIoResources, ControllIdentifier, ControllerInternal, Controllers, CustomizedAttribute,
+    Resources, Subsystem,
 };
 
 /// A controller that allows controlling the `blkio` subsystem of a Cgroup.
@@ -31,6 +32,7 @@ pub struct BlkIoController {
 }
 
 #[derive(Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// Per-device information
 pub struct BlkIoData {
     /// The major number of the device.
@@ -42,6 +44,7 @@ pub struct BlkIoData {
 }
 
 #[derive(Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// Per-device activity from the control group.
 pub struct IoService {
     /// The major number of the device.
@@ -61,6 +64,7 @@ pub struct IoService {
 }
 
 #[derive(Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// Per-device activity from the control group.
 /// Only for cgroup v2
 pub struct IoStat {
@@ -203,6 +207,7 @@ fn parse_blkio_data(s: String) -> Result<Vec<BlkIoData>> {
 /// Current state and statistics about how throttled are the block devices when accessed from the
 /// controller's control group.
 #[derive(Default, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct BlkIoThrottle {
     /// Statistics about the bytes transferred between the block devices by the tasks in this
     /// control group.
@@ -238,6 +243,7 @@ pub struct BlkIoThrottle {
 
 /// Statistics and state of the block devices.
 #[derive(Default, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct BlkIo {
     /// The number of BIOS requests merged into I/O requests by the control group's tasks.
     pub io_merged: Vec<IoService>,
@@ -373,6 +379,10 @@ impl ControllerInternal for BlkIoController {
             let _ = self.throttle_write_iops_for_device(dev.major, dev.minor, dev.rate);
         }
 
+        res.attrs.iter().for_each(|(k, v)| {
+            let _ = self.set(k, v);
+        });
+
         Ok(())
     }
 }
@@ -766,6 +776,7 @@ impl BlkIoController {
     }
 }
 
+impl CustomizedAttribute for BlkIoController {}
 #[cfg(test)]
 mod test {
     use crate::blkio::{parse_blkio_data, BlkIoData};

src/cgroup.rs

@@ -359,9 +359,18 @@ fn create_v2_cgroup(root: PathBuf, path: &str) -> Result<()> {
 }
 
 pub fn get_cgroups_relative_paths() -> Result<HashMap<String, String>> {
+    let path = "/proc/self/cgroup".to_string();
+    get_cgroups_relative_paths_by_path(path)
+}
+
+pub fn get_cgroups_relative_paths_by_pid(pid: u32) -> Result<HashMap<String, String>> {
+    let path = format!("/proc/{}/cgroup", pid);
+    get_cgroups_relative_paths_by_path(path)
+}
+
+fn get_cgroups_relative_paths_by_path(path: String) -> Result<HashMap<String, String>> {
     let mut m = HashMap::new();
-    let content =
-        fs::read_to_string("/proc/self/cgroup").map_err(|e| Error::with_cause(ReadFailed, e))?;
+    let content = fs::read_to_string(path).map_err(|e| Error::with_cause(ReadFailed, e))?;
     for l in content.lines() {
         let fl: Vec<&str> = l.split(':').collect();
         if fl.len() != 3 {

src/cpu.rs

@@ -36,6 +36,7 @@ pub struct CpuController {
 
 /// The current state of the control group and its processes.
 #[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Cpu {
     /// Reports CPU time statistics.
     ///
@@ -294,7 +295,7 @@ fn parse_cfs_quota_and_period(mut file: File) -> Result<CfsQuotaAndPeriod> {
         return Err(Error::from_string(format!("invaild format: {}", content)));
     }
 
-    let quota = parse_max_value(&fields[0].to_string())?;
+    let quota = parse_max_value(fields[0])?;
     let period = fields[1]
         .parse::<u64>()
         .map_err(|e| Error::with_cause(ParseError, e))?;

src/cpuacct.rs

@@ -27,6 +27,7 @@ pub struct CpuAcctController {
 }
 
 /// Represents the statistics retrieved from the control group.
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct CpuAcct {
     /// Divides the time used by the tasks into `user` time and `system` time.
     pub stat: String,

src/cpuset.rs

@@ -33,6 +33,7 @@ pub struct CpuSetController {
 }
 
 /// The current state of the `cpuset` controller for this control group.
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct CpuSet {
     /// If true, no other control groups can share the CPUs listed in the `cpus` field.
     pub cpu_exclusive: bool,

src/devices.rs

@@ -32,6 +32,11 @@ pub struct DevicesController {
 
 /// An enum holding the different types of devices that can be manipulated using this controller.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Serialize, serde::Deserialize),
+    serde(rename_all = "snake_case")
+)]
 pub enum DeviceType {
     /// The rule applies to all devices.
     All,
@@ -71,6 +76,11 @@ impl DeviceType {
 
 /// An enum with the permissions that can be allowed/denied to the control group.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Serialize, serde::Deserialize),
+    serde(rename_all = "snake_case")
+)]
 pub enum DevicePermissions {
     /// Permission to read from the device.
     Read,

src/events.rs

@@ -52,12 +52,11 @@ fn register_memory_event(
         eventfd(0, EfdFlags::EFD_CLOEXEC).map_err(|e| Error::with_cause(ReadFailed, e))?;
 
     let event_control_path = cg_dir.join("cgroup.event_control");
-    let data;
-    if arg.is_empty() {
-        data = format!("{} {}", eventfd, event_file.as_raw_fd());
+    let data = if arg.is_empty() {
+        format!("{} {}", eventfd, event_file.as_raw_fd())
     } else {
-        data = format!("{} {} {}", eventfd, event_file.as_raw_fd(), arg);
-    }
+        format!("{} {} {}", eventfd, event_file.as_raw_fd(), arg)
+    };
 
     // write to file and set mode to 0700(FIXME)
     fs::write(&event_control_path, data).map_err(|e| Error::with_cause(WriteFailed, e))?;

src/freezer.rs

@@ -32,6 +32,7 @@ pub struct FreezerController {
 }
 
 /// The current state of the control group
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum FreezerState {
     /// The processes in the control group are _not_ frozen.
     Thawed,

src/hierarchies.rs

@@ -87,7 +87,7 @@ fn mountinfo_file(file: &mut File) -> Vec<Mountinfo> {
                     }
                 }
             }
-            Err(_) => continue,
+            Err(_) => break,
         }
     }
     r
@@ -170,7 +170,7 @@ impl Hierarchy for V1 {
     }
 
     fn root_control_group(&self) -> Cgroup {
-        Cgroup::load(auto(), "".to_string())
+        Cgroup::load(auto(), "")
     }
 
     fn root(&self) -> PathBuf {
@@ -202,7 +202,12 @@ impl Hierarchy for V2 {
         let mut subs = vec![];
 
         let controllers = ret.unwrap().trim().to_string();
-        let controller_list: Vec<&str> = controllers.split(' ').collect();
+        let mut controller_list: Vec<&str> = controllers.split(' ').collect();
+
+        // The freezer functionality is present in V2, but not as a controller,
+        // but apparently as a core functionality. FreezerController supports
+        // that, but we must explicitly fake the controller here.
+        controller_list.push("freezer");
 
         for s in controller_list {
             match s {
@@ -241,7 +246,7 @@ impl Hierarchy for V2 {
     }
 
     fn root_control_group(&self) -> Cgroup {
-        Cgroup::load(auto(), "".to_string())
+        Cgroup::load(auto(), "")
     }
 
     fn root(&self) -> PathBuf {
@@ -292,7 +297,10 @@ impl Default for V2 {
 
 pub const UNIFIED_MOUNTPOINT: &str = "/sys/fs/cgroup";
 
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(
+    all(target_os = "linux", not(target_env = "musl")),
+    target_os = "android"
+))]
 pub fn is_cgroup2_unified_mode() -> bool {
     use nix::sys::statfs;
 

src/hugetlb.rs

@@ -8,6 +8,7 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/hugetlb.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/hugetlb.txt)
+use log::warn;
 use std::io::Write;
 use std::path::PathBuf;
 
@@ -88,7 +89,7 @@ impl<'a> From<&'a Subsystem> for &'a HugeTlbController {
 impl HugeTlbController {
     /// Constructs a new `HugeTlbController` with `root` serving as the root of the control group.
     pub fn new(root: PathBuf, v2: bool) -> Self {
-        let sizes = get_hugepage_sizes().unwrap();
+        let sizes = get_hugepage_sizes();
         Self {
             base: root.clone(),
             path: root,
@@ -180,27 +181,29 @@ use regex::Regex;
 use std::collections::HashMap;
 use std::fs;
 
-fn get_hugepage_sizes() -> Result<Vec<String>> {
-    let mut m = Vec::new();
+fn get_hugepage_sizes() -> Vec<String> {
     let dirs = fs::read_dir(HUGEPAGESIZE_DIR);
     if dirs.is_err() {
-        return Ok(m);
+        return Vec::new();
     }
 
-    for e in dirs.unwrap() {
-        let entry = e.unwrap();
-        let name = entry.file_name().into_string().unwrap();
-        let parts: Vec<&str> = name.split('-').collect();
-        if parts.len() != 2 {
-            continue;
-        }
-        let bmap = get_binary_size_map();
-        let size = parse_size(parts[1], &bmap)?;
-        let dabbrs = get_decimal_abbrs();
-        m.push(custom_size(size as f64, 1024.0, &dabbrs));
-    }
+    dirs.unwrap()
+        .filter_map(|e| {
+            let entry = e.map_err(|e| warn!("readdir error: {:?}", e)).ok()?;
+            let name = entry.file_name().into_string().unwrap();
+            let parts: Vec<&str> = name.split('-').collect();
+            if parts.len() != 2 {
+                return None;
+            }
+            let bmap = get_binary_size_map();
+            let size = parse_size(parts[1], &bmap)
+                .map_err(|e| warn!("parse_size error: {:?}", e))
+                .ok()?;
+            let dabbrs = get_decimal_abbrs();
 
-    Ok(m)
+            Some(custom_size(size as f64, 1024.0, &dabbrs))
+        })
+        .collect()
 }
 
 pub const KB: u128 = 1000;

src/lib.rs

@@ -332,7 +332,23 @@ where
             return Ok(());
         }
 
-        remove_dir(self.get_path())
+        // Compatible with runC for remove dir operation
+        // https://github.com/opencontainers/runc/blob/main/libcontainer/cgroups/utils.go#L272
+        //
+        // We trying to remove all paths five times with increasing delay between tries.
+        // If after all there are not removed cgroups - appropriate error will be
+        // returned.
+        let mut delay = std::time::Duration::from_millis(10);
+        let cgroup_path = self.get_path();
+        for _i in 0..4 {
+            if let Ok(()) = remove_dir(cgroup_path) {
+                return Ok(());
+            }
+            std::thread::sleep(delay);
+            delay *= 2;
+        }
+
+        remove_dir(cgroup_path)
     }
 
     /// Attach a task to this controller.
@@ -365,9 +381,14 @@ where
             .map(|file| {
                 let bf = BufReader::new(file);
                 let mut v = Vec::new();
-                for line in bf.lines().flatten() {
-                    let n = line.trim().parse().unwrap_or(0u64);
-                    v.push(n);
+                for line in bf.lines() {
+                    match line {
+                        Ok(line) => {
+                            let n = line.trim().parse().unwrap_or(0u64);
+                            v.push(n);
+                        }
+                        Err(_) => break,
+                    }
                 }
                 v.into_iter().map(CgroupPid::from).collect()
             })
@@ -423,6 +444,7 @@ pub trait Hierarchy: std::fmt::Debug + Send + Sync {
 
 /// Resource limits for the memory subsystem.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MemoryResources {
     /// How much memory (in bytes) can the kernel consume.
     pub kernel_memory_limit: Option<i64>,
@@ -446,13 +468,15 @@ pub struct MemoryResources {
     /// # Usage:
     /// ```
     /// let resource = &mut cgroups_rs::Resources::default();
-    /// resource.memory.attrs.insert("memory.numa_balancing", "true".to_string());
+    /// resource.memory.attrs.insert("memory.numa_balancing".to_string(), "true".to_string());
     /// // apply here
-    pub attrs: std::collections::HashMap<&'static str, String>,
+    /// ```
+    pub attrs: HashMap<String, String>,
 }
 
 /// Resources limits on the number of processes.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct PidResources {
     /// The maximum number of processes that can exist in the control group.
     ///
@@ -464,6 +488,7 @@ pub struct PidResources {
 
 /// Resources limits about how the tasks can use the CPU.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct CpuResources {
     // cpuset
     /// A comma-separated list of CPU IDs where the task in the control group can run. Dashes
@@ -488,14 +513,15 @@ pub struct CpuResources {
     /// # Usage:
     /// ```
     /// let resource = &mut cgroups_rs::Resources::default();
-    /// resource.cpu.attrs.insert("cpu.cfs_init_buffer_us", "10".to_string());
+    /// resource.cpu.attrs.insert("cpu.cfs_init_buffer_us".to_string(), "10".to_string());
     /// // apply here
     /// ```
-    pub attrs: std::collections::HashMap<&'static str, String>,
+    pub attrs: HashMap<String, String>,
 }
 
 /// A device resource that can be allowed or denied access to.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct DeviceResource {
     /// If true, access to the device is allowed, otherwise it's denied.
     pub allow: bool,
@@ -511,6 +537,7 @@ pub struct DeviceResource {
 
 /// Limit the usage of devices for the control group's tasks.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct DeviceResources {
     /// For each device in the list, the limits in the structure are applied.
     pub devices: Vec<DeviceResource>,
@@ -518,6 +545,7 @@ pub struct DeviceResources {
 
 /// Assigned priority for a network device.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NetworkPriority {
     /// The name (as visible in `ifconfig`) of the interface.
     pub name: String,
@@ -528,6 +556,7 @@ pub struct NetworkPriority {
 /// Collections of limits and tags that can be imposed on packets emitted by the tasks in the
 /// control group.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NetworkResources {
     /// The networking class identifier to attach to the packets.
     ///
@@ -539,6 +568,7 @@ pub struct NetworkResources {
 
 /// A hugepage type and its consumption limit for the control group.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct HugePageResource {
     /// The size of the hugepage, i.e. `2MB`, `1GB`, etc.
     pub size: String,
@@ -549,6 +579,7 @@ pub struct HugePageResource {
 
 /// Provides the ability to set consumption limit on each type of hugepages.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct HugePageResources {
     /// Set a limit of consumption for each hugepages type.
     pub limits: Vec<HugePageResource>,
@@ -556,6 +587,7 @@ pub struct HugePageResources {
 
 /// Weight for a particular block device.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct BlkIoDeviceResource {
     /// The major number of the device.
     pub major: u64,
@@ -569,6 +601,7 @@ pub struct BlkIoDeviceResource {
 
 /// Provides the ability to throttle a device (both byte/sec, and IO op/s)
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct BlkIoDeviceThrottleResource {
     /// The major number of the device.
     pub major: u64,
@@ -580,6 +613,7 @@ pub struct BlkIoDeviceThrottleResource {
 
 /// General block I/O resource limits.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct BlkIoResources {
     /// The weight of the control group against descendant nodes.
     pub weight: Option<u16>,
@@ -595,10 +629,20 @@ pub struct BlkIoResources {
     pub throttle_write_bps_device: Vec<BlkIoDeviceThrottleResource>,
     /// Throttled write IO operations per second can be provided for each device.
     pub throttle_write_iops_device: Vec<BlkIoDeviceThrottleResource>,
+
+    /// Customized key-value attributes
+    /// # Usage:
+    /// ```
+    /// let resource = &mut cgroups_rs::Resources::default();
+    /// resource.blkio.attrs.insert("io.cost.weight".to_string(), "10".to_string());
+    /// // apply here
+    /// ```
+    pub attrs: HashMap<String, String>,
 }
 
 /// The resource limits and constraints that will be set on the control group.
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Resources {
     /// Memory usage related limits.
     pub memory: MemoryResources,
@@ -724,6 +768,7 @@ impl Subsystem {
 
 /// The values for `memory.hight` or `pids.max`
 #[derive(Eq, PartialEq, Copy, Clone, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum MaxValue {
     /// This value is returned when the text is `"max"`.
     Max,
@@ -751,7 +796,7 @@ impl fmt::Display for MaxValue {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             MaxValue::Max => write!(f, "max"),
-            MaxValue::Value(num) => write!(f, "{}", num.to_string()),
+            MaxValue::Value(num) => write!(f, "{}", num),
         }
     }
 }

src/memory.rs

@@ -8,6 +8,7 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/memory.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt)
+use log::warn;
 use std::collections::HashMap;
 use std::io::Write;
 use std::path::PathBuf;
@@ -38,6 +39,7 @@ pub struct MemController {
 }
 
 #[derive(Default, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct SetMemory {
     pub low: Option<MaxValue>,
     pub high: Option<MaxValue>,
@@ -47,6 +49,7 @@ pub struct SetMemory {
 
 /// Controls statistics and controls about the OOM killer operating in this control group.
 #[derive(Default, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct OomControl {
     /// If true, the OOM killer has been disabled for the tasks in this control group.
     pub oom_kill_disable: bool,
@@ -87,6 +90,7 @@ fn parse_oom_control(s: String) -> Result<OomControl> {
 
 /// Contains statistics about the NUMA locality of the control group's tasks.
 #[derive(Default, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct NumaStat {
     /// Total amount of pages used by the control group.
     pub total_pages: u64,
@@ -302,6 +306,7 @@ fn parse_numa_stat(s: String) -> Result<NumaStat> {
 }
 
 #[derive(Default, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MemoryStat {
     pub cache: u64,
     pub rss: u64,
@@ -403,6 +408,7 @@ fn parse_memory_stat(s: String) -> Result<MemoryStat> {
 /// Contains statistics about the current usage of memory and swap (together, not seperately) by
 /// the control group's tasks.
 #[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MemSwap {
     /// How many times the limit has been hit.
     pub fail_cnt: u64,
@@ -417,6 +423,7 @@ pub struct MemSwap {
 /// State of and statistics gathered by the kernel about the memory usage of the control group's
 /// tasks.
 #[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Memory {
     /// How many times the limit has been hit.
     pub fail_cnt: u64,
@@ -461,6 +468,7 @@ pub struct Memory {
 /// The current state of and gathered statistics about the kernel's memory usage for TCP-related
 /// data structures.
 #[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Tcp {
     /// How many times the limit has been hit.
     pub fail_cnt: u64,
@@ -479,6 +487,7 @@ pub struct Tcp {
 /// these tasks if it would think that the limits here would be violated. It's important to note
 /// that interrupts in particular might not be able to enforce these limits.
 #[derive(Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Kmem {
     /// How many times the limit has been hit.
     pub fail_cnt: u64,
@@ -832,8 +841,15 @@ impl MemController {
 
         self.open_path("memory.kmem.limit_in_bytes", true)
             .and_then(|mut file| {
-                file.write_all(limit.to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                let r = file.write_all(limit.to_string().as_ref());
+                match r {
+                    Ok(()) => Ok(()),
+                    Err(ref e) if e.raw_os_error() == Some(libc::EOPNOTSUPP) => {
+                        warn!("memory.kmem.limit_in_bytes is unsupported by the kernel");
+                        Ok(())
+                    }
+                    Err(e) => Err(Error::with_cause(WriteFailed, e)),
+                }
             })
     }
 

src/systemd.rs

@@ -17,7 +17,7 @@ use crate::{ControllIdentifier, ControllerInternal, Controllers, Resources, Subs
 pub struct SystemdController {
     base: PathBuf,
     path: PathBuf,
-    v2: bool,
+    _v2: bool,
 }
 
 impl ControllerInternal for SystemdController {
@@ -66,7 +66,7 @@ impl SystemdController {
         Self {
             base: root.clone(),
             path: root,
-            v2,
+            _v2: v2,
         }
     }
 }

tests/builder.rs

@@ -47,7 +47,8 @@ pub fn test_memory_res_build() {
     {
         let c: &MemController = cg.controller_of().unwrap();
         if !c.v2() {
-            assert_eq!(c.kmem_stat().limit_in_bytes, 128 * 1024 * 1024);
+            // Note: we don't tests the value of c.kmem_stat().limit_in_bytes because on Linux
+            // kernel >= 5.16 setting this value is unsupported.
             assert_eq!(c.memory_stat().swappiness, 70);
         }
         assert_eq!(c.memory_stat().limit_in_bytes, 1024 * 1024 * 1024);
@@ -137,11 +138,8 @@ pub fn test_hugepages_res_build() {
 
     {
         let c: &HugeTlbController = cg.controller_of().unwrap();
-        assert!(c.limit_in_bytes(&"2MB".to_string()).is_ok());
-        assert_eq!(
-            c.limit_in_bytes(&"2MB".to_string()).unwrap(),
-            4 * 2 * 1024 * 1024
-        );
+        assert!(c.limit_in_bytes("2MB").is_ok());
+        assert_eq!(c.limit_in_bytes("2MB").unwrap(), 4 * 2 * 1024 * 1024);
     }
     cg.delete().unwrap();
 }

tests/cpuset.rs

@@ -51,7 +51,7 @@ fn test_cpuset_set_cpus() {
         let cpus = fs::read_to_string("/sys/fs/cgroup/cpuset.cpus.effective").unwrap_or_default();
         let cpus = cpus.trim();
         if !cpus.is_empty() {
-            let r = cpuset.set_cpus(&cpus);
+            let r = cpuset.set_cpus(cpus);
             assert!(r.is_ok());
             let set = cpuset.cpuset();
             assert_eq!(1, set.cpus.len());

tests/hugetlb.rs

@@ -40,5 +40,5 @@ fn test_hugetlb_sizes() {
 }
 
 fn assert_no_error(r: Result<u64>) {
-    assert!(!r.is_err())
+    assert!(r.is_ok())
 }

tests/memory.rs

@@ -23,7 +23,7 @@ fn test_disable_oom_killer() {
         if !mem_controller.v2() {
             // disable oom killer
             let r = mem_controller.disable_oom_killer();
-            assert!(!r.is_err());
+            assert!(r.is_ok());
 
             // after disable
             let m = mem_controller.memory_stat();
@@ -33,6 +33,21 @@ fn test_disable_oom_killer() {
     cg.delete().unwrap();
 }
 
+#[test]
+fn set_kmem_limit_v1() {
+    let h = cgroups_rs::hierarchies::auto();
+    if h.v2() {
+        return;
+    }
+
+    let cg = Cgroup::new(h, String::from("set_kmem_limit_v1"));
+    {
+        let mem_controller: &MemController = cg.controller_of().unwrap();
+        mem_controller.set_kmem_limit(1).unwrap();
+    }
+    cg.delete().unwrap();
+}
+
 #[test]
 fn set_mem_v2() {
     let h = cgroups_rs::hierarchies::auto();