Merge pull request #101 from Tim-Zhang/release-0.2.12

release: v0.2.12

.clippy.toml

@@ -0,0 +1 @@
+upper-case-acronyms-aggressive = true

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,17 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: 'bug, needs-review'
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/enhancement-request.md

@@ -0,0 +1,20 @@
+---
+name: Enhancement request
+about: Suggest an improvement to an existing feature
+title: ''
+labels: enhancement, needs-review
+assignees: ''
+
+---
+
+**Which feature do you think can be improved?**
+
+Specify the feature you think could be made better.
+
+**How can it be improved?**
+
+Describe how specifically you think it could be improved.
+
+**Additional Information**
+
+Anything else to add?

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: 'feature, needs-review'
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/PR-wip-checks.yaml

@@ -0,0 +1,21 @@
+name: Pull request WIP checks
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - edited
+      - labeled
+      - unlabeled
+
+jobs:
+  pr_wip_check:
+    runs-on: ubuntu-latest
+    name: WIP Check
+    steps:
+    - name: WIP Check
+      uses: tim-actions/wip-check@1c2a1ca6c110026b3e2297bb2ef39e1747b5a755
+      with:
+        labels: '["do-not-merge", "wip", "rfc"]'
+        keywords: '["WIP", "wip", "RFC", "rfc", "dnm", "DNM", "do-not-merge"]'

.github/workflows/bvt.yaml

@@ -0,0 +1,38 @@
+name: BVT
+on: [pull_request]
+env:
+  RUST_VERSION: 1.52
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - 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:
+    name: Clippy 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 clippy
+      - run: make clippy
+  test:
+    name: Run Unit Test
+    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

@@ -0,0 +1,53 @@
+name: Commit Message Check
+on:
+  pull_request:
+    types:
+      - opened
+      - reopened
+      - synchronize
+
+env:
+  error_msg: |+
+    See the document below for help on formatting commits for the project.
+
+    https://github.com/kata-containers/community/blob/master/CONTRIBUTING.md#patch-forma
+
+jobs:
+  commit-message-check:
+    runs-on: ubuntu-latest
+    name: Commit Message Check
+    steps:
+    - name: Get PR Commits
+      id: 'get-pr-commits'
+      uses: tim-actions/get-pr-commits@v1.0.0
+      with:
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: DCO Check
+      uses: tim-actions/dco@2fd0504dc0d27b33f542867c300c60840c6dcb20
+      with:
+        commits: ${{ steps.get-pr-commits.outputs.commits }}
+
+    - name: Commit Body Missing Check
+      if: ${{ success() || failure() }}
+      uses: tim-actions/commit-body-check@v1.0.2
+      with:
+        commits: ${{ steps.get-pr-commits.outputs.commits }}
+
+    - name: Check Subject Line Length
+      if: ${{ success() || failure() }}
+      uses: tim-actions/commit-message-checker-with-regex@v0.3.1
+      with:
+        commits: ${{ steps.get-pr-commits.outputs.commits }}
+        pattern: '^.{0,75}(\n.*)*$'
+        error: 'Subject too long (max 75)'
+        post_error: ${{ env.error_msg }}
+
+    - name: Check Body Line Length
+      if: ${{ success() || failure() }}
+      uses: tim-actions/commit-message-checker-with-regex@v0.3.1
+      with:
+        commits: ${{ steps.get-pr-commits.outputs.commits }}
+        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 }}

.travis.yml

@@ -1,11 +0,0 @@
-language: rust
-rust:
-  - stable
-  - beta
-  - nightly
-matrix:
-  allow_failures:
-    - rust: nightly
-  fast_finish: true
-script:
-  - cargo build --verbose --all

Cargo.toml

@@ -1,19 +1,26 @@
 [package]
-name = "cgroups"
+name = "cgroups-rs"
 description = "Native Rust crate for managing control groups on Linux"
-repository = "https://github.com/levex/cgroups-rs"
+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.1.1-alpha.0"
-authors = ["Levente Kurusa <lkurusa@acm.org>", "Sam Wilson <tecywiz121@hotmail.com>"]
+version = "0.2.12"
+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"
+readme = "README.md"
 
 [dependencies]
 log = "0.4"
 regex = "1.1"
-nix = "0.18.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 = []

Makefile

@@ -0,0 +1,37 @@
+all: debug fmt test
+
+#
+# Build
+#
+
+.PHONY: debug
+debug:
+	RUSTFLAGS="--deny warnings" cargo build
+
+.PHONY: release
+release:
+	cargo build --release
+
+.PHONY: build
+build: debug
+
+#
+# Tests and linters
+#
+
+.PHONY: test
+test:
+	cargo test -- --color always --nocapture
+
+.PHONY: check
+check: fmt clippy
+
+
+.PHONY: fmt
+fmt:
+	cargo fmt --all -- --check
+
+.PHONY: clippy
+clippy:
+	cargo clippy --all-targets --all-features -- -D warnings
+

README.md

@@ -1,32 +1,36 @@
-# cgroups-rs ![Build](https://travis-ci.org/levex/cgroups-rs.svg?branch=master)
+# cgroups-rs ![Build](https://travis-ci.org/kata-containers/cgroups-rs.svg?branch=master)
 Native Rust library for managing control groups under Linux
 
-Right now the crate only support the original, V1 hierarchy, however support
-is planned for the Unified hierarchy.
+Both v1 and v2 of cgroups are supported.
 
 # Examples
 
 ## Create a control group using the builder pattern
 
 ``` rust
-// Acquire a handle for the V1 cgroup hierarchy.
-let hier = ::hierarchies::V1::new();
+
+
+use cgroups_rs::*;
+use cgroups_rs::cgroup_builder::*;
+
+// Acquire a handle for the cgroup hierarchy.
+let hier = cgroups_rs::hierarchies::auto();
 
 // Use the builder pattern (see the documentation to create the control group)
 //
 // This creates a control group named "example" in the V1 hierarchy.
-let cg: Cgroup = CgroupBuilder::new("example", &v1)
-	.cpu()
-		.shares(85)
-		.done()
-	.build();
+    let cg: Cgroup = CgroupBuilder::new("example")
+        .cpu()
+        .shares(85)
+        .done()
+        .build(hier);
 
 // Now `cg` is a control group that gets 85% of the CPU time in relative to
 // other control groups.
 
 // Get a handle to the CPU controller.
-let cpus: &CpuController = cg.controller_of().unwrap();
-cpus.add_task(1234u64);
+let cpus: &cgroups_rs::cpu::CpuController = cg.controller_of().unwrap();
+cpus.add_task(&CgroupPid::from(1234u64));
 
 // [...]
 

src/blkio.rs

@@ -8,15 +8,16 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/blkio-controller.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/blkio-controller.txt)
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::{read_string_from, read_u64_from};
 use crate::{
-    BlkIoResources, ControllIdentifier, ControllerInternal, Controllers, Resources, Subsystem,
+    BlkIoResources, ControllIdentifier, ControllerInternal, Controllers, CustomizedAttribute,
+    Resources, Subsystem,
 };
 
 /// A controller that allows controlling the `blkio` subsystem of a Cgroup.
@@ -31,6 +32,7 @@ pub struct BlkIoController {
 }
 
 #[derive(Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// Per-device information
 pub struct BlkIoData {
     /// The major number of the device.
@@ -42,6 +44,7 @@ pub struct BlkIoData {
 }
 
 #[derive(Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// Per-device activity from the control group.
 pub struct IoService {
     /// The major number of the device.
@@ -61,6 +64,7 @@ pub struct IoService {
 }
 
 #[derive(Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 /// Per-device activity from the control group.
 /// Only for cgroup v2
 pub struct IoStat {
@@ -84,14 +88,14 @@ pub struct IoStat {
 
 fn parse_io_service(s: String) -> Result<Vec<IoService>> {
     s.lines()
-        .filter(|x| x.split_whitespace().collect::<Vec<_>>().len() == 3)
+        .filter(|x| x.split_whitespace().count() == 3)
         .map(|x| {
             let mut spl = x.split_whitespace();
-            (spl.nth(0).unwrap(), spl.nth(0).unwrap(), spl.nth(0).unwrap())
+            (spl.next().unwrap(), spl.next().unwrap(), spl.next().unwrap())
         })
         .map(|(a, b, c)| {
-            let mut spl = a.split(":");
-            (spl.nth(0).unwrap(), spl.nth(0).unwrap(), b, c)
+            let mut spl = a.split(':');
+            (spl.next().unwrap(), spl.next().unwrap(), b, c)
         })
         .collect::<Vec<_>>()
         .chunks(5)
@@ -131,15 +135,14 @@ fn get_value(s: &str) -> String {
     arr[1].to_string()
 }
 
-fn parse_io_stat(s: String) -> Result<Vec<IoStat>> {
+fn parse_io_stat(s: String) -> Vec<IoStat> {
     // line:
     // 8:0 rbytes=180224 wbytes=0 rios=3 wios=0 dbytes=0 dios=0
-    let v = s
-        .lines()
-        .filter(|x| x.split_whitespace().collect::<Vec<_>>().len() == 7)
+    s.lines()
+        .filter(|x| x.split_whitespace().count() == 7)
         .map(|x| {
             let arr = x.split_whitespace().collect::<Vec<&str>>();
-            let device = arr[0].split(":").collect::<Vec<&str>>();
+            let device = arr[0].split(':').collect::<Vec<&str>>();
             let (major, minor) = (device[0], device[1]);
 
             IoStat {
@@ -153,14 +156,12 @@ fn parse_io_stat(s: String) -> Result<Vec<IoStat>> {
                 dios: get_value(arr[6]).parse::<u64>().unwrap(),
             }
         })
-        .collect::<Vec<IoStat>>();
-
-    Ok(v)
+        .collect::<Vec<IoStat>>()
 }
 
 fn parse_io_service_total(s: String) -> Result<u64> {
     s.lines()
-        .filter(|x| x.split_whitespace().collect::<Vec<_>>().len() == 2)
+        .filter(|x| x.split_whitespace().count() == 2)
         .fold(Err(Error::new(ParseError)), |_, x| {
             match x.split_whitespace().collect::<Vec<_>>().as_slice() {
                 ["Total", val] => val.parse::<u64>().map_err(|_| Error::new(ParseError)),
@@ -197,15 +198,16 @@ fn parse_blkio_data(s: String) -> Result<Vec<BlkIoData>> {
     });
 
     if err.is_err() {
-        return Err(Error::new(ParseError));
+        Err(Error::new(ParseError))
     } else {
-        return Ok(res);
+        Ok(res)
     }
 }
 
 /// 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.
@@ -241,6 +243,7 @@ pub struct BlkIoThrottle {
 
 /// Statistics and state of the block devices.
 #[derive(Default, Debug)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct BlkIo {
     /// The number of BIOS requests merged into I/O requests by the control group's tasks.
     pub io_merged: Vec<IoService>,
@@ -344,41 +347,42 @@ impl ControllerInternal for BlkIoController {
         // get the resources that apply to this controller
         let res: &BlkIoResources = &res.blkio;
 
-        if res.update_values {
-            if let Some(weight) = res.weight {
-                let _ = self.set_weight(weight as u64);
-            }
-            if let Some(leaf_weight) = res.leaf_weight {
-                let _ = self.set_leaf_weight(leaf_weight as u64);
-            }
+        if let Some(weight) = res.weight {
+            let _ = self.set_weight(weight as u64);
+        }
+        if let Some(leaf_weight) = res.leaf_weight {
+            let _ = self.set_leaf_weight(leaf_weight as u64);
+        }
 
-            for dev in &res.weight_device {
-                if let Some(weight) = dev.weight {
-                    let _ = self.set_weight_for_device(dev.major, dev.minor, weight as u64);
-                }
-                if let Some(leaf_weight) = dev.leaf_weight {
-                    let _ =
-                        self.set_leaf_weight_for_device(dev.major, dev.minor, leaf_weight as u64);
-                }
+        for dev in &res.weight_device {
+            if let Some(weight) = dev.weight {
+                let _ = self.set_weight_for_device(dev.major, dev.minor, weight as u64);
             }
-
-            for dev in &res.throttle_read_bps_device {
-                let _ = self.throttle_read_bps_for_device(dev.major, dev.minor, dev.rate);
-            }
-
-            for dev in &res.throttle_write_bps_device {
-                let _ = self.throttle_write_bps_for_device(dev.major, dev.minor, dev.rate);
-            }
-
-            for dev in &res.throttle_read_iops_device {
-                let _ = self.throttle_read_iops_for_device(dev.major, dev.minor, dev.rate);
-            }
-
-            for dev in &res.throttle_write_iops_device {
-                let _ = self.throttle_write_iops_for_device(dev.major, dev.minor, dev.rate);
+            if let Some(leaf_weight) = dev.leaf_weight {
+                let _ = self.set_leaf_weight_for_device(dev.major, dev.minor, leaf_weight as u64);
             }
         }
 
+        for dev in &res.throttle_read_bps_device {
+            let _ = self.throttle_read_bps_for_device(dev.major, dev.minor, dev.rate);
+        }
+
+        for dev in &res.throttle_write_bps_device {
+            let _ = self.throttle_write_bps_for_device(dev.major, dev.minor, dev.rate);
+        }
+
+        for dev in &res.throttle_read_iops_device {
+            let _ = self.throttle_read_iops_for_device(dev.major, dev.minor, dev.rate);
+        }
+
+        for dev in &res.throttle_write_iops_device {
+            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(())
     }
 }
@@ -396,55 +400,33 @@ impl<'a> From<&'a Subsystem> for &'a BlkIoController {
                 Subsystem::BlkIo(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-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)),
-    }
-}
-
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl BlkIoController {
-    /// Constructs a new `BlkIoController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf, v2: bool) -> Self {
-        let mut root = oroot;
-        if !v2 {
-            root.push(Self::controller_type().to_string());
-        }
+    /// Constructs a new `BlkIoController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf, v2: bool) -> Self {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 
     fn blkio_v2(&self) -> BlkIo {
-        let mut blkio: BlkIo = Default::default();
-        blkio.io_stat = self
-            .open_path("io.stat", false)
-            .and_then(read_string_from)
-            .and_then(parse_io_stat)
-            .unwrap_or(Vec::new());
-
-        blkio
+        BlkIo {
+            io_stat: self
+                .open_path("io.stat", false)
+                .and_then(read_string_from)
+                .map(parse_io_stat)
+                .unwrap_or_default(),
+            ..Default::default()
+        }
     }
 
     /// Gathers statistics about and reports the state of the block devices used by the control
@@ -458,222 +440,222 @@ impl BlkIoController {
                 .open_path("blkio.io_merged", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_merged_total: self
                 .open_path("blkio.io_merged", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_merged_recursive: self
                 .open_path("blkio.io_merged_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_merged_recursive_total: self
                 .open_path("blkio.io_merged_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_queued: self
                 .open_path("blkio.io_queued", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_queued_total: self
                 .open_path("blkio.io_queued", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_queued_recursive: self
                 .open_path("blkio.io_queued_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_queued_recursive_total: self
                 .open_path("blkio.io_queued_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_service_bytes: self
                 .open_path("blkio.io_service_bytes", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_service_bytes_total: self
                 .open_path("blkio.io_service_bytes", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_service_bytes_recursive: self
                 .open_path("blkio.io_service_bytes_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_service_bytes_recursive_total: self
                 .open_path("blkio.io_service_bytes_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_serviced: self
                 .open_path("blkio.io_serviced", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_serviced_total: self
                 .open_path("blkio.io_serviced", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_serviced_recursive: self
                 .open_path("blkio.io_serviced_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_serviced_recursive_total: self
                 .open_path("blkio.io_serviced_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_service_time: self
                 .open_path("blkio.io_service_time", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_service_time_total: self
                 .open_path("blkio.io_service_time", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_service_time_recursive: self
                 .open_path("blkio.io_service_time_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_service_time_recursive_total: self
                 .open_path("blkio.io_service_time_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_wait_time: self
                 .open_path("blkio.io_wait_time", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_wait_time_total: self
                 .open_path("blkio.io_wait_time", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             io_wait_time_recursive: self
                 .open_path("blkio.io_wait_time_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_wait_time_recursive_total: self
                 .open_path("blkio.io_wait_time_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_io_service_total)
-                .unwrap_or(0),
+                .unwrap_or_default(),
             leaf_weight: self
                 .open_path("blkio.leaf_weight", false)
-                .and_then(|file| read_u64_from(file))
+                .and_then(read_u64_from)
                 .unwrap_or(0u64),
             leaf_weight_device: self
                 .open_path("blkio.leaf_weight_device", false)
                 .and_then(read_string_from)
                 .and_then(parse_blkio_data)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             sectors: self
                 .open_path("blkio.sectors", false)
                 .and_then(read_string_from)
                 .and_then(parse_blkio_data)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             sectors_recursive: self
                 .open_path("blkio.sectors_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_blkio_data)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             throttle: BlkIoThrottle {
                 io_service_bytes: self
                     .open_path("blkio.throttle.io_service_bytes", false)
                     .and_then(read_string_from)
                     .and_then(parse_io_service)
-                    .unwrap_or(Vec::new()),
+                    .unwrap_or_default(),
                 io_service_bytes_total: self
                     .open_path("blkio.throttle.io_service_bytes", false)
                     .and_then(read_string_from)
                     .and_then(parse_io_service_total)
-                    .unwrap_or(0),
+                    .unwrap_or_default(),
                 io_service_bytes_recursive: self
                     .open_path("blkio.throttle.io_service_bytes_recursive", false)
                     .and_then(read_string_from)
                     .and_then(parse_io_service)
-                    .unwrap_or(Vec::new()),
+                    .unwrap_or_default(),
                 io_service_bytes_recursive_total: self
                     .open_path("blkio.throttle.io_service_bytes_recursive", false)
                     .and_then(read_string_from)
                     .and_then(parse_io_service_total)
-                    .unwrap_or(0),
+                    .unwrap_or_default(),
                 io_serviced: self
                     .open_path("blkio.throttle.io_serviced", false)
                     .and_then(read_string_from)
                     .and_then(parse_io_service)
-                    .unwrap_or(Vec::new()),
+                    .unwrap_or_default(),
                 io_serviced_total: self
                     .open_path("blkio.throttle.io_serviced", false)
                     .and_then(read_string_from)
                     .and_then(parse_io_service_total)
-                    .unwrap_or(0),
+                    .unwrap_or_default(),
                 io_serviced_recursive: self
                     .open_path("blkio.throttle.io_serviced_recursive", false)
                     .and_then(read_string_from)
                     .and_then(parse_io_service)
-                    .unwrap_or(Vec::new()),
+                    .unwrap_or_default(),
                 io_serviced_recursive_total: self
                     .open_path("blkio.throttle.io_serviced_recursive", false)
                     .and_then(read_string_from)
                     .and_then(parse_io_service_total)
-                    .unwrap_or(0),
+                    .unwrap_or_default(),
                 read_bps_device: self
                     .open_path("blkio.throttle.read_bps_device", false)
                     .and_then(read_string_from)
                     .and_then(parse_blkio_data)
-                    .unwrap_or(Vec::new()),
+                    .unwrap_or_default(),
                 read_iops_device: self
                     .open_path("blkio.throttle.read_iops_device", false)
                     .and_then(read_string_from)
                     .and_then(parse_blkio_data)
-                    .unwrap_or(Vec::new()),
+                    .unwrap_or_default(),
                 write_bps_device: self
                     .open_path("blkio.throttle.write_bps_device", false)
                     .and_then(read_string_from)
                     .and_then(parse_blkio_data)
-                    .unwrap_or(Vec::new()),
+                    .unwrap_or_default(),
                 write_iops_device: self
                     .open_path("blkio.throttle.write_iops_device", false)
                     .and_then(read_string_from)
                     .and_then(parse_blkio_data)
-                    .unwrap_or(Vec::new()),
+                    .unwrap_or_default(),
             },
             time: self
                 .open_path("blkio.time", false)
                 .and_then(read_string_from)
                 .and_then(parse_blkio_data)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             time_recursive: self
                 .open_path("blkio.time_recursive", false)
                 .and_then(read_string_from)
                 .and_then(parse_blkio_data)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             weight: self
                 .open_path("blkio.weight", false)
-                .and_then(|file| read_u64_from(file))
+                .and_then(read_u64_from)
                 .unwrap_or(0u64),
             weight_device: self
                 .open_path("blkio.weight_device", false)
                 .and_then(read_string_from)
                 .and_then(parse_blkio_data)
-                .unwrap_or(Vec::new()),
+                .unwrap_or_default(),
             io_stat: Vec::new(),
         }
     }
@@ -683,8 +665,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,
+                    )
+                })
             })
     }
 
@@ -693,7 +679,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,
+                        )
+                    })
             })
     }
 
@@ -701,99 +695,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};

src/cgroup.rs

@@ -9,8 +9,6 @@
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
-use crate::libc_rmdir;
-
 use crate::{CgroupPid, ControllIdentifier, Controller, Hierarchy, Resources, Subsystem};
 
 use std::collections::HashMap;
@@ -30,84 +28,164 @@ use std::path::{Path, PathBuf};
 /// > specialized behaviour.
 ///
 /// This crate is an attempt at providing a Rust-native way of managing these cgroups.
-pub struct Cgroup<'b> {
+#[derive(Debug)]
+pub struct Cgroup {
     /// The list of subsystems that control this cgroup
     subsystems: Vec<Subsystem>,
 
     /// The hierarchy.
-    hier: Box<&'b dyn Hierarchy>,
+    hier: Box<dyn Hierarchy>,
     path: String,
+
+    /// List of controllers specifically enabled in the control group.
+    specified_controllers: Option<Vec<String>>,
 }
 
-impl<'b> Cgroup<'b> {
+impl Clone for Cgroup {
+    fn clone(&self) -> Self {
+        Cgroup {
+            subsystems: self.subsystems.clone(),
+            hier: crate::hierarchies::auto(),
+            path: self.path.clone(),
+            specified_controllers: None,
+        }
+    }
+}
+
+impl Default for Cgroup {
+    fn default() -> Self {
+        Cgroup {
+            subsystems: Vec::new(),
+            hier: crate::hierarchies::auto(),
+            path: "".to_string(),
+            specified_controllers: None,
+        }
+    }
+}
+
+impl Cgroup {
+    pub fn v2(&self) -> bool {
+        self.hier.v2()
+    }
+
     /// Create this control group.
-    fn create(&self) {
+    fn create(&self) -> Result<()> {
         if self.hier.v2() {
-            create_v2_cgroup(self.hier.root().clone(), &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) -> Result<Cgroup> {
+        let cg = Cgroup::load(hier, path);
+        cg.create()?;
+        Ok(cg)
+    }
+
+    /// Create a new control group in the hierarchy `hier`, with name `path`.
     ///
-    /// Note that if the handle goes out of scope and is dropped, the control group is _not_
-    /// destroyed.
-    pub fn new<P: AsRef<Path>>(hier: Box<&'b dyn Hierarchy>, path: P) -> Cgroup<'b> {
-        let relative_paths = get_cgroups_relative_paths().unwrap();
-        Cgroup::new_with_relative_paths(hier, path, relative_paths)
+    /// 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.
+    pub fn new_with_relative_paths<P: AsRef<Path>>(
+        hier: Box<dyn Hierarchy>,
+        path: P,
+        relative_paths: HashMap<String, String>,
+    ) -> Result<Cgroup> {
+        let cg = Cgroup::load_with_relative_paths(hier, path, relative_paths);
+        cg.create()?;
+        Ok(cg)
     }
 
     /// Create a handle for a 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.
-    ///
-    /// Note that if the handle goes out of scope and is dropped, the control group is _not_
-    /// destroyed.
-    pub fn load<P: AsRef<Path>>(hier: Box<&'b dyn Hierarchy>, path: P) -> Cgroup<'b> {
-        let relative_paths = get_cgroups_relative_paths().unwrap();
-        Cgroup::load_with_relative_paths(hier, path, relative_paths)
+    pub fn load<P: AsRef<Path>>(hier: Box<dyn Hierarchy>, path: P) -> Cgroup {
+        let path = path.as_ref();
+        let mut subsystems = hier.subsystems();
+        if path.as_os_str() != "" {
+            subsystems = subsystems
+                .into_iter()
+                .map(|x| x.enter(path))
+                .collect::<Vec<_>>();
+        }
+
+        Cgroup {
+            path: path.to_str().unwrap().to_string(),
+            subsystems,
+            hier,
+            specified_controllers: None,
+        }
     }
 
-    /// Create a new control group in the hierarchy `hier`, with name `path`.
-    /// and relative paths from `/proc/self/cgroup`
+    /// Create a handle for a specified control group in the hierarchy `hier`, with name `path`.
     ///
-    /// Returns a handle to the control group that can be used to manipulate it.
-    ///
-    /// Note that if the handle goes out of scope and is dropped, the control group is _not_
-    /// destroyed.
-    pub fn new_with_relative_paths<P: AsRef<Path>>(
-        hier: Box<&'b dyn Hierarchy>,
+    /// 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,
-        relative_paths: HashMap<String, String>,
-    ) -> Cgroup<'b> {
-        let cg = Cgroup::load_with_relative_paths(hier, path, relative_paths);
-        cg.create();
-        cg
+        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),
+        }
     }
 
-    /// Create a handle for a control group in the hierarchy `hier`, with name `path`,
-    /// and relative paths from `/proc/self/cgroup`
+    /// Create a handle for a control group in the hierarchy `hier`, with name `path` and `relative_paths`
     ///
     /// Returns a handle to the control group (that possibly does not exist until `create()` has
     /// been called on the cgroup.
     ///
-    /// Note that if the handle goes out of scope and is dropped, the control group is _not_
-    /// destroyed.
+    /// Note that this method is only meaningful for cgroup v1, call it is equivalent to call `load` in the v2 mode
     pub fn load_with_relative_paths<P: AsRef<Path>>(
-        hier: Box<&'b dyn Hierarchy>,
+        hier: Box<dyn Hierarchy>,
         path: P,
         relative_paths: HashMap<String, String>,
-    ) -> Cgroup<'b> {
+    ) -> Cgroup {
+        // relative_paths only valid for cgroup v1
+        if hier.v2() {
+            return Self::load(hier, path);
+        }
+
         let path = path.as_ref();
         let mut subsystems = hier.subsystems();
         if path.as_os_str() != "" {
@@ -117,7 +195,7 @@ impl<'b> Cgroup<'b> {
                     let cn = x.controller_name();
                     if relative_paths.contains_key(&cn) {
                         let rp = relative_paths.get(&cn).unwrap();
-                        let valid_path = rp.trim_start_matches("/").to_string();
+                        let valid_path = rp.trim_start_matches('/').to_string();
                         let mut p = PathBuf::from(valid_path);
                         p.push(path);
                         x.enter(p.as_ref())
@@ -128,13 +206,12 @@ impl<'b> Cgroup<'b> {
                 .collect::<Vec<_>>();
         }
 
-        let cg = Cgroup {
-            subsystems: subsystems,
-            hier: hier,
+        Cgroup {
+            subsystems,
+            hier,
             path: path.to_str().unwrap().to_string(),
-        };
-
-        cg
+            specified_controllers: None,
+        }
     }
 
     /// The list of subsystems that this control group supports.
@@ -148,17 +225,17 @@ impl<'b> Cgroup<'b> {
     /// system call will fail if there are any descendants. Thus, one should check whether it was
     /// actually removed, and remove the descendants first if not. In the future, this behavior
     /// will change.
-    pub fn delete(self) {
+    pub fn delete(&self) -> Result<()> {
         if self.v2() {
-            if self.path != "" {
-                let mut p = self.hier.root().clone();
-                p.push(self.path);
-                libc_rmdir(p.to_str().unwrap());
+            if !self.path.is_empty() {
+                let mut p = self.hier.root();
+                p.push(self.path.clone());
+                return fs::remove_dir(p).map_err(|e| Error::with_cause(RemoveFailed, e));
             }
-            return;
+            return Ok(());
         }
 
-        self.subsystems.into_iter().for_each(|sub| match sub {
+        self.subsystems.iter().try_for_each(|sub| match sub {
             Subsystem::Pid(pidc) => pidc.delete(),
             Subsystem::Mem(c) => c.delete(),
             Subsystem::CpuSet(c) => c.delete(),
@@ -173,7 +250,7 @@ impl<'b> Cgroup<'b> {
             Subsystem::HugeTlb(c) => c.delete(),
             Subsystem::Rdma(c) => c.delete(),
             Subsystem::Systemd(c) => c.delete(),
-        });
+        })
     }
 
     /// Apply a set of resource limits to the control group.
@@ -193,7 +270,7 @@ impl<'b> Cgroup<'b> {
     /// let cpu: &CpuController = control_group.controller_of()
     ///                             .expect("No cpu controller attached!");
     /// ```
-    pub fn controller_of<'a, T>(self: &'a Self) -> Option<&'a T>
+    pub fn controller_of<'a, T>(&'a self) -> Option<&'a T>
     where
         &'a T: From<&'a Subsystem>,
         T: Controller + ControllIdentifier,
@@ -208,38 +285,176 @@ impl<'b> Cgroup<'b> {
         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.len() > 0 {
+            if !subsystems.is_empty() {
                 let c = subsystems[0].to_controller();
-                c.add_task(&pid)
+                c.add_task(&tid)
             } 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 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();
+                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.
+    pub fn set_notify_on_release(&self, enable: bool) -> Result<()> {
+        self.subsystems()
+            .iter()
+            .try_for_each(|sub| sub.to_controller().set_notify_on_release(enable))
+    }
+
+    /// Set release_agent
+    pub fn set_release_agent(&self, path: &str) -> Result<()> {
+        self.hier
+            .root_control_group()
+            .subsystems()
+            .iter()
+            .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> {
         // Collect the tasks from all subsystems
         let mut v = if self.v2() {
             let subsystems = self.subsystems();
-            if subsystems.len() > 0 {
+            if !subsystems.is_empty() {
                 let c = subsystems[0].to_controller();
                 c.tasks()
             } else {
@@ -261,45 +476,56 @@ impl<'b> Cgroup<'b> {
     }
 }
 
-pub const UNIFIED_MOUNTPOINT: &'static str = "/sys/fs/cgroup";
+pub const UNIFIED_MOUNTPOINT: &str = "/sys/fs/cgroup";
 
-fn enable_controllers(controllers: &Vec<String>, path: &PathBuf) {
-    let mut f = path.clone();
-    f.push("cgroup.subtree_control");
+fn enable_controllers(controllers: &[String], path: &Path) {
+    let f = path.join("cgroup.subtree_control");
     for c in controllers {
         let body = format!("+{}", c);
         let _rest = fs::write(f.as_path(), body.as_bytes());
     }
 }
 
-fn supported_controllers(p: &PathBuf) -> Vec<String> {
+fn supported_controllers() -> Vec<String> {
     let p = format!("{}/{}", UNIFIED_MOUNTPOINT, "cgroup.controllers");
     let ret = fs::read_to_string(p.as_str());
-    ret.unwrap_or(String::new())
-        .split(" ")
+    ret.unwrap_or_default()
+        .split(' ')
         .map(|x| x.to_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(&root);
+    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
     enable_controllers(&controllers, &fp);
 
     // path: "a/b/c"
-    let elements = path.split("/").collect::<Vec<&str>>();
+    let elements = path.split('/').collect::<Vec<&str>>();
     let last_index = elements.len() - 1;
     for (i, ele) in elements.iter().enumerate() {
         // ROOT/a
         fp.push(ele);
         // create dir, need not check if is a file or directory
         if !fp.exists() {
-            match ::std::fs::create_dir(fp.clone()) {
-                Err(e) => return Err(Error::with_cause(ErrorKind::FsError, e)),
-                Ok(_) => {}
+            if let Err(e) = std::fs::create_dir(fp.clone()) {
+                return Err(Error::with_cause(ErrorKind::FsError, e));
             }
         }
 
@@ -312,10 +538,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 {
@@ -324,13 +570,7 @@ pub fn get_cgroups_relative_paths() -> Result<HashMap<String, String>> {
 
         let keys: Vec<&str> = fl[1].split(',').collect();
         for key in &keys {
-            // this is a workaround, cgroup file are using `name=systemd`,
-            // but if file system the name is `systemd`
-            if *key == "name=systemd" {
-                m.insert("systemd".to_string(), fl[2].to_string());
-            } else {
-                m.insert(key.to_string(), fl[2].to_string());
-            }
+            m.insert(key.to_string(), fl[2].to_string());
         }
     }
     Ok(m)

src/cgroup_builder.rs

@@ -16,12 +16,11 @@
 //! by a call to `build()`.
 //!
 //! ```rust,no_run
-//! # use cgroups::*;
-//! # use cgroups::devices::*;
-//! # use cgroups::cgroup_builder::*;
-//! let h = cgroups::hierarchies::auto();
-//! let h = Box::new(&*h);
-//! let cgroup: Cgroup = CgroupBuilder::new("hello", h)
+//! # use cgroups_rs::*;
+//! # use cgroups_rs::devices::*;
+//! # use cgroups_rs::cgroup_builder::*;
+//! let h = cgroups_rs::hierarchies::auto();
+//! let cgroup: Cgroup = CgroupBuilder::new("hello")
 //!      .memory()
 //!          .kernel_memory_limit(1024 * 1024)
 //!          .memory_hard_limit(1024 * 1024)
@@ -47,8 +46,8 @@
 //!          .limit("2G".to_string(), 2 * 1024 * 1024 * 1024)
 //!          .done()
 //!      .blkio()
-//!          .weight(Some(123))
-//!          .leaf_weight(Some(99))
+//!          .weight(123)
+//!          .leaf_weight(99)
 //!          .weight_device(6, 1, Some(100), Some(55))
 //!          .weight_device(6, 1, Some(100), Some(55))
 //!          .throttle_iops()
@@ -58,12 +57,11 @@
 //!              .read(6, 1, 10)
 //!              .write(11, 1, 100)
 //!          .done()
-//!      .build();
+//!      .build(h).unwrap();
 //! ```
-use crate::error::*;
 
 use crate::{
-    pid, BlkIoDeviceResource, BlkIoDeviceThrottleResource, Cgroup, DeviceResource, Hierarchy,
+    BlkIoDeviceResource, BlkIoDeviceThrottleResource, Cgroup, DeviceResource, Error, Hierarchy,
     HugePageResource, MaxValue, NetworkPriority, Resources,
 };
 
@@ -71,67 +69,67 @@ macro_rules! gen_setter {
     ($res:ident, $cont:ident, $func:ident, $name:ident, $ty:ty) => {
         /// See the similarly named function in the respective controller.
         pub fn $name(mut self, $name: $ty) -> Self {
-            self.cgroup.resources.$res.update_values = true;
-            self.cgroup.resources.$res.$name = $name;
+            self.cgroup.resources.$res.$name = Some($name);
             self
         }
     };
 }
 
 /// A control group builder instance
-pub struct CgroupBuilder<'a> {
+pub struct CgroupBuilder {
     name: String,
-    hierarchy: Box<&'a dyn Hierarchy>,
     /// 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<'a> CgroupBuilder<'a> {
+impl CgroupBuilder {
     /// Start building a control group with the supplied hierarchy and name pair.
     ///
     /// Note that this does not actually create the control group until `build()` is called.
-    pub fn new(name: &'a str, hierarchy: Box<&'a dyn Hierarchy>) -> CgroupBuilder<'a> {
+    pub fn new(name: &str) -> CgroupBuilder {
         CgroupBuilder {
             name: name.to_owned(),
-            hierarchy: hierarchy,
             resources: Resources::default(),
+            specified_controllers: None,
         }
     }
 
     /// Builds the memory resources of the control group.
-    pub fn memory(self) -> MemoryResourceBuilder<'a> {
+    pub fn memory(self) -> MemoryResourceBuilder {
         MemoryResourceBuilder { cgroup: self }
     }
 
     /// Builds the pid resources of the control group.
-    pub fn pid(self) -> PidResourceBuilder<'a> {
+    pub fn pid(self) -> PidResourceBuilder {
         PidResourceBuilder { cgroup: self }
     }
 
     /// Builds the cpu resources of the control group.
-    pub fn cpu(self) -> CpuResourceBuilder<'a> {
+    pub fn cpu(self) -> CpuResourceBuilder {
         CpuResourceBuilder { cgroup: self }
     }
 
     /// Builds the devices resources of the control group, disallowing or
     /// allowing access to certain devices in the system.
-    pub fn devices(self) -> DeviceResourceBuilder<'a> {
+    pub fn devices(self) -> DeviceResourceBuilder {
         DeviceResourceBuilder { cgroup: self }
     }
 
     /// Builds the network resources of the control group, setting class id, or
     /// various priorities on networking interfaces.
-    pub fn network(self) -> NetworkResourceBuilder<'a> {
+    pub fn network(self) -> NetworkResourceBuilder {
         NetworkResourceBuilder { cgroup: self }
     }
 
     /// Builds the hugepage/hugetlb resources available to the control group.
-    pub fn hugepages(self) -> HugepagesResourceBuilder<'a> {
+    pub fn hugepages(self) -> HugepagesResourceBuilder {
         HugepagesResourceBuilder { cgroup: self }
     }
 
     /// Builds the block I/O resources available for the control group.
-    pub fn blkio(self) -> BlkIoResourcesBuilder<'a> {
+    pub fn blkio(self) -> BlkIoResourcesBuilder {
         BlkIoResourcesBuilder {
             cgroup: self,
             throttling_iops: false,
@@ -139,19 +137,31 @@ impl<'a> CgroupBuilder<'a> {
     }
 
     /// Finalize the control group, consuming the builder and creating the control group.
-    pub fn build(self) -> Cgroup<'a> {
-        let cg = Cgroup::new(self.hierarchy, self.name);
-        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
     }
 }
 
 /// A builder that configures the memory controller of a control group.
-pub struct MemoryResourceBuilder<'a> {
-    cgroup: CgroupBuilder<'a>,
+pub struct MemoryResourceBuilder {
+    cgroup: CgroupBuilder,
 }
 
-impl<'a> MemoryResourceBuilder<'a> {
+impl MemoryResourceBuilder {
     gen_setter!(
         memory,
         MemController,
@@ -184,17 +194,17 @@ impl<'a> MemoryResourceBuilder<'a> {
     gen_setter!(memory, MemController, set_swappiness, swappiness, u64);
 
     /// Finish the construction of the memory resources of a control group.
-    pub fn done(self) -> CgroupBuilder<'a> {
+    pub fn done(self) -> CgroupBuilder {
         self.cgroup
     }
 }
 
 /// A builder that configures the pid controller of a control group.
-pub struct PidResourceBuilder<'a> {
-    cgroup: CgroupBuilder<'a>,
+pub struct PidResourceBuilder {
+    cgroup: CgroupBuilder,
 }
 
-impl<'a> PidResourceBuilder<'a> {
+impl PidResourceBuilder {
     gen_setter!(
         pid,
         PidController,
@@ -204,19 +214,18 @@ impl<'a> PidResourceBuilder<'a> {
     );
 
     /// Finish the construction of the pid resources of a control group.
-    pub fn done(self) -> CgroupBuilder<'a> {
+    pub fn done(self) -> CgroupBuilder {
         self.cgroup
     }
 }
 
 /// A builder that configures the cpuset & cpu controllers of a control group.
-pub struct CpuResourceBuilder<'a> {
-    cgroup: CgroupBuilder<'a>,
+pub struct CpuResourceBuilder {
+    cgroup: CgroupBuilder,
 }
 
-impl<'a> CpuResourceBuilder<'a> {
-    // FIXME this should all changed to options.
-    gen_setter!(cpu, CpuSetController, set_cpus, cpus, Option<String>);
+impl CpuResourceBuilder {
+    gen_setter!(cpu, CpuSetController, set_cpus, cpus, String);
     gen_setter!(cpu, CpuSetController, set_mems, mems, String);
     gen_setter!(cpu, CpuController, set_shares, shares, u64);
     gen_setter!(cpu, CpuController, set_cfs_quota, quota, i64);
@@ -225,17 +234,17 @@ impl<'a> CpuResourceBuilder<'a> {
     gen_setter!(cpu, CpuController, set_rt_period, realtime_period, u64);
 
     /// Finish the construction of the cpu resources of a control group.
-    pub fn done(self) -> CgroupBuilder<'a> {
+    pub fn done(self) -> CgroupBuilder {
         self.cgroup
     }
 }
 
 /// A builder that configures the devices controller of a control group.
-pub struct DeviceResourceBuilder<'a> {
-    cgroup: CgroupBuilder<'a>,
+pub struct DeviceResourceBuilder {
+    cgroup: CgroupBuilder,
 }
 
-impl<'a> DeviceResourceBuilder<'a> {
+impl DeviceResourceBuilder {
     /// Restrict (or allow) a device to the tasks inside the control group.
     pub fn device(
         mut self,
@@ -244,36 +253,34 @@ impl<'a> DeviceResourceBuilder<'a> {
         devtype: crate::devices::DeviceType,
         allow: bool,
         access: Vec<crate::devices::DevicePermissions>,
-    ) -> DeviceResourceBuilder<'a> {
-        self.cgroup.resources.devices.update_values = true;
+    ) -> DeviceResourceBuilder {
         self.cgroup.resources.devices.devices.push(DeviceResource {
+            allow,
+            devtype,
             major,
             minor,
-            devtype,
-            allow,
             access,
         });
         self
     }
 
     /// Finish the construction of the devices resources of a control group.
-    pub fn done(self) -> CgroupBuilder<'a> {
+    pub fn done(self) -> CgroupBuilder {
         self.cgroup
     }
 }
 
 /// A builder that configures the net_cls & net_prio controllers of a control group.
-pub struct NetworkResourceBuilder<'a> {
-    cgroup: CgroupBuilder<'a>,
+pub struct NetworkResourceBuilder {
+    cgroup: CgroupBuilder,
 }
 
-impl<'a> NetworkResourceBuilder<'a> {
+impl NetworkResourceBuilder {
     gen_setter!(network, NetclsController, set_class, class_id, u64);
 
     /// Set the priority of the tasks when operating on a networking device defined by `name` to be
     /// `priority`.
-    pub fn priority(mut self, name: String, priority: u64) -> NetworkResourceBuilder<'a> {
-        self.cgroup.resources.network.update_values = true;
+    pub fn priority(mut self, name: String, priority: u64) -> NetworkResourceBuilder {
         self.cgroup
             .resources
             .network
@@ -283,20 +290,19 @@ impl<'a> NetworkResourceBuilder<'a> {
     }
 
     /// Finish the construction of the network resources of a control group.
-    pub fn done(self) -> CgroupBuilder<'a> {
+    pub fn done(self) -> CgroupBuilder {
         self.cgroup
     }
 }
 
 /// A builder that configures the hugepages controller of a control group.
-pub struct HugepagesResourceBuilder<'a> {
-    cgroup: CgroupBuilder<'a>,
+pub struct HugepagesResourceBuilder {
+    cgroup: CgroupBuilder,
 }
 
-impl<'a> HugepagesResourceBuilder<'a> {
+impl HugepagesResourceBuilder {
     /// Limit the usage of certain hugepages (determined by `size`) to be at most `limit` bytes.
-    pub fn limit(mut self, size: String, limit: u64) -> HugepagesResourceBuilder<'a> {
-        self.cgroup.resources.hugepages.update_values = true;
+    pub fn limit(mut self, size: String, limit: u64) -> HugepagesResourceBuilder {
         self.cgroup
             .resources
             .hugepages
@@ -306,26 +312,20 @@ impl<'a> HugepagesResourceBuilder<'a> {
     }
 
     /// Finish the construction of the network resources of a control group.
-    pub fn done(self) -> CgroupBuilder<'a> {
+    pub fn done(self) -> CgroupBuilder {
         self.cgroup
     }
 }
 
 /// A builder that configures the blkio controller of a control group.
-pub struct BlkIoResourcesBuilder<'a> {
-    cgroup: CgroupBuilder<'a>,
+pub struct BlkIoResourcesBuilder {
+    cgroup: CgroupBuilder,
     throttling_iops: bool,
 }
 
-impl<'a> BlkIoResourcesBuilder<'a> {
-    gen_setter!(blkio, BlkIoController, set_weight, weight, Option<u16>);
-    gen_setter!(
-        blkio,
-        BlkIoController,
-        set_leaf_weight,
-        leaf_weight,
-        Option<u16>
-    );
+impl BlkIoResourcesBuilder {
+    gen_setter!(blkio, BlkIoController, set_weight, weight, u16);
+    gen_setter!(blkio, BlkIoController, set_leaf_weight, leaf_weight, u16);
 
     /// Set the weight of a certain device.
     pub fn weight_device(
@@ -334,8 +334,7 @@ impl<'a> BlkIoResourcesBuilder<'a> {
         minor: u64,
         weight: Option<u16>,
         leaf_weight: Option<u16>,
-    ) -> BlkIoResourcesBuilder<'a> {
-        self.cgroup.resources.blkio.update_values = true;
+    ) -> BlkIoResourcesBuilder {
         self.cgroup
             .resources
             .blkio
@@ -350,20 +349,19 @@ impl<'a> BlkIoResourcesBuilder<'a> {
     }
 
     /// Start configuring the I/O operations per second metric.
-    pub fn throttle_iops(mut self) -> BlkIoResourcesBuilder<'a> {
+    pub fn throttle_iops(mut self) -> BlkIoResourcesBuilder {
         self.throttling_iops = true;
         self
     }
 
     /// Start configuring the bytes per second metric.
-    pub fn throttle_bps(mut self) -> BlkIoResourcesBuilder<'a> {
+    pub fn throttle_bps(mut self) -> BlkIoResourcesBuilder {
         self.throttling_iops = false;
         self
     }
 
     /// Limit the read rate of the current metric for a certain device.
-    pub fn read(mut self, major: u64, minor: u64, rate: u64) -> BlkIoResourcesBuilder<'a> {
-        self.cgroup.resources.blkio.update_values = true;
+    pub fn read(mut self, major: u64, minor: u64, rate: u64) -> BlkIoResourcesBuilder {
         let throttle = BlkIoDeviceThrottleResource { major, minor, rate };
         if self.throttling_iops {
             self.cgroup
@@ -382,8 +380,7 @@ impl<'a> BlkIoResourcesBuilder<'a> {
     }
 
     /// Limit the write rate of the current metric for a certain device.
-    pub fn write(mut self, major: u64, minor: u64, rate: u64) -> BlkIoResourcesBuilder<'a> {
-        self.cgroup.resources.blkio.update_values = true;
+    pub fn write(mut self, major: u64, minor: u64, rate: u64) -> BlkIoResourcesBuilder {
         let throttle = BlkIoDeviceThrottleResource { major, minor, rate };
         if self.throttling_iops {
             self.cgroup
@@ -402,7 +399,7 @@ impl<'a> BlkIoResourcesBuilder<'a> {
     }
 
     /// Finish the construction of the blkio resources of a control group.
-    pub fn done(self) -> CgroupBuilder<'a> {
+    pub fn done(self) -> CgroupBuilder {
         self.cgroup
     }
 }

src/cpu.rs

@@ -15,11 +15,11 @@ use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
-use crate::{parse_max_value, read_i64_from};
+use crate::{parse_max_value, read_i64_from, read_u64_from};
 
 use crate::{
-    ControllIdentifier, ControllerInternal, Controllers, CpuResources, MaxValue, Resources,
-    Subsystem,
+    ControllIdentifier, ControllerInternal, Controllers, CpuResources, CustomizedAttribute,
+    MaxValue, Resources, Subsystem,
 };
 
 /// A controller that allows controlling the `cpu` subsystem of a Cgroup.
@@ -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.
     ///
@@ -45,7 +46,7 @@ pub struct Cpu {
 
 /// The current state of the control group and its processes.
 #[derive(Debug)]
-struct CFSQuotaAndPeriod {
+struct CfsQuotaAndPeriod {
     quota: MaxValue,
     period: u64,
 }
@@ -75,24 +76,15 @@ impl ControllerInternal for CpuController {
         // get the resources that apply to this controller
         let res: &CpuResources = &res.cpu;
 
-        if res.update_values {
-            let _ = self.set_shares(res.shares);
-            if self.shares()? != res.shares as u64 {
-                return Err(Error::new(ErrorKind::Other));
-            }
+        update_and_test!(self, set_shares, res.shares, shares);
+        update_and_test!(self, set_cfs_period, res.period, cfs_period);
+        update_and_test!(self, set_cfs_quota, res.quota, cfs_quota);
 
-            let _ = self.set_cfs_period(res.period);
-            if self.cfs_period()? != res.period as u64 {
-                return Err(Error::new(ErrorKind::Other));
-            }
+        res.attrs.iter().for_each(|(k, v)| {
+            let _ = self.set(k, v);
+        });
 
-            let _ = self.set_cfs_quota(res.quota);
-            if self.cfs_quota()? != res.quota {
-                return Err(Error::new(ErrorKind::Other));
-            }
-
-            // TODO: rt properties (CONFIG_RT_GROUP_SCHED) are not yet supported
-        }
+        // TODO: rt properties (CONFIG_RT_GROUP_SCHED) are not yet supported
 
         Ok(())
     }
@@ -111,35 +103,21 @@ impl<'a> From<&'a Subsystem> for &'a CpuController {
                 Subsystem::Cpu(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl CpuController {
-    /// Contructs a new `CpuController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf, v2: bool) -> Self {
-        let mut root = oroot;
-        if !v2 {
-            root.push(Self::controller_type().to_string());
-        }
+    /// Contructs a new `CpuController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf, v2: bool) -> Self {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 
@@ -153,10 +131,10 @@ 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("".to_string()),
+                .unwrap_or_default(),
         }
     }
 
@@ -167,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)
+            })
         })
     }
 
@@ -196,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,
+                    )
+                })
             })
     }
 
@@ -222,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,
+                    )
+                })
             })
     }
 
@@ -284,44 +271,51 @@ 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,
+                    )
+                })
             })
     }
 }
 
-fn parse_cfs_quota_and_period(mut file: File) -> Result<CFSQuotaAndPeriod> {
+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))?;
 
-    Ok(CFSQuotaAndPeriod {
-        quota: quota,
-        period: period,
-    })
+    Ok(CfsQuotaAndPeriod { quota, period })
 }

src/cpuacct.rs

@@ -7,13 +7,13 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/cpuacct.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/cpuacct.txt)
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::{read_string_from, read_u64_from};
 use crate::{ControllIdentifier, ControllerInternal, Controllers, Resources, Subsystem};
 
 /// A controller that allows controlling the `cpuacct` subsystem of a Cgroup.
@@ -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,
@@ -89,38 +90,17 @@ impl<'a> From<&'a Subsystem> for &'a CpuAcctController {
                 Subsystem::CpuAcct(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    let res = file.read_to_string(&mut string);
-    match res {
-        Ok(_) => match string.trim().parse() {
-            Ok(e) => Ok(e),
-            Err(e) => Err(Error::with_cause(ParseError, e)),
-        },
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
-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)),
-    }
-}
-
 impl CpuAcctController {
-    /// Contructs a new `CpuAcctController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf) -> Self {
-        let mut root = oroot;
-        root.push(Self::controller_type().to_string());
+    /// Contructs a new `CpuAcctController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf) -> Self {
         Self {
             base: root.clone(),
             path: root,
@@ -132,35 +112,35 @@ impl CpuAcctController {
         CpuAcct {
             stat: self
                 .open_path("cpuacct.stat", false)
-                .and_then(|file| read_string_from(file))
-                .unwrap_or("".to_string()),
+                .and_then(read_string_from)
+                .unwrap_or_default(),
             usage: self
                 .open_path("cpuacct.usage", false)
-                .and_then(|file| read_u64_from(file))
+                .and_then(read_u64_from)
                 .unwrap_or(0),
             usage_all: self
                 .open_path("cpuacct.usage_all", false)
-                .and_then(|file| read_string_from(file))
-                .unwrap_or("".to_string()),
+                .and_then(read_string_from)
+                .unwrap_or_default(),
             usage_percpu: self
                 .open_path("cpuacct.usage_percpu", false)
-                .and_then(|file| read_string_from(file))
-                .unwrap_or("".to_string()),
+                .and_then(read_string_from)
+                .unwrap_or_default(),
             usage_percpu_sys: self
                 .open_path("cpuacct.usage_percpu_sys", false)
-                .and_then(|file| read_string_from(file))
-                .unwrap_or("".to_string()),
+                .and_then(read_string_from)
+                .unwrap_or_default(),
             usage_percpu_user: self
                 .open_path("cpuacct.usage_percpu_user", false)
-                .and_then(|file| read_string_from(file))
-                .unwrap_or("".to_string()),
+                .and_then(read_string_from)
+                .unwrap_or_default(),
             usage_sys: self
                 .open_path("cpuacct.usage_sys", false)
-                .and_then(|file| read_u64_from(file))
+                .and_then(read_u64_from)
                 .unwrap_or(0),
             usage_user: self
                 .open_path("cpuacct.usage_user", false)
-                .and_then(|file| read_u64_from(file))
+                .and_then(read_u64_from)
                 .unwrap_or(0),
         }
     }
@@ -168,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

@@ -10,13 +10,13 @@
 //!  [Documentation/cgroup-v1/cpusets.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/cpusets.txt)
 
 use log::*;
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::{read_string_from, read_u64_from};
 use crate::{
     ControllIdentifier, ControllerInternal, Controllers, CpuResources, Resources, Subsystem,
 };
@@ -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,
@@ -110,12 +111,8 @@ impl ControllerInternal for CpuSetController {
         // get the resources that apply to this controller
         let res: &CpuResources = &res.cpu;
 
-        if res.update_values {
-            if res.cpus.is_some() {
-                let _ = self.set_cpus(res.cpus.as_ref().unwrap().as_str());
-            }
-            let _ = self.set_mems(&res.mems);
-        }
+        update!(self, set_cpus, res.cpus.as_ref());
+        update!(self, set_mems, res.mems.as_ref());
 
         Ok(())
     }
@@ -125,10 +122,6 @@ impl ControllerInternal for CpuSetController {
             return;
         }
         let current = self.get_path();
-        let parent = match current.parent() {
-            Some(p) => p,
-            None => return,
-        };
 
         if current != self.get_base() {
             match copy_from_parent(current.to_str().unwrap(), "cpuset.cpus") {
@@ -151,10 +144,15 @@ 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 != "" {
+        if !current_value.is_empty() {
             return Ok((current_value, v));
         }
         v.push(current_path.clone());
@@ -175,7 +173,7 @@ fn copy_from_parent(current: &str, file: &str) -> Result<()> {
     // find not empty cpus/memes from current directory.
     let (value, parents) = find_no_empty_parent(current, file)?;
 
-    if value == "" || parents.len() == 0 {
+    if value.is_empty() || parents.is_empty() {
         return Ok(());
     }
 
@@ -184,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,
+                ))
+            }
         }
     }
 
@@ -204,47 +207,29 @@ impl<'a> From<&'a Subsystem> for &'a CpuSetController {
                 Subsystem::CpuSet(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-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)),
-    }
-}
-
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 /// Parse a string like "1,2,4-5,8" into a list of (start, end) tuples.
 fn parse_range(s: String) -> Result<Vec<(u64, u64)>> {
     let mut fin = Vec::new();
 
-    if s == "".to_string() {
+    if s.is_empty() {
         return Ok(fin);
     }
 
     // first split by commas
-    let comma_split = s.split(",");
+    let comma_split = s.split(',');
 
     for sp in comma_split {
-        if sp.contains("-") {
+        if sp.contains('-') {
             // this is a true range
-            let dash_split = sp.split("-").collect::<Vec<_>>();
+            let dash_split = sp.split('-').collect::<Vec<_>>();
             if dash_split.len() != 2 {
                 return Err(Error::new(ParseError));
             }
@@ -268,16 +253,12 @@ fn parse_range(s: String) -> Result<Vec<(u64, u64)>> {
 }
 
 impl CpuSetController {
-    /// Contructs a new `CpuSetController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf, v2: bool) -> Self {
-        let mut root = oroot;
-        if !v2 {
-            root.push(Self::controller_type().to_string());
-        }
+    /// Contructs a new `CpuSetController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf, v2: bool) -> Self {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 
@@ -287,7 +268,7 @@ impl CpuSetController {
         CpuSet {
             cpu_exclusive: {
                 self.open_path("cpuset.cpu_exclusive", false)
-                    .and_then(|file| read_u64_from(file))
+                    .and_then(read_u64_from)
                     .map(|x| x == 1)
                     .unwrap_or(false)
             },
@@ -295,19 +276,19 @@ impl CpuSetController {
                 self.open_path("cpuset.cpus", false)
                     .and_then(read_string_from)
                     .and_then(parse_range)
-                    .unwrap_or(Vec::new())
+                    .unwrap_or_default()
             },
             effective_cpus: {
                 self.open_path("cpuset.effective_cpus", false)
                     .and_then(read_string_from)
                     .and_then(parse_range)
-                    .unwrap_or(Vec::new())
+                    .unwrap_or_default()
             },
             effective_mems: {
                 self.open_path("cpuset.effective_mems", false)
                     .and_then(read_string_from)
                     .and_then(parse_range)
-                    .unwrap_or(Vec::new())
+                    .unwrap_or_default()
             },
             mem_exclusive: {
                 self.open_path("cpuset.mem_exclusive", false)
@@ -354,7 +335,7 @@ impl CpuSetController {
                 self.open_path("cpuset.mems", false)
                     .and_then(read_string_from)
                     .and_then(parse_range)
-                    .unwrap_or(Vec::new())
+                    .unwrap_or_default()
             },
             sched_load_balance: {
                 self.open_path("cpuset.sched_load_balance", false)
@@ -376,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,
+                        )
+                    })
                 }
             })
     }
@@ -391,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,
+                        )
+                    })
                 }
             })
     }
@@ -406,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)
+            })
         })
     }
 
@@ -416,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)
+            })
         })
     }
 
@@ -430,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,
+                        )
+                    })
                 }
             })
     }
@@ -445,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,
+                        )
+                    })
                 }
             })
     }
@@ -460,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,
+                    )
+                })
             })
     }
 
@@ -471,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,
+                        )
+                    })
                 }
             })
     }
@@ -486,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,
+                        )
+                    })
                 }
             })
     }
@@ -501,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,
+                        )
+                    })
                 }
             })
     }
@@ -522,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,
@@ -49,6 +54,7 @@ impl Default for DeviceType {
 
 impl DeviceType {
     /// Convert a DeviceType into the character that the kernel recognizes.
+    #[allow(clippy::should_implement_trait, clippy::wrong_self_convention)]
     pub fn to_char(&self) -> char {
         match self {
             DeviceType::All => 'a',
@@ -70,6 +76,11 @@ impl DeviceType {
 
 /// An enum with the permissions that can be allowed/denied to the control group.
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Serialize, serde::Deserialize),
+    serde(rename_all = "snake_case")
+)]
 pub enum DevicePermissions {
     /// Permission to read from the device.
     Read,
@@ -82,6 +93,7 @@ pub enum DevicePermissions {
 
 impl DevicePermissions {
     /// Convert a DevicePermissions into the character that the kernel recognizes.
+    #[allow(clippy::should_implement_trait, clippy::wrong_self_convention)]
     pub fn to_char(&self) -> char {
         match self {
             DevicePermissions::Read => 'r',
@@ -102,7 +114,7 @@ impl DevicePermissions {
 
     /// Checks whether the string is a valid descriptor of DevicePermissions.
     pub fn is_valid(s: &str) -> bool {
-        if s == "" {
+        if s.is_empty() {
             return false;
         }
         for i in s.chars() {
@@ -110,7 +122,7 @@ impl DevicePermissions {
                 return false;
             }
         }
-        return true;
+        true
     }
 
     /// Returns a Vec will all the permissions that a device can have.
@@ -123,9 +135,10 @@ impl DevicePermissions {
     }
 
     /// Convert a string into DevicePermissions.
+    #[allow(clippy::should_implement_trait)]
     pub fn from_str(s: &str) -> Result<Vec<DevicePermissions>> {
         let mut v = Vec::new();
-        if s == "" {
+        if s.is_empty() {
             return Ok(v);
         }
         for e in s.chars() {
@@ -155,13 +168,11 @@ impl ControllerInternal for DevicesController {
         // get the resources that apply to this controller
         let res: &DeviceResources = &res.devices;
 
-        if res.update_values {
-            for i in &res.devices {
-                if i.allow {
-                    let _ = self.allow_device(i.devtype, i.major, i.minor, &i.access);
-                } else {
-                    let _ = self.deny_device(i.devtype, i.major, i.minor, &i.access);
-                }
+        for i in &res.devices {
+            if i.allow {
+                let _ = self.allow_device(i.devtype, i.major, i.minor, &i.access);
+            } else {
+                let _ = self.deny_device(i.devtype, i.major, i.minor, &i.access);
             }
         }
 
@@ -182,7 +193,8 @@ impl<'a> From<&'a Subsystem> for &'a DevicesController {
                 Subsystem::Devices(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
@@ -190,10 +202,8 @@ impl<'a> From<&'a Subsystem> for &'a DevicesController {
 }
 
 impl DevicesController {
-    /// Constructs a new `DevicesController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf) -> Self {
-        let mut root = oroot;
-        root.push(Self::controller_type().to_string());
+    /// Constructs a new `DevicesController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf) -> Self {
         Self {
             base: root.clone(),
             path: root,
@@ -209,7 +219,7 @@ impl DevicesController {
         devtype: DeviceType,
         major: i64,
         minor: i64,
-        perm: &Vec<DevicePermissions>,
+        perm: &[DevicePermissions],
     ) -> Result<()> {
         let perms = perm
             .iter()
@@ -227,8 +237,9 @@ 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("devices.allow".to_string(), final_str), e)
+            })
         })
     }
 
@@ -241,7 +252,7 @@ impl DevicesController {
         devtype: DeviceType,
         major: i64,
         minor: i64,
-        perm: &Vec<DevicePermissions>,
+        perm: &[DevicePermissions],
     ) -> Result<()> {
         let perms = perm
             .iter()
@@ -259,8 +270,9 @@ 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("devices.deny".to_string(), final_str), e)
+            })
         })
     }
 
@@ -277,13 +289,13 @@ impl DevicesController {
                             error!("allowed_devices: acc: {:?}, ls: {:?}", acc, ls);
                             Err(Error::new(ParseError))
                         } else {
-                            let devtype = DeviceType::from_char(ls[0].chars().nth(0));
+                            let devtype = DeviceType::from_char(ls[0].chars().next());
                             let mut major = ls[1].parse::<i64>();
                             let mut minor = ls[2].parse::<i64>();
-                            if major.is_err() && ls[1] == "*".to_string() {
+                            if major.is_err() && ls[1] == "*" {
                                 major = Ok(-1);
                             }
-                            if minor.is_err() && ls[2] == "*".to_string() {
+                            if minor.is_err() && ls[2] == "*" {
                                 minor = Ok(-1);
                             }
                             if devtype.is_none() || major.is_err() || minor.is_err() || !DevicePermissions::is_valid(&ls[3]) {
@@ -298,14 +310,14 @@ impl DevicesController {
                                     devtype: devtype.unwrap(),
                                     major: major.unwrap(),
                                     minor: minor.unwrap(),
-                                    access: access,
+                                    access,
                                 });
                                 Ok(acc)
                             }
                         }
                     })
                 },
-                Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                Err(e) => Err(Error::with_cause(ReadFailed("devices.list".to_string()), e)),
             }
         })
     }

src/error.rs

@@ -8,66 +8,85 @@ 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,
+
+    /// Subsystems is empty.
+    #[error("subsystems is empty")]
+    SubsystemsEmpty,
+
     /// An unknown error has occured.
+    #[error("an unknown error")]
     Other,
 }
 
 #[derive(Debug)]
 pub struct Error {
     kind: ErrorKind,
-    cause: Option<Box<StdError + Send + Sync>>,
+    cause: Option<Box<dyn StdError + Send + Sync>>,
 }
 
 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::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(),
-        };
-
-        write!(f, "{}", msg)
+        if let Some(cause) = &self.cause {
+            write!(f, "{} caused by: {:?}", &self.kind, cause)
+        } else {
+            write!(f, "{}", &self.kind)
+        }
     }
 }
 
 impl StdError for Error {
-    fn cause(&self) -> Option<&StdError> {
+    fn cause(&self) -> Option<&dyn StdError> {
+        #[allow(clippy::manual_map)]
         match self.cause {
             Some(ref x) => Some(&**x),
             None => None,

src/events.rs

@@ -8,7 +8,7 @@ use nix::sys::eventfd;
 use std::fs::{self, File};
 use std::io::Read;
 use std::os::unix::io::{AsRawFd, FromRawFd};
-use std::path::{Path, PathBuf};
+use std::path::Path;
 use std::sync::mpsc::{self, Receiver};
 use std::thread;
 
@@ -17,18 +17,18 @@ use crate::error::*;
 
 // notify_on_oom returns channel on which you can expect event about OOM,
 // if process died without OOM this channel will be closed.
-pub fn notify_on_oom_v2(key: &str, dir: &PathBuf) -> Result<Receiver<String>> {
+pub fn notify_on_oom_v2(key: &str, dir: &Path) -> Result<Receiver<String>> {
     register_memory_event(key, dir, "memory.oom_control", "")
 }
 
 // notify_on_oom returns channel on which you can expect event about OOM,
 // if process died without OOM this channel will be closed.
-pub fn notify_on_oom_v1(key: &str, dir: &PathBuf) -> Result<Receiver<String>> {
+pub fn notify_on_oom_v1(key: &str, dir: &Path) -> Result<Receiver<String>> {
     register_memory_event(key, dir, "memory.oom_control", "")
 }
 
 // level is one of "low", "medium", or "critical"
-pub fn notify_memory_pressure(key: &str, dir: &PathBuf, level: &str) -> Result<Receiver<String>> {
+pub fn notify_memory_pressure(key: &str, dir: &Path, level: &str) -> Result<Receiver<String>> {
     if level != "low" && level != "medium" && level != "critical" {
         return Err(Error::from_string(format!(
             "invalid pressure level {}",
@@ -41,26 +41,31 @@ pub fn notify_memory_pressure(key: &str, dir: &PathBuf, level: &str) -> Result<R
 
 fn register_memory_event(
     key: &str,
-    cg_dir: &PathBuf,
+    cg_dir: &Path,
     event_name: &str,
     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 == "" {
-        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) };
 
@@ -70,11 +75,8 @@ fn register_memory_event(
     thread::spawn(move || {
         loop {
             let mut buf = [0; 8];
-            match eventfd_file.read(&mut buf) {
-                Err(err) => {
-                    return;
-                }
-                Ok(_) => {}
+            if eventfd_file.read(&mut buf).is_err() {
+                return;
             }
 
             // When a cgroup is destroyed, an event is sent to 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,
@@ -73,7 +74,8 @@ impl<'a> From<&'a Subsystem> for &'a FreezerController {
                 Subsystem::Freezer(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
@@ -81,59 +83,55 @@ impl<'a> From<&'a Subsystem> for &'a FreezerController {
 }
 
 impl FreezerController {
-    /// Contructs a new `FreezerController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf, v2: bool) -> Self {
-        let mut root = oroot;
-        if !v2 {
-            root.push(Self::controller_type().to_string());
-        }
+    /// Contructs a new `FreezerController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf, v2: bool) -> Self {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 
     /// 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 {
-                Ok(_) => match s.as_ref() {
+                Ok(_) => match s.trim() {
                     "FROZEN" => Ok(FreezerState::Frozen),
                     "THAWED" => Ok(FreezerState::Thawed),
                     "1" => Ok(FreezerState::Frozen),
@@ -141,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

@@ -8,15 +8,12 @@
 //!
 //! Currently, we only support the cgroupv1 hierarchy, but in the future we will add support for
 //! the Unified Hierarchy.
-use nix::sys::statfs;
 
-use std::fs::{self, File};
-use std::io::BufRead;
-use std::io::BufReader;
+use std::fs;
+use std::fs::File;
+use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
 
-use log::*;
-
 use crate::blkio::BlkIoController;
 use crate::cpu::CpuController;
 use crate::cpuacct::CpuAcctController;
@@ -35,11 +32,82 @@ use crate::{Controllers, Hierarchy, Subsystem};
 
 use crate::cgroup::Cgroup;
 
-/// The standard, original cgroup implementation. Often referred to as "cgroupv1".
-pub struct V1 {
-    mount_point: String,
+/// Process mounts information.
+///
+/// See `proc(5)` for format details.
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
+pub struct Mountinfo {
+    /// Mount pathname relative to the process's root.
+    pub mount_point: PathBuf,
+    /// Filesystem type (main type with optional sub-type).
+    pub fs_type: (String, Option<String>),
+    /// Superblock options.
+    pub super_opts: Vec<String>,
 }
 
+pub(crate) fn parse_mountinfo_for_line(line: &str) -> Option<Mountinfo> {
+    let s_values: Vec<_> = line.split(" - ").collect();
+    if s_values.len() != 2 {
+        return None;
+    }
+
+    let s0_values: Vec<_> = s_values[0].trim().split(' ').collect();
+    let s1_values: Vec<_> = s_values[1].trim().split(' ').collect();
+    if s0_values.len() < 6 || s1_values.len() < 3 {
+        return None;
+    }
+    let mount_point = PathBuf::from(s0_values[4]);
+    let fs_type_values: Vec<_> = s1_values[0].trim().split('.').collect();
+    let fs_type = match fs_type_values.len() {
+        1 => (fs_type_values[0].to_string(), None),
+        2 => (
+            fs_type_values[0].to_string(),
+            Some(fs_type_values[1].to_string()),
+        ),
+        _ => return None,
+    };
+
+    let super_opts: Vec<String> = s1_values[2].trim().split(',').map(String::from).collect();
+    Some(Mountinfo {
+        mount_point,
+        fs_type,
+        super_opts,
+    })
+}
+
+/// Parses the provided mountinfo file.
+fn mountinfo_file(file: &mut File) -> Vec<Mountinfo> {
+    let mut r = Vec::new();
+    for line in BufReader::new(file).lines() {
+        match line {
+            Ok(line) => {
+                if let Some(mi) = parse_mountinfo_for_line(&line) {
+                    if mi.fs_type.0 == "cgroup" {
+                        r.push(mi);
+                    }
+                }
+            }
+            Err(_) => break,
+        }
+    }
+    r
+}
+
+/// Returns mounts information for the current process.
+pub fn mountinfo_self() -> Vec<Mountinfo> {
+    match File::open("/proc/self/mountinfo") {
+        Ok(mut file) => mountinfo_file(&mut file),
+        Err(_) => vec![],
+    }
+}
+
+/// The standard, original cgroup implementation. Often referred to as "cgroupv1".
+#[derive(Debug, Clone)]
+pub struct V1 {
+    mountinfo: Vec<Mountinfo>,
+}
+
+#[derive(Debug, Clone)]
 pub struct V2 {
     root: String,
 }
@@ -51,80 +119,77 @@ impl Hierarchy for V1 {
 
     fn subsystems(&self) -> Vec<Subsystem> {
         let mut subs = vec![];
-        if self.check_support(Controllers::Pids) {
-            subs.push(Subsystem::Pid(PidController::new(self.root(), false)));
+
+        // The cgroup writeback feature requires cooperation between memcgs and blkcgs
+        // To avoid exceptions, we should add_task for blkcg before memcg(push BlkIo before Mem)
+        // For more Information: https://www.alibabacloud.com/help/doc-detail/155509.htm
+        if let Some(root) = self.get_mount_point(Controllers::BlkIo) {
+            subs.push(Subsystem::BlkIo(BlkIoController::new(root, false)));
         }
-        if self.check_support(Controllers::Mem) {
-            subs.push(Subsystem::Mem(MemController::new(self.root(), false)));
+        if let Some(root) = self.get_mount_point(Controllers::Mem) {
+            subs.push(Subsystem::Mem(MemController::new(root, false)));
         }
-        if self.check_support(Controllers::CpuSet) {
-            subs.push(Subsystem::CpuSet(CpuSetController::new(self.root(), false)));
+        if let Some(root) = self.get_mount_point(Controllers::Pids) {
+            subs.push(Subsystem::Pid(PidController::new(root, false)));
         }
-        if self.check_support(Controllers::CpuAcct) {
-            subs.push(Subsystem::CpuAcct(CpuAcctController::new(self.root())));
+        if let Some(root) = self.get_mount_point(Controllers::CpuSet) {
+            subs.push(Subsystem::CpuSet(CpuSetController::new(root, false)));
         }
-        if self.check_support(Controllers::Cpu) {
-            subs.push(Subsystem::Cpu(CpuController::new(self.root(), false)));
+        if let Some(root) = self.get_mount_point(Controllers::CpuAcct) {
+            subs.push(Subsystem::CpuAcct(CpuAcctController::new(root)));
         }
-        if self.check_support(Controllers::Devices) {
-            subs.push(Subsystem::Devices(DevicesController::new(self.root())));
+        if let Some(root) = self.get_mount_point(Controllers::Cpu) {
+            subs.push(Subsystem::Cpu(CpuController::new(root, false)));
         }
-        if self.check_support(Controllers::Freezer) {
-            subs.push(Subsystem::Freezer(FreezerController::new(
-                self.root(),
-                false,
-            )));
+        if let Some(root) = self.get_mount_point(Controllers::Devices) {
+            subs.push(Subsystem::Devices(DevicesController::new(root)));
         }
-        if self.check_support(Controllers::NetCls) {
-            subs.push(Subsystem::NetCls(NetClsController::new(self.root())));
+        if let Some(root) = self.get_mount_point(Controllers::Freezer) {
+            subs.push(Subsystem::Freezer(FreezerController::new(root, false)));
         }
-        if self.check_support(Controllers::BlkIo) {
-            subs.push(Subsystem::BlkIo(BlkIoController::new(self.root(), false)));
+        if let Some(root) = self.get_mount_point(Controllers::NetCls) {
+            subs.push(Subsystem::NetCls(NetClsController::new(root)));
         }
-        if self.check_support(Controllers::PerfEvent) {
-            subs.push(Subsystem::PerfEvent(PerfEventController::new(self.root())));
+        if let Some(root) = self.get_mount_point(Controllers::PerfEvent) {
+            subs.push(Subsystem::PerfEvent(PerfEventController::new(root)));
         }
-        if self.check_support(Controllers::NetPrio) {
-            subs.push(Subsystem::NetPrio(NetPrioController::new(self.root())));
+        if let Some(root) = self.get_mount_point(Controllers::NetPrio) {
+            subs.push(Subsystem::NetPrio(NetPrioController::new(root)));
         }
-        if self.check_support(Controllers::HugeTlb) {
-            subs.push(Subsystem::HugeTlb(HugeTlbController::new(
-                self.root(),
-                false,
-            )));
+        if let Some(root) = self.get_mount_point(Controllers::HugeTlb) {
+            subs.push(Subsystem::HugeTlb(HugeTlbController::new(root, false)));
         }
-        if self.check_support(Controllers::Rdma) {
-            subs.push(Subsystem::Rdma(RdmaController::new(self.root())));
+        if let Some(root) = self.get_mount_point(Controllers::Rdma) {
+            subs.push(Subsystem::Rdma(RdmaController::new(root)));
         }
-        if self.check_support(Controllers::Systemd) {
-            subs.push(Subsystem::Systemd(SystemdController::new(
-                self.root(),
-                false,
-            )));
+        if let Some(root) = self.get_mount_point(Controllers::Systemd) {
+            subs.push(Subsystem::Systemd(SystemdController::new(root, false)));
         }
 
         subs
     }
 
     fn root_control_group(&self) -> Cgroup {
-        let b: &Hierarchy = self as &Hierarchy;
-        Cgroup::load(Box::new(&*b), "".to_string())
+        Cgroup::load(auto(), "")
     }
 
-    fn check_support(&self, sub: Controllers) -> bool {
-        let root = self.root().read_dir().unwrap();
-        for entry in root {
-            if let Ok(entry) = entry {
-                if entry.file_name().into_string().unwrap() == sub.to_string() {
-                    return true;
-                }
-            }
-        }
-        return false;
+    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 {
-        PathBuf::from(self.mount_point.clone())
+        self.mountinfo
+            .iter()
+            .find_map(|m| {
+                if m.fs_type.0 == "cgroup" {
+                    return Some(m.mount_point.parent().unwrap());
+                }
+                None
+            })
+            .unwrap()
+            .to_path_buf()
     }
 }
 
@@ -143,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 {
@@ -182,12 +252,13 @@ impl Hierarchy for V2 {
     }
 
     fn root_control_group(&self) -> Cgroup {
-        let b: &Hierarchy = self as &Hierarchy;
-        Cgroup::load(Box::new(&*b), "".to_string())
+        Cgroup::load(auto(), "")
     }
 
-    fn check_support(&self, _sub: Controllers) -> bool {
-        return false;
+    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 {
@@ -199,11 +270,25 @@ impl V1 {
     /// Finds where control groups are mounted to and returns a hierarchy in which control groups
     /// can be created.
     pub fn new() -> V1 {
-        let mount_point = find_v1_mount().unwrap();
         V1 {
-            mount_point: mount_point,
+            mountinfo: mountinfo_self(),
         }
     }
+
+    pub fn get_mount_point(&self, controller: Controllers) -> Option<PathBuf> {
+        self.mountinfo.iter().find_map(|m| {
+            if m.fs_type.0 == "cgroup" && m.super_opts.contains(&controller.to_string()) {
+                return Some(m.mount_point.clone());
+            }
+            None
+        })
+    }
+}
+
+impl Default for V1 {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl V2 {
@@ -216,11 +301,22 @@ impl V2 {
     }
 }
 
-pub const UNIFIED_MOUNTPOINT: &'static str = "/sys/fs/cgroup";
+impl Default for V2 {
+    fn default() -> Self {
+        Self::new()
+    }
+}
 
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+pub const UNIFIED_MOUNTPOINT: &str = "/sys/fs/cgroup";
+
+#[cfg(any(
+    all(target_os = "linux", not(target_env = "musl")),
+    target_os = "android"
+))]
 pub fn is_cgroup2_unified_mode() -> bool {
-    let path = Path::new(UNIFIED_MOUNTPOINT);
+    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;
@@ -230,7 +326,7 @@ pub fn is_cgroup2_unified_mode() -> bool {
     fs_stat.unwrap().filesystem_type() == statfs::CGROUP2_SUPER_MAGIC
 }
 
-pub const INIT_CGROUP_PATHS: &'static str = "/proc/1/cgroup";
+pub const INIT_CGROUP_PATHS: &str = "/proc/1/cgroup";
 
 #[cfg(all(target_os = "linux", target_env = "musl"))]
 pub fn is_cgroup2_unified_mode() -> bool {
@@ -260,39 +356,35 @@ pub fn auto() -> Box<dyn Hierarchy> {
     }
 }
 
-fn find_v1_mount() -> Option<String> {
-    // Open mountinfo so we can get a parseable mount list
-    let mountinfo_path = Path::new("/proc/self/mountinfo");
+#[cfg(test)]
+mod tests {
+    use super::*;
 
-    // If /proc isn't mounted, or something else happens, then bail out
-    if mountinfo_path.exists() == false {
-        return None;
-    }
+    #[test]
+    fn test_parse_mount() {
+        let mountinfo = vec![
+            ("29 26 0:26 / /sys/fs/cgroup/cpuset,cpu,cpuacct rw,nosuid,nodev,noexec,relatime shared:10 - cgroup cgroup rw,cpuset,cpu,cpuacct",
+             Mountinfo{mount_point: PathBuf::from("/sys/fs/cgroup/cpuset,cpu,cpuacct"), fs_type: ("cgroup".to_string(), None), super_opts: vec![
+                "rw".to_string(),
+                "cpuset".to_string(),
+                "cpu".to_string(),
+                "cpuacct".to_string(),
+             ]}),
+            ("121 1731 0:42 / /shm rw,nosuid,nodev,noexec,relatime shared:68 master:66 - tmpfs shm rw,size=65536k",
+             Mountinfo{mount_point: PathBuf::from("/shm"), fs_type: ("tmpfs".to_string(), None), super_opts: vec![
+                "rw".to_string(),
+                "size=65536k".to_string(),
+             ]}),
+            ("121 1731 0:42 / /shm rw,nosuid,nodev,noexec,relatime shared:68 master:66 - tmpfs.123 shm rw,size=65536k",
+             Mountinfo{mount_point: PathBuf::from("/shm"), fs_type: ("tmpfs".to_string(), Some("123".to_string())), super_opts: vec![
+                "rw".to_string(),
+                "size=65536k".to_string(),
+             ]}),
+        ];
 
-    let mountinfo_file = File::open(mountinfo_path).unwrap();
-    let mountinfo_reader = BufReader::new(&mountinfo_file);
-    for _line in mountinfo_reader.lines() {
-        let line = _line.unwrap();
-        let mut fields = line.split_whitespace();
-        let index = line.find(" - ").unwrap();
-        let more_fields = line[index + 3..].split_whitespace().collect::<Vec<_>>();
-        if more_fields.len() == 0 {
-            continue;
-        }
-        if more_fields[0] == "cgroup" {
-            if more_fields.len() < 3 {
-                continue;
-            }
-            let cgroups_mount = fields.nth(4).unwrap();
-            if let Some(parent) = std::path::Path::new(cgroups_mount).parent() {
-                if let Some(path) = parent.as_os_str().to_str() {
-                    debug!("found cgroups {:?} from {:?}", path, cgroups_mount);
-                    return Some(path.to_string());
-                }
-            }
-            continue;
+        for mi in mountinfo {
+            let info = parse_mountinfo_for_line(mi.0).unwrap();
+            assert_eq!(info, mi.1)
         }
     }
-
-    None
 }

src/hugetlb.rs

@@ -8,13 +8,13 @@
 //!
 //! 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 std::fs::File;
-use std::io::{Read, Write};
+use log::warn;
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
-use crate::flat_keyed_to_vec;
+use crate::{flat_keyed_to_vec, read_u64_from};
 
 use crate::{
     ControllIdentifier, ControllerInternal, Controllers, HugePageResources, Resources, Subsystem,
@@ -54,14 +54,13 @@ impl ControllerInternal for HugeTlbController {
         // get the resources that apply to this controller
         let res: &HugePageResources = &res.hugepages;
 
-        if res.update_values {
-            for i in &res.limits {
-                let _ = self.set_limit_in_bytes(&i.size, i.limit);
-                if self.limit_in_bytes(&i.size)? != i.limit {
-                    return Err(Error::new(Other));
-                }
+        for i in &res.limits {
+            let _ = self.set_limit_in_bytes(&i.size, i.limit);
+            if self.limit_in_bytes(&i.size)? != i.limit {
+                return Err(Error::new(Other));
             }
         }
+
         Ok(())
     }
 }
@@ -79,37 +78,23 @@ impl<'a> From<&'a Subsystem> for &'a HugeTlbController {
                 Subsystem::HugeTlb(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl HugeTlbController {
-    /// Constructs a new `HugeTlbController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf, v2: bool) -> Self {
-        let mut root = oroot;
-        if !v2 {
-            root.push(Self::controller_type().to_string());
-        }
-        let sizes = get_hugepage_sizes().unwrap();
+    /// 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();
         Self {
             base: root.clone(),
             path: root,
-            sizes: sizes,
-            v2: v2,
+            sizes,
+            v2,
         }
     }
 
@@ -131,7 +116,7 @@ impl HugeTlbController {
         self.open_path(&format!("hugetlb.{}.events", hugetlb_size), false)
             .and_then(flat_keyed_to_vec)
             .and_then(|x| {
-                if x.len() == 0 {
+                if x.is_empty() {
                     return Err(Error::from_string(format!(
                         "get empty from hugetlb.{}.events",
                         hugetlb_size
@@ -180,43 +165,46 @@ 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)
+            })
         })
     }
 }
 
-pub const HUGEPAGESIZE_DIR: &'static str = "/sys/kernel/mm/hugepages";
+pub const HUGEPAGESIZE_DIR: &str = "/sys/kernel/mm/hugepages";
 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;
@@ -225,10 +213,15 @@ pub const GB: u128 = 1000 * MB;
 pub const TB: u128 = 1000 * GB;
 pub const PB: u128 = 1000 * TB;
 
+#[allow(non_upper_case_globals)]
 pub const KiB: u128 = 1024;
+#[allow(non_upper_case_globals)]
 pub const MiB: u128 = 1024 * KiB;
+#[allow(non_upper_case_globals)]
 pub const GiB: u128 = 1024 * MiB;
+#[allow(non_upper_case_globals)]
 pub const TiB: u128 = 1024 * GiB;
+#[allow(non_upper_case_globals)]
 pub const PiB: u128 = 1024 * TiB;
 
 pub fn get_binary_size_map() -> HashMap<String, u128> {
@@ -275,8 +268,8 @@ fn parse_size(s: &str, m: &HashMap<String, u128>) -> Result<u128> {
     let caps = re.unwrap().captures(s).unwrap();
 
     let num = caps.name("num");
-    let size: u128 = if num.is_some() {
-        let n = num.unwrap().as_str().trim().parse::<u128>();
+    let size: u128 = if let Some(num) = num {
+        let n = num.as_str().trim().parse::<u128>();
         if n.is_err() {
             return Err(Error::new(InvalidBytesSize));
         }
@@ -286,10 +279,10 @@ fn parse_size(s: &str, m: &HashMap<String, u128>) -> Result<u128> {
     };
 
     let q = caps.name("mul");
-    let mul: u128 = if q.is_some() {
-        let t = m.get(q.unwrap().as_str());
-        if t.is_some() {
-            *t.unwrap()
+    let mul: u128 = if let Some(q) = q {
+        let t = m.get(q.as_str());
+        if let Some(t) = t {
+            *t
         } else {
             return Err(Error::new(InvalidBytesSize));
         }
@@ -300,7 +293,7 @@ fn parse_size(s: &str, m: &HashMap<String, u128>) -> Result<u128> {
     Ok(size * mul)
 }
 
-fn custom_size(mut size: f64, base: f64, m: &Vec<String>) -> String {
+fn custom_size(mut size: f64, base: f64, m: &[String]) -> String {
     let mut i = 0;
     while size >= base && i < m.len() - 1 {
         size /= base;

src/lib.rs

@@ -4,12 +4,34 @@
 // SPDX-License-Identifier: Apache-2.0 or MIT
 //
 
+#![allow(clippy::unnecessary_unwrap)]
 use log::*;
 
 use std::collections::HashMap;
-use std::fs::File;
+use std::fmt;
+use std::fs::{self, File};
 use std::io::{BufRead, BufReader, Read, Write};
 use std::path::{Path, PathBuf};
+use std::str::FromStr;
+
+macro_rules! update_and_test {
+    ($self: ident, $set_func:ident, $value:expr, $get_func:ident) => {
+        if let Some(v) = $value {
+            $self.$set_func(v)?;
+            if $self.$get_func()? != v {
+                return Err(Error::new(Other));
+            }
+        }
+    };
+}
+
+macro_rules! update {
+    ($self: ident, $set_func:ident, $value:expr) => {
+        if let Some(v) = $value {
+            let _ = $self.$set_func(v);
+        }
+    };
+}
 
 pub mod blkio;
 pub mod cgroup;
@@ -48,10 +70,11 @@ use crate::pid::PidController;
 use crate::rdma::RdmaController;
 use crate::systemd::SystemdController;
 
+#[doc(inline)]
 pub use crate::cgroup::Cgroup;
 
 /// Contains all the subsystems that are available in this crate.
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum Subsystem {
     /// Controller for the `Pid` subsystem, see `PidController` for more information.
     Pid(PidController),
@@ -84,7 +107,7 @@ pub enum Subsystem {
 }
 
 #[doc(hidden)]
-#[derive(Eq, PartialEq, Debug)]
+#[derive(Eq, PartialEq, Debug, Clone)]
 pub enum Controllers {
     Pids,
     Mem,
@@ -102,23 +125,23 @@ pub enum Controllers {
     Systemd,
 }
 
-impl Controllers {
-    pub fn to_string(&self) -> String {
+impl fmt::Display for Controllers {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Controllers::Pids => return "pids".to_string(),
-            Controllers::Mem => return "memory".to_string(),
-            Controllers::CpuSet => return "cpuset".to_string(),
-            Controllers::CpuAcct => return "cpuacct".to_string(),
-            Controllers::Cpu => return "cpu".to_string(),
-            Controllers::Devices => return "devices".to_string(),
-            Controllers::Freezer => return "freezer".to_string(),
-            Controllers::NetCls => return "net_cls".to_string(),
-            Controllers::BlkIo => return "blkio".to_string(),
-            Controllers::PerfEvent => return "perf_event".to_string(),
-            Controllers::NetPrio => return "net_prio".to_string(),
-            Controllers::HugeTlb => return "hugetlb".to_string(),
-            Controllers::Rdma => return "rdma".to_string(),
-            Controllers::Systemd => return "systemd".to_string(),
+            Controllers::Pids => write!(f, "pids"),
+            Controllers::Mem => write!(f, "memory"),
+            Controllers::CpuSet => write!(f, "cpuset"),
+            Controllers::CpuAcct => write!(f, "cpuacct"),
+            Controllers::Cpu => write!(f, "cpu"),
+            Controllers::Devices => write!(f, "devices"),
+            Controllers::Freezer => write!(f, "freezer"),
+            Controllers::NetCls => write!(f, "net_cls"),
+            Controllers::BlkIo => write!(f, "blkio"),
+            Controllers::PerfEvent => write!(f, "perf_event"),
+            Controllers::NetPrio => write!(f, "net_prio"),
+            Controllers::HugeTlb => write!(f, "hugetlb"),
+            Controllers::Rdma => write!(f, "rdma"),
+            Controllers::Systemd => write!(f, "name=systemd"),
         }
     }
 }
@@ -158,13 +181,22 @@ mod sealed {
 
             if w {
                 match File::create(&path) {
-                    Err(e) => return Err(Error::with_cause(ErrorKind::WriteFailed, e)),
-                    Ok(file) => return Ok(file),
+                    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) => return Err(Error::with_cause(ErrorKind::ReadFailed, e)),
-                    Ok(file) => return Ok(file),
+                    Err(e) => Err(Error::with_cause(
+                        ErrorKind::ReadFailed(path.display().to_string()),
+                        e,
+                    )),
+                    Ok(file) => Ok(file),
                 }
             }
         }
@@ -175,23 +207,43 @@ 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)),
                 }
             })
         }
 
         #[doc(hidden)]
         fn path_exists(&self, p: &str) -> bool {
-            if let Err(_) = self.verify_path() {
+            if self.verify_path().is_err() {
                 return false;
             }
 
             std::path::Path::new(p).exists()
         }
     }
+
+    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(key.to_string(), value.to_string()), e)
+                })
+            })
+        }
+
+        fn get(&self, key: &str) -> Result<String> {
+            self.open_path(key, 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(ReadFailed(key.to_string()), e)),
+                }
+            })
+        }
+    }
 }
 
-pub(crate) use crate::sealed::ControllerInternal;
+pub(crate) use crate::sealed::{ControllerInternal, CustomizedAttribute};
 
 /// A Controller is a subsystem attached to the control group.
 ///
@@ -213,15 +265,33 @@ pub trait Controller {
     /// Does this controller already exist?
     fn exists(&self) -> bool;
 
+    /// Set notify_on_release
+    fn set_notify_on_release(&self, enable: bool) -> Result<()>;
+
+    /// Set release_agent
+    fn set_release_agent(&self, path: &str) -> Result<()>;
+
     /// Delete the controller.
-    fn delete(&self);
+    fn delete(&self) -> Result<()>;
 
     /// Attach a task to this controller.
     fn add_task(&self, pid: &CgroupPid) -> Result<()>;
 
+    /// 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;
 }
 
@@ -246,57 +316,180 @@ where
     /// Create this controller
     fn create(&self) {
         self.verify_path()
-            .expect(format!("path should be valid: {:?}", self.path()).as_str());
+            .unwrap_or_else(|_| panic!("path should be valid: {:?}", self.path()));
 
         match ::std::fs::create_dir_all(self.get_path()) {
             Ok(_) => self.post_create(),
-            Err(e) => warn!("error create_dir {:?}", e),
+            Err(e) => warn!("error create_dir: {:?} error: {:?}", self.get_path(), e),
         }
     }
 
+    /// 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("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("release_agent".to_string(), path.to_string()),
+                    e,
+                )
+            })
+        })
+    }
     /// Does this controller already exist?
     fn exists(&self) -> bool {
         self.get_path().exists()
     }
 
     /// Delete the controller.
-    fn delete(&self) {
-        if self.get_path().exists() {
-            libc_rmdir(self.get_path().to_str().unwrap());
+    fn delete(&self) -> Result<()> {
+        if !self.get_path().exists() {
+            return Ok(());
         }
+
+        // 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<()> {
+        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 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() {
+                    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 = "tasks";
+        let mut file_name = "tasks";
         if self.is_v2() {
-            file = "cgroup.procs";
+            file_name = "cgroup.threads";
         }
-        self.open_path(file, false)
-            .and_then(|file| {
+        self.open_path(file_name, false)
+            .map(|file| {
                 let bf = BufReader::new(file);
                 let mut v = Vec::new();
                 for line in bf.lines() {
-                    if let Ok(line) = line {
-                        let n = line.trim().parse().unwrap_or(0u64);
-                        v.push(n);
+                    match line {
+                        Ok(line) => {
+                            let n = line.trim().parse().unwrap_or(0u64);
+                            v.push(n);
+                        }
+                        Err(_) => break,
                     }
                 }
-                Ok(v.into_iter().map(CgroupPid::from).collect())
+                v.into_iter().map(CgroupPid::from).collect()
             })
-            .unwrap_or(vec![])
+            .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 {
@@ -304,6 +497,31 @@ where
     }
 }
 
+// remove_dir aims to remove cgroup path. It does so recursively,
+// by removing any subdirectories (sub-cgroups) first.
+fn remove_dir(dir: &Path) -> Result<()> {
+    // try the fast path first.
+    if fs::remove_dir(dir).is_ok() {
+        return Ok(());
+    }
+
+    if dir.exists() && dir.is_dir() {
+        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)?;
+            }
+        }
+        fs::remove_dir(dir).map_err(|e| Error::with_cause(RemoveFailed, e))?;
+    }
+
+    Ok(())
+}
+
 #[doc(hidden)]
 pub trait ControllIdentifier {
     fn controller_type() -> Controllers;
@@ -311,7 +529,7 @@ pub trait ControllIdentifier {
 
 /// Control group hierarchy (right now, only V1 is supported, but in the future Unified will be
 /// implemented as well).
-pub trait Hierarchy {
+pub trait Hierarchy: std::fmt::Debug + Send + Sync {
     /// Returns what subsystems are supported by the hierarchy.
     fn subsystems(&self) -> Vec<Subsystem>;
 
@@ -321,80 +539,92 @@ pub trait Hierarchy {
     /// Return a handle to the root control group in the hierarchy.
     fn root_control_group(&self) -> Cgroup;
 
-    fn v2(&self) -> bool;
+    /// Return a handle to the parent control group in the hierarchy.
+    fn parent_control_group(&self, path: &str) -> Cgroup;
 
-    /// Checks whether a certain subsystem is supported in the hierarchy.
-    ///
-    /// This is an internal function and should not be used.
-    #[doc(hidden)]
-    fn check_support(&self, sub: Controllers) -> bool;
+    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 {
-    /// Whether values should be applied to the controller.
-    pub update_values: bool,
     /// How much memory (in bytes) can the kernel consume.
-    pub kernel_memory_limit: i64,
+    pub kernel_memory_limit: Option<i64>,
     /// Upper limit of memory usage of the control group's tasks.
-    pub memory_hard_limit: i64,
+    pub memory_hard_limit: Option<i64>,
     /// How much memory the tasks in the control group can use when the system is under memory
     /// pressure.
-    pub memory_soft_limit: i64,
+    pub memory_soft_limit: Option<i64>,
     /// How much of the kernel's memory (in bytes) can be used for TCP-related buffers.
-    pub kernel_tcp_memory_limit: i64,
+    pub kernel_tcp_memory_limit: Option<i64>,
     /// How much memory and swap together can the tasks in the control group use.
-    pub memory_swap_limit: i64,
+    pub memory_swap_limit: Option<i64>,
     /// Controls the tendency of the kernel to swap out parts of the address space of the tasks to
     /// disk. Lower value implies less likely.
     ///
     /// Note, however, that a value of zero does not mean the process is never swapped out. Use the
     /// traditional `mlock(2)` system call for that purpose.
-    pub swappiness: u64,
+    pub swappiness: Option<u64>,
+    /// Customized key-value attributes
+    ///
+    /// # Usage:
+    /// ```
+    /// let resource = &mut cgroups_rs::Resources::default();
+    /// resource.memory.attrs.insert("memory.numa_balancing".to_string(), "true".to_string());
+    /// // apply here
+    /// ```
+    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 {
-    /// Whether values should be applied to the controller.
-    pub update_values: bool,
     /// The maximum number of processes that can exist in the control group.
     ///
     /// Note that attaching processes to the control group will still succeed _even_ if the limit
     /// would be violated, however forks/clones inside the control group will have with `EAGAIN` if
     /// they would violate the limit set here.
-    pub maximum_number_of_processes: MaxValue,
+    pub maximum_number_of_processes: Option<MaxValue>,
 }
 
 /// 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 {
-    /// Whether values should be applied to the controller.
-    pub update_values: bool,
     // cpuset
     /// A comma-separated list of CPU IDs where the task in the control group can run. Dashes
     /// between numbers indicate ranges.
     pub cpus: Option<String>,
     /// Same syntax as the `cpus` field of this structure, but applies to memory nodes instead of
     /// processors.
-    pub mems: String,
+    pub mems: Option<String>,
     // cpu
     /// 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: u64,
+    pub shares: Option<u64>,
     /// In one `period`, how much can the tasks run in nanoseconds.
-    pub quota: i64,
+    pub quota: Option<i64>,
     /// Period of time in nanoseconds.
-    pub period: u64,
+    pub period: Option<u64>,
     /// This is currently a no-operation.
-    pub realtime_runtime: i64,
+    pub realtime_runtime: Option<i64>,
     /// This is currently a no-operation.
-    pub realtime_period: u64,
+    pub realtime_period: Option<u64>,
+    /// Customized key-value attributes
+    /// # Usage:
+    /// ```
+    /// let resource = &mut cgroups_rs::Resources::default();
+    /// resource.cpu.attrs.insert("cpu.cfs_init_buffer_us".to_string(), "10".to_string());
+    /// // apply here
+    /// ```
+    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,
@@ -410,15 +640,15 @@ 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 {
-    /// Whether values should be applied to the controller.
-    pub update_values: bool,
     /// For each device in the list, the limits in the structure are applied.
     pub devices: Vec<DeviceResource>,
 }
 
 /// 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,
@@ -429,19 +659,19 @@ 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 {
-    /// Whether values should be applied to the controller.
-    pub update_values: bool,
     /// The networking class identifier to attach to the packets.
     ///
     /// This can then later be used in iptables and such to have special rules.
-    pub class_id: u64,
+    pub class_id: Option<u64>,
     /// Priority of the egress traffic for each interface.
     pub priorities: Vec<NetworkPriority>,
 }
 
 /// 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,
@@ -452,15 +682,15 @@ 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 {
-    /// Whether values should be applied to the controller.
-    pub update_values: bool,
     /// Set a limit of consumption for each hugepages type.
     pub limits: Vec<HugePageResource>,
 }
 
 /// 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,
@@ -474,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,
@@ -485,9 +716,8 @@ 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 {
-    /// Whether values should be applied to the controller.
-    pub update_values: bool,
     /// The weight of the control group against descendant nodes.
     pub weight: Option<u16>,
     /// The weight of the control group against sibling nodes.
@@ -502,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,
@@ -546,80 +786,66 @@ impl<'a> From<&'a std::process::Child> for CgroupPid {
 impl Subsystem {
     fn enter(self, path: &Path) -> Self {
         match self {
-            Subsystem::Pid(cont) => Subsystem::Pid({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::Pid(mut cont) => Subsystem::Pid({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::Mem(cont) => Subsystem::Mem({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::Mem(mut cont) => Subsystem::Mem({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::CpuSet(cont) => Subsystem::CpuSet({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::CpuSet(mut cont) => Subsystem::CpuSet({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::CpuAcct(cont) => Subsystem::CpuAcct({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::CpuAcct(mut cont) => Subsystem::CpuAcct({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::Cpu(cont) => Subsystem::Cpu({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::Cpu(mut cont) => Subsystem::Cpu({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::Devices(cont) => Subsystem::Devices({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::Devices(mut cont) => Subsystem::Devices({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::Freezer(cont) => Subsystem::Freezer({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::Freezer(mut cont) => Subsystem::Freezer({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::NetCls(cont) => Subsystem::NetCls({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::NetCls(mut cont) => Subsystem::NetCls({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::BlkIo(cont) => Subsystem::BlkIo({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::BlkIo(mut cont) => Subsystem::BlkIo({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::PerfEvent(cont) => Subsystem::PerfEvent({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::PerfEvent(mut cont) => Subsystem::PerfEvent({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::NetPrio(cont) => Subsystem::NetPrio({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::NetPrio(mut cont) => Subsystem::NetPrio({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::HugeTlb(cont) => Subsystem::HugeTlb({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::HugeTlb(mut cont) => Subsystem::HugeTlb({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::Rdma(cont) => Subsystem::Rdma({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::Rdma(mut cont) => Subsystem::Rdma({
+                cont.get_path_mut().push(path);
+                cont
             }),
-            Subsystem::Systemd(cont) => Subsystem::Systemd({
-                let mut c = cont.clone();
-                c.get_path_mut().push(path);
-                c
+            Subsystem::Systemd(mut cont) => Subsystem::Systemd({
+                cont.get_path_mut().push(path);
+                cont
             }),
         }
     }
 
-    fn to_controller(&self) -> &dyn Controller {
+    pub fn to_controller(&self) -> &dyn Controller {
         match self {
             Subsystem::Pid(cont) => cont,
             Subsystem::Mem(cont) => cont,
@@ -638,13 +864,14 @@ impl Subsystem {
         }
     }
 
-    fn controller_name(&self) -> String {
+    pub fn controller_name(&self) -> String {
         self.to_controller().control_type().to_string()
     }
 }
 
 /// 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,
@@ -659,22 +886,25 @@ impl Default for MaxValue {
 }
 
 impl MaxValue {
+    #[allow(clippy::should_implement_trait, clippy::wrong_self_convention)]
     fn to_i64(&self) -> i64 {
         match self {
             MaxValue::Max => -1,
             MaxValue::Value(num) => *num,
         }
     }
+}
 
-    fn to_string(&self) -> String {
+impl fmt::Display for MaxValue {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            MaxValue::Max => "max".to_string(),
-            MaxValue::Value(num) => num.to_string(),
+            MaxValue::Max => write!(f, "max"),
+            MaxValue::Value(num) => write!(f, "{}", num),
         }
     }
 }
 
-pub fn parse_max_value(s: &String) -> Result<MaxValue> {
+pub fn parse_max_value(s: &str) -> Result<MaxValue> {
     if s.trim() == "max" {
         return Ok(MaxValue::Max);
     }
@@ -690,17 +920,14 @@ pub fn parse_max_value(s: &String) -> 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() {
         let parts: Vec<&str> = line.split(' ').collect();
         if parts.len() == 2 {
-            match parts[1].parse::<i64>() {
-                Ok(i) => {
-                    v.push((parts[0].to_string(), i));
-                }
-                Err(_) => {}
+            if let Ok(i) = parts[1].parse::<i64>() {
+                v.push((parts[0].to_string(), i));
             }
         }
     }
@@ -713,17 +940,14 @@ 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() {
         let parts: Vec<&str> = line.split(' ').collect();
         if parts.len() == 2 {
-            match parts[1].parse::<i64>() {
-                Ok(i) => {
-                    h.insert(parts[0].to_string(), i);
-                }
-                Err(_) => {}
+            if let Ok(i) = parts[1].parse::<i64>() {
+                h.insert(parts[0].to_string(), i);
             }
         }
     }
@@ -736,23 +960,20 @@ 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() {
         let parts: Vec<&str> = line.split(' ').collect();
-        if parts.len() == 0 {
+        if parts.is_empty() {
             continue;
         }
         let mut th = HashMap::new();
-        for item in parts[1..].into_iter() {
+        for item in parts[1..].iter() {
             let fields: Vec<&str> = item.split('=').collect();
             if fields.len() == 2 {
-                match fields[1].parse::<i64>() {
-                    Ok(i) => {
-                        th.insert(fields[0].to_string(), i);
-                    }
-                    Err(_) => {}
+                if let Ok(i) = fields[1].parse::<i64>() {
+                    th.insert(fields[0].to_string(), i);
                 }
             }
         }
@@ -762,21 +983,41 @@ pub fn nested_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, HashMap
     Ok(h)
 }
 
-/// fs::remove_dir_all or fs::remove_dir can't work with cgroup directory sometimes.
-/// with error: `Os { code: 1, kind: PermissionDenied, message: "Operation not permitted" }`
-pub fn libc_rmdir(p: &str) {
-    // with int return value
-    let _ = unsafe { libc::rmdir(p.as_ptr() as *const i8) };
-}
-
-/// read and parse an i64 data
-pub fn read_i64_from(mut file: File) -> Result<i64> {
+fn read_from<T>(mut file: File) -> Result<T>
+where
+    T: FromStr,
+    <T as FromStr>::Err: 'static + Send + Sync + std::error::Error,
+{
     let mut string = String::new();
     match file.read_to_string(&mut string) {
         Ok(_) => string
             .trim()
-            .parse()
+            .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,
+        )),
     }
 }
+
+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("FIXME: can't get path in fn read_string_from".to_string()),
+            e,
+        )),
+    }
+}
+
+/// read and parse an u64 data
+fn read_u64_from(file: File) -> Result<u64> {
+    read_from::<u64>(file)
+}
+
+/// read and parse an i64 data
+fn read_i64_from(file: File) -> Result<i64> {
+    read_from::<i64>(file)
+}

src/memory.rs

@@ -8,21 +8,22 @@
 //!
 //! 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::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 use std::sync::mpsc::Receiver;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 use crate::events;
+use crate::{read_i64_from, read_string_from, read_u64_from};
 
 use crate::flat_keyed_to_hashmap;
 
 use crate::{
-    ControllIdentifier, ControllerInternal, Controllers, MaxValue, MemoryResources, Resources,
-    Subsystem,
+    ControllIdentifier, ControllerInternal, Controllers, CustomizedAttribute, MaxValue,
+    MemoryResources, Resources, Subsystem,
 };
 
 /// A controller that allows controlling the `memory` subsystem of a Cgroup.
@@ -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,
@@ -56,18 +59,38 @@ pub struct OomControl {
     pub oom_kill: u64,
 }
 
+#[allow(clippy::unnecessary_wraps)]
 fn parse_oom_control(s: String) -> Result<OomControl> {
     let spl = s.split_whitespace().collect::<Vec<_>>();
 
+    let oom_kill_disable = if spl.len() > 1 {
+        spl[1].parse::<u64>().unwrap() == 1
+    } else {
+        false
+    };
+
+    let under_oom = if spl.len() > 3 {
+        spl[3].parse::<u64>().unwrap() == 1
+    } else {
+        false
+    };
+
+    let oom_kill = if spl.len() > 5 {
+        spl[5].parse::<u64>().unwrap()
+    } else {
+        0
+    };
+
     Ok(OomControl {
-        oom_kill_disable: spl[1].parse::<u64>().unwrap() == 1,
-        under_oom: spl[3].parse::<u64>().unwrap() == 1,
-        oom_kill: spl[5].parse::<u64>().unwrap(),
+        oom_kill_disable,
+        under_oom,
+        oom_kill,
     })
 }
 
 /// 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,
@@ -104,18 +127,19 @@ pub struct NumaStat {
     pub hierarchical_unevictable_pages_per_node: Vec<u64>,
 }
 
+#[allow(clippy::unnecessary_wraps)]
 fn parse_numa_stat(s: String) -> Result<NumaStat> {
     // Parse the number of nodes
-    let _nodes = (s.split_whitespace().collect::<Vec<_>>().len() - 8) / 8;
+    let _nodes = (s.split_whitespace().count() - 8) / 8;
     let mut ls = s.lines();
     let total_line = ls.next().unwrap();
     let file_line = ls.next().unwrap();
     let anon_line = ls.next().unwrap();
     let unevict_line = ls.next().unwrap();
-    let hier_total_line = ls.next().unwrap();
-    let hier_file_line = ls.next().unwrap();
-    let hier_anon_line = ls.next().unwrap();
-    let hier_unevict_line = ls.next().unwrap();
+    let hier_total_line = ls.next().unwrap_or_default();
+    let hier_file_line = ls.next().unwrap_or_default();
+    let hier_anon_line = ls.next().unwrap_or_default();
+    let hier_unevict_line = ls.next().unwrap_or_default();
 
     Ok(NumaStat {
         total_pages: total_line
@@ -124,10 +148,10 @@ fn parse_numa_stat(s: String) -> Result<NumaStat> {
             .parse::<u64>()
             .unwrap_or(0),
         total_pages_per_node: {
-            let spl = &total_line.split(" ").collect::<Vec<_>>()[1..];
+            let spl = &total_line.split(' ').collect::<Vec<_>>()[1..];
             spl.iter()
                 .map(|x| {
-                    x.split("=").collect::<Vec<_>>()[1]
+                    x.split('=').collect::<Vec<_>>()[1]
                         .parse::<u64>()
                         .unwrap_or(0)
                 })
@@ -139,10 +163,10 @@ fn parse_numa_stat(s: String) -> Result<NumaStat> {
             .parse::<u64>()
             .unwrap_or(0),
         file_pages_per_node: {
-            let spl = &file_line.split(" ").collect::<Vec<_>>()[1..];
+            let spl = &file_line.split(' ').collect::<Vec<_>>()[1..];
             spl.iter()
                 .map(|x| {
-                    x.split("=").collect::<Vec<_>>()[1]
+                    x.split('=').collect::<Vec<_>>()[1]
                         .parse::<u64>()
                         .unwrap_or(0)
                 })
@@ -154,10 +178,10 @@ fn parse_numa_stat(s: String) -> Result<NumaStat> {
             .parse::<u64>()
             .unwrap_or(0),
         anon_pages_per_node: {
-            let spl = &anon_line.split(" ").collect::<Vec<_>>()[1..];
+            let spl = &anon_line.split(' ').collect::<Vec<_>>()[1..];
             spl.iter()
                 .map(|x| {
-                    x.split("=").collect::<Vec<_>>()[1]
+                    x.split('=').collect::<Vec<_>>()[1]
                         .parse::<u64>()
                         .unwrap_or(0)
                 })
@@ -169,79 +193,120 @@ fn parse_numa_stat(s: String) -> Result<NumaStat> {
             .parse::<u64>()
             .unwrap_or(0),
         unevictable_pages_per_node: {
-            let spl = &unevict_line.split(" ").collect::<Vec<_>>()[1..];
+            let spl = &unevict_line.split(' ').collect::<Vec<_>>()[1..];
             spl.iter()
                 .map(|x| {
-                    x.split("=").collect::<Vec<_>>()[1]
+                    x.split('=').collect::<Vec<_>>()[1]
                         .parse::<u64>()
                         .unwrap_or(0)
                 })
                 .collect()
         },
-        hierarchical_total_pages: hier_total_line
-            .split(|x| x == ' ' || x == '=')
-            .collect::<Vec<_>>()[1]
-            .parse::<u64>()
-            .unwrap_or(0),
+        hierarchical_total_pages: {
+            if !hier_total_line.is_empty() {
+                hier_total_line
+                    .split(|x| x == ' ' || x == '=')
+                    .collect::<Vec<_>>()[1]
+                    .parse::<u64>()
+                    .unwrap_or(0)
+            } else {
+                0
+            }
+        },
         hierarchical_total_pages_per_node: {
-            let spl = &hier_total_line.split(" ").collect::<Vec<_>>()[1..];
-            spl.iter()
-                .map(|x| {
-                    x.split("=").collect::<Vec<_>>()[1]
-                        .parse::<u64>()
-                        .unwrap_or(0)
-                })
-                .collect()
+            if !hier_total_line.is_empty() {
+                let spl = &hier_total_line.split(' ').collect::<Vec<_>>()[1..];
+                spl.iter()
+                    .map(|x| {
+                        x.split('=').collect::<Vec<_>>()[1]
+                            .parse::<u64>()
+                            .unwrap_or(0)
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            }
+        },
+        hierarchical_file_pages: {
+            if !hier_file_line.is_empty() {
+                hier_file_line
+                    .split(|x| x == ' ' || x == '=')
+                    .collect::<Vec<_>>()[1]
+                    .parse::<u64>()
+                    .unwrap_or(0)
+            } else {
+                0
+            }
         },
-        hierarchical_file_pages: hier_file_line
-            .split(|x| x == ' ' || x == '=')
-            .collect::<Vec<_>>()[1]
-            .parse::<u64>()
-            .unwrap_or(0),
         hierarchical_file_pages_per_node: {
-            let spl = &hier_file_line.split(" ").collect::<Vec<_>>()[1..];
-            spl.iter()
-                .map(|x| {
-                    x.split("=").collect::<Vec<_>>()[1]
-                        .parse::<u64>()
-                        .unwrap_or(0)
-                })
-                .collect()
+            if !hier_file_line.is_empty() {
+                let spl = &hier_file_line.split(' ').collect::<Vec<_>>()[1..];
+                spl.iter()
+                    .map(|x| {
+                        x.split('=').collect::<Vec<_>>()[1]
+                            .parse::<u64>()
+                            .unwrap_or(0)
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            }
+        },
+        hierarchical_anon_pages: {
+            if !hier_anon_line.is_empty() {
+                hier_anon_line
+                    .split(|x| x == ' ' || x == '=')
+                    .collect::<Vec<_>>()[1]
+                    .parse::<u64>()
+                    .unwrap_or(0)
+            } else {
+                0
+            }
         },
-        hierarchical_anon_pages: hier_anon_line
-            .split(|x| x == ' ' || x == '=')
-            .collect::<Vec<_>>()[1]
-            .parse::<u64>()
-            .unwrap_or(0),
         hierarchical_anon_pages_per_node: {
-            let spl = &hier_anon_line.split(" ").collect::<Vec<_>>()[1..];
-            spl.iter()
-                .map(|x| {
-                    x.split("=").collect::<Vec<_>>()[1]
-                        .parse::<u64>()
-                        .unwrap_or(0)
-                })
-                .collect()
+            if !hier_anon_line.is_empty() {
+                let spl = &hier_anon_line.split(' ').collect::<Vec<_>>()[1..];
+                spl.iter()
+                    .map(|x| {
+                        x.split('=').collect::<Vec<_>>()[1]
+                            .parse::<u64>()
+                            .unwrap_or(0)
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            }
+        },
+        hierarchical_unevictable_pages: {
+            if !hier_unevict_line.is_empty() {
+                hier_unevict_line
+                    .split(|x| x == ' ' || x == '=')
+                    .collect::<Vec<_>>()[1]
+                    .parse::<u64>()
+                    .unwrap_or(0)
+            } else {
+                0
+            }
         },
-        hierarchical_unevictable_pages: hier_unevict_line
-            .split(|x| x == ' ' || x == '=')
-            .collect::<Vec<_>>()[1]
-            .parse::<u64>()
-            .unwrap_or(0),
         hierarchical_unevictable_pages_per_node: {
-            let spl = &hier_unevict_line.split(" ").collect::<Vec<_>>()[1..];
-            spl.iter()
-                .map(|x| {
-                    x.split("=").collect::<Vec<_>>()[1]
-                        .parse::<u64>()
-                        .unwrap_or(0)
-                })
-                .collect()
+            if !hier_unevict_line.is_empty() {
+                let spl = &hier_unevict_line.split(' ').collect::<Vec<_>>()[1..];
+                spl.iter()
+                    .map(|x| {
+                        x.split('=').collect::<Vec<_>>()[1]
+                            .parse::<u64>()
+                            .unwrap_or(0)
+                    })
+                    .collect()
+            } else {
+                Vec::new()
+            }
         },
     })
 }
 
 #[derive(Default, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct MemoryStat {
     pub cache: u64,
     pub rss: u64,
@@ -282,6 +347,7 @@ pub struct MemoryStat {
     pub raw: HashMap<String, u64>,
 }
 
+#[allow(clippy::unnecessary_wraps)]
 fn parse_memory_stat(s: String) -> Result<MemoryStat> {
     let mut raw = HashMap::new();
 
@@ -335,13 +401,14 @@ fn parse_memory_stat(s: String) -> Result<MemoryStat> {
         total_inactive_file: *raw.get("total_inactive_file").unwrap_or(&0),
         total_active_file: *raw.get("total_active_file").unwrap_or(&0),
         total_unevictable: *raw.get("total_unevictable").unwrap_or(&0),
-        raw: raw,
+        raw,
     })
 }
 
 /// 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,
@@ -356,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,
@@ -400,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,
@@ -418,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,
@@ -453,30 +523,28 @@ impl ControllerInternal for MemController {
         // get the resources that apply to this controller
         let memres: &MemoryResources = &res.memory;
 
-        if memres.update_values {
-            let _ = self.set_limit(memres.memory_hard_limit);
-            let _ = self.set_soft_limit(memres.memory_soft_limit);
-            let _ = self.set_kmem_limit(memres.kernel_memory_limit);
-            let _ = self.set_memswap_limit(memres.memory_swap_limit);
-            let _ = self.set_tcp_limit(memres.kernel_tcp_memory_limit);
-            let _ = self.set_swappiness(memres.swappiness);
-        }
+        update!(self, set_limit, memres.memory_hard_limit);
+        update!(self, set_soft_limit, memres.memory_soft_limit);
+        update!(self, set_kmem_limit, memres.kernel_memory_limit);
+        update!(self, set_memswap_limit, memres.memory_swap_limit);
+        update!(self, set_tcp_limit, memres.kernel_tcp_memory_limit);
+        update!(self, set_swappiness, memres.swappiness);
+
+        memres.attrs.iter().for_each(|(k, v)| {
+            let _ = self.set(k, v);
+        });
 
         Ok(())
     }
 }
 
 impl MemController {
-    /// Contructs a new `MemController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf, v2: bool) -> Self {
-        let mut root = oroot;
-        if !v2 {
-            root.push(Self::controller_type().to_string());
-        }
+    /// Contructs a new `MemController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf, v2: bool) -> Self {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 
@@ -491,11 +559,12 @@ impl MemController {
         for value in values {
             let v = value.0;
             let f = value.1;
-            if v.is_some() {
-                let v = v.unwrap().to_string();
+            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)
+                    })
                 })?;
             }
         }
@@ -505,10 +574,11 @@ impl MemController {
     // for v2
     pub fn get_mem(&self) -> Result<SetMemory> {
         let mut m: SetMemory = Default::default();
-        self.get_max_value("memory.high").map(|x| m.high = Some(x));
-        self.get_max_value("memory.low").map(|x| m.low = Some(x));
-        self.get_max_value("memory.max").map(|x| m.max = Some(x));
-        self.get_max_value("memory.min").map(|x| m.min = Some(x));
+        self.get_max_value("memory.high")
+            .map(|x| m.high = Some(x))?;
+        self.get_max_value("memory.low").map(|x| m.low = Some(x))?;
+        self.get_max_value("memory.max").map(|x| m.max = Some(x))?;
+        self.get_max_value("memory.min").map(|x| m.min = Some(x))?;
 
         Ok(m)
     }
@@ -532,7 +602,7 @@ impl MemController {
                 .open_path("memory.stat", false)
                 .and_then(read_string_from)
                 .and_then(parse_memory_stat)
-                .unwrap_or(MemoryStat::default()),
+                .unwrap_or_default(),
             swappiness: self
                 .open_path("memory.swap.current", false)
                 .and_then(read_u64_from)
@@ -576,12 +646,12 @@ impl MemController {
                 .open_path("memory.numa_stat", false)
                 .and_then(read_string_from)
                 .and_then(parse_numa_stat)
-                .unwrap_or(NumaStat::default()),
+                .unwrap_or_default(),
             oom_control: self
                 .open_path("memory.oom_control", false)
                 .and_then(read_string_from)
                 .and_then(parse_oom_control)
-                .unwrap_or(OomControl::default()),
+                .unwrap_or_default(),
             soft_limit_in_bytes: self
                 .open_path("memory.soft_limit_in_bytes", false)
                 .and_then(read_i64_from)
@@ -590,7 +660,7 @@ impl MemController {
                 .open_path("memory.stat", false)
                 .and_then(read_string_from)
                 .and_then(parse_memory_stat)
-                .unwrap_or(MemoryStat::default()),
+                .unwrap_or_default(),
             swappiness: self
                 .open_path("memory.swappiness", false)
                 .and_then(read_u64_from)
@@ -624,7 +694,7 @@ impl MemController {
             slabinfo: self
                 .open_path("memory.kmem.slabinfo", false)
                 .and_then(read_string_from)
-                .unwrap_or("".to_string()),
+                .unwrap_or_default(),
         }
     }
 
@@ -656,7 +726,7 @@ impl MemController {
             fail_cnt: self
                 .open_path("memory.swap.events", false)
                 .and_then(flat_keyed_to_hashmap)
-                .and_then(|x| Ok(*x.get("fail").unwrap_or(&0) as u64))
+                .map(|x| *x.get("fail").unwrap_or(&0) as u64)
                 .unwrap(),
             limit_in_bytes: self
                 .open_path("memory.swap.max", false)
@@ -700,26 +770,48 @@ 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,
+                )
+            })
         })
     }
 
     /// Reset the kernel memory fail counter
     pub fn reset_kmem_fail_count(&self) -> Result<()> {
+        // Ignore kmem because there is no kmem in cgroup v2
+        if self.v2 {
+            return Ok(());
+        }
+
         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,
+                    )
+                })
             })
     }
 
     /// Reset the TCP related fail counter
     pub fn reset_tcp_fail_count(&self) -> Result<()> {
+        // Ignore kmem because there is no kmem in cgroup v2
+        if self.v2 {
+            return Ok(());
+        }
+
         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,
+                    )
+                })
             })
     }
 
@@ -727,50 +819,96 @@ 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,
+                    )
+                })
+            })
+    }
+
+    /// Reset the max memory usage recorded
+    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("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";
         if self.v2 {
-            file = "memory.max";
+            file_name = "memory.max";
         }
-        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)
+            })
         })
     }
 
     /// Set the kernel memory limit of the control group, in bytes.
     pub fn set_kmem_limit(&self, limit: i64) -> Result<()> {
+        // Ignore kmem because there is no kmem in cgroup v2
+        if self.v2 {
+            return Ok(());
+        }
+
         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";
         if self.v2 {
-            file = "memory.swap.max";
+            file_name = "memory.swap.max";
         }
-        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)
+            })
         })
     }
 
     /// Set how much kernel memory can be used for TCP-related buffers by the control group.
     pub fn set_tcp_limit(&self, limit: i64) -> Result<()> {
+        // Ignore kmem because there is no kmem in cgroup v2
+        if self.v2 {
+            return Ok(());
+        }
+
         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,
+                    )
+                })
             })
     }
 
@@ -779,13 +917,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)
+            })
         })
     }
 
@@ -794,18 +933,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<()> {
-        self.open_path("memory.swappiness", true)
-            .and_then(|mut file| {
-                file.write_all(swp.to_string().as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+        let mut file_name = "memory.swappiness";
+        if self.v2 {
+            file_name = "memory.swap.max"
+        }
+
+        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,
+                    )
+                })
             })
     }
 
@@ -824,6 +972,8 @@ impl ControllIdentifier for MemController {
     }
 }
 
+impl CustomizedAttribute for MemController {}
+
 impl<'a> From<&'a Subsystem> for &'a MemController {
     fn from(sub: &'a Subsystem) -> &'a MemController {
         unsafe {
@@ -831,49 +981,19 @@ impl<'a> From<&'a Subsystem> for &'a MemController {
                 Subsystem::Mem(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
-fn read_i64_from(mut file: File) -> Result<i64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
-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)),
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::memory::{
         parse_memory_stat, parse_numa_stat, parse_oom_control, MemoryStat, NumaStat, OomControl,
     };
-    use std::collections::HashMap;
 
     static GOOD_VALUE: &str = "\
 total=51189 N0=51189 N1=123
@@ -886,7 +1006,24 @@ hierarchical_anon=770402 N0=770402 N1=123
 hierarchical_unevictable=20 N0=20 N1=123
 ";
 
-    static GOOD_OOMCONTROL_VAL: &str = "\
+    static GOOD_VALUE_NON_HIERARCHICAL: &str = "\
+total=51189 N0=51189 N1=123
+file=50175 N0=50175 N1=123
+anon=1014 N0=1014 N1=123
+unevictable=0 N0=0 N1=123
+";
+
+    static GOOD_OOMCONTROL_VAL_1: &str = "\
+oom_kill_disable 0
+oom_kill 1337
+";
+
+    static GOOD_OOMCONTROL_VAL_2: &str = "\
+oom_kill_disable 0
+under_oom 1
+";
+
+    static GOOD_OOMCONTROL_VAL_3: &str = "\
 oom_kill_disable 0
 under_oom 1
 oom_kill 1337
@@ -956,11 +1093,61 @@ total_unevictable 81920
                 hierarchical_unevictable_pages_per_node: vec![20, 123],
             }
         );
+        let ok = parse_numa_stat(GOOD_VALUE_NON_HIERARCHICAL.to_string()).unwrap();
+        assert_eq!(
+            ok,
+            NumaStat {
+                total_pages: 51189,
+                total_pages_per_node: vec![51189, 123],
+                file_pages: 50175,
+                file_pages_per_node: vec![50175, 123],
+                anon_pages: 1014,
+                anon_pages_per_node: vec![1014, 123],
+                unevictable_pages: 0,
+                unevictable_pages_per_node: vec![0, 123],
+
+                hierarchical_total_pages: 0,
+                hierarchical_total_pages_per_node: vec![],
+                hierarchical_file_pages: 0,
+                hierarchical_file_pages_per_node: vec![],
+                hierarchical_anon_pages: 0,
+                hierarchical_anon_pages_per_node: vec![],
+                hierarchical_unevictable_pages: 0,
+                hierarchical_unevictable_pages_per_node: vec![],
+            }
+        );
     }
 
     #[test]
     fn test_parse_oom_control() {
-        let ok = parse_oom_control(GOOD_OOMCONTROL_VAL.to_string()).unwrap();
+        let ok = parse_oom_control("".to_string()).unwrap();
+        assert_eq!(
+            ok,
+            OomControl {
+                oom_kill_disable: false,
+                under_oom: false,
+                oom_kill: 0,
+            }
+        );
+        let ok = parse_oom_control(GOOD_OOMCONTROL_VAL_1.to_string()).unwrap();
+        assert_eq!(
+            ok,
+            OomControl {
+                oom_kill_disable: false,
+                under_oom: false,
+                oom_kill: 0,
+            }
+        );
+        let ok = parse_oom_control(GOOD_OOMCONTROL_VAL_2.to_string()).unwrap();
+        assert_eq!(
+            ok,
+            OomControl {
+                oom_kill_disable: false,
+                under_oom: true,
+                oom_kill: 0,
+            }
+        );
+        let ok = parse_oom_control(GOOD_OOMCONTROL_VAL_3.to_string()).unwrap();
         assert_eq!(
             ok,
             OomControl {
@@ -1014,7 +1201,7 @@ total_unevictable 81920
                 total_inactive_file: 1272135680,
                 total_active_file: 2338816000,
                 total_unevictable: 81920,
-                raw: raw,
+                raw,
             }
         );
     }

src/net_cls.rs

@@ -7,13 +7,13 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/net_cls.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/net_cls.txt)
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::read_u64_from;
 use crate::{
     ControllIdentifier, ControllerInternal, Controllers, NetworkResources, Resources, Subsystem,
 };
@@ -47,13 +47,9 @@ impl ControllerInternal for NetClsController {
         // get the resources that apply to this controller
         let res: &NetworkResources = &res.network;
 
-        if res.update_values {
-            let _ = self.set_class(res.class_id);
-            if self.get_class()? != res.class_id {
-                return Err(Error::new(Other));
-            }
-        }
-        return Ok(());
+        update_and_test!(self, set_class, res.class_id, get_class);
+
+        Ok(())
     }
 }
 
@@ -70,29 +66,17 @@ impl<'a> From<&'a Subsystem> for &'a NetClsController {
                 Subsystem::NetCls(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl NetClsController {
-    /// Constructs a new `NetClsController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf) -> Self {
-        let mut root = oroot;
-        root.push(Self::controller_type().to_string());
+    /// Constructs a new `NetClsController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf) -> Self {
         Self {
             base: root.clone(),
             path: root,
@@ -104,14 +88,15 @@ 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)
+                })
             })
     }
 
     /// Get the network class id of the outgoing packets of the control group's tasks.
     pub fn get_class(&self) -> Result<u64> {
         self.open_path("net_cls.classid", false)
-            .and_then(|file| read_u64_from(file))
+            .and_then(read_u64_from)
     }
 }

src/net_prio.rs

@@ -8,13 +8,13 @@
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/net_prio.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/net_prio.txt)
 use std::collections::HashMap;
-use std::fs::File;
-use std::io::{BufRead, BufReader, Read, Write};
+use std::io::{BufRead, BufReader, Write};
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::read_u64_from;
 use crate::{
     ControllIdentifier, ControllerInternal, Controllers, NetworkResources, Resources, Subsystem,
 };
@@ -48,10 +48,8 @@ impl ControllerInternal for NetPrioController {
         // get the resources that apply to this controller
         let res: &NetworkResources = &res.network;
 
-        if res.update_values {
-            for i in &res.priorities {
-                let _ = self.set_if_prio(&i.name, i.priority);
-            }
+        for i in &res.priorities {
+            let _ = self.set_if_prio(&i.name, i.priority);
         }
 
         Ok(())
@@ -71,29 +69,17 @@ impl<'a> From<&'a Subsystem> for &'a NetPrioController {
                 Subsystem::NetPrio(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl NetPrioController {
-    /// Constructs a new `NetPrioController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf) -> Self {
-        let mut root = oroot;
-        root.push(Self::controller_type().to_string());
+    /// Constructs a new `NetPrioController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf) -> Self {
         Self {
             base: root.clone(),
             path: root,
@@ -108,6 +94,7 @@ impl NetPrioController {
     }
 
     /// A map of priorities for each network interface.
+    #[allow(clippy::iter_nth_zero, clippy::unnecessary_unwrap)]
     pub fn ifpriomap(&self) -> Result<HashMap<String, u64>> {
         self.open_path("net_prio.ifpriomap", false)
             .and_then(|file| {
@@ -119,6 +106,7 @@ impl NetPrioController {
                         let mut acc = acc.unwrap();
                         let l = line.unwrap();
                         let mut sp = l.split_whitespace();
+
                         let ifname = sp.nth(0);
                         let ifprio = sp.nth(1);
                         if ifname.is_none() || ifprio.is_none() {
@@ -144,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/perf_event.rs

@@ -55,7 +55,8 @@ impl<'a> From<&'a Subsystem> for &'a PerfEventController {
                 Subsystem::PerfEvent(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
@@ -63,10 +64,8 @@ impl<'a> From<&'a Subsystem> for &'a PerfEventController {
 }
 
 impl PerfEventController {
-    /// Constructs a new `PerfEventController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf) -> Self {
-        let mut root = oroot;
-        root.push(Self::controller_type().to_string());
+    /// Constructs a new `PerfEventController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf) -> Self {
         Self {
             base: root.clone(),
             path: root,

src/pid.rs

@@ -8,13 +8,13 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroups-v1/pids.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/pids.txt)
-use std::fs::File;
 use std::io::{Read, Write};
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::read_u64_from;
 use crate::{
     parse_max_value, ControllIdentifier, ControllerInternal, Controllers, MaxValue, PidResources,
     Resources, Subsystem,
@@ -50,17 +50,13 @@ impl ControllerInternal for PidController {
         // get the resources that apply to this controller
         let pidres: &PidResources = &res.pid;
 
-        if pidres.update_values {
-            // apply pid_max
-            let _ = self.set_pid_max(pidres.maximum_number_of_processes);
-
-            // now, verify
-            if self.get_pid_max()? == pidres.maximum_number_of_processes {
-                return Ok(());
-            } else {
-                return Err(Error::new(Other));
-            }
-        }
+        // apply pid_max
+        update_and_test!(
+            self,
+            set_pid_max,
+            pidres.maximum_number_of_processes,
+            get_pid_max
+        );
 
         Ok(())
     }
@@ -85,36 +81,22 @@ impl<'a> From<&'a Subsystem> for &'a PidController {
                 Subsystem::Pid(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-fn read_u64_from(mut file: File) -> Result<u64> {
-    let mut string = String::new();
-    match file.read_to_string(&mut string) {
-        Ok(_) => string
-            .trim()
-            .parse()
-            .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
-    }
-}
-
 impl PidController {
-    /// Constructors a new `PidController` instance, with `oroot` serving as the controller's root
+    /// Constructors a new `PidController` instance, with `root` serving as the controller's root
     /// directory.
-    pub fn new(oroot: PathBuf, v2: bool) -> Self {
-        let mut root = oroot;
-        if !v2 {
-            root.push(Self::controller_type().to_string());
-        }
+    pub fn new(root: PathBuf, v2: bool) -> Self {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 
@@ -130,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)),
             }
         })
     }
@@ -148,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)),
             }
         })
     }
@@ -163,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

@@ -7,13 +7,13 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/rdma.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/rdma.txt)
-use std::fs::File;
-use std::io::{Read, Write};
+use std::io::Write;
 use std::path::PathBuf;
 
 use crate::error::ErrorKind::*;
 use crate::error::*;
 
+use crate::read_string_from;
 use crate::{ControllIdentifier, ControllerInternal, Controllers, Resources, Subsystem};
 
 /// A controller that allows controlling the `rdma` subsystem of a Cgroup.
@@ -58,26 +58,17 @@ impl<'a> From<&'a Subsystem> for &'a RdmaController {
                 Subsystem::Rdma(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
     }
 }
 
-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)),
-    }
-}
-
 impl RdmaController {
-    /// Constructs a new `RdmaController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf) -> Self {
-        let mut root = oroot;
-        root.push(Self::controller_type().to_string());
+    /// Constructs a new `RdmaController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf) -> Self {
         Self {
             base: root.clone(),
             path: root,
@@ -93,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

@@ -7,7 +7,6 @@
 //!
 use std::path::PathBuf;
 
-use crate::error::ErrorKind::*;
 use crate::error::*;
 
 use crate::{ControllIdentifier, ControllerInternal, Controllers, Resources, Subsystem};
@@ -18,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 {
@@ -53,7 +52,8 @@ impl<'a> From<&'a Subsystem> for &'a SystemdController {
                 Subsystem::Systemd(c) => c,
                 _ => {
                     assert_eq!(1, 0);
-                    ::std::mem::uninitialized()
+                    let v = std::mem::MaybeUninit::uninit();
+                    v.assume_init()
                 }
             }
         }
@@ -61,16 +61,12 @@ impl<'a> From<&'a Subsystem> for &'a SystemdController {
 }
 
 impl SystemdController {
-    /// Constructs a new `SystemdController` with `oroot` serving as the root of the control group.
-    pub fn new(oroot: PathBuf, v2: bool) -> Self {
-        let mut root = oroot;
-        if !v2 {
-            root.push(Self::controller_type().to_string());
-        }
+    /// Constructs a new `SystemdController` with `root` serving as the root of the control group.
+    pub fn new(root: PathBuf, v2: bool) -> Self {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            _v2: v2,
         }
     }
 }

tests/builder.rs

@@ -5,25 +5,25 @@
 //
 
 //! Some simple tests covering the builder pattern for control groups.
-use cgroups::blkio::*;
-use cgroups::cgroup_builder::*;
-use cgroups::cpu::*;
-use cgroups::devices::*;
-use cgroups::hugetlb::*;
-use cgroups::memory::*;
-use cgroups::net_cls::*;
-use cgroups::pid::*;
-use cgroups::*;
+use cgroups_rs::blkio::*;
+use cgroups_rs::cgroup_builder::*;
+use cgroups_rs::cpu::*;
+use cgroups_rs::devices::*;
+use cgroups_rs::hugetlb::*;
+use cgroups_rs::memory::*;
+use cgroups_rs::net_cls::*;
+use cgroups_rs::pid::*;
+use cgroups_rs::*;
 
 #[test]
 pub fn test_cpu_res_build() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg: Cgroup = CgroupBuilder::new("test_cpu_res_build", h)
+    let h = cgroups_rs::hierarchies::auto();
+    let cg: Cgroup = CgroupBuilder::new("test_cpu_res_build")
         .cpu()
         .shares(85)
         .done()
-        .build();
+        .build(h)
+        .unwrap();
 
     {
         let cpu: &CpuController = cg.controller_of().unwrap();
@@ -31,42 +31,43 @@ pub fn test_cpu_res_build() {
         assert_eq!(cpu.shares().unwrap(), 85);
     }
 
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 pub fn test_memory_res_build() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg: Cgroup = CgroupBuilder::new("test_memory_res_build", h)
+    let h = cgroups_rs::hierarchies::auto();
+    let cg: Cgroup = CgroupBuilder::new("test_memory_res_build")
         .memory()
         .kernel_memory_limit(128 * 1024 * 1024)
         .swappiness(70)
         .memory_hard_limit(1024 * 1024 * 1024)
         .done()
-        .build();
+        .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);
     }
 
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 pub fn test_pid_res_build() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg: Cgroup = CgroupBuilder::new("test_pid_res_build", h)
+    let h = cgroups_rs::hierarchies::auto();
+    let cg: Cgroup = CgroupBuilder::new("test_pid_res_build")
         .pid()
         .maximum_number_of_processes(MaxValue::Value(123))
         .done()
-        .build();
+        .build(h)
+        .unwrap();
 
     {
         let c: &PidController = cg.controller_of().unwrap();
@@ -74,19 +75,19 @@ pub fn test_pid_res_build() {
         assert_eq!(c.get_pid_max().unwrap(), MaxValue::Value(123));
     }
 
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 #[ignore] // ignore this test for now, not sure why my kernel doesn't like it
 pub fn test_devices_res_build() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg: Cgroup = CgroupBuilder::new("test_devices_res_build", h)
+    let h = cgroups_rs::hierarchies::auto();
+    let cg: Cgroup = CgroupBuilder::new("test_devices_res_build")
         .devices()
         .device(1, 6, DeviceType::Char, true, vec![DevicePermissions::Read])
         .done()
-        .build();
+        .build(h)
+        .unwrap();
 
     {
         let c: &DevicesController = cg.controller_of().unwrap();
@@ -102,70 +103,67 @@ pub fn test_devices_res_build() {
             }]
         );
     }
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 pub fn test_network_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     if h.v2() {
         // FIXME add cases for v2
         return;
     }
-    let h = Box::new(&*h);
-    let cg: Cgroup = CgroupBuilder::new("test_network_res_build", h)
+    let cg: Cgroup = CgroupBuilder::new("test_network_res_build")
         .network()
         .class_id(1337)
         .done()
-        .build();
+        .build(h)
+        .unwrap();
 
     {
         let c: &NetClsController = cg.controller_of().unwrap();
         assert!(c.get_class().is_ok());
         assert_eq!(c.get_class().unwrap(), 1337);
     }
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 pub fn test_hugepages_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     if h.v2() {
         // FIXME add cases for v2
         return;
     }
-    let h = Box::new(&*h);
-    let cg: Cgroup = CgroupBuilder::new("test_hugepages_res_build", h)
+    let cg: Cgroup = CgroupBuilder::new("test_hugepages_res_build")
         .hugepages()
         .limit("2MB".to_string(), 4 * 2 * 1024 * 1024)
         .done()
-        .build();
+        .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();
+    cg.delete().unwrap();
 }
 
 #[test]
 #[ignore] // high version kernel not support `blkio.weight`
 pub fn test_blkio_res_build() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg: Cgroup = CgroupBuilder::new("test_blkio_res_build", h)
+    let h = cgroups_rs::hierarchies::auto();
+    let cg: Cgroup = CgroupBuilder::new("test_blkio_res_build")
         .blkio()
-        .weight(Some(100))
+        .weight(100)
         .done()
-        .build();
+        .build(h)
+        .unwrap();
 
     {
         let c: &BlkIoController = cg.controller_of().unwrap();
         assert_eq!(c.blkio().weight, 100);
     }
-    cg.delete();
+    cg.delete().unwrap();
 }

tests/cgroup.rs

@@ -5,56 +5,93 @@
 //
 
 //! Simple unit tests about the control groups system.
-use cgroups::memory::{MemController, SetMemory};
-use cgroups::Controller;
-use cgroups::{Cgroup, CgroupPid, Hierarchy, Subsystem};
-use std::collections::HashMap;
+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() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
+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(CgroupPid::from(pid)).unwrap();
+        cg.add_task_by_tgid(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
-        assert_eq!(tasks.next(), Some(CgroupPid::from(pid)));
-        assert_eq!(tasks.next(), None);
+        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(CgroupPid::from(pid));
-        tasks = cg.tasks().into_iter();
+        cg.remove_task_by_tgid(CgroupPid::from(pid)).unwrap();
+        procs = cg.procs().into_iter();
 
         // Verify that it was indeed removed.
-        assert_eq!(tasks.next(), None);
+        assert_eq!(procs.next(), None);
     }
-    cg.delete();
+    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_none());
+    }
+    cg.delete().unwrap();
 }
 
 #[test]
 fn test_cgroup_with_relative_paths() {
-    if cgroups::hierarchies::is_cgroup2_unified_mode() {
+    if cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
         return;
     }
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cgroup_root = h.root();
-    let h = Box::new(&*h);
-    let mut relative_paths = HashMap::new();
-    let mem_relative_path = "/mmm/abc/def";
-    relative_paths.insert("memory".to_string(), mem_relative_path.to_string());
     let cgroup_name = "test_cgroup_with_relative_paths";
 
-    let cg = Cgroup::new_with_relative_paths(h, String::from(cgroup_name), relative_paths);
+    let cg = Cgroup::load(h, String::from(cgroup_name));
     {
         let subsystems = cg.subsystems();
-        subsystems.into_iter().for_each(|sub| match sub {
+        subsystems.iter().for_each(|sub| match sub {
             Subsystem::Pid(c) => {
                 let cgroup_path = c.path().to_str().unwrap();
                 let relative_path = "/pids/";
@@ -74,35 +111,29 @@ fn test_cgroup_with_relative_paths() {
                 // cgroup_path = cgroup_root + relative_path + cgroup_name
                 assert_eq!(
                     cgroup_path,
-                    format!(
-                        "{}/memory{}/{}",
-                        cgroup_root.to_str().unwrap(),
-                        mem_relative_path,
-                        cgroup_name
-                    )
+                    format!("{}/memory/{}", cgroup_root.to_str().unwrap(), cgroup_name)
                 );
             }
             _ => {}
         });
     }
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 fn test_cgroup_v2() {
-    if !cgroups::hierarchies::is_cgroup2_unified_mode() {
+    if !cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
         return;
     }
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new_with_relative_paths(h, String::from("test_v2"), HashMap::new());
+    let h = cgroups_rs::hierarchies::auto();
+    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);
 
-    let _ = mem_controller.set_limit(mem);
-    let _ = mem_controller.set_memswap_limit(swp);
-    let _ = mem_controller.set_soft_limit(rev);
+    mem_controller.set_limit(mem).unwrap();
+    mem_controller.set_memswap_limit(swp).unwrap();
+    mem_controller.set_soft_limit(rev).unwrap();
 
     let memory_stat = mem_controller.memory_stat();
     println!("memory_stat {:?}", memory_stat);
@@ -113,5 +144,59 @@ fn test_cgroup_v2() {
     println!("memswap {:?}", memswap);
     assert_eq!(swp, memswap.limit_in_bytes);
 
-    cg.delete();
+    cg.delete().unwrap();
+}
+
+#[test]
+fn test_tasks_iterator_cgroup_threaded_mode() {
+    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_threaded_mode")).unwrap();
+    let h = cgroups_rs::hierarchies::auto();
+    let specified_controllers = vec![String::from("cpuset"), String::from("cpu")];
+    let cg_threaded = Cgroup::new_with_specified_controllers(
+        h,
+        String::from("test_tasks_iterator_cgroup_threaded_mode/threaded"),
+        Some(specified_controllers),
+    )
+    .unwrap();
+    cg_threaded.set_cgroup_type("threaded").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);
+
+        // Add a task to the sub control group.
+        cg_threaded.add_task(CgroupPid::from(pid)).unwrap();
+
+        let mut tasks = cg_threaded.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
+            .move_task_to_parent(CgroupPid::from(pid))
+            .unwrap();
+        tasks = cg_threaded.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.delete().unwrap();
+    cg.delete().unwrap();
 }

tests/cpu.rs

@@ -4,17 +4,13 @@
 //
 
 //! Simple unit tests about the CPU control groups system.
-use cgroups::cpu::CpuController;
-use cgroups::error::ErrorKind;
-use cgroups::{Cgroup, CgroupPid, CpuResources, Hierarchy, Resources};
-
-use std::fs;
+use cgroups_rs::cpu::CpuController;
+use cgroups_rs::Cgroup;
 
 #[test]
 fn test_cfs_quota_and_periods() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("test_cfs_quota_and_periods"));
+    let h = cgroups_rs::hierarchies::auto();
+    let cg = Cgroup::new(h, String::from("test_cfs_quota_and_periods")).unwrap();
 
     let cpu_controller: &CpuController = cg.controller_of().unwrap();
 
@@ -27,7 +23,7 @@ fn test_cfs_quota_and_periods() {
     assert_eq!(100000, current_peroid);
 
     // case 1 set quota
-    let r = cpu_controller.set_cfs_quota(2000);
+    let _ = cpu_controller.set_cfs_quota(2000);
 
     let current_quota = cpu_controller.cfs_quota().unwrap();
     let current_peroid = cpu_controller.cfs_period().unwrap();
@@ -35,14 +31,16 @@ fn test_cfs_quota_and_periods() {
     assert_eq!(100000, current_peroid);
 
     // case 2 set period
-    cpu_controller.set_cfs_period(1000000);
+    cpu_controller.set_cfs_period(1000000).unwrap();
     let current_quota = cpu_controller.cfs_quota().unwrap();
     let current_peroid = cpu_controller.cfs_period().unwrap();
     assert_eq!(2000, current_quota);
     assert_eq!(1000000, current_peroid);
 
     // case 3 set both quota and period
-    cpu_controller.set_cfs_quota_and_period(Some(5000), Some(100000));
+    cpu_controller
+        .set_cfs_quota_and_period(Some(5000), Some(100000))
+        .unwrap();
 
     let current_quota = cpu_controller.cfs_quota().unwrap();
     let current_peroid = cpu_controller.cfs_period().unwrap();
@@ -50,12 +48,14 @@ fn test_cfs_quota_and_periods() {
     assert_eq!(100000, current_peroid);
 
     // case 4 set both quota and period, set quota to -1
-    cpu_controller.set_cfs_quota_and_period(Some(-1), None);
+    cpu_controller
+        .set_cfs_quota_and_period(Some(-1), None)
+        .unwrap();
 
     let current_quota = cpu_controller.cfs_quota().unwrap();
     let current_peroid = cpu_controller.cfs_period().unwrap();
     assert_eq!(-1, current_quota);
     assert_eq!(100000, current_peroid);
 
-    cg.delete();
+    cg.delete().unwrap();
 }

tests/cpuset.rs

@@ -4,17 +4,16 @@
 // SPDX-License-Identifier: Apache-2.0 or MIT
 //
 
-use cgroups::cpuset::CpuSetController;
-use cgroups::error::ErrorKind;
-use cgroups::{Cgroup, CgroupPid, CpuResources, Hierarchy, Resources};
+use cgroups_rs::cpuset::CpuSetController;
+use cgroups_rs::error::ErrorKind;
+use cgroups_rs::{Cgroup, CgroupPid};
 
 use std::fs;
 
 #[test]
 fn test_cpuset_memory_pressure_root_cg() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("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")).unwrap();
     {
         let cpuset: &CpuSetController = cg.controller_of().unwrap();
 
@@ -22,14 +21,13 @@ fn test_cpuset_memory_pressure_root_cg() {
         let res = cpuset.set_enable_memory_pressure(true);
         assert_eq!(res.unwrap_err().kind(), &ErrorKind::InvalidOperation);
     }
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 fn test_cpuset_set_cpus() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus"));
+    let h = cgroups_rs::hierarchies::auto();
+    let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus")).unwrap();
     {
         let cpuset: &CpuSetController = cg.controller_of().unwrap();
 
@@ -38,37 +36,35 @@ fn test_cpuset_set_cpus() {
             assert_eq!(0, set.cpus.len());
         } else {
             // for cgroup v1, cpuset is copied from parent.
-            assert_eq!(true, set.cpus.len() > 0);
+            assert!(!set.cpus.is_empty());
         }
 
         // 0
         let r = cpuset.set_cpus("0");
-        assert_eq!(true, r.is_ok());
+        assert!(r.is_ok());
 
         let set = cpuset.cpuset();
         assert_eq!(1, set.cpus.len());
         assert_eq!((0, 0), set.cpus[0]);
 
         // all cpus in system
-        let cpus =
-            fs::read_to_string("/sys/fs/cgroup/cpuset.cpus.effective").unwrap_or("".to_string());
+        let cpus = fs::read_to_string("/sys/fs/cgroup/cpuset.cpus.effective").unwrap_or_default();
         let cpus = cpus.trim();
-        if cpus != "" {
-            let r = cpuset.set_cpus(&cpus);
-            assert_eq!(true, r.is_ok());
+        if !cpus.is_empty() {
+            let r = cpuset.set_cpus(cpus);
+            assert!(r.is_ok());
             let set = cpuset.cpuset();
             assert_eq!(1, set.cpus.len());
             assert_eq!(format!("{}-{}", set.cpus[0].0, set.cpus[0].1), cpus);
         }
     }
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 fn test_cpuset_set_cpus_add_task() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus_add_task/sub-dir"));
+    let h = cgroups_rs::hierarchies::auto();
+    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();
@@ -76,21 +72,21 @@ fn test_cpuset_set_cpus_add_task() {
         assert_eq!(0, set.cpus.len());
     } else {
         // for cgroup v1, cpuset is copied from parent.
-        assert_eq!(true, set.cpus.len() > 0);
+        assert!(!set.cpus.is_empty());
     }
 
     // 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_eq!(true, tasks.len() > 0);
+    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());
 
-    cg.delete();
+    cg.delete().unwrap();
 }

tests/devices.rs

@@ -6,33 +6,34 @@
 
 //! Integration tests about the devices subsystem
 
-use cgroups::devices::{DevicePermissions, DeviceType, DevicesController};
-use cgroups::{Cgroup, DeviceResource, Hierarchy};
+use cgroups_rs::devices::{DevicePermissions, DeviceType, DevicesController};
+use cgroups_rs::{Cgroup, DeviceResource};
 
 #[test]
 fn test_devices_parsing() {
     // now only v2
-    if cgroups::hierarchies::is_cgroup2_unified_mode() {
+    if cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
         return;
     }
 
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("test_devices_parsing"));
+    let h = cgroups_rs::hierarchies::auto();
+    let cg = Cgroup::new(h, String::from("test_devices_parsing")).unwrap();
     {
         let devices: &DevicesController = cg.controller_of().unwrap();
 
         // Deny access to all devices first
-        devices.deny_device(
-            DeviceType::All,
-            -1,
-            -1,
-            &vec![
-                DevicePermissions::Read,
-                DevicePermissions::Write,
-                DevicePermissions::MkNod,
-            ],
-        );
+        devices
+            .deny_device(
+                DeviceType::All,
+                -1,
+                -1,
+                &[
+                    DevicePermissions::Read,
+                    DevicePermissions::Write,
+                    DevicePermissions::MkNod,
+                ],
+            )
+            .unwrap();
         // Acquire the list of allowed devices after we denied all
         let allowed_devices = devices.allowed_devices();
         // Verify that there are no devices that we can access.
@@ -40,7 +41,9 @@ fn test_devices_parsing() {
         assert_eq!(allowed_devices.unwrap(), Vec::new());
 
         // Now add mknod access to /dev/null device
-        devices.allow_device(DeviceType::Char, 1, 3, &vec![DevicePermissions::MkNod]);
+        devices
+            .allow_device(DeviceType::Char, 1, 3, &[DevicePermissions::MkNod])
+            .unwrap();
         let allowed_devices = devices.allowed_devices();
         assert!(allowed_devices.is_ok());
         let allowed_devices = allowed_devices.unwrap();
@@ -57,12 +60,14 @@ fn test_devices_parsing() {
         );
 
         // Now deny, this device explicitly.
-        devices.deny_device(DeviceType::Char, 1, 3, &DevicePermissions::all());
+        devices
+            .deny_device(DeviceType::Char, 1, 3, &DevicePermissions::all())
+            .unwrap();
         // Finally, check that.
         let allowed_devices = devices.allowed_devices();
         // Verify that there are no devices that we can access.
         assert!(allowed_devices.is_ok());
         assert_eq!(allowed_devices.unwrap(), Vec::new());
     }
-    cg.delete();
+    cg.delete().unwrap();
 }

tests/hugetlb.rs

@@ -4,27 +4,23 @@
 //
 
 //! Integration tests about the hugetlb subsystem
-use cgroups::hugetlb::{self, HugeTlbController};
-use cgroups::Controller;
-use cgroups::{Cgroup, Hierarchy};
-
-use cgroups::error::ErrorKind::*;
-use cgroups::error::*;
+use cgroups_rs::error::*;
+use cgroups_rs::hugetlb::{self, HugeTlbController};
+use cgroups_rs::Cgroup;
 use std::fs;
 
 #[test]
 fn test_hugetlb_sizes() {
     // now only v2
-    if cgroups::hierarchies::is_cgroup2_unified_mode() {
+    if cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
         return;
     }
 
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("test_hugetlb_sizes"));
+    let h = cgroups_rs::hierarchies::auto();
+    let cg = Cgroup::new(h, String::from("test_hugetlb_sizes")).unwrap();
     {
         let hugetlb_controller: &HugeTlbController = cg.controller_of().unwrap();
-        let sizes = hugetlb_controller.get_sizes();
+        let _ = hugetlb_controller.get_sizes();
 
         // test sizes count
         let sizes = hugetlb_controller.get_sizes();
@@ -33,16 +29,16 @@ fn test_hugetlb_sizes() {
 
         for size in sizes {
             let supported = hugetlb_controller.size_supported(&size);
-            assert_eq!(supported, true);
+            assert!(supported);
             assert_no_error(hugetlb_controller.failcnt(&size));
             assert_no_error(hugetlb_controller.limit_in_bytes(&size));
             assert_no_error(hugetlb_controller.usage_in_bytes(&size));
             assert_no_error(hugetlb_controller.max_usage_in_bytes(&size));
         }
     }
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 fn assert_no_error(r: Result<u64>) {
-    assert_eq!(!r.is_err(), true)
+    assert!(r.is_ok())
 }

tests/memory.rs

@@ -4,45 +4,58 @@
 //
 
 //! Integration tests about the hugetlb subsystem
-use cgroups::memory::{MemController, SetMemory};
-use cgroups::Controller;
-use cgroups::{Cgroup, MaxValue};
+use cgroups_rs::memory::{MemController, SetMemory};
+use cgroups_rs::Controller;
+use cgroups_rs::{Cgroup, MaxValue};
 
 #[test]
 fn test_disable_oom_killer() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("test_disable_oom_killer"));
+    let h = cgroups_rs::hierarchies::auto();
+    let cg = Cgroup::new(h, String::from("test_disable_oom_killer")).unwrap();
     {
         let mem_controller: &MemController = cg.controller_of().unwrap();
 
         // before disable
         let m = mem_controller.memory_stat();
-        assert_eq!(m.oom_control.oom_kill_disable, false);
+        assert!(!m.oom_control.oom_kill_disable);
 
         // now only v1
         if !mem_controller.v2() {
             // disable oom killer
             let r = mem_controller.disable_oom_killer();
-            assert_eq!(r.is_err(), false);
+            assert!(r.is_ok());
 
             // after disable
             let m = mem_controller.memory_stat();
-            assert_eq!(m.oom_control.oom_kill_disable, true);
+            assert!(m.oom_control.oom_kill_disable);
         }
     }
-    cg.delete();
+    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::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     if !h.v2() {
         return;
     }
 
-    let h = Box::new(&*h);
-    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();
 
@@ -62,7 +75,7 @@ fn set_mem_v2() {
             max: None,
         };
         let r = mem_controller.set_mem(m);
-        assert_eq!(true, r.is_ok());
+        assert!(r.is_ok());
 
         let m = mem_controller.get_mem().unwrap();
         // get
@@ -79,7 +92,7 @@ fn set_mem_v2() {
             low: None,
         };
         let r = mem_controller.set_mem(m);
-        assert_eq!(true, r.is_ok());
+        assert!(r.is_ok());
 
         let m = mem_controller.get_mem().unwrap();
         // get
@@ -89,5 +102,5 @@ fn set_mem_v2() {
         assert_eq!(m.high, Some(MaxValue::Max));
     }
 
-    cg.delete();
+    cg.delete().unwrap();
 }

tests/pids.rs

@@ -5,73 +5,67 @@
 //
 
 //! Integration tests about the pids subsystem
-use cgroups::pid::PidController;
-use cgroups::Controller;
-use cgroups::{Cgroup, CgroupPid, Hierarchy, MaxValue, PidResources, Resources};
+use cgroups_rs::pid::PidController;
+use cgroups_rs::Controller;
+use cgroups_rs::{Cgroup, MaxValue};
 
 use nix::sys::wait::{waitpid, WaitStatus};
-use nix::unistd::{fork, ForkResult, Pid};
+use nix::unistd::{fork, ForkResult};
 
 use libc::pid_t;
 
-use std::thread;
-
 #[test]
 fn create_and_delete_cgroup() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("create_and_delete_cgroup"));
+    let h = cgroups_rs::hierarchies::auto();
+    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));
+        pidcontroller.set_pid_max(MaxValue::Value(1337)).unwrap();
         let max = pidcontroller.get_pid_max();
         assert!(max.is_ok());
         assert_eq!(max.unwrap(), MaxValue::Value(1337));
     }
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 fn test_pids_current_is_zero() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("test_pids_current_is_zero"));
+    let h = cgroups_rs::hierarchies::auto();
+    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();
         assert_eq!(current.unwrap(), 0);
     }
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 fn test_pids_events_is_zero() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("test_pids_events_is_zero"));
+    let h = cgroups_rs::hierarchies::auto();
+    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();
         assert!(events.is_ok());
         assert_eq!(events.unwrap(), 0);
     }
-    cg.delete();
+    cg.delete().unwrap();
 }
 
 #[test]
 fn test_pid_events_is_not_zero() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("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")).unwrap();
     {
         let pids: &PidController = cg.controller_of().unwrap();
         let before = pids.get_pid_events();
         let before = before.unwrap();
 
-        match fork() {
+        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);
 
@@ -95,7 +89,7 @@ fn test_pid_events_is_not_zero() {
             Ok(ForkResult::Child) => loop {
                 let pids_max = pids.get_pid_max();
                 if pids_max.is_ok() && pids_max.unwrap() == MaxValue::Value(1) {
-                    if let Err(_) = fork() {
+                    if unsafe { fork() }.is_err() {
                         unsafe { libc::exit(0) };
                     } else {
                         unsafe { libc::exit(1) };
@@ -105,5 +99,5 @@ fn test_pid_events_is_not_zero() {
             Err(_) => panic!("failed to fork"),
         }
     }
-    cg.delete();
+    cg.delete().unwrap();
 }

tests/resources.rs

@@ -5,29 +5,27 @@
 //
 
 //! Integration test about setting resources using `apply()`
-use cgroups::pid::PidController;
-use cgroups::{Cgroup, Hierarchy, MaxValue, PidResources, Resources};
+use cgroups_rs::pid::PidController;
+use cgroups_rs::{Cgroup, MaxValue, PidResources, Resources};
 
 #[test]
 fn pid_resources() {
-    let h = cgroups::hierarchies::auto();
-    let h = Box::new(&*h);
-    let cg = Cgroup::new(h, String::from("pid_resources"));
+    let h = cgroups_rs::hierarchies::auto();
+    let cg = Cgroup::new(h, String::from("pid_resources")).unwrap();
     {
         let res = Resources {
             pid: PidResources {
-                update_values: true,
-                maximum_number_of_processes: MaxValue::Value(512),
+                maximum_number_of_processes: Some(MaxValue::Value(512)),
             },
             ..Default::default()
         };
-        cg.apply(&res);
+        cg.apply(&res).unwrap();
 
         // verify
         let pidcontroller: &PidController = cg.controller_of().unwrap();
         let pid_max = pidcontroller.get_pid_max();
-        assert_eq!(pid_max.is_ok(), true);
+        assert!(pid_max.is_ok());
         assert_eq!(pid_max.unwrap(), MaxValue::Value(512));
     }
-    cg.delete();
+    cg.delete().unwrap();
 }