Merge pull request #130 from Tim-Zhang/release-0.3.4

release: v0.3.4

.github/workflows/bvt.yaml

@@ -1,20 +1,22 @@
 name: BVT
 on: [pull_request]
+env:
+  RUST_VERSION: 1.69.0
 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 }}

.gitignore

@@ -8,7 +8,3 @@ Cargo.lock
 
 # These are backup files generated by rustfmt
 **/*.rs.bk
-
-/target
-**/*.rs.bk
-Cargo.lock

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.3.4"
 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,13 @@ readme = "README.md"
 [dependencies]
 log = "0.4"
 regex = "1.1"
-nix = "0.20.0"
+nix = { version = "0.25.0", default-features = false, features = ["event", "fs", "process"] }
 libc = "0.2"
+serde = { version = "1.0", features = ["derive"], optional = true }
+thiserror = "1"
 
 [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.
@@ -41,7 +43,8 @@ pub struct BlkIoData {
     pub data: u64,
 }
 
-#[derive(Eq, PartialEq, Debug)]
+#[derive(Eq, PartialEq, Debug, Default)]
+#[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.
@@ -56,11 +59,14 @@ pub struct IoService {
     pub sync: u64,
     /// How many items were asynchronously transferred.
     pub r#async: u64,
+    /// How many items were discarded.
+    pub discard: u64,
     /// Total number of items transferred.
     pub total: u64,
 }
 
 #[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 {
@@ -83,44 +89,62 @@ pub struct IoStat {
 }
 
 fn parse_io_service(s: String) -> Result<Vec<IoService>> {
-    s.lines()
+    let mut io_services = Vec::<IoService>::new();
+    let mut io_service = IoService::default();
+
+    let lines = s
+        .lines()
         .filter(|x| x.split_whitespace().count() == 3)
         .map(|x| {
             let mut spl = x.split_whitespace();
-            (spl.next().unwrap(), spl.next().unwrap(), spl.next().unwrap())
+            (
+                spl.next().unwrap(),
+                spl.next().unwrap(),
+                spl.next().unwrap(),
+            )
         })
         .map(|(a, b, c)| {
             let mut spl = a.split(':');
-            (spl.next().unwrap(), spl.next().unwrap(), b, c)
-        })
-        .collect::<Vec<_>>()
-        .chunks(5)
-        .map(|x| {
-            match x {
-                [(major, minor, "Read", read_val), (_, _, "Write", write_val),
-                   (_, _, "Sync", sync_val), (_, _, "Async", async_val),
-                   (_, _, "Total", total_val)] =>
-                    Some(IoService {
-                        major: major.parse::<i16>().unwrap(),
-                        minor: minor.parse::<i16>().unwrap(),
-                        read: read_val.parse::<u64>().unwrap(),
-                        write: write_val.parse::<u64>().unwrap(),
-                        sync: sync_val.parse::<u64>().unwrap(),
-                        r#async: async_val.parse::<u64>().unwrap(),
-                        total: total_val.parse::<u64>().unwrap(),
-                    }),
-               _ => None,
-            }
-        })
-        .fold(Ok(Vec::new()), |acc, x| {
-            if acc.is_err() || x.is_none() {
-                Err(Error::new(ParseError))
-            } else {
-                let mut acc = acc.unwrap();
-                acc.push(x.unwrap());
-                Ok(acc)
-            }
+            (
+                spl.next().unwrap().parse::<i16>(),
+                spl.next().unwrap().parse::<i16>(),
+                b,
+                c,
+            )
         })
+        .collect::<Vec<_>>();
+
+    for (major_num, minor_num, op, val) in lines.iter() {
+        let major = *major_num.as_ref().map_err(|_| Error::new(ParseError))?;
+        let minor = *minor_num.as_ref().map_err(|_| Error::new(ParseError))?;
+
+        if (major != io_service.major || minor != io_service.minor) && io_service.major != 0 {
+            // new block device
+            io_services.push(io_service);
+            io_service = IoService::default();
+        }
+
+        io_service.major = major;
+        io_service.minor = minor;
+
+        let val = val.parse::<u64>().map_err(|_| Error::new(ParseError))?;
+
+        match *op {
+            "Read" => io_service.read = val,
+            "Write" => io_service.write = val,
+            "Sync" => io_service.sync = val,
+            "Async" => io_service.r#async = val,
+            "Discard" => io_service.discard = val,
+            "Total" => io_service.total = val,
+            _ => {}
+        }
+    }
+
+    if io_service.major != 0 {
+        io_services.push(io_service);
+    }
+
+    Ok(io_services)
 }
 
 fn get_value(s: &str) -> String {
@@ -203,6 +227,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 +263,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 +399,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(())
     }
 }
@@ -655,8 +685,12 @@ impl BlkIoController {
     pub fn set_leaf_weight(&self, w: u64) -> Result<()> {
         self.open_path("blkio.leaf_weight", true)
             .and_then(|mut file| {
-                file.write_all(w.to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all(w.to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("blkio.leaf_weight".to_string(), w.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -665,7 +699,15 @@ impl BlkIoController {
         self.open_path("blkio.leaf_weight_device", true)
             .and_then(|mut file| {
                 file.write_all(format!("{}:{} {}", major, minor, weight).as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    .map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed(
+                                "blkio.leaf_weight_device".to_string(),
+                                format!("{}:{} {}", major, minor, weight),
+                            ),
+                            e,
+                        )
+                    })
             })
     }
 
@@ -673,99 +715,117 @@ impl BlkIoController {
     pub fn reset_stats(&self) -> Result<()> {
         self.open_path("blkio.reset_stats", true)
             .and_then(|mut file| {
-                file.write_all("1".to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all("1".to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("blkio.reset_stats".to_string(), "1".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
     /// Throttle the bytes per second rate of read operation affecting the block device
     /// `major:minor` to `bps`.
     pub fn throttle_read_bps_for_device(&self, major: u64, minor: u64, bps: u64) -> Result<()> {
-        let mut file = "blkio.throttle.read_bps_device";
+        let mut file_name = "blkio.throttle.read_bps_device";
         let mut content = format!("{}:{} {}", major, minor, bps);
         if self.v2 {
-            file = "io.max";
+            file_name = "io.max";
             content = format!("{}:{} rbps={}", major, minor, bps);
         }
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(content.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(content.as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed(file_name.to_string(), content.to_string()), e)
+            })
         })
     }
 
     /// Throttle the I/O operations per second rate of read operation affecting the block device
     /// `major:minor` to `bps`.
     pub fn throttle_read_iops_for_device(&self, major: u64, minor: u64, iops: u64) -> Result<()> {
-        let mut file = "blkio.throttle.read_iops_device";
+        let mut file_name = "blkio.throttle.read_iops_device";
         let mut content = format!("{}:{} {}", major, minor, iops);
         if self.v2 {
-            file = "io.max";
+            file_name = "io.max";
             content = format!("{}:{} riops={}", major, minor, iops);
         }
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(content.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(content.as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed(file_name.to_string(), content.to_string()), e)
+            })
         })
     }
     /// Throttle the bytes per second rate of write operation affecting the block device
     /// `major:minor` to `bps`.
     pub fn throttle_write_bps_for_device(&self, major: u64, minor: u64, bps: u64) -> Result<()> {
-        let mut file = "blkio.throttle.write_bps_device";
+        let mut file_name = "blkio.throttle.write_bps_device";
         let mut content = format!("{}:{} {}", major, minor, bps);
         if self.v2 {
-            file = "io.max";
+            file_name = "io.max";
             content = format!("{}:{} wbps={}", major, minor, bps);
         }
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(content.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(content.as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed(file_name.to_string(), content.to_string()), e)
+            })
         })
     }
 
     /// Throttle the I/O operations per second rate of write operation affecting the block device
     /// `major:minor` to `bps`.
     pub fn throttle_write_iops_for_device(&self, major: u64, minor: u64, iops: u64) -> Result<()> {
-        let mut file = "blkio.throttle.write_iops_device";
+        let mut file_name = "blkio.throttle.write_iops_device";
         let mut content = format!("{}:{} {}", major, minor, iops);
         if self.v2 {
-            file = "io.max";
+            file_name = "io.max";
             content = format!("{}:{} wiops={}", major, minor, iops);
         }
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(content.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(content.as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed(file_name.to_string(), content.to_string()), e)
+            })
         })
     }
 
     /// Set the weight of the control group's tasks.
     pub fn set_weight(&self, w: u64) -> Result<()> {
         // Attation: may not find in high kernel version.
-        let mut file = "blkio.weight";
+        let mut file_name = "blkio.weight";
         if self.v2 {
-            file = "io.bfq.weight";
+            file_name = "io.bfq.weight";
         }
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(w.to_string().as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(w.to_string().as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed(file_name.to_string(), w.to_string()), e)
+            })
         })
     }
 
     /// Same as `set_weight()`, but settable per each block device.
     pub fn set_weight_for_device(&self, major: u64, minor: u64, weight: u64) -> Result<()> {
-        let mut file = "blkio.weight_device";
+        let mut file_name = "blkio.weight_device";
         if self.v2 {
             // Attation: there is no weight for device in runc
             // https://github.com/opencontainers/runc/blob/46be7b612e2533c494e6a251111de46d8e286ed5/libcontainer/cgroups/fs2/io.go#L30
             // may depends on IO schedulers https://wiki.ubuntu.com/Kernel/Reference/IOSchedulers
-            file = "io.bfq.weight";
+            file_name = "io.bfq.weight";
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
             file.write_all(format!("{}:{} {}", major, minor, weight).as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                .map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed(
+                            file_name.to_string(),
+                            format!("{}:{} {}", major, minor, weight),
+                        ),
+                        e,
+                    )
+                })
         })
     }
 }
 
+impl CustomizedAttribute for BlkIoController {}
 #[cfg(test)]
 mod test {
     use crate::blkio::{parse_blkio_data, BlkIoData};
@@ -777,6 +837,7 @@ mod test {
 8:32 Write 0
 8:32 Sync 4280320
 8:32 Async 0
+8:32 Discard 1
 8:32 Total 4280320
 8:48 Read 5705479168
 8:48 Write 56096055296
@@ -793,28 +854,6 @@ mod test {
 8:0 Sync 7192576
 8:0 Async 0
 8:0 Total 7192576
-Total 61823067136
- ";
-
-    static TEST_WRONG_VALUE: &str = "\
-8:32 Read 4280320
-8:32 Write 0
-8:32 Async 0
-8:32 Total 4280320 8:48 Read 5705479168
-8:48 Write 56096055296
-8:48 Sync 11213923328
-8:48 Async 50587611136
-8:48 Total 61801534464
-8:16 Read 10059776
-8:16 Write 0
-8:16 Sync 10059776
-8:16 Async 0
-8:16 Total 10059776
-8:0 Read 7192576
-8:0 Write 0
-8:0 Sync 7192576
-8:0 Async 0
-8:0 Total 7192576
 Total 61823067136
  ";
 
@@ -844,6 +883,7 @@ Total 61823067136
                     write: 0,
                     sync: 4280320,
                     r#async: 0,
+                    discard: 1,
                     total: 4280320,
                 },
                 IoService {
@@ -853,6 +893,7 @@ Total 61823067136
                     write: 56096055296,
                     sync: 11213923328,
                     r#async: 50587611136,
+                    discard: 0,
                     total: 61801534464,
                 },
                 IoService {
@@ -862,6 +903,7 @@ Total 61823067136
                     write: 0,
                     sync: 10059776,
                     r#async: 0,
+                    discard: 0,
                     total: 10059776,
                 },
                 IoService {
@@ -871,12 +913,34 @@ Total 61823067136
                     write: 0,
                     sync: 7192576,
                     r#async: 0,
+                    discard: 0,
                     total: 7192576,
                 }
             ]
         );
-        let err = parse_io_service(TEST_WRONG_VALUE.to_string()).unwrap_err();
-        assert_eq!(err.kind(), &ErrorKind::ParseError,);
+
+        let invalid_values = vec![
+            "\
+8:32 Read 4280320
+8:32 Write a
+8:32 Async 1
+",
+            "\
+8:32 Read 4280320
+b:32 Write 1
+8:32 Async 1
+",
+            "\
+8:32 Read 4280320
+8:32 Write 1
+8:c Async 1
+",
+        ];
+
+        for value in invalid_values {
+            let err = parse_io_service(value.to_string()).unwrap_err();
+            assert_eq!(err.kind(), &ErrorKind::ParseError,);
+        }
     }
 
     #[test]

src/cgroup.rs

@@ -16,6 +16,11 @@ use std::convert::From;
 use std::fs;
 use std::path::{Path, PathBuf};
 
+pub const CGROUP_MODE_DOMAIN: &str = "domain";
+pub const CGROUP_MODE_DOMAIN_THREADED: &str = "domain threaded";
+pub const CGROUP_MODE_DOMAIN_INVALID: &str = "domain invalid";
+pub const CGROUP_MODE_THREADED: &str = "threaded";
+
 /// A control group is the central structure to this crate.
 ///
 ///
@@ -36,14 +41,18 @@ pub struct Cgroup {
     /// The hierarchy.
     hier: Box<dyn Hierarchy>,
     path: String,
+
+    /// List of controllers specifically enabled in the control group.
+    specified_controllers: Option<Vec<String>>,
 }
 
 impl Clone for Cgroup {
     fn clone(&self) -> Self {
         Cgroup {
             subsystems: self.subsystems.clone(),
-            path: self.path.clone(),
             hier: crate::hierarchies::auto(),
+            path: self.path.clone(),
+            specified_controllers: None,
         }
     }
 }
@@ -54,48 +63,72 @@ impl Default for Cgroup {
             subsystems: Vec::new(),
             hier: crate::hierarchies::auto(),
             path: "".to_string(),
+            specified_controllers: None,
         }
     }
 }
 
 impl Cgroup {
+    pub fn v2(&self) -> bool {
+        self.hier.v2()
+    }
+
+    /// Return the path the cgroup is located at.
+    pub fn path(&self) -> &str {
+        &self.path
+    }
+
     /// Create this control group.
-    fn create(&self) {
+    pub fn create(&self) -> Result<()> {
         if self.hier.v2() {
-            let _ret = create_v2_cgroup(self.hier.root(), &self.path);
+            create_v2_cgroup(self.hier.root(), &self.path, &self.specified_controllers)
         } else {
             for subsystem in &self.subsystems {
                 subsystem.to_controller().create();
             }
+            Ok(())
         }
     }
 
-    pub fn v2(&self) -> bool {
-        self.hier.v2()
-    }
-
     /// Create a new control group in the hierarchy `hier`, with name `path`.
     ///
     /// Returns a handle to the control group that can be used to manipulate it.
-    pub fn new<P: AsRef<Path>>(hier: Box<dyn Hierarchy>, path: P) -> Cgroup {
+    pub fn new<P: AsRef<Path>>(hier: Box<dyn Hierarchy>, path: P) -> Result<Cgroup> {
         let cg = Cgroup::load(hier, path);
-        cg.create();
-        cg
+        cg.create()?;
+        Ok(cg)
+    }
+
+    /// Create a new control group in the hierarchy `hier`, with name `path`.
+    ///
+    /// Returns a handle to the control group that can be used to manipulate it.
+    pub fn new_with_specified_controllers<P: AsRef<Path>>(
+        hier: Box<dyn Hierarchy>,
+        path: P,
+        specified_controllers: Option<Vec<String>>,
+    ) -> Result<Cgroup> {
+        let cg = if let Some(sc) = specified_controllers {
+            Cgroup::load_with_specified_controllers(hier, path, sc)
+        } else {
+            Cgroup::load(hier, path)
+        };
+        cg.create()?;
+        Ok(cg)
     }
 
     /// Create a new control group in the hierarchy `hier`, with name `path` and `relative_paths`
     ///
     /// Returns a handle to the control group that can be used to manipulate it.
     ///
-    /// Note that this method is only meaningful for cgroup v1, call it is equivalent to call `new` in the v2 mode
+    /// Note that this method is only meaningful for cgroup v1, call it is equivalent to call `new` in the v2 mode.
     pub fn new_with_relative_paths<P: AsRef<Path>>(
         hier: Box<dyn Hierarchy>,
         path: P,
         relative_paths: HashMap<String, String>,
-    ) -> Cgroup {
+    ) -> Result<Cgroup> {
         let cg = Cgroup::load_with_relative_paths(hier, path, relative_paths);
-        cg.create();
-        cg
+        cg.create()?;
+        Ok(cg)
     }
 
     /// Create a handle for a control group in the hierarchy `hier`, with name `path`.
@@ -116,6 +149,34 @@ impl Cgroup {
             path: path.to_str().unwrap().to_string(),
             subsystems,
             hier,
+            specified_controllers: None,
+        }
+    }
+
+    /// Create a handle for a specified control group in the hierarchy `hier`, with name `path`.
+    ///
+    /// Returns a handle to the control group (that possibly does not exist until `create()` has
+    /// been called on the cgroup.
+    pub fn load_with_specified_controllers<P: AsRef<Path>>(
+        hier: Box<dyn Hierarchy>,
+        path: P,
+        specified_controllers: Vec<String>,
+    ) -> Cgroup {
+        let path = path.as_ref();
+        let mut subsystems = hier.subsystems();
+        if path.as_os_str() != "" {
+            subsystems = subsystems
+                .into_iter()
+                .filter(|x| specified_controllers.contains(&x.controller_name()))
+                .map(|x| x.enter(path))
+                .collect::<Vec<_>>();
+        }
+
+        Cgroup {
+            path: path.to_str().unwrap().to_string(),
+            subsystems,
+            hier,
+            specified_controllers: Some(specified_controllers),
         }
     }
 
@@ -159,6 +220,7 @@ impl Cgroup {
             subsystems,
             hier,
             path: path.to_str().unwrap().to_string(),
+            specified_controllers: None,
         }
     }
 
@@ -233,36 +295,137 @@ impl Cgroup {
         None
     }
 
+    /// Removes tasks from the control group by thread group id.
+    ///
+    /// Note that this means that the task will be moved back to the root control group in the
+    /// hierarchy and any rules applied to that control group will _still_ apply to the proc.
+    pub fn remove_task_by_tgid(&self, tgid: CgroupPid) -> Result<()> {
+        self.hier.root_control_group().add_task_by_tgid(tgid)
+    }
+
     /// Removes a task from the control group.
     ///
     /// Note that this means that the task will be moved back to the root control group in the
     /// hierarchy and any rules applied to that control group will _still_ apply to the task.
-    pub fn remove_task(&self, pid: CgroupPid) {
-        let _ = self.hier.root_control_group().add_task(pid);
+    pub fn remove_task(&self, tid: CgroupPid) -> Result<()> {
+        self.hier.root_control_group().add_task(tid)
+    }
+
+    /// Moves tasks to the parent control group by thread group id.
+    pub fn move_task_to_parent_by_tgid(&self, tgid: CgroupPid) -> Result<()> {
+        self.hier
+            .parent_control_group(&self.path)
+            .add_task_by_tgid(tgid)
+    }
+
+    /// Moves a task to the parent control group.
+    pub fn move_task_to_parent(&self, tid: CgroupPid) -> Result<()> {
+        self.hier.parent_control_group(&self.path).add_task(tid)
+    }
+
+    /// Return a handle to the parent control group in the hierarchy.
+    pub fn parent_control_group(&self) -> Cgroup {
+        self.hier.parent_control_group(&self.path)
+    }
+
+    /// Kill every process in the control group. Only supported for v2 cgroups and on
+    /// kernels 5.14+. This will fail with InvalidOperation if the 'cgroup.kill' file does
+    /// not exist.
+    pub fn kill(&self) -> Result<()> {
+        if !self.v2() {
+            return Err(Error::new(CgroupVersion));
+        }
+
+        let val = "1";
+        let file_name = "cgroup.kill";
+        let p = self.hier.root().join(self.path.clone()).join(file_name);
+
+        // If cgroup.kill doesn't exist they're not on 5.14+ so lets
+        // surface some error the caller can check against.
+        if !p.exists() {
+            return Err(Error::new(InvalidOperation));
+        }
+
+        fs::write(p, val)
+            .map_err(|e| Error::with_cause(WriteFailed(file_name.to_string(), val.to_string()), e))
     }
 
     /// Attach a task to the control group.
-    pub fn add_task(&self, pid: CgroupPid) -> Result<()> {
+    pub fn add_task(&self, tid: CgroupPid) -> Result<()> {
         if self.v2() {
             let subsystems = self.subsystems();
             if !subsystems.is_empty() {
                 let c = subsystems[0].to_controller();
-                c.add_task(&pid)
+                let cgroup_type = self.get_cgroup_type()?;
+                // In cgroup v2, writing to the cgroup.threads file is only supported in thread mode.
+                if cgroup_type == *CGROUP_MODE_DOMAIN_THREADED
+                    || cgroup_type == *CGROUP_MODE_THREADED
+                {
+                    // It is used to move the threads of a process into a cgroup in thread mode.
+                    c.add_task(&tid)
+                } else {
+                    // When the cgroup type is domain or domain invalid,
+                    // cgroup.threads cannot be written.
+                    Err(Error::new(CgroupMode))
+                }
             } else {
-                Ok(())
+                Err(Error::new(SubsystemsEmpty))
             }
         } else {
             self.subsystems()
                 .iter()
-                .try_for_each(|sub| sub.to_controller().add_task(&pid))
+                .try_for_each(|sub| sub.to_controller().add_task(&tid))
         }
     }
 
-    /// Attach a task to the control group by thread group id.
-    pub fn add_task_by_tgid(&self, pid: CgroupPid) -> Result<()> {
-        self.subsystems()
-            .iter()
-            .try_for_each(|sub| sub.to_controller().add_task_by_tgid(&pid))
+    /// Attach tasks to the control group by thread group id.
+    pub fn add_task_by_tgid(&self, tgid: CgroupPid) -> Result<()> {
+        if self.v2() {
+            let subsystems = self.subsystems();
+            if !subsystems.is_empty() {
+                let c = subsystems[0].to_controller();
+                // It is used to move a thread of the process to a cgroup,
+                // and other threads of the process will also move together.
+                c.add_task_by_tgid(&tgid)
+            } else {
+                Err(Error::new(SubsystemsEmpty))
+            }
+        } else {
+            self.subsystems()
+                .iter()
+                .try_for_each(|sub| sub.to_controller().add_task_by_tgid(&tgid))
+        }
+    }
+
+    /// set cgroup.type
+    pub fn set_cgroup_type(&self, cgroup_type: &str) -> Result<()> {
+        if self.v2() {
+            let subsystems = self.subsystems();
+            if !subsystems.is_empty() {
+                let c = subsystems[0].to_controller();
+                c.set_cgroup_type(cgroup_type)
+            } else {
+                Err(Error::new(SubsystemsEmpty))
+            }
+        } else {
+            Err(Error::new(CgroupVersion))
+        }
+    }
+
+    /// get cgroup.type
+    pub fn get_cgroup_type(&self) -> Result<String> {
+        if self.v2() {
+            let subsystems = self.subsystems();
+            if !subsystems.is_empty() {
+                let c = subsystems[0].to_controller();
+                let cgroup_type = c.get_cgroup_type()?;
+                Ok(cgroup_type)
+            } else {
+                Err(Error::new(SubsystemsEmpty))
+            }
+        } else {
+            Err(Error::new(CgroupVersion))
+        }
     }
 
     /// Set notify_on_release to the control group.
@@ -281,6 +444,33 @@ impl Cgroup {
             .try_for_each(|sub| sub.to_controller().set_release_agent(path))
     }
 
+    /// Returns an Iterator that can be used to iterate over the procs that are currently in the
+    /// control group.
+    pub fn procs(&self) -> Vec<CgroupPid> {
+        // Collect the procs from all subsystems
+        let mut v = if self.v2() {
+            let subsystems = self.subsystems();
+            if !subsystems.is_empty() {
+                let c = subsystems[0].to_controller();
+                c.procs()
+            } else {
+                vec![]
+            }
+        } else {
+            self.subsystems()
+                .iter()
+                .map(|x| x.to_controller().procs())
+                .fold(vec![], |mut acc, mut x| {
+                    acc.append(&mut x);
+                    acc
+                })
+        };
+
+        v.sort();
+        v.dedup();
+        v
+    }
+
     /// Returns an Iterator that can be used to iterate over the tasks that are currently in the
     /// control group.
     pub fn tasks(&self) -> Vec<CgroupPid> {
@@ -307,6 +497,13 @@ impl Cgroup {
         v.dedup();
         v
     }
+
+    /// Checks if the cgroup exists.
+    ///
+    /// Returns true if at least one subsystem exists.
+    pub fn exists(&self) -> bool {
+        self.subsystems().iter().any(|e| e.to_controller().exists())
+    }
 }
 
 pub const UNIFIED_MOUNTPOINT: &str = "/sys/fs/cgroup";
@@ -328,9 +525,22 @@ fn supported_controllers() -> Vec<String> {
         .collect::<Vec<String>>()
 }
 
-fn create_v2_cgroup(root: PathBuf, path: &str) -> Result<()> {
+fn create_v2_cgroup(
+    root: PathBuf,
+    path: &str,
+    specified_controllers: &Option<Vec<String>>,
+) -> Result<()> {
     // controler list ["memory", "cpu"]
-    let controllers = supported_controllers();
+    let controllers = if let Some(s_controllers) = specified_controllers.clone() {
+        if verify_supported_controllers(s_controllers.as_ref()) {
+            s_controllers
+        } else {
+            return Err(Error::new(ErrorKind::SpecifiedControllers));
+        }
+    } else {
+        supported_controllers()
+    };
+
     let mut fp = root;
 
     // enable for root
@@ -358,10 +568,30 @@ fn create_v2_cgroup(root: PathBuf, path: &str) -> Result<()> {
     Ok(())
 }
 
+pub fn verify_supported_controllers(controllers: &[String]) -> bool {
+    let sc = supported_controllers();
+    for controller in controllers.iter() {
+        if !sc.contains(controller) {
+            return false;
+        }
+    }
+    true
+}
+
 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))?;
+        fs::read_to_string(path.clone()).map_err(|e| Error::with_cause(ReadFailed(path), e))?;
     for l in content.lines() {
         let fl: Vec<&str> = l.split(':').collect();
         if fl.len() != 3 {

src/cgroup_builder.rs

@@ -57,11 +57,11 @@
 //!              .read(6, 1, 10)
 //!              .write(11, 1, 100)
 //!          .done()
-//!      .build(h);
+//!      .build(h).unwrap();
 //! ```
 
 use crate::{
-    BlkIoDeviceResource, BlkIoDeviceThrottleResource, Cgroup, DeviceResource, Hierarchy,
+    BlkIoDeviceResource, BlkIoDeviceThrottleResource, Cgroup, DeviceResource, Error, Hierarchy,
     HugePageResource, MaxValue, NetworkPriority, Resources,
 };
 
@@ -80,6 +80,8 @@ pub struct CgroupBuilder {
     name: String,
     /// Internal, unsupported field: use the associated builders instead.
     resources: Resources,
+    /// List of controllers specifically enabled in the control group.
+    specified_controllers: Option<Vec<String>>,
 }
 
 impl CgroupBuilder {
@@ -90,6 +92,7 @@ impl CgroupBuilder {
         CgroupBuilder {
             name: name.to_owned(),
             resources: Resources::default(),
+            specified_controllers: None,
         }
     }
 
@@ -134,10 +137,22 @@ impl CgroupBuilder {
     }
 
     /// Finalize the control group, consuming the builder and creating the control group.
-    pub fn build(self, hier: Box<dyn Hierarchy>) -> Cgroup {
-        let cg = Cgroup::new(hier, self.name);
-        let _ret = cg.apply(&self.resources);
-        cg
+    pub fn build(self, hier: Box<dyn Hierarchy>) -> Result<Cgroup, Error> {
+        if let Some(controllers) = self.specified_controllers {
+            let cg = Cgroup::new_with_specified_controllers(hier, self.name, Some(controllers))?;
+            cg.apply(&self.resources)?;
+            Ok(cg)
+        } else {
+            let cg = Cgroup::new(hier, self.name)?;
+            cg.apply(&self.resources)?;
+            Ok(cg)
+        }
+    }
+
+    /// Specifically enable some controllers in the control group.
+    pub fn set_specified_controllers(mut self, specified_controllers: Vec<String>) -> Self {
+        self.specified_controllers = Some(specified_controllers);
+        self
     }
 }
 

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.
     ///
@@ -130,7 +131,7 @@ impl CpuController {
                     let res = file.read_to_string(&mut s);
                     match res {
                         Ok(_) => Ok(s),
-                        Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                        Err(e) => Err(Error::with_cause(ReadFailed("cpu.stat".to_string()), e)),
                     }
                 })
                 .unwrap_or_default(),
@@ -144,14 +145,15 @@ impl CpuController {
     /// `shares` to `200` ensures that control group `B` receives twice as much as CPU bandwidth.
     /// (Assuming both `A` and `B` are of the same parent)
     pub fn set_shares(&self, shares: u64) -> Result<()> {
-        let mut file = "cpu.shares";
+        let mut file_name = "cpu.shares";
         if self.v2 {
-            file = "cpu.weight";
+            file_name = "cpu.weight";
         }
         // NOTE: .CpuShares is not used here. Conversion is the caller's responsibility.
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(shares.to_string().as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(shares.to_string().as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed(file_name.to_string(), shares.to_string()), e)
+            })
         })
     }
 
@@ -173,8 +175,12 @@ impl CpuController {
         }
         self.open_path("cpu.cfs_period_us", true)
             .and_then(|mut file| {
-                file.write_all(us.to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all(us.to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("cpu.cfs_period_us".to_string(), us.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -199,8 +205,12 @@ impl CpuController {
         }
         self.open_path("cpu.cfs_quota_us", true)
             .and_then(|mut file| {
-                file.write_all(us.to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all(us.to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("cpu.cfs_quota_us".to_string(), us.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -261,23 +271,31 @@ impl CpuController {
         let line = format!("{} {}", new_quota, new_period);
         self.open_path("cpu.max", true).and_then(|mut file| {
             file.write_all(line.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                .map_err(|e| Error::with_cause(WriteFailed("cpu.max".to_string(), line), e))
         })
     }
 
     pub fn set_rt_runtime(&self, us: i64) -> Result<()> {
         self.open_path("cpu.rt_runtime_us", true)
             .and_then(|mut file| {
-                file.write_all(us.to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all(us.to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("cpu.rt_runtime_us".to_string(), us.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
     pub fn set_rt_period_us(&self, us: u64) -> Result<()> {
         self.open_path("cpu.rt_period_us", true)
             .and_then(|mut file| {
-                file.write_all(us.to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all(us.to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("cpu.rt_period_us".to_string(), us.to_string()),
+                        e,
+                    )
+                })
             })
     }
 }
@@ -287,14 +305,14 @@ impl CustomizedAttribute for CpuController {}
 fn parse_cfs_quota_and_period(mut file: File) -> Result<CfsQuotaAndPeriod> {
     let mut content = String::new();
     file.read_to_string(&mut content)
-        .map_err(|e| Error::with_cause(ReadFailed, e))?;
+        .map_err(|e| Error::with_cause(ReadFailed("cpu.max".to_string()), e))?;
 
     let fields = content.trim().split(' ').collect::<Vec<&str>>();
     if fields.len() != 2 {
         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,
@@ -147,8 +148,9 @@ impl CpuAcctController {
     /// Reset the statistics the kernel has gathered about the control group.
     pub fn reset(&self) -> Result<()> {
         self.open_path("cpuacct.usage", true).and_then(|mut file| {
-            file.write_all(b"0")
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+            file.write_all(b"0").map_err(|e| {
+                Error::with_cause(WriteFailed("cpuacct.usage".to_string(), "0".to_string()), e)
+            })
         })
     }
 }

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,
@@ -143,7 +144,12 @@ fn find_no_empty_parent(from: &str, file: &str) -> Result<(String, Vec<PathBuf>)
         let current_value =
             match ::std::fs::read_to_string(current_path.clone().join(file).to_str().unwrap()) {
                 Ok(cpus) => String::from(cpus.trim()),
-                Err(e) => return Err(Error::with_cause(ReadFailed, e)),
+                Err(e) => {
+                    return Err(Error::with_cause(
+                        ReadFailed(current_path.display().to_string()),
+                        e,
+                    ))
+                }
             };
 
         if !current_value.is_empty() {
@@ -176,7 +182,12 @@ fn copy_from_parent(current: &str, file: &str) -> Result<()> {
         pb.push(file);
         match ::std::fs::write(pb.to_str().unwrap(), value.as_bytes()) {
             Ok(_) => (),
-            Err(e) => return Err(Error::with_cause(WriteFailed, e)),
+            Err(e) => {
+                return Err(Error::with_cause(
+                    WriteFailed(pb.display().to_string(), pb.display().to_string()),
+                    e,
+                ))
+            }
         }
     }
 
@@ -346,11 +357,19 @@ impl CpuSetController {
         self.open_path("cpuset.cpu_exclusive", true)
             .and_then(|mut file| {
                 if b {
-                    file.write_all(b"1")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"1").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.cpu_exclusive".to_string(), "1".to_string()),
+                            e,
+                        )
+                    })
                 } else {
-                    file.write_all(b"0")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"0").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.cpu_exclusive".to_string(), "0".to_string()),
+                            e,
+                        )
+                    })
                 }
             })
     }
@@ -361,11 +380,19 @@ impl CpuSetController {
         self.open_path("cpuset.mem_exclusive", true)
             .and_then(|mut file| {
                 if b {
-                    file.write_all(b"1")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"1").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.mem_exclusive".to_string(), "1".to_string()),
+                            e,
+                        )
+                    })
                 } else {
-                    file.write_all(b"0")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"0").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.mem_exclusive".to_string(), "0".to_string()),
+                            e,
+                        )
+                    })
                 }
             })
     }
@@ -376,8 +403,9 @@ impl CpuSetController {
     /// be represented via dashes.
     pub fn set_cpus(&self, cpus: &str) -> Result<()> {
         self.open_path("cpuset.cpus", true).and_then(|mut file| {
-            file.write_all(cpus.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+            file.write_all(cpus.as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed("cpuset.cpus".to_string(), cpus.to_string()), e)
+            })
         })
     }
 
@@ -386,8 +414,9 @@ impl CpuSetController {
     /// Syntax is the same as with `set_cpus()`.
     pub fn set_mems(&self, mems: &str) -> Result<()> {
         self.open_path("cpuset.mems", true).and_then(|mut file| {
-            file.write_all(mems.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+            file.write_all(mems.as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed("cpuset.mems".to_string(), mems.to_string()), e)
+            })
         })
     }
 
@@ -400,11 +429,19 @@ impl CpuSetController {
         self.open_path("cpuset.mem_hardwall", true)
             .and_then(|mut file| {
                 if b {
-                    file.write_all(b"1")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"1").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.mem_hardwall".to_string(), "1".to_string()),
+                            e,
+                        )
+                    })
                 } else {
-                    file.write_all(b"0")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"0").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.mem_hardwall".to_string(), "0".to_string()),
+                            e,
+                        )
+                    })
                 }
             })
     }
@@ -415,11 +452,19 @@ impl CpuSetController {
         self.open_path("cpuset.sched_load_balance", true)
             .and_then(|mut file| {
                 if b {
-                    file.write_all(b"1")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"1").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.sched_load_balance".to_string(), "1".to_string()),
+                            e,
+                        )
+                    })
                 } else {
-                    file.write_all(b"0")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"0").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.sched_load_balance".to_string(), "0".to_string()),
+                            e,
+                        )
+                    })
                 }
             })
     }
@@ -430,8 +475,12 @@ impl CpuSetController {
     pub fn set_rebalance_relax_domain_level(&self, i: i64) -> Result<()> {
         self.open_path("cpuset.sched_relax_domain_level", true)
             .and_then(|mut file| {
-                file.write_all(i.to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all(i.to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("cpuset.sched_relax_domain_level".to_string(), i.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -441,11 +490,19 @@ impl CpuSetController {
         self.open_path("cpuset.memory_migrate", true)
             .and_then(|mut file| {
                 if b {
-                    file.write_all(b"1")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"1").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.memory_migrate".to_string(), "1".to_string()),
+                            e,
+                        )
+                    })
                 } else {
-                    file.write_all(b"0")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"0").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.memory_migrate".to_string(), "0".to_string()),
+                            e,
+                        )
+                    })
                 }
             })
     }
@@ -456,11 +513,19 @@ impl CpuSetController {
         self.open_path("cpuset.memory_spread_page", true)
             .and_then(|mut file| {
                 if b {
-                    file.write_all(b"1")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"1").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.memory_spread_page".to_string(), "1".to_string()),
+                            e,
+                        )
+                    })
                 } else {
-                    file.write_all(b"0")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"0").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.memory_spread_page".to_string(), "0".to_string()),
+                            e,
+                        )
+                    })
                 }
             })
     }
@@ -471,11 +536,19 @@ impl CpuSetController {
         self.open_path("cpuset.memory_spread_slab", true)
             .and_then(|mut file| {
                 if b {
-                    file.write_all(b"1")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"1").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.memory_spread_slab".to_string(), "1".to_string()),
+                            e,
+                        )
+                    })
                 } else {
-                    file.write_all(b"0")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"0").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed("cpuset.memory_spread_slab".to_string(), "0".to_string()),
+                            e,
+                        )
+                    })
                 }
             })
     }
@@ -492,11 +565,25 @@ impl CpuSetController {
         self.open_path("cpuset.memory_pressure_enabled", true)
             .and_then(|mut file| {
                 if b {
-                    file.write_all(b"1")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"1").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed(
+                                "cpuset.memory_pressure_enabled".to_string(),
+                                "1".to_string(),
+                            ),
+                            e,
+                        )
+                    })
                 } else {
-                    file.write_all(b"0")
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(b"0").map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed(
+                                "cpuset.memory_pressure_enabled".to_string(),
+                                "0".to_string(),
+                            ),
+                            e,
+                        )
+                    })
                 }
             })
     }

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,
@@ -41,6 +46,7 @@ pub enum DeviceType {
     Block,
 }
 
+#[allow(clippy::derivable_impls)]
 impl Default for DeviceType {
     fn default() -> Self {
         DeviceType::All
@@ -71,6 +77,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,
@@ -160,9 +171,9 @@ impl ControllerInternal for DevicesController {
 
         for i in &res.devices {
             if i.allow {
-                let _ = self.allow_device(i.devtype, i.major, i.minor, &i.access);
+                self.allow_device(i.devtype, i.major, i.minor, &i.access)?;
             } else {
-                let _ = self.deny_device(i.devtype, i.major, i.minor, &i.access);
+                self.deny_device(i.devtype, i.major, i.minor, &i.access)?;
             }
         }
 
@@ -227,8 +238,15 @@ impl DevicesController {
         };
         let final_str = format!("{} {}:{} {}", devtype.to_char(), major, minor, perms);
         self.open_path("devices.allow", true).and_then(|mut file| {
-            file.write_all(final_str.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+            file.write_all(final_str.as_ref()).map_err(|e| {
+                Error::with_cause(
+                    WriteFailed(
+                        self.get_path().join("devices.allow").display().to_string(),
+                        final_str,
+                    ),
+                    e,
+                )
+            })
         })
     }
 
@@ -259,8 +277,15 @@ impl DevicesController {
         };
         let final_str = format!("{} {}:{} {}", devtype.to_char(), major, minor, perms);
         self.open_path("devices.deny", true).and_then(|mut file| {
-            file.write_all(final_str.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+            file.write_all(final_str.as_ref()).map_err(|e| {
+                Error::with_cause(
+                    WriteFailed(
+                        self.get_path().join("devices.deny").display().to_string(),
+                        final_str,
+                    ),
+                    e,
+                )
+            })
         })
     }
 
@@ -305,7 +330,7 @@ impl DevicesController {
                         }
                     })
                 },
-                Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                Err(e) => Err(Error::with_cause(ReadFailed("devices.list".to_string()), e)),
             }
         })
     }

src/error.rs

@@ -8,40 +8,67 @@ use std::error::Error as StdError;
 use std::fmt;
 
 /// The different types of errors that can occur while manipulating control groups.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(thiserror::Error, Debug, Eq, PartialEq)]
 pub enum ErrorKind {
+    #[error("fs error")]
     FsError,
+
+    #[error("common error: {0}")]
     Common(String),
 
     /// An error occured while writing to a control group file.
-    WriteFailed,
+    #[error("unable to write to a control group file {0}, value {1}")]
+    WriteFailed(String, String),
 
     /// An error occured while trying to read from a control group file.
-    ReadFailed,
+    #[error("unable to read a control group file {0}")]
+    ReadFailed(String),
 
     /// An error occured while trying to remove a control group.
+    #[error("unable to remove a control group")]
     RemoveFailed,
 
     /// An error occured while trying to parse a value from a control group file.
     ///
     /// In the future, there will be some information attached to this field.
+    #[error("unable to parse control group file")]
     ParseError,
 
     /// You tried to do something invalid.
     ///
     /// This could be because you tried to set a value in a control group that is not a root
     /// control group. Or, when using unified hierarchy, you tried to add a task in a leaf node.
+    #[error("the requested operation is invalid")]
     InvalidOperation,
 
     /// The path of the control group was invalid.
     ///
     /// This could be caused by trying to escape the control group filesystem via a string of "..".
     /// This crate checks against this and operations will fail with this error.
+    #[error("the given path is invalid")]
     InvalidPath,
 
+    #[error("invalid bytes size")]
     InvalidBytesSize,
 
+    /// The specified controller is not in the list of supported controllers.
+    #[error("specified controller is not in the list of supported controllers")]
+    SpecifiedControllers,
+
+    /// Using method in wrong cgroup version.
+    #[error("using method in wrong cgroup version")]
+    CgroupVersion,
+
+    /// Using method in wrong cgroup mode.
+    #[error("using method in wrong cgroup mode.")]
+    CgroupMode,
+
+    /// Subsystems is empty.
+    #[error("subsystems is empty")]
+    SubsystemsEmpty,
+
     /// An unknown error has occured.
+    #[error("an unknown error")]
     Other,
 }
 
@@ -53,29 +80,16 @@ pub struct Error {
 
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let msg = match &self.kind {
-            ErrorKind::FsError => "fs error".to_string(),
-            ErrorKind::Common(s) => s.clone(),
-            ErrorKind::WriteFailed => "unable to write to a control group file".to_string(),
-            ErrorKind::ReadFailed => "unable to read a control group file".to_string(),
-            ErrorKind::RemoveFailed => "unable to remove a control group".to_string(),
-            ErrorKind::ParseError => "unable to parse control group file".to_string(),
-            ErrorKind::InvalidOperation => "the requested operation is invalid".to_string(),
-            ErrorKind::InvalidPath => "the given path is invalid".to_string(),
-            ErrorKind::InvalidBytesSize => "invalid bytes size".to_string(),
-            ErrorKind::Other => "an unknown error".to_string(),
-        };
-
         if let Some(cause) = &self.cause {
-            write!(f, "{} caused by: {:?}", msg, cause)
+            write!(f, "{} caused by: {:?}", &self.kind, cause)
         } else {
-            write!(f, "{}", msg)
+            write!(f, "{}", &self.kind)
         }
     }
 }
 
 impl StdError for Error {
-    fn cause(&self) -> Option<&dyn StdError> {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
         #[allow(clippy::manual_map)]
         match self.cause {
             Some(ref x) => Some(&**x),

src/events.rs

@@ -46,21 +46,26 @@ fn register_memory_event(
     arg: &str,
 ) -> Result<Receiver<String>> {
     let path = cg_dir.join(event_name);
-    let event_file = File::open(path).map_err(|e| Error::with_cause(ReadFailed, e))?;
+    let event_file = File::open(path.clone())
+        .map_err(|e| Error::with_cause(ReadFailed(path.display().to_string()), e))?;
 
-    let eventfd =
-        eventfd(0, EfdFlags::EFD_CLOEXEC).map_err(|e| Error::with_cause(ReadFailed, e))?;
+    let eventfd = eventfd(0, EfdFlags::EFD_CLOEXEC)
+        .map_err(|e| Error::with_cause(ReadFailed("eventfd".to_string()), 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))?;
+    fs::write(&event_control_path, data.clone()).map_err(|e| {
+        Error::with_cause(
+            WriteFailed(event_control_path.display().to_string(), data),
+            e,
+        )
+    })?;
 
     let mut eventfd_file = unsafe { File::from_raw_fd(eventfd) };
 

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,
@@ -93,40 +94,40 @@ impl FreezerController {
 
     /// Freezes the processes in the control group.
     pub fn freeze(&self) -> Result<()> {
-        let mut file = "freezer.state";
+        let mut file_name = "freezer.state";
         let mut content = "FROZEN".to_string();
         if self.v2 {
-            file = "cgroup.freeze";
+            file_name = "cgroup.freeze";
             content = "1".to_string();
         }
 
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
             file.write_all(content.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                .map_err(|e| Error::with_cause(WriteFailed(file_name.to_string(), content), e))
         })
     }
 
     /// Thaws, that is, unfreezes the processes in the control group.
     pub fn thaw(&self) -> Result<()> {
-        let mut file = "freezer.state";
+        let mut file_name = "freezer.state";
         let mut content = "THAWED".to_string();
         if self.v2 {
-            file = "cgroup.freeze";
+            file_name = "cgroup.freeze";
             content = "0".to_string();
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
             file.write_all(content.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                .map_err(|e| Error::with_cause(WriteFailed(file_name.to_string(), content), e))
         })
     }
 
     /// Retrieve the state of processes in the control group.
     pub fn state(&self) -> Result<FreezerState> {
-        let mut file = "freezer.state";
+        let mut file_name = "freezer.state";
         if self.v2 {
-            file = "cgroup.freeze";
+            file_name = "cgroup.freeze";
         }
-        self.open_path(file, false).and_then(|mut file| {
+        self.open_path(file_name, false).and_then(|mut file| {
             let mut s = String::new();
             let res = file.read_to_string(&mut s);
             match res {
@@ -138,7 +139,7 @@ impl FreezerController {
                     "FREEZING" => Ok(FreezerState::Freezing),
                     _ => Err(Error::new(ParseError)),
                 },
-                Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                Err(e) => Err(Error::with_cause(ReadFailed(file_name.to_string()), e)),
             }
         })
     }

src/hierarchies.rs

@@ -12,7 +12,7 @@
 use std::fs;
 use std::fs::File;
 use std::io::{BufRead, BufReader};
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use crate::blkio::BlkIoController;
 use crate::cpu::CpuController;
@@ -87,7 +87,7 @@ fn mountinfo_file(file: &mut File) -> Vec<Mountinfo> {
                     }
                 }
             }
-            Err(_) => continue,
+            Err(_) => break,
         }
     }
     r
@@ -170,7 +170,13 @@ impl Hierarchy for V1 {
     }
 
     fn root_control_group(&self) -> Cgroup {
-        Cgroup::load(auto(), "".to_string())
+        Cgroup::load(auto(), "")
+    }
+
+    fn parent_control_group(&self, path: &str) -> Cgroup {
+        let path = Path::new(path);
+        let parent_path = path.parent().unwrap().to_string_lossy().to_string();
+        Cgroup::load(auto(), parent_path)
     }
 
     fn root(&self) -> PathBuf {
@@ -202,7 +208,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 +252,13 @@ impl Hierarchy for V2 {
     }
 
     fn root_control_group(&self) -> Cgroup {
-        Cgroup::load(auto(), "".to_string())
+        Cgroup::load(auto(), "")
+    }
+
+    fn parent_control_group(&self, path: &str) -> Cgroup {
+        let path = Path::new(path);
+        let parent_path = path.parent().unwrap().to_string_lossy().to_string();
+        Cgroup::load(auto(), parent_path)
     }
 
     fn root(&self) -> PathBuf {
@@ -292,40 +309,16 @@ impl Default for V2 {
 
 pub const UNIFIED_MOUNTPOINT: &str = "/sys/fs/cgroup";
 
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
 pub fn is_cgroup2_unified_mode() -> bool {
     use nix::sys::statfs;
 
     let path = std::path::Path::new(UNIFIED_MOUNTPOINT);
-    let fs_stat = statfs::statfs(path);
-    if fs_stat.is_err() {
-        return false;
-    }
+    let fs_stat = match statfs::statfs(path) {
+        Ok(fs_stat) => fs_stat,
+        Err(_) => return false,
+    };
 
-    // FIXME notwork, nix will not compile CGROUP2_SUPER_MAGIC because not(target_env = "musl")
-    fs_stat.unwrap().filesystem_type() == statfs::CGROUP2_SUPER_MAGIC
-}
-
-pub const INIT_CGROUP_PATHS: &str = "/proc/1/cgroup";
-
-#[cfg(all(target_os = "linux", target_env = "musl"))]
-pub fn is_cgroup2_unified_mode() -> bool {
-    let lines = fs::read_to_string(INIT_CGROUP_PATHS);
-    if lines.is_err() {
-        return false;
-    }
-
-    for line in lines.unwrap().lines() {
-        let fields: Vec<&str> = line.split(':').collect();
-        if fields.len() != 3 {
-            continue;
-        }
-        if fields[0] != "0" {
-            return false;
-        }
-    }
-
-    true
+    fs_stat.filesystem_type() == statfs::CGROUP2_SUPER_MAGIC
 }
 
 pub fn auto() -> Box<dyn Hierarchy> {

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,
@@ -137,8 +138,11 @@ impl HugeTlbController {
     /// Get the limit (in bytes) of how much memory can be backed by hugepages of a certain size
     /// (`hugetlb_size`).
     pub fn limit_in_bytes(&self, hugetlb_size: &str) -> Result<u64> {
-        self.open_path(&format!("hugetlb.{}.limit_in_bytes", hugetlb_size), false)
-            .and_then(read_u64_from)
+        let mut file_name = format!("hugetlb.{}.limit_in_bytes", hugetlb_size);
+        if self.v2 {
+            file_name = format!("hugetlb.{}.max", hugetlb_size);
+        }
+        self.open_path(&file_name, false).and_then(read_u64_from)
     }
 
     /// Get the current usage of memory that is backed by hugepages of a certain size
@@ -164,13 +168,14 @@ impl HugeTlbController {
     /// Set the limit (in bytes) of how much memory can be backed by hugepages of a certain size
     /// (`hugetlb_size`).
     pub fn set_limit_in_bytes(&self, hugetlb_size: &str, limit: u64) -> Result<()> {
-        let mut file = format!("hugetlb.{}.limit_in_bytes", hugetlb_size);
+        let mut file_name = format!("hugetlb.{}.limit_in_bytes", hugetlb_size);
         if self.v2 {
-            file = format!("hugetlb.{}.max", hugetlb_size);
+            file_name = format!("hugetlb.{}.max", hugetlb_size);
         }
-        self.open_path(&file, true).and_then(|mut file| {
-            file.write_all(limit.to_string().as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(&file_name, true).and_then(|mut file| {
+            file.write_all(limit.to_string().as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed(file_name.to_string(), limit.to_string()), e)
+            })
         })
     }
 }
@@ -180,27 +185,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

@@ -181,12 +181,21 @@ mod sealed {
 
             if w {
                 match File::create(&path) {
-                    Err(e) => Err(Error::with_cause(ErrorKind::WriteFailed, e)),
+                    Err(e) => Err(Error::with_cause(
+                        ErrorKind::WriteFailed(
+                            path.display().to_string(),
+                            "[CREATE FILE]".to_string(),
+                        ),
+                        e,
+                    )),
                     Ok(file) => Ok(file),
                 }
             } else {
                 match File::open(&path) {
-                    Err(e) => Err(Error::with_cause(ErrorKind::ReadFailed, e)),
+                    Err(e) => Err(Error::with_cause(
+                        ErrorKind::ReadFailed(path.display().to_string()),
+                        e,
+                    )),
                     Ok(file) => Ok(file),
                 }
             }
@@ -198,7 +207,7 @@ mod sealed {
                 let res = file.read_to_string(&mut string);
                 match res {
                     Ok(_) => parse_max_value(&string),
-                    Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                    Err(e) => Err(Error::with_cause(ReadFailed(f.to_string()), e)),
                 }
             })
         }
@@ -216,8 +225,9 @@ mod sealed {
     pub trait CustomizedAttribute: ControllerInternal {
         fn set(&self, key: &str, value: &str) -> Result<()> {
             self.open_path(key, true).and_then(|mut file| {
-                file.write_all(value.as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all(value.as_ref()).map_err(|e| {
+                    Error::with_cause(WriteFailed(key.to_string(), value.to_string()), e)
+                })
             })
         }
 
@@ -226,7 +236,7 @@ mod sealed {
                 let mut string = String::new();
                 match file.read_to_string(&mut string) {
                     Ok(_) => Ok(string.trim().to_owned()),
-                    Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                    Err(e) => Err(Error::with_cause(ReadFailed(key.to_string()), e)),
                 }
             })
         }
@@ -270,9 +280,18 @@ pub trait Controller {
     /// Attach a task to this controller.
     fn add_task_by_tgid(&self, pid: &CgroupPid) -> Result<()>;
 
+    /// set cgroup type.
+    fn set_cgroup_type(&self, cgroup_type: &str) -> Result<()>;
+
+    /// get cgroup type.
+    fn get_cgroup_type(&self) -> Result<String>;
+
     /// Get the list of tasks that this controller has.
     fn tasks(&self) -> Vec<CgroupPid>;
 
+    /// Get the list of procs that this controller has.
+    fn procs(&self) -> Vec<CgroupPid>;
+
     fn v2(&self) -> bool;
 }
 
@@ -307,18 +326,32 @@ where
 
     /// Set notify_on_release
     fn set_notify_on_release(&self, enable: bool) -> Result<()> {
+        if self.is_v2() {
+            return Err(Error::new(ErrorKind::CgroupVersion));
+        }
         self.open_path("notify_on_release", true)
             .and_then(|mut file| {
-                write!(file, "{}", enable as i32)
-                    .map_err(|e| Error::with_cause(ErrorKind::WriteFailed, e))
+                write!(file, "{}", enable as i32).map_err(|e| {
+                    Error::with_cause(
+                        ErrorKind::WriteFailed("notify_on_release".to_string(), enable.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
     /// Set release_agent
     fn set_release_agent(&self, path: &str) -> Result<()> {
+        if self.is_v2() {
+            return Err(Error::new(ErrorKind::CgroupVersion));
+        }
         self.open_path("release_agent", true).and_then(|mut file| {
-            file.write_all(path.as_bytes())
-                .map_err(|e| Error::with_cause(ErrorKind::WriteFailed, e))
+            file.write_all(path.as_bytes()).map_err(|e| {
+                Error::with_cause(
+                    ErrorKind::WriteFailed("release_agent".to_string(), path.to_string()),
+                    e,
+                )
+            })
         })
     }
     /// Does this controller already exist?
@@ -332,48 +365,133 @@ 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.
     fn add_task(&self, pid: &CgroupPid) -> Result<()> {
-        let mut file = "tasks";
+        let mut file_name = "tasks";
         if self.is_v2() {
-            file = "cgroup.procs";
+            file_name = "cgroup.threads";
         }
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(pid.pid.to_string().as_ref())
-                .map_err(|e| Error::with_cause(ErrorKind::WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(pid.pid.to_string().as_ref()).map_err(|e| {
+                Error::with_cause(
+                    ErrorKind::WriteFailed(file_name.to_string(), pid.pid.to_string()),
+                    e,
+                )
+            })
         })
     }
 
     /// Attach a task to this controller by thread group id.
     fn add_task_by_tgid(&self, pid: &CgroupPid) -> Result<()> {
-        self.open_path("cgroup.procs", true).and_then(|mut file| {
-            file.write_all(pid.pid.to_string().as_ref())
-                .map_err(|e| Error::with_cause(ErrorKind::WriteFailed, e))
+        let file_name = "cgroup.procs";
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(pid.pid.to_string().as_ref()).map_err(|e| {
+                Error::with_cause(
+                    ErrorKind::WriteFailed(file_name.to_string(), pid.pid.to_string()),
+                    e,
+                )
+            })
         })
     }
 
-    /// Get the list of tasks that this controller has.
-    fn tasks(&self) -> Vec<CgroupPid> {
-        let mut file = "tasks";
-        if self.is_v2() {
-            file = "cgroup.procs";
-        }
-        self.open_path(file, false)
+    /// Get the list of procs that this controller has.
+    fn procs(&self) -> Vec<CgroupPid> {
+        let file_name = "cgroup.procs";
+        self.open_path(file_name, false)
             .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()
             })
             .unwrap_or_default()
     }
 
+    /// Get the list of tasks that this controller has.
+    fn tasks(&self) -> Vec<CgroupPid> {
+        let mut file_name = "tasks";
+        if self.is_v2() {
+            file_name = "cgroup.threads";
+        }
+        self.open_path(file_name, false)
+            .map(|file| {
+                let bf = BufReader::new(file);
+                let mut v = Vec::new();
+                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()
+            })
+            .unwrap_or_default()
+    }
+
+    /// set cgroup.type
+    fn set_cgroup_type(&self, cgroup_type: &str) -> Result<()> {
+        if !self.is_v2() {
+            return Err(Error::new(ErrorKind::CgroupVersion));
+        }
+        let file_name = "cgroup.type";
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(cgroup_type.as_bytes()).map_err(|e| {
+                Error::with_cause(
+                    ErrorKind::WriteFailed(file_name.to_string(), cgroup_type.to_string()),
+                    e,
+                )
+            })
+        })
+    }
+
+    /// get cgroup.type
+    fn get_cgroup_type(&self) -> Result<String> {
+        if !self.is_v2() {
+            return Err(Error::new(ErrorKind::CgroupVersion));
+        }
+        let file_name = "cgroup.type";
+        self.open_path(file_name, false).and_then(|mut file: File| {
+            let mut string = String::new();
+            match file.read_to_string(&mut string) {
+                Ok(_) => Ok(string.trim().to_owned()),
+                Err(e) => Err(Error::with_cause(
+                    ErrorKind::ReadFailed(file_name.to_string()),
+                    e,
+                )),
+            }
+        })
+    }
+
     fn v2(&self) -> bool {
         self.is_v2()
     }
@@ -388,8 +506,11 @@ fn remove_dir(dir: &Path) -> Result<()> {
     }
 
     if dir.exists() && dir.is_dir() {
-        for entry in fs::read_dir(dir).map_err(|e| Error::with_cause(ReadFailed, e))? {
-            let entry = entry.map_err(|e| Error::with_cause(ReadFailed, e))?;
+        for entry in fs::read_dir(dir)
+            .map_err(|e| Error::with_cause(ReadFailed(dir.display().to_string()), e))?
+        {
+            let entry =
+                entry.map_err(|e| Error::with_cause(ReadFailed(dir.display().to_string()), e))?;
             let path = entry.path();
             if path.is_dir() {
                 remove_dir(&path)?;
@@ -418,11 +539,15 @@ pub trait Hierarchy: std::fmt::Debug + Send + Sync {
     /// Return a handle to the root control group in the hierarchy.
     fn root_control_group(&self) -> Cgroup;
 
+    /// Return a handle to the parent control group in the hierarchy.
+    fn parent_control_group(&self, path: &str) -> Cgroup;
+
     fn v2(&self) -> bool;
 }
 
 /// 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 +571,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 +591,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
@@ -476,9 +604,9 @@ pub struct CpuResources {
     /// Weight of how much of the total CPU time should this control group get. Note that this is
     /// hierarchical, so this is weighted against the siblings of this control group.
     pub shares: Option<u64>,
-    /// In one `period`, how much can the tasks run in nanoseconds.
+    /// In one `period`, how much can the tasks run in microseconds.
     pub quota: Option<i64>,
-    /// Period of time in nanoseconds.
+    /// Period of time in microseconds.
     pub period: Option<u64>,
     /// This is currently a no-operation.
     pub realtime_runtime: Option<i64>,
@@ -488,14 +616,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 +640,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 +648,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 +659,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 +671,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 +682,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 +690,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 +704,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 +716,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 +732,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 +871,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,
@@ -731,6 +879,7 @@ pub enum MaxValue {
     Value(i64),
 }
 
+#[allow(clippy::derivable_impls)]
 impl Default for MaxValue {
     fn default() -> Self {
         MaxValue::Max
@@ -751,7 +900,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),
         }
     }
 }
@@ -772,7 +921,7 @@ pub fn parse_max_value(s: &str) -> Result<MaxValue> {
 pub fn flat_keyed_to_vec(mut file: File) -> Result<Vec<(String, i64)>> {
     let mut content = String::new();
     file.read_to_string(&mut content)
-        .map_err(|e| Error::with_cause(ReadFailed, e))?;
+        .map_err(|e| Error::with_cause(ReadFailed("FIXME: read_string_from".to_string()), e))?;
 
     let mut v = Vec::new();
     for line in content.lines() {
@@ -792,7 +941,7 @@ pub fn flat_keyed_to_vec(mut file: File) -> Result<Vec<(String, i64)>> {
 pub fn flat_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, i64>> {
     let mut content = String::new();
     file.read_to_string(&mut content)
-        .map_err(|e| Error::with_cause(ReadFailed, e))?;
+        .map_err(|e| Error::with_cause(ReadFailed("FIXME: read_string_from".to_string()), e))?;
 
     let mut h = HashMap::new();
     for line in content.lines() {
@@ -812,7 +961,7 @@ pub fn flat_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, i64>> {
 pub fn nested_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, HashMap<String, i64>>> {
     let mut content = String::new();
     file.read_to_string(&mut content)
-        .map_err(|e| Error::with_cause(ReadFailed, e))?;
+        .map_err(|e| Error::with_cause(ReadFailed("FIXME: read_string_from".to_string()), e))?;
 
     let mut h = HashMap::new();
     for line in content.lines() {
@@ -846,7 +995,10 @@ where
             .trim()
             .parse::<T>()
             .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
+        Err(e) => Err(Error::with_cause(
+            ReadFailed("FIXME: can't get path in fn read_from".to_string()),
+            e,
+        )),
     }
 }
 
@@ -854,7 +1006,10 @@ fn read_string_from(mut file: File) -> Result<String> {
     let mut string = String::new();
     match file.read_to_string(&mut string) {
         Ok(_) => Ok(string.trim().to_string()),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
+        Err(e) => Err(Error::with_cause(
+            ReadFailed("FIXME: can't get path in fn read_string_from".to_string()),
+            e,
+        )),
     }
 }
 

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,
@@ -553,8 +562,9 @@ impl MemController {
             if let Some(v) = v {
                 let v = v.to_string();
                 self.open_path(f, true).and_then(|mut file| {
-                    file.write_all(v.as_ref())
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                    file.write_all(v.as_ref()).map_err(|e| {
+                        Error::with_cause(WriteFailed(f.to_string(), format!("{:?}", v)), e)
+                    })
                 })?;
             }
         }
@@ -583,7 +593,10 @@ impl MemController {
                 .open_path("memory.current", false)
                 .and_then(read_u64_from)
                 .unwrap_or(0),
-            max_usage_in_bytes: 0,
+            max_usage_in_bytes: self
+                .open_path("memory.peak", false)
+                .and_then(read_u64_from)
+                .unwrap_or(0),
             move_charge_at_immigrate: 0,
             numa_stat: NumaStat::default(),
             oom_control: OomControl::default(),
@@ -726,7 +739,10 @@ impl MemController {
                 .open_path("memory.swap.current", false)
                 .and_then(read_u64_from)
                 .unwrap_or(0),
-            max_usage_in_bytes: 0,
+            max_usage_in_bytes: self
+                .open_path("memory.swap.peak", false)
+                .and_then(read_u64_from)
+                .unwrap_or(0),
         }
     }
 
@@ -760,8 +776,12 @@ impl MemController {
     /// Reset the fail counter
     pub fn reset_fail_count(&self) -> Result<()> {
         self.open_path("memory.failcnt", true).and_then(|mut file| {
-            file.write_all("0".to_string().as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+            file.write_all("0".to_string().as_ref()).map_err(|e| {
+                Error::with_cause(
+                    WriteFailed("memory.failcnt".to_string(), "0".to_string()),
+                    e,
+                )
+            })
         })
     }
 
@@ -774,8 +794,12 @@ impl MemController {
 
         self.open_path("memory.kmem.failcnt", true)
             .and_then(|mut file| {
-                file.write_all("0".to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all("0".to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("memory.kmem.failcnt".to_string(), "0".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -788,8 +812,12 @@ impl MemController {
 
         self.open_path("memory.kmem.tcp.failcnt", true)
             .and_then(|mut file| {
-                file.write_all("0".to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all("0".to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("memory.kmem.tcp.failcnt".to_string(), "0".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -797,8 +825,12 @@ impl MemController {
     pub fn reset_memswap_fail_count(&self) -> Result<()> {
         self.open_path("memory.memsw.failcnt", true)
             .and_then(|mut file| {
-                file.write_all("0".to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all("0".to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("memory.memsw.failcnt".to_string(), "0".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -806,20 +838,28 @@ impl MemController {
     pub fn reset_max_usage(&self) -> Result<()> {
         self.open_path("memory.max_usage_in_bytes", true)
             .and_then(|mut file| {
-                file.write_all("0".to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all("0".to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("memory.max_usage_in_bytes".to_string(), "0".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
     /// Set the memory usage limit of the control group, in bytes.
     pub fn set_limit(&self, limit: i64) -> Result<()> {
-        let mut file = "memory.limit_in_bytes";
+        let mut file_name = "memory.limit_in_bytes";
+        let mut limit_str = limit.to_string();
         if self.v2 {
-            file = "memory.max";
+            file_name = "memory.max";
+            if limit == -1 {
+                limit_str = "max".to_string();
+            }
         }
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(limit.to_string().as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(limit_str.as_ref())
+                .map_err(|e| Error::with_cause(WriteFailed(file_name.to_string(), limit_str), e))
         })
     }
 
@@ -832,20 +872,34 @@ 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("memory.kmem.limit_in_bytes".to_string(), limit.to_string()),
+                        e,
+                    )),
+                }
             })
     }
 
     /// Set the memory+swap limit of the control group, in bytes.
     pub fn set_memswap_limit(&self, limit: i64) -> Result<()> {
-        let mut file = "memory.memsw.limit_in_bytes";
+        let mut file_name = "memory.memsw.limit_in_bytes";
+        let mut limit_str = limit.to_string();
         if self.v2 {
-            file = "memory.swap.max";
+            file_name = "memory.swap.max";
+            if limit == -1 {
+                limit_str = "max".to_string();
+            }
         }
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(limit.to_string().as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(limit_str.as_ref())
+                .map_err(|e| Error::with_cause(WriteFailed(file_name.to_string(), limit_str), e))
         })
     }
 
@@ -858,8 +912,15 @@ impl MemController {
 
         self.open_path("memory.kmem.tcp.limit_in_bytes", true)
             .and_then(|mut file| {
-                file.write_all(limit.to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all(limit.to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed(
+                            "memory.kmem.tcp.limit_in_bytes".to_string(),
+                            limit.to_string(),
+                        ),
+                        e,
+                    )
+                })
             })
     }
 
@@ -868,13 +929,14 @@ impl MemController {
     /// This limit is enforced when the system is nearing OOM conditions. Contrast this with the
     /// hard limit, which is _always_ enforced.
     pub fn set_soft_limit(&self, limit: i64) -> Result<()> {
-        let mut file = "memory.soft_limit_in_bytes";
+        let mut file_name = "memory.soft_limit_in_bytes";
         if self.v2 {
-            file = "memory.low"
+            file_name = "memory.low"
         }
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(limit.to_string().as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(limit.to_string().as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed(file_name.to_string(), limit.to_string()), e)
+            })
         })
     }
 
@@ -883,22 +945,27 @@ impl MemController {
     ///
     /// Note that a value of zero does not imply that the process will not be swapped out.
     pub fn set_swappiness(&self, swp: u64) -> Result<()> {
-        let mut file = "memory.swappiness";
+        let mut file_name = "memory.swappiness";
         if self.v2 {
-            file = "memory.swap.max"
+            file_name = "memory.swap.max"
         }
 
-        self.open_path(file, true).and_then(|mut file| {
-            file.write_all(swp.to_string().as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+        self.open_path(file_name, true).and_then(|mut file| {
+            file.write_all(swp.to_string().as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed(file_name.to_string(), swp.to_string()), e)
+            })
         })
     }
 
     pub fn disable_oom_killer(&self) -> Result<()> {
         self.open_path("memory.oom_control", true)
             .and_then(|mut file| {
-                file.write_all("1".to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all("1".to_string().as_ref()).map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed("memory.oom_control".to_string(), "1".to_string()),
+                        e,
+                    )
+                })
             })
     }
 

src/net_cls.rs

@@ -88,8 +88,9 @@ impl NetClsController {
         self.open_path("net_cls.classid", true)
             .and_then(|mut file| {
                 let s = format!("{:#08X}", class);
-                file.write_all(s.as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                file.write_all(s.as_ref()).map_err(|e| {
+                    Error::with_cause(WriteFailed("net_cls.classid".to_string(), s), e)
+                })
             })
     }
 

src/net_prio.rs

@@ -132,7 +132,15 @@ impl NetPrioController {
         self.open_path("net_prio.ifpriomap", true)
             .and_then(|mut file| {
                 file.write_all(format!("{} {}", eif, prio).as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    .map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed(
+                                "net_prio.ifpriomap".to_string(),
+                                format!("{} {}", eif, prio),
+                            ),
+                            e,
+                        )
+                    })
             })
     }
 }

src/pid.rs

@@ -112,7 +112,7 @@ impl PidController {
                     },
                     None => Err(Error::new(ParseError)),
                 },
-                Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                Err(e) => Err(Error::with_cause(ReadFailed("pids.events".to_string()), e)),
             }
         })
     }
@@ -130,7 +130,7 @@ impl PidController {
             let res = file.read_to_string(&mut string);
             match res {
                 Ok(_) => parse_max_value(&string),
-                Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                Err(e) => Err(Error::with_cause(ReadFailed("pids.max".to_string()), e)),
             }
         })
     }
@@ -145,7 +145,10 @@ impl PidController {
             let string_to_write = max_pid.to_string();
             match file.write_all(string_to_write.as_ref()) {
                 Ok(_) => Ok(()),
-                Err(e) => Err(Error::with_cause(WriteFailed, e)),
+                Err(e) => Err(Error::with_cause(
+                    WriteFailed("pids.max".to_string(), format!("{:?}", max_pid)),
+                    e,
+                )),
             }
         })
     }

src/rdma.rs

@@ -84,8 +84,9 @@ impl RdmaController {
     /// Set a maximum usage for each RDMA/IB resource.
     pub fn set_max(&self, max: &str) -> Result<()> {
         self.open_path("rdma.max", true).and_then(|mut file| {
-            file.write_all(max.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+            file.write_all(max.as_ref()).map_err(|e| {
+                Error::with_cause(WriteFailed("rdma.max".to_string(), max.to_string()), 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

@@ -22,7 +22,8 @@ pub fn test_cpu_res_build() {
         .cpu()
         .shares(85)
         .done()
-        .build(h);
+        .build(h)
+        .unwrap();
 
     {
         let cpu: &CpuController = cg.controller_of().unwrap();
@@ -42,12 +43,14 @@ pub fn test_memory_res_build() {
         .swappiness(70)
         .memory_hard_limit(1024 * 1024 * 1024)
         .done()
-        .build(h);
+        .build(h)
+        .unwrap();
 
     {
         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);
@@ -63,7 +66,8 @@ pub fn test_pid_res_build() {
         .pid()
         .maximum_number_of_processes(MaxValue::Value(123))
         .done()
-        .build(h);
+        .build(h)
+        .unwrap();
 
     {
         let c: &PidController = cg.controller_of().unwrap();
@@ -82,7 +86,8 @@ pub fn test_devices_res_build() {
         .devices()
         .device(1, 6, DeviceType::Char, true, vec![DevicePermissions::Read])
         .done()
-        .build(h);
+        .build(h)
+        .unwrap();
 
     {
         let c: &DevicesController = cg.controller_of().unwrap();
@@ -112,7 +117,8 @@ pub fn test_network_res_build() {
         .network()
         .class_id(1337)
         .done()
-        .build(h);
+        .build(h)
+        .unwrap();
 
     {
         let c: &NetClsController = cg.controller_of().unwrap();
@@ -133,15 +139,13 @@ pub fn test_hugepages_res_build() {
         .hugepages()
         .limit("2MB".to_string(), 4 * 2 * 1024 * 1024)
         .done()
-        .build(h);
+        .build(h)
+        .unwrap();
 
     {
         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();
 }
@@ -154,7 +158,8 @@ pub fn test_blkio_res_build() {
         .blkio()
         .weight(100)
         .done()
-        .build(h);
+        .build(h)
+        .unwrap();
 
     {
         let c: &BlkIoController = cg.controller_of().unwrap();

tests/cgroup.rs

@@ -5,29 +5,60 @@
 //
 
 //! Simple unit tests about the control groups system.
+use cgroups_rs::cgroup::{
+    CGROUP_MODE_DOMAIN, CGROUP_MODE_DOMAIN_INVALID, CGROUP_MODE_DOMAIN_THREADED,
+    CGROUP_MODE_THREADED,
+};
 use cgroups_rs::memory::MemController;
 use cgroups_rs::Controller;
 use cgroups_rs::{Cgroup, CgroupPid, Subsystem};
+use std::process::Command;
+use std::thread::sleep;
+use std::time::Duration;
 
 #[test]
-fn test_tasks_iterator() {
+fn test_procs_iterator_cgroup() {
     let h = cgroups_rs::hierarchies::auto();
     let pid = libc::pid_t::from(nix::unistd::getpid()) as u64;
-    let cg = Cgroup::new(h, String::from("test_tasks_iterator"));
+    let cg = Cgroup::new(h, String::from("test_procs_iterator_cgroup")).unwrap();
+    {
+        // Add a task to the control group.
+        cg.add_task_by_tgid(CgroupPid::from(pid)).unwrap();
+
+        let mut procs = cg.procs().into_iter();
+        // Verify that the task is indeed in the xcontrol group
+        assert_eq!(procs.next(), Some(CgroupPid::from(pid)));
+        assert_eq!(procs.next(), None);
+
+        // Now, try removing it.
+        cg.remove_task_by_tgid(CgroupPid::from(pid)).unwrap();
+        procs = cg.procs().into_iter();
+
+        // Verify that it was indeed removed.
+        assert_eq!(procs.next(), None);
+    }
+    cg.delete().unwrap();
+}
+
+#[test]
+fn test_tasks_iterator_cgroup_v1() {
+    if cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
+        return;
+    }
+    let h = cgroups_rs::hierarchies::auto();
+    let pid = libc::pid_t::from(nix::unistd::getpid()) as u64;
+    let cg = Cgroup::new(h, String::from("test_tasks_iterator_cgroup_v1")).unwrap();
     {
         // Add a task to the control group.
         cg.add_task(CgroupPid::from(pid)).unwrap();
 
-        use std::{thread, time};
-        thread::sleep(time::Duration::from_millis(100));
-
         let mut tasks = cg.tasks().into_iter();
-        // Verify that the task is indeed in the control group
+        // Verify that the task is indeed in the xcontrol group
         assert_eq!(tasks.next(), Some(CgroupPid::from(pid)));
         assert_eq!(tasks.next(), None);
 
         // Now, try removing it.
-        cg.remove_task(CgroupPid::from(pid));
+        cg.remove_task(CgroupPid::from(pid)).unwrap();
         tasks = cg.tasks().into_iter();
 
         // Verify that it was indeed removed.
@@ -36,6 +67,143 @@ fn test_tasks_iterator() {
     cg.delete().unwrap();
 }
 
+#[test]
+fn test_tasks_iterator_cgroup_threaded_mode() {
+    if !cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
+        return;
+    }
+    let pid = libc::pid_t::from(nix::unistd::getpid()) as u64;
+    let cg = Cgroup::new(
+        cgroups_rs::hierarchies::auto(),
+        String::from("test_tasks_iterator_cgroup_threaded_mode"),
+    )
+    .unwrap();
+    let cg_threaded_sub1 = Cgroup::new_with_specified_controllers(
+        cgroups_rs::hierarchies::auto(),
+        String::from("test_tasks_iterator_cgroup_threaded_mode/threaded_sub1"),
+        Some(vec![String::from("cpuset"), String::from("cpu")]),
+    )
+    .unwrap();
+    let cg_threaded_sub2 = Cgroup::new_with_specified_controllers(
+        cgroups_rs::hierarchies::auto(),
+        String::from("test_tasks_iterator_cgroup_threaded_mode/threaded_sub2"),
+        Some(vec![String::from("cpuset"), String::from("cpu")]),
+    )
+    .unwrap();
+    {
+        // Verify that cgroup type of the control group is domain mode.
+        assert_eq!(cg.get_cgroup_type().unwrap(), CGROUP_MODE_DOMAIN);
+
+        // Set cgroup type of the sub-control group is thread mode.
+        cg_threaded_sub1
+            .set_cgroup_type(CGROUP_MODE_THREADED)
+            .unwrap();
+        // Verify that cgroup type of the sub-control group is thread mode.
+        assert_eq!(
+            cg_threaded_sub1.get_cgroup_type().unwrap(),
+            CGROUP_MODE_THREADED
+        );
+        // Verify that the cgroup type of the sub-control group that does
+        // not set the cgroup type is domain invalid mode.
+        assert_eq!(
+            cg_threaded_sub2.get_cgroup_type().unwrap(),
+            CGROUP_MODE_DOMAIN_INVALID
+        );
+        // Verify whether the cgroup type of the parent control group of
+        // the control group whose cgroup type is set to thread mode is
+        // domain thread mode.
+        assert_eq!(cg.get_cgroup_type().unwrap(), CGROUP_MODE_DOMAIN_THREADED);
+
+        // Set cgroup type of the sub-control group is thread mode.
+        cg_threaded_sub2
+            .set_cgroup_type(CGROUP_MODE_THREADED)
+            .unwrap();
+        // Verify that cgroup type of the sub-control group is thread mode.
+        assert_eq!(
+            cg_threaded_sub2.get_cgroup_type().unwrap(),
+            CGROUP_MODE_THREADED
+        );
+
+        // Add a proc to the control group.
+        cg.add_task_by_tgid(CgroupPid::from(pid)).unwrap();
+
+        let mut procs = cg.procs().into_iter();
+        // Verify that the task is indeed in the x control group
+        assert_eq!(procs.next(), Some(CgroupPid::from(pid)));
+        assert_eq!(procs.next(), None);
+
+        // Add a task to the sub control group.
+        cg_threaded_sub1.add_task(CgroupPid::from(pid)).unwrap();
+
+        let mut tasks = cg_threaded_sub1.tasks().into_iter();
+        // Verify that the task is indeed in the xcontrol group
+        assert_eq!(tasks.next(), Some(CgroupPid::from(pid)));
+        assert_eq!(tasks.next(), None);
+
+        // Now, try move it to parent.
+        cg_threaded_sub1
+            .move_task_to_parent(CgroupPid::from(pid))
+            .unwrap();
+        tasks = cg_threaded_sub1.tasks().into_iter();
+
+        // Verify that it was indeed removed.
+        assert_eq!(tasks.next(), None);
+
+        // Now, try removing it.
+        cg.remove_task_by_tgid(CgroupPid::from(pid)).unwrap();
+        procs = cg.procs().into_iter();
+
+        // Verify that it was indeed removed.
+        assert_eq!(procs.next(), None);
+    }
+    cg_threaded_sub1.delete().unwrap();
+    cg_threaded_sub2.delete().unwrap();
+    cg.delete().unwrap();
+}
+
+#[test]
+fn test_kill_cgroup() {
+    if !cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
+        return;
+    }
+    let h = cgroups_rs::hierarchies::auto();
+    let cg = Cgroup::new(h, String::from("test_kill_cgroup")).unwrap();
+    {
+        // Spawn a proc, don't want to getpid(2) here.
+        let mut child = Command::new("sleep").arg("infinity").spawn().unwrap();
+        cg.add_task_by_tgid(CgroupPid::from(child.id() as u64))
+            .unwrap();
+
+        let cg_procs = cg.procs();
+        assert_eq!(cg_procs.len(), 1_usize);
+
+        // Now kill and wait on the proc.
+        cg.kill().unwrap();
+
+        let mut tries = 0;
+        let status: Option<std::process::ExitStatus> = loop {
+            match child.try_wait() {
+                Ok(Some(status)) => {
+                    break Some(status);
+                }
+                Ok(None) => {
+                    if tries > 3 {
+                        break None;
+                    }
+                    sleep(Duration::from_millis(100));
+                    tries += 1;
+                }
+                Err(e) => {
+                    child.kill().unwrap();
+                    panic!("error attempting to wait: {}", e);
+                }
+            }
+        };
+        assert!(status.is_some());
+    }
+    cg.delete().unwrap();
+}
+
 #[test]
 fn test_cgroup_with_relative_paths() {
     if cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
@@ -83,7 +251,7 @@ fn test_cgroup_v2() {
         return;
     }
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_v2"));
+    let cg = Cgroup::new(h, String::from("test_v2")).unwrap();
 
     let mem_controller: &MemController = cg.controller_of().unwrap();
     let (mem, swp, rev) = (4 * 1024 * 1000, 2 * 1024 * 1000, 1024 * 1000);

tests/cpu.rs

@@ -10,7 +10,7 @@ use cgroups_rs::Cgroup;
 #[test]
 fn test_cfs_quota_and_periods() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_cfs_quota_and_periods"));
+    let cg = Cgroup::new(h, String::from("test_cfs_quota_and_periods")).unwrap();
 
     let cpu_controller: &CpuController = cg.controller_of().unwrap();
 

tests/cpuset.rs

@@ -13,7 +13,7 @@ use std::fs;
 #[test]
 fn test_cpuset_memory_pressure_root_cg() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_cpuset_memory_pressure_root_cg"));
+    let cg = Cgroup::new(h, String::from("test_cpuset_memory_pressure_root_cg")).unwrap();
     {
         let cpuset: &CpuSetController = cg.controller_of().unwrap();
 
@@ -27,7 +27,7 @@ fn test_cpuset_memory_pressure_root_cg() {
 #[test]
 fn test_cpuset_set_cpus() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus"));
+    let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus")).unwrap();
     {
         let cpuset: &CpuSetController = cg.controller_of().unwrap();
 
@@ -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());
@@ -64,7 +64,7 @@ fn test_cpuset_set_cpus() {
 #[test]
 fn test_cpuset_set_cpus_add_task() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus_add_task/sub-dir"));
+    let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus_add_task/sub-dir")).unwrap();
 
     let cpuset: &CpuSetController = cg.controller_of().unwrap();
     let set = cpuset.cpuset();
@@ -77,13 +77,13 @@ fn test_cpuset_set_cpus_add_task() {
 
     // Add a task to the control group.
     let pid_i = libc::pid_t::from(nix::unistd::getpid()) as u64;
-    let _ = cg.add_task(CgroupPid::from(pid_i));
+    let _ = cg.add_task_by_tgid(CgroupPid::from(pid_i));
     let tasks = cg.tasks();
     assert!(!tasks.is_empty());
     println!("tasks after added: {:?}", tasks);
 
     // remove task
-    let _ = cg.remove_task(CgroupPid::from(pid_i));
+    cg.remove_task_by_tgid(CgroupPid::from(pid_i)).unwrap();
     let tasks = cg.tasks();
     println!("tasks after deleted: {:?}", tasks);
     assert_eq!(0, tasks.len());

tests/devices.rs

@@ -17,7 +17,7 @@ fn test_devices_parsing() {
     }
 
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_devices_parsing"));
+    let cg = Cgroup::new(h, String::from("test_devices_parsing")).unwrap();
     {
         let devices: &DevicesController = cg.controller_of().unwrap();
 

tests/hugetlb.rs

@@ -17,7 +17,7 @@ fn test_hugetlb_sizes() {
     }
 
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_hugetlb_sizes"));
+    let cg = Cgroup::new(h, String::from("test_hugetlb_sizes")).unwrap();
     {
         let hugetlb_controller: &HugeTlbController = cg.controller_of().unwrap();
         let _ = hugetlb_controller.get_sizes();
@@ -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

@@ -11,7 +11,7 @@ use cgroups_rs::{Cgroup, MaxValue};
 #[test]
 fn test_disable_oom_killer() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_disable_oom_killer"));
+    let cg = Cgroup::new(h, String::from("test_disable_oom_killer")).unwrap();
     {
         let mem_controller: &MemController = cg.controller_of().unwrap();
 
@@ -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")).unwrap();
+    {
+        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();
@@ -40,7 +55,7 @@ fn set_mem_v2() {
         return;
     }
 
-    let cg = Cgroup::new(h, String::from("set_mem_v2"));
+    let cg = Cgroup::new(h, String::from("set_mem_v2")).unwrap();
     {
         let mem_controller: &MemController = cg.controller_of().unwrap();
 

tests/pids.rs

@@ -17,7 +17,7 @@ use libc::pid_t;
 #[test]
 fn create_and_delete_cgroup() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("create_and_delete_cgroup"));
+    let cg = Cgroup::new(h, String::from("create_and_delete_cgroup")).unwrap();
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
         pidcontroller.set_pid_max(MaxValue::Value(1337)).unwrap();
@@ -31,7 +31,7 @@ fn create_and_delete_cgroup() {
 #[test]
 fn test_pids_current_is_zero() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_pids_current_is_zero"));
+    let cg = Cgroup::new(h, String::from("test_pids_current_is_zero")).unwrap();
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
         let current = pidcontroller.get_pid_current();
@@ -43,7 +43,7 @@ fn test_pids_current_is_zero() {
 #[test]
 fn test_pids_events_is_zero() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_pids_events_is_zero"));
+    let cg = Cgroup::new(h, String::from("test_pids_events_is_zero")).unwrap();
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
         let events = pidcontroller.get_pid_events();
@@ -56,7 +56,7 @@ fn test_pids_events_is_zero() {
 #[test]
 fn test_pid_events_is_not_zero() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("test_pid_events_is_not_zero"));
+    let cg = Cgroup::new(h, String::from("test_pid_events_is_not_zero")).unwrap();
     {
         let pids: &PidController = cg.controller_of().unwrap();
         let before = pids.get_pid_events();
@@ -65,7 +65,7 @@ fn test_pid_events_is_not_zero() {
         match unsafe { fork() } {
             Ok(ForkResult::Parent { child, .. }) => {
                 // move the process into the control group
-                let _ = pids.add_task(&(pid_t::from(child) as u64).into());
+                let _ = pids.add_task_by_tgid(&(pid_t::from(child) as u64).into());
 
                 println!("added task to cg: {:?}", child);
 

tests/resources.rs

@@ -11,7 +11,7 @@ use cgroups_rs::{Cgroup, MaxValue, PidResources, Resources};
 #[test]
 fn pid_resources() {
     let h = cgroups_rs::hierarchies::auto();
-    let cg = Cgroup::new(h, String::from("pid_resources"));
+    let cg = Cgroup::new(h, String::from("pid_resources")).unwrap();
     {
         let res = Resources {
             pid: PidResources {