Merge pull request #40 from Jakob-Naucke/v0.2.4

release: v0.2.4

.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/bvt.yaml

@@ -0,0 +1,34 @@
+name: BVT
+on: [pull_request]
+jobs:
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Build
+        run: make debug
+
+  fmt:
+    name: Format Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: rustup component add rustfmt
+      - run: make fmt
+  clippy:
+    name: Clippy Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: rustup component add clippy
+      - run: make clippy
+  test:
+    name: Run Unit Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: make test
+
+

.travis.yml

@@ -1,31 +0,0 @@
-# Copyright (c) 2018 Levente Kurusa
-# Copyright (c) 2020 Ant Group
-#
-# SPDX-License-Identifier: Apache-2.0
-#
-
-dist: bionic
-os: linux
-language: rust
-cache: cargo
-
-arch:
-  - amd64
-  - arm64
-
-install:
-  - rustup component add rustfmt
-
-script:
-  - RUSTFLAGS="--deny warnings" cargo build
-  - if [ "$TRAVIS_CPU_ARCH" == "amd64" ]; then cargo test -- --color always --nocapture ; fi
-  - cargo fmt -- --check
-
-rust:
-  - 1.44.1
-  - nightly
-
-jobs:
-  allow_failures:
-    - rust: nightly
-  fast_finish: true

Cargo.toml

@@ -1,20 +1,21 @@
 [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.2.0"
-authors = ["Levente Kurusa <lkurusa@acm.org>", "Sam Wilson <tecywiz121@hotmail.com>"]
+version = "0.2.4"
+authors = ["The Kata Containers community <kata-dev@lists.katacontainers.io>", "Levente Kurusa <lkurusa@acm.org>", "Sam Wilson <tecywiz121@hotmail.com>"]
 edition = "2018"
+homepage = "https://github.com/kata-containers/cgroups-rs"
+readme = "README.md"
 
 [dependencies]
 log = "0.4"
 regex = "1.1"
-nix = "0.18.0"
+nix = "0.20.0"
 libc = "0.2"
-procinfo = "0.4.2"
 
 [dev-dependencies]
 libc = "0.2.76"

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,8 +1,7 @@
-# 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
 
@@ -11,11 +10,11 @@ is planned for the Unified hierarchy.
 ``` rust
 
 
-use cgroups::*;
-use cgroups::cgroup_builder::*;
+use cgroups_rs::*;
+use cgroups_rs::cgroup_builder::*;
 
 // Acquire a handle for the cgroup hierarchy.
-let hier = cgroups::hierarchies::auto();
+let hier = cgroups_rs::hierarchies::auto();
 
 // Use the builder pattern (see the documentation to create the control group)
 //
@@ -30,7 +29,7 @@ let hier = cgroups::hierarchies::auto();
 // other control groups.
 
 // Get a handle to the CPU controller.
-let cpus: &cgroups::cpu::CpuController = cg.controller_of().unwrap();
+let cpus: &cgroups_rs::cpu::CpuController = cg.controller_of().unwrap();
 cpus.add_task(&CgroupPid::from(1234u64));
 
 // [...]

src/blkio.rs

@@ -8,13 +8,13 @@
 //!
 //! 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,
 };
@@ -84,14 +84,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 +131,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 +152,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,9 +194,9 @@ 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)
     }
 }
 
@@ -401,44 +398,25 @@ impl<'a> From<&'a Subsystem> for &'a BlkIoController {
     }
 }
 
-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 `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
@@ -452,222 +430,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(),
         }
     }

src/cgroup.rs

@@ -62,7 +62,7 @@ impl Cgroup {
     /// Create this control group.
     fn create(&self) {
         if self.hier.v2() {
-            let _ret = create_v2_cgroup(self.hier.root().clone(), &self.path);
+            let _ret = create_v2_cgroup(self.hier.root(), &self.path);
         } else {
             for subsystem in &self.subsystems {
                 subsystem.to_controller().create();
@@ -112,13 +112,11 @@ impl Cgroup {
                 .collect::<Vec<_>>();
         }
 
-        let cg = Cgroup {
+        Cgroup {
             path: path.to_str().unwrap().to_string(),
-            subsystems: subsystems,
+            subsystems,
             hier,
-        };
-
-        cg
+        }
     }
 
     /// Create a handle for a control group in the hierarchy `hier`, with name `path` and `relative_paths`
@@ -146,7 +144,7 @@ impl Cgroup {
                     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())
@@ -157,13 +155,11 @@ impl Cgroup {
                 .collect::<Vec<_>>();
         }
 
-        let cg = Cgroup {
-            subsystems: subsystems,
+        Cgroup {
+            subsystems,
             hier,
             path: path.to_str().unwrap().to_string(),
-        };
-
-        cg
+        }
     }
 
     /// The list of subsystems that this control group supports.
@@ -179,8 +175,8 @@ impl Cgroup {
     /// will change.
     pub fn delete(&self) -> Result<()> {
         if self.v2() {
-            if self.path != "" {
-                let mut p = self.hier.root().clone();
+            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));
             }
@@ -222,7 +218,7 @@ impl Cgroup {
     /// 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,
@@ -249,7 +245,7 @@ impl Cgroup {
     pub fn add_task(&self, pid: 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)
             } else {
@@ -291,7 +287,7 @@ impl Cgroup {
         // 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 {
@@ -313,9 +309,9 @@ impl Cgroup {
     }
 }
 
-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) {
+fn enable_controllers(controllers: &[String], path: &PathBuf) {
     let mut f = path.clone();
     f.push("cgroup.subtree_control");
     for c in controllers {
@@ -327,8 +323,8 @@ fn enable_controllers(controllers: &Vec<String>, path: &PathBuf) {
 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>>()
 }
@@ -342,16 +338,15 @@ fn create_v2_cgroup(root: PathBuf, path: &str) -> Result<()> {
     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));
             }
         }
 

src/cgroup_builder.rs

@@ -16,10 +16,10 @@
 //! by a call to `build()`.
 //!
 //! ```rust,no_run
-//! # use cgroups::*;
-//! # use cgroups::devices::*;
-//! # use cgroups::cgroup_builder::*;
-//! let h = cgroups::hierarchies::auto();
+//! # 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)

src/cpu.rs

@@ -15,7 +15,7 @@ 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, CustomizedAttribute,
@@ -110,24 +110,13 @@ impl<'a> From<&'a Subsystem> for &'a CpuController {
     }
 }
 
-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 `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,
         }
     }
 
@@ -144,7 +133,7 @@ impl CpuController {
                         Err(e) => Err(Error::with_cause(ReadFailed, e)),
                     }
                 })
-                .unwrap_or("".to_string()),
+                .unwrap_or_default(),
         }
     }
 
@@ -310,8 +299,5 @@ fn parse_cfs_quota_and_period(mut file: File) -> Result<CFSQuotaAndPeriod> {
         .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.
@@ -97,26 +97,6 @@ impl<'a> From<&'a Subsystem> for &'a CpuAcctController {
     }
 }
 
-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 `root` serving as the root of the control group.
     pub fn new(root: PathBuf) -> Self {
@@ -131,35 +111,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),
         }
     }

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,
 };
@@ -146,7 +146,7 @@ fn find_no_empty_parent(from: &str, file: &str) -> Result<(String, Vec<PathBuf>)
                 Err(e) => return Err(Error::with_cause(ReadFailed, e)),
             };
 
-        if current_value != "" {
+        if !current_value.is_empty() {
             return Ok((current_value, v));
         }
         v.push(current_path.clone());
@@ -167,7 +167,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(());
     }
 
@@ -204,40 +204,21 @@ impl<'a> From<&'a Subsystem> for &'a CpuSetController {
     }
 }
 
-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));
             }
@@ -266,7 +247,7 @@ impl CpuSetController {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 
@@ -276,7 +257,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)
             },
@@ -284,19 +265,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)
@@ -343,7 +324,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)

src/devices.rs

@@ -102,7 +102,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 +110,7 @@ impl DevicePermissions {
                 return false;
             }
         }
-        return true;
+        true
     }
 
     /// Returns a Vec will all the permissions that a device can have.
@@ -123,9 +123,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() {
@@ -206,7 +207,7 @@ impl DevicesController {
         devtype: DeviceType,
         major: i64,
         minor: i64,
-        perm: &Vec<DevicePermissions>,
+        perm: &[DevicePermissions],
     ) -> Result<()> {
         let perms = perm
             .iter()
@@ -238,7 +239,7 @@ impl DevicesController {
         devtype: DeviceType,
         major: i64,
         minor: i64,
-        perm: &Vec<DevicePermissions>,
+        perm: &[DevicePermissions],
     ) -> Result<()> {
         let perms = perm
             .iter()
@@ -274,13 +275,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]) {
@@ -295,7 +296,7 @@ impl DevicesController {
                                     devtype: devtype.unwrap(),
                                     major: major.unwrap(),
                                     minor: minor.unwrap(),
-                                    access: access,
+                                    access,
                                 });
                                 Ok(acc)
                             }

src/events.rs

@@ -53,7 +53,7 @@ fn register_memory_event(
 
     let event_control_path = cg_dir.join("cgroup.event_control");
     let data;
-    if arg == "" {
+    if arg.is_empty() {
         data = format!("{} {}", eventfd, event_file.as_raw_fd());
     } else {
         data = format!("{} {} {}", eventfd, event_file.as_raw_fd(), arg);
@@ -70,11 +70,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

@@ -87,7 +87,7 @@ impl FreezerController {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 

src/hierarchies.rs

@@ -9,8 +9,9 @@
 //! Currently, we only support the cgroupv1 hierarchy, but in the future we will add support for
 //! the Unified Hierarchy.
 
-use procinfo::pid::{mountinfo_self, Mountinfo};
 use std::fs;
+use std::fs::File;
+use std::io::{BufRead, BufReader};
 use std::path::PathBuf;
 
 use crate::blkio::BlkIoController;
@@ -31,6 +32,75 @@ use crate::{Controllers, Hierarchy, Subsystem};
 
 use crate::cgroup::Cgroup;
 
+/// Process mounts information.
+///
+/// See `proc(5)` for format details.
+#[derive(Debug, PartialEq, Eq, Hash)]
+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(_) => continue,
+        }
+    }
+    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)]
 pub struct V1 {
@@ -184,7 +254,7 @@ impl V1 {
     /// can be created.
     pub fn new() -> V1 {
         V1 {
-            mountinfo: mountinfo_self().unwrap(),
+            mountinfo: mountinfo_self(),
         }
     }
 
@@ -198,6 +268,12 @@ impl V1 {
     }
 }
 
+impl Default for V1 {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl V2 {
     /// Finds where control groups are mounted to and returns a hierarchy in which control groups
     /// can be created.
@@ -208,7 +284,13 @@ impl V2 {
     }
 }
 
-pub const UNIFIED_MOUNTPOINT: &'static str = "/sys/fs/cgroup";
+impl Default for V2 {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub const UNIFIED_MOUNTPOINT: &str = "/sys/fs/cgroup";
 
 #[cfg(all(target_os = "linux", not(target_env = "musl")))]
 pub fn is_cgroup2_unified_mode() -> bool {
@@ -224,7 +306,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 {
@@ -253,3 +335,36 @@ pub fn auto() -> Box<dyn Hierarchy> {
         Box::new(V1::new())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[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(),
+             ]}),
+        ];
+
+        for mi in mountinfo {
+            let info = parse_mountinfo_for_line(mi.0).unwrap();
+            assert_eq!(info, mi.1)
+        }
+    }
+}

src/hugetlb.rs

@@ -8,13 +8,12 @@
 //!
 //! 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 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,
@@ -86,17 +85,6 @@ impl<'a> From<&'a Subsystem> for &'a HugeTlbController {
     }
 }
 
-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 `root` serving as the root of the control group.
     pub fn new(root: PathBuf, v2: bool) -> Self {
@@ -104,8 +92,8 @@ impl HugeTlbController {
         Self {
             base: root.clone(),
             path: root,
-            sizes: sizes,
-            v2: v2,
+            sizes,
+            v2,
         }
     }
 
@@ -127,7 +115,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
@@ -187,7 +175,7 @@ impl HugeTlbController {
     }
 }
 
-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;
@@ -276,8 +264,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));
         }
@@ -287,10 +275,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));
         }
@@ -301,7 +289,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,15 @@
 // SPDX-License-Identifier: Apache-2.0 or MIT
 //
 
+#![allow(clippy::unnecessary_unwrap)]
 use log::*;
 
 use std::collections::HashMap;
+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) => {
@@ -122,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 "name=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"),
         }
     }
 }
@@ -178,13 +181,13 @@ 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, 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, e)),
+                    Ok(file) => Ok(file),
                 }
             }
         }
@@ -202,7 +205,7 @@ mod sealed {
 
         #[doc(hidden)]
         fn path_exists(&self, p: &str) -> bool {
-            if let Err(_) = self.verify_path() {
+            if self.verify_path().is_err() {
                 return false;
             }
 
@@ -294,7 +297,7 @@ 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(),
@@ -329,7 +332,7 @@ where
             return Ok(());
         }
 
-        fs::remove_dir(self.get_path()).map_err(|e| Error::with_cause(ErrorKind::RemoveFailed, e))
+        remove_dir(self.get_path())
     }
 
     /// Attach a task to this controller.
@@ -359,7 +362,7 @@ where
             file = "cgroup.procs";
         }
         self.open_path(file, false)
-            .and_then(|file| {
+            .map(|file| {
                 let bf = BufReader::new(file);
                 let mut v = Vec::new();
                 for line in bf.lines() {
@@ -368,9 +371,9 @@ where
                         v.push(n);
                     }
                 }
-                Ok(v.into_iter().map(CgroupPid::from).collect())
+                v.into_iter().map(CgroupPid::from).collect()
             })
-            .unwrap_or(vec![])
+            .unwrap_or_default()
     }
 
     fn v2(&self) -> bool {
@@ -378,6 +381,28 @@ where
     }
 }
 
+// remove_dir aims to remove cgroup path. It does so recursively,
+// by removing any subdirectories (sub-cgroups) first.
+fn remove_dir(dir: &PathBuf) -> 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, e))? {
+            let entry = entry.map_err(|e| Error::with_cause(ReadFailed, 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;
@@ -385,7 +410,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: std::fmt::Debug + Send {
+pub trait Hierarchy: std::fmt::Debug + Send + Sync {
     /// Returns what subsystems are supported by the hierarchy.
     fn subsystems(&self) -> Vec<Subsystem>;
 
@@ -422,7 +447,7 @@ pub struct MemoryResources {
     ///
     /// # Usage:
     /// ```
-    /// let resource = &mut cgroups::Resources::default();
+    /// let resource = &mut cgroups_rs::Resources::default();
     /// resource.memory.attrs.insert("memory.numa_balancing", "true".to_string());
     /// // apply here
     pub attrs: std::collections::HashMap<&'static str, String>,
@@ -464,7 +489,7 @@ pub struct CpuResources {
     /// Customized key-value attributes
     /// # Usage:
     /// ```
-    /// let resource = &mut cgroups::Resources::default();
+    /// let resource = &mut cgroups_rs::Resources::default();
     /// resource.cpu.attrs.insert("cpu.cfs_init_buffer_us", "10".to_string());
     /// // apply here
     /// ```
@@ -616,75 +641,61 @@ 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
             }),
         }
     }
@@ -735,16 +746,18 @@ impl MaxValue {
             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.to_string()),
         }
     }
 }
 
-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);
     }
@@ -766,11 +779,8 @@ pub fn flat_keyed_to_vec(mut file: File) -> Result<Vec<(String, i64)>> {
     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));
             }
         }
     }
@@ -789,11 +799,8 @@ pub fn flat_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, i64>> {
     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);
             }
         }
     }
@@ -811,18 +818,15 @@ pub fn nested_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, HashMap
     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);
                 }
             }
         }
@@ -832,14 +836,35 @@ pub fn nested_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, HashMap
     Ok(h)
 }
 
-/// read and parse an i64 data
-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)),
     }
 }
+
+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)),
+    }
+}
+
+/// 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

@@ -9,15 +9,14 @@
 //! 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 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;
+use crate::{read_i64_from, read_string_from, read_u64_from};
 
 use crate::flat_keyed_to_hashmap;
 
@@ -57,13 +56,32 @@ 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,
     })
 }
 
@@ -105,18 +123,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
@@ -125,10 +144,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)
                 })
@@ -140,10 +159,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)
                 })
@@ -155,10 +174,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)
                 })
@@ -170,74 +189,114 @@ 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()
+            }
         },
     })
 }
@@ -283,6 +342,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();
 
@@ -336,7 +396,7 @@ 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,
     })
 }
 
@@ -461,6 +521,10 @@ impl ControllerInternal for MemController {
         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(())
     }
 }
@@ -471,7 +535,7 @@ impl MemController {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 
@@ -486,8 +550,8 @@ 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))
@@ -528,7 +592,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)
@@ -572,12 +636,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)
@@ -586,7 +650,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)
@@ -620,7 +684,7 @@ impl MemController {
             slabinfo: self
                 .open_path("memory.kmem.slabinfo", false)
                 .and_then(read_string_from)
-                .unwrap_or("".to_string()),
+                .unwrap_or_default(),
         }
     }
 
@@ -652,7 +716,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)
@@ -870,30 +934,12 @@ impl<'a> From<&'a Subsystem> for &'a MemController {
     }
 }
 
-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_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,
     };
+
     static GOOD_VALUE: &str = "\
 total=51189 N0=51189 N1=123
 file=50175 N0=50175 N1=123
@@ -905,7 +951,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
@@ -975,11 +1038,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 {
@@ -1033,7 +1146,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,
 };
@@ -49,7 +49,7 @@ impl ControllerInternal for NetClsController {
 
         update_and_test!(self, set_class, res.class_id, get_class);
 
-        return Ok(());
+        Ok(())
     }
 }
 
@@ -74,17 +74,6 @@ impl<'a> From<&'a Subsystem> for &'a NetClsController {
     }
 }
 
-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 `root` serving as the root of the control group.
     pub fn new(root: PathBuf) -> Self {
@@ -107,6 +96,6 @@ impl NetClsController {
     /// 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,
 };
@@ -77,17 +77,6 @@ impl<'a> From<&'a Subsystem> for &'a NetPrioController {
     }
 }
 
-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 `root` serving as the root of the control group.
     pub fn new(root: PathBuf) -> Self {
@@ -105,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| {
@@ -116,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() {

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,
@@ -89,17 +89,6 @@ impl<'a> From<&'a Subsystem> for &'a PidController {
     }
 }
 
-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 `root` serving as the controller's root
     /// directory.
@@ -107,7 +96,7 @@ impl PidController {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 

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.
@@ -66,14 +66,6 @@ impl<'a> From<&'a Subsystem> for &'a RdmaController {
     }
 }
 
-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 `root` serving as the root of the control group.
     pub fn new(root: PathBuf) -> Self {

src/systemd.rs

@@ -66,7 +66,7 @@ impl SystemdController {
         Self {
             base: root.clone(),
             path: root,
-            v2: v2,
+            v2,
         }
     }
 }

tests/builder.rs

@@ -5,19 +5,19 @@
 //
 
 //! 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 = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_cpu_res_build")
         .cpu()
         .shares(85)
@@ -35,7 +35,7 @@ pub fn test_cpu_res_build() {
 
 #[test]
 pub fn test_memory_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_memory_res_build")
         .memory()
         .kernel_memory_limit(128 * 1024 * 1024)
@@ -58,7 +58,7 @@ pub fn test_memory_res_build() {
 
 #[test]
 pub fn test_pid_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_pid_res_build")
         .pid()
         .maximum_number_of_processes(MaxValue::Value(123))
@@ -77,7 +77,7 @@ pub fn test_pid_res_build() {
 #[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 = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_devices_res_build")
         .devices()
         .device(1, 6, DeviceType::Char, true, vec![DevicePermissions::Read])
@@ -103,7 +103,7 @@ pub fn test_devices_res_build() {
 
 #[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;
@@ -124,7 +124,7 @@ pub fn test_network_res_build() {
 
 #[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;
@@ -149,7 +149,7 @@ pub fn test_hugepages_res_build() {
 #[test]
 #[ignore] // high version kernel not support `blkio.weight`
 pub fn test_blkio_res_build() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg: Cgroup = CgroupBuilder::new("test_blkio_res_build")
         .blkio()
         .weight(100)

tests/cgroup.rs

@@ -5,13 +5,13 @@
 //
 
 //! Simple unit tests about the control groups system.
-use cgroups::memory::MemController;
-use cgroups::Controller;
-use cgroups::{Cgroup, CgroupPid, Subsystem};
+use cgroups_rs::memory::MemController;
+use cgroups_rs::Controller;
+use cgroups_rs::{Cgroup, CgroupPid, Subsystem};
 
 #[test]
 fn test_tasks_iterator() {
-    let h = cgroups::hierarchies::auto();
+    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"));
     {
@@ -38,17 +38,17 @@ fn test_tasks_iterator() {
 
 #[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 cgroup_name = "test_cgroup_with_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/";
@@ -79,10 +79,10 @@ fn test_cgroup_with_relative_paths() {
 
 #[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 = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_v2"));
 
     let mem_controller: &MemController = cg.controller_of().unwrap();

tests/cpu.rs

@@ -4,12 +4,12 @@
 //
 
 //! Simple unit tests about the CPU control groups system.
-use cgroups::cpu::CpuController;
-use cgroups::Cgroup;
+use cgroups_rs::cpu::CpuController;
+use cgroups_rs::Cgroup;
 
 #[test]
 fn test_cfs_quota_and_periods() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_cfs_quota_and_periods"));
 
     let cpu_controller: &CpuController = cg.controller_of().unwrap();

tests/cpuset.rs

@@ -4,15 +4,15 @@
 // SPDX-License-Identifier: Apache-2.0 or MIT
 //
 
-use cgroups::cpuset::CpuSetController;
-use cgroups::error::ErrorKind;
-use cgroups::{Cgroup, CgroupPid};
+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 = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_cpuset_memory_pressure_root_cg"));
     {
         let cpuset: &CpuSetController = cg.controller_of().unwrap();
@@ -26,7 +26,7 @@ fn test_cpuset_memory_pressure_root_cg() {
 
 #[test]
 fn test_cpuset_set_cpus() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus"));
     {
         let cpuset: &CpuSetController = cg.controller_of().unwrap();
@@ -36,7 +36,7 @@ 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_eq!(true, !set.cpus.is_empty());
         }
 
         // 0
@@ -48,10 +48,9 @@ fn test_cpuset_set_cpus() {
         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 != "" {
+        if !cpus.is_empty() {
             let r = cpuset.set_cpus(&cpus);
             assert_eq!(true, r.is_ok());
             let set = cpuset.cpuset();
@@ -64,7 +63,7 @@ fn test_cpuset_set_cpus() {
 
 #[test]
 fn test_cpuset_set_cpus_add_task() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus_add_task/sub-dir"));
 
     let cpuset: &CpuSetController = cg.controller_of().unwrap();
@@ -73,14 +72,14 @@ 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_eq!(true, !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 tasks = cg.tasks();
-    assert_eq!(true, tasks.len() > 0);
+    assert_eq!(true, !tasks.is_empty());
     println!("tasks after added: {:?}", tasks);
 
     // remove task

tests/devices.rs

@@ -6,17 +6,17 @@
 
 //! Integration tests about the devices subsystem
 
-use cgroups::devices::{DevicePermissions, DeviceType, DevicesController};
-use cgroups::{Cgroup, DeviceResource};
+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 = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_devices_parsing"));
     {
         let devices: &DevicesController = cg.controller_of().unwrap();
@@ -27,7 +27,7 @@ fn test_devices_parsing() {
                 DeviceType::All,
                 -1,
                 -1,
-                &vec![
+                &[
                     DevicePermissions::Read,
                     DevicePermissions::Write,
                     DevicePermissions::MkNod,
@@ -42,7 +42,7 @@ fn test_devices_parsing() {
 
         // Now add mknod access to /dev/null device
         devices
-            .allow_device(DeviceType::Char, 1, 3, &vec![DevicePermissions::MkNod])
+            .allow_device(DeviceType::Char, 1, 3, &[DevicePermissions::MkNod])
             .unwrap();
         let allowed_devices = devices.allowed_devices();
         assert!(allowed_devices.is_ok());

tests/hugetlb.rs

@@ -4,19 +4,19 @@
 //
 
 //! Integration tests about the hugetlb subsystem
-use cgroups::error::*;
-use cgroups::hugetlb::{self, HugeTlbController};
-use cgroups::Cgroup;
+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 = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_hugetlb_sizes"));
     {
         let hugetlb_controller: &HugeTlbController = cg.controller_of().unwrap();

tests/memory.rs

@@ -4,13 +4,13 @@
 //
 
 //! 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 = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_disable_oom_killer"));
     {
         let mem_controller: &MemController = cg.controller_of().unwrap();
@@ -35,7 +35,7 @@ fn test_disable_oom_killer() {
 
 #[test]
 fn set_mem_v2() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     if !h.v2() {
         return;
     }

tests/pids.rs

@@ -5,9 +5,9 @@
 //
 
 //! Integration tests about the pids subsystem
-use cgroups::pid::PidController;
-use cgroups::Controller;
-use cgroups::{Cgroup, MaxValue};
+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};
@@ -16,7 +16,7 @@ use libc::pid_t;
 
 #[test]
 fn create_and_delete_cgroup() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("create_and_delete_cgroup"));
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
@@ -30,7 +30,7 @@ fn create_and_delete_cgroup() {
 
 #[test]
 fn test_pids_current_is_zero() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_pids_current_is_zero"));
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
@@ -42,7 +42,7 @@ fn test_pids_current_is_zero() {
 
 #[test]
 fn test_pids_events_is_zero() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_pids_events_is_zero"));
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
@@ -55,14 +55,14 @@ fn test_pids_events_is_zero() {
 
 #[test]
 fn test_pid_events_is_not_zero() {
-    let h = cgroups::hierarchies::auto();
+    let h = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("test_pid_events_is_not_zero"));
     {
         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());
@@ -89,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) };

tests/resources.rs

@@ -5,12 +5,12 @@
 //
 
 //! Integration test about setting resources using `apply()`
-use cgroups::pid::PidController;
-use cgroups::{Cgroup, 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 = cgroups_rs::hierarchies::auto();
     let cg = Cgroup::new(h, String::from("pid_resources"));
     {
         let res = Resources {