Merge pull request #94 from liubin/fix/93-include-path-in-error-message

error: introduce thiserror to add path to error message

Cargo.toml

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

src/blkio.rs

@@ -16,7 +16,8 @@ use crate::error::*;
 
 use crate::{read_string_from, read_u64_from};
 use crate::{
-    BlkIoResources, ControllIdentifier, ControllerInternal, Controllers, Resources, Subsystem,
+    BlkIoResources, ControllIdentifier, ControllerInternal, Controllers, CustomizedAttribute,
+    Resources, Subsystem,
 };
 
 /// A controller that allows controlling the `blkio` subsystem of a Cgroup.
@@ -378,6 +379,10 @@ impl ControllerInternal for BlkIoController {
             let _ = self.throttle_write_iops_for_device(dev.major, dev.minor, dev.rate);
         }
 
+        res.attrs.iter().for_each(|(k, v)| {
+            let _ = self.set(k, v);
+        });
+
         Ok(())
     }
 }
@@ -660,8 +665,12 @@ impl BlkIoController {
     pub fn set_leaf_weight(&self, w: u64) -> Result<()> {
         self.open_path("blkio.leaf_weight", true)
             .and_then(|mut file| {
-                file.write_all(w.to_string().as_ref())
+                file.write_all(w.to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("blkio.leaf_weight".to_string(), w.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -670,7 +679,15 @@ impl BlkIoController {
         self.open_path("blkio.leaf_weight_device", true)
             .and_then(|mut file| {
                 file.write_all(format!("{}:{} {}", major, minor, weight).as_ref())
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    .map_err(|e| {
+                        Error::with_cause(
+                            WriteFailed(
+                                "blkio.leaf_weight_device".to_string(),
+                                format!("{}:{} {}", major, minor, weight),
+                            ),
+                            e,
+                        )
+                    })
             })
     }
 
@@ -678,99 +695,117 @@ impl BlkIoController {
     pub fn reset_stats(&self) -> Result<()> {
         self.open_path("blkio.reset_stats", true)
             .and_then(|mut file| {
-                file.write_all("1".to_string().as_ref())
+                file.write_all("1".to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("blkio.reset_stats".to_string(), "1".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
     /// Throttle the bytes per second rate of read operation affecting the block device
     /// `major:minor` to `bps`.
     pub fn throttle_read_bps_for_device(&self, major: u64, minor: u64, bps: u64) -> Result<()> {
-        let mut file = "blkio.throttle.read_bps_device";
+        let mut file_name = "blkio.throttle.read_bps_device";
         let mut content = format!("{}:{} {}", major, minor, bps);
         if self.v2 {
-            file = "io.max";
+            file_name = "io.max";
             content = format!("{}:{} rbps={}", major, minor, bps);
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(content.as_ref())
+            file.write_all(content.as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), content.to_string()), e)
+            })
         })
     }
 
     /// Throttle the I/O operations per second rate of read operation affecting the block device
     /// `major:minor` to `bps`.
     pub fn throttle_read_iops_for_device(&self, major: u64, minor: u64, iops: u64) -> Result<()> {
-        let mut file = "blkio.throttle.read_iops_device";
+        let mut file_name = "blkio.throttle.read_iops_device";
         let mut content = format!("{}:{} {}", major, minor, iops);
         if self.v2 {
-            file = "io.max";
+            file_name = "io.max";
             content = format!("{}:{} riops={}", major, minor, iops);
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(content.as_ref())
+            file.write_all(content.as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), content.to_string()), e)
+            })
         })
     }
     /// Throttle the bytes per second rate of write operation affecting the block device
     /// `major:minor` to `bps`.
     pub fn throttle_write_bps_for_device(&self, major: u64, minor: u64, bps: u64) -> Result<()> {
-        let mut file = "blkio.throttle.write_bps_device";
+        let mut file_name = "blkio.throttle.write_bps_device";
         let mut content = format!("{}:{} {}", major, minor, bps);
         if self.v2 {
-            file = "io.max";
+            file_name = "io.max";
             content = format!("{}:{} wbps={}", major, minor, bps);
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(content.as_ref())
+            file.write_all(content.as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), content.to_string()), e)
+            })
         })
     }
 
     /// Throttle the I/O operations per second rate of write operation affecting the block device
     /// `major:minor` to `bps`.
     pub fn throttle_write_iops_for_device(&self, major: u64, minor: u64, iops: u64) -> Result<()> {
-        let mut file = "blkio.throttle.write_iops_device";
+        let mut file_name = "blkio.throttle.write_iops_device";
         let mut content = format!("{}:{} {}", major, minor, iops);
         if self.v2 {
-            file = "io.max";
+            file_name = "io.max";
             content = format!("{}:{} wiops={}", major, minor, iops);
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(content.as_ref())
+            file.write_all(content.as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), content.to_string()), e)
+            })
         })
     }
 
     /// Set the weight of the control group's tasks.
     pub fn set_weight(&self, w: u64) -> Result<()> {
         // Attation: may not find in high kernel version.
-        let mut file = "blkio.weight";
+        let mut file_name = "blkio.weight";
         if self.v2 {
-            file = "io.bfq.weight";
+            file_name = "io.bfq.weight";
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(w.to_string().as_ref())
+            file.write_all(w.to_string().as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), w.to_string()), e)
+            })
         })
     }
 
     /// Same as `set_weight()`, but settable per each block device.
     pub fn set_weight_for_device(&self, major: u64, minor: u64, weight: u64) -> Result<()> {
-        let mut file = "blkio.weight_device";
+        let mut file_name = "blkio.weight_device";
         if self.v2 {
             // Attation: there is no weight for device in runc
             // https://github.com/opencontainers/runc/blob/46be7b612e2533c494e6a251111de46d8e286ed5/libcontainer/cgroups/fs2/io.go#L30
             // may depends on IO schedulers https://wiki.ubuntu.com/Kernel/Reference/IOSchedulers
-            file = "io.bfq.weight";
+            file_name = "io.bfq.weight";
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
             file.write_all(format!("{}:{} {}", major, minor, weight).as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                .map_err(|e| {
+                    Error::with_cause(
+                        WriteFailed(
+                            file_name.to_string(),
+                            format!("{}:{} {}", major, minor, weight),
+                        ),
+                        e,
+                    )
+                })
         })
     }
 }
 
+impl CustomizedAttribute for BlkIoController {}
 #[cfg(test)]
 mod test {
     use crate::blkio::{parse_blkio_data, BlkIoData};

src/cgroup.rs

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

src/cpu.rs

@@ -131,7 +131,7 @@ impl CpuController {
                     let res = file.read_to_string(&mut s);
                     match res {
                         Ok(_) => Ok(s),
-                        Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                        Err(e) => Err(Error::with_cause(ReadFailed("cpu.stat".to_string()), e)),
                     }
                 })
                 .unwrap_or_default(),
@@ -145,14 +145,15 @@ impl CpuController {
     /// `shares` to `200` ensures that control group `B` receives twice as much as CPU bandwidth.
     /// (Assuming both `A` and `B` are of the same parent)
     pub fn set_shares(&self, shares: u64) -> Result<()> {
-        let mut file = "cpu.shares";
+        let mut file_name = "cpu.shares";
         if self.v2 {
-            file = "cpu.weight";
+            file_name = "cpu.weight";
         }
         // NOTE: .CpuShares is not used here. Conversion is the caller's responsibility.
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(shares.to_string().as_ref())
+            file.write_all(shares.to_string().as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), shares.to_string()), e)
+            })
         })
     }
 
@@ -174,8 +175,12 @@ impl CpuController {
         }
         self.open_path("cpu.cfs_period_us", true)
             .and_then(|mut file| {
-                file.write_all(us.to_string().as_ref())
+                file.write_all(us.to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("cpu.cfs_period_us".to_string(), us.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -200,8 +205,12 @@ impl CpuController {
         }
         self.open_path("cpu.cfs_quota_us", true)
             .and_then(|mut file| {
-                file.write_all(us.to_string().as_ref())
+                file.write_all(us.to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("cpu.cfs_quota_us".to_string(), us.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -262,23 +271,31 @@ impl CpuController {
         let line = format!("{} {}", new_quota, new_period);
         self.open_path("cpu.max", true).and_then(|mut file| {
             file.write_all(line.as_ref())
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                .map_err(|e| Error::with_cause(WriteFailed("cpu.max".to_string(), line), e))
         })
     }
 
     pub fn set_rt_runtime(&self, us: i64) -> Result<()> {
         self.open_path("cpu.rt_runtime_us", true)
             .and_then(|mut file| {
-                file.write_all(us.to_string().as_ref())
+                file.write_all(us.to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("cpu.rt_runtime_us".to_string(), us.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
     pub fn set_rt_period_us(&self, us: u64) -> Result<()> {
         self.open_path("cpu.rt_period_us", true)
             .and_then(|mut file| {
-                file.write_all(us.to_string().as_ref())
+                file.write_all(us.to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("cpu.rt_period_us".to_string(), us.to_string()),
+                        e,
+                    )
+                })
             })
     }
 }
@@ -288,14 +305,14 @@ impl CustomizedAttribute for CpuController {}
 fn parse_cfs_quota_and_period(mut file: File) -> Result<CfsQuotaAndPeriod> {
     let mut content = String::new();
     file.read_to_string(&mut content)
-        .map_err(|e| Error::with_cause(ReadFailed, e))?;
+        .map_err(|e| Error::with_cause(ReadFailed("cpu.max".to_string()), e))?;
 
     let fields = content.trim().split(' ').collect::<Vec<&str>>();
     if fields.len() != 2 {
         return Err(Error::from_string(format!("invaild format: {}", content)));
     }
 
-    let quota = parse_max_value(&fields[0].to_string())?;
+    let quota = parse_max_value(fields[0])?;
     let period = fields[1]
         .parse::<u64>()
         .map_err(|e| Error::with_cause(ParseError, e))?;

src/cpuacct.rs

@@ -148,8 +148,9 @@ impl CpuAcctController {
     /// Reset the statistics the kernel has gathered about the control group.
     pub fn reset(&self) -> Result<()> {
         self.open_path("cpuacct.usage", true).and_then(|mut file| {
-            file.write_all(b"0")
+            file.write_all(b"0").map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed("cpuacct.usage".to_string(), "0".to_string()), e)
+            })
         })
     }
 }

src/cpuset.rs

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

src/devices.rs

@@ -237,8 +237,9 @@ impl DevicesController {
         };
         let final_str = format!("{} {}:{} {}", devtype.to_char(), major, minor, perms);
         self.open_path("devices.allow", true).and_then(|mut file| {
-            file.write_all(final_str.as_ref())
+            file.write_all(final_str.as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed("devices.allow".to_string(), final_str), e)
+            })
         })
     }
 
@@ -269,8 +270,9 @@ impl DevicesController {
         };
         let final_str = format!("{} {}:{} {}", devtype.to_char(), major, minor, perms);
         self.open_path("devices.deny", true).and_then(|mut file| {
-            file.write_all(final_str.as_ref())
+            file.write_all(final_str.as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed("devices.deny".to_string(), final_str), e)
+            })
         })
     }
 
@@ -315,7 +317,7 @@ impl DevicesController {
                         }
                     })
                 },
-                Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                Err(e) => Err(Error::with_cause(ReadFailed("devices.list".to_string()), e)),
             }
         })
     }

src/error.rs

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

src/events.rs

@@ -46,21 +46,26 @@ fn register_memory_event(
     arg: &str,
 ) -> Result<Receiver<String>> {
     let path = cg_dir.join(event_name);
-    let event_file = File::open(path).map_err(|e| Error::with_cause(ReadFailed, e))?;
+    let event_file = File::open(path.clone())
+        .map_err(|e| Error::with_cause(ReadFailed(path.display().to_string()), e))?;
 
-    let eventfd =
+    let eventfd = eventfd(0, EfdFlags::EFD_CLOEXEC)
-        eventfd(0, EfdFlags::EFD_CLOEXEC).map_err(|e| Error::with_cause(ReadFailed, e))?;
+        .map_err(|e| Error::with_cause(ReadFailed("eventfd".to_string()), e))?;
 
     let event_control_path = cg_dir.join("cgroup.event_control");
-    let data;
+    let data = if arg.is_empty() {
-    if arg.is_empty() {
+        format!("{} {}", eventfd, event_file.as_raw_fd())
-        data = format!("{} {}", eventfd, event_file.as_raw_fd());
     } else {
-        data = format!("{} {} {}", eventfd, event_file.as_raw_fd(), arg);
+        format!("{} {} {}", eventfd, event_file.as_raw_fd(), arg)
-    }
+    };
 
     // write to file and set mode to 0700(FIXME)
-    fs::write(&event_control_path, data).map_err(|e| Error::with_cause(WriteFailed, e))?;
+    fs::write(&event_control_path, data.clone()).map_err(|e| {
+        Error::with_cause(
+            WriteFailed(event_control_path.display().to_string(), data),
+            e,
+        )
+    })?;
 
     let mut eventfd_file = unsafe { File::from_raw_fd(eventfd) };
 

src/freezer.rs

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

src/hierarchies.rs

@@ -170,7 +170,7 @@ impl Hierarchy for V1 {
     }
 
     fn root_control_group(&self) -> Cgroup {
-        Cgroup::load(auto(), "".to_string())
+        Cgroup::load(auto(), "")
     }
 
     fn root(&self) -> PathBuf {
@@ -246,7 +246,7 @@ impl Hierarchy for V2 {
     }
 
     fn root_control_group(&self) -> Cgroup {
-        Cgroup::load(auto(), "".to_string())
+        Cgroup::load(auto(), "")
     }
 
     fn root(&self) -> PathBuf {
@@ -297,7 +297,10 @@ impl Default for V2 {
 
 pub const UNIFIED_MOUNTPOINT: &str = "/sys/fs/cgroup";
 
-#[cfg(all(target_os = "linux", not(target_env = "musl")))]
+#[cfg(any(
+    all(target_os = "linux", not(target_env = "musl")),
+    target_os = "android"
+))]
 pub fn is_cgroup2_unified_mode() -> bool {
     use nix::sys::statfs;
 

src/hugetlb.rs

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

src/lib.rs

@@ -181,12 +181,21 @@ mod sealed {
 
             if w {
                 match File::create(&path) {
-                    Err(e) => Err(Error::with_cause(ErrorKind::WriteFailed, e)),
+                    Err(e) => Err(Error::with_cause(
+                        ErrorKind::WriteFailed(
+                            path.display().to_string(),
+                            "[CREATE FILE]".to_string(),
+                        ),
+                        e,
+                    )),
                     Ok(file) => Ok(file),
                 }
             } else {
                 match File::open(&path) {
-                    Err(e) => Err(Error::with_cause(ErrorKind::ReadFailed, e)),
+                    Err(e) => Err(Error::with_cause(
+                        ErrorKind::ReadFailed(path.display().to_string()),
+                        e,
+                    )),
                     Ok(file) => Ok(file),
                 }
             }
@@ -198,7 +207,7 @@ mod sealed {
                 let res = file.read_to_string(&mut string);
                 match res {
                     Ok(_) => parse_max_value(&string),
-                    Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                    Err(e) => Err(Error::with_cause(ReadFailed(f.to_string()), e)),
                 }
             })
         }
@@ -216,8 +225,9 @@ mod sealed {
     pub trait CustomizedAttribute: ControllerInternal {
         fn set(&self, key: &str, value: &str) -> Result<()> {
             self.open_path(key, true).and_then(|mut file| {
-                file.write_all(value.as_ref())
+                file.write_all(value.as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(WriteFailed(key.to_string(), value.to_string()), e)
+                })
             })
         }
 
@@ -226,7 +236,7 @@ mod sealed {
                 let mut string = String::new();
                 match file.read_to_string(&mut string) {
                     Ok(_) => Ok(string.trim().to_owned()),
-                    Err(e) => Err(Error::with_cause(ReadFailed, e)),
+                    Err(e) => Err(Error::with_cause(ReadFailed(key.to_string()), e)),
                 }
             })
         }
@@ -309,16 +319,24 @@ where
     fn set_notify_on_release(&self, enable: bool) -> Result<()> {
         self.open_path("notify_on_release", true)
             .and_then(|mut file| {
-                write!(file, "{}", enable as i32)
+                write!(file, "{}", enable as i32).map_err(|e| {
-                    .map_err(|e| Error::with_cause(ErrorKind::WriteFailed, e))
+                    Error::with_cause(
+                        ErrorKind::WriteFailed("notify_on_release".to_string(), enable.to_string()),
+                        e,
+                    )
+                })
             })
     }
 
     /// Set release_agent
     fn set_release_agent(&self, path: &str) -> Result<()> {
         self.open_path("release_agent", true).and_then(|mut file| {
-            file.write_all(path.as_bytes())
+            file.write_all(path.as_bytes()).map_err(|e| {
-                .map_err(|e| Error::with_cause(ErrorKind::WriteFailed, e))
+                Error::with_cause(
+                    ErrorKind::WriteFailed("release_agent".to_string(), path.to_string()),
+                    e,
+                )
+            })
         })
     }
     /// Does this controller already exist?
@@ -332,26 +350,50 @@ where
             return Ok(());
         }
 
-        remove_dir(self.get_path())
+        // Compatible with runC for remove dir operation
+        // https://github.com/opencontainers/runc/blob/main/libcontainer/cgroups/utils.go#L272
+        //
+        // We trying to remove all paths five times with increasing delay between tries.
+        // If after all there are not removed cgroups - appropriate error will be
+        // returned.
+        let mut delay = std::time::Duration::from_millis(10);
+        let cgroup_path = self.get_path();
+        for _i in 0..4 {
+            if let Ok(()) = remove_dir(cgroup_path) {
+                return Ok(());
+            }
+            std::thread::sleep(delay);
+            delay *= 2;
+        }
+
+        remove_dir(cgroup_path)
     }
 
     /// Attach a task to this controller.
     fn add_task(&self, pid: &CgroupPid) -> Result<()> {
-        let mut file = "tasks";
+        let mut file_name = "tasks";
         if self.is_v2() {
-            file = "cgroup.procs";
+            file_name = "cgroup.procs";
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(pid.pid.to_string().as_ref())
+            file.write_all(pid.pid.to_string().as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(ErrorKind::WriteFailed, e))
+                Error::with_cause(
+                    ErrorKind::WriteFailed(file_name.to_string(), pid.pid.to_string()),
+                    e,
+                )
+            })
         })
     }
 
     /// Attach a task to this controller by thread group id.
     fn add_task_by_tgid(&self, pid: &CgroupPid) -> Result<()> {
         self.open_path("cgroup.procs", true).and_then(|mut file| {
-            file.write_all(pid.pid.to_string().as_ref())
+            file.write_all(pid.pid.to_string().as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(ErrorKind::WriteFailed, e))
+                Error::with_cause(
+                    ErrorKind::WriteFailed("cgroup.procs".to_string(), pid.pid.to_string()),
+                    e,
+                )
+            })
         })
     }
 
@@ -393,8 +435,11 @@ fn remove_dir(dir: &Path) -> Result<()> {
     }
 
     if dir.exists() && dir.is_dir() {
-        for entry in fs::read_dir(dir).map_err(|e| Error::with_cause(ReadFailed, e))? {
+        for entry in fs::read_dir(dir)
-            let entry = entry.map_err(|e| Error::with_cause(ReadFailed, e))?;
+            .map_err(|e| Error::with_cause(ReadFailed(dir.display().to_string()), e))?
+        {
+            let entry =
+                entry.map_err(|e| Error::with_cause(ReadFailed(dir.display().to_string()), e))?;
             let path = entry.path();
             if path.is_dir() {
                 remove_dir(&path)?;
@@ -613,6 +658,15 @@ pub struct BlkIoResources {
     pub throttle_write_bps_device: Vec<BlkIoDeviceThrottleResource>,
     /// Throttled write IO operations per second can be provided for each device.
     pub throttle_write_iops_device: Vec<BlkIoDeviceThrottleResource>,
+
+    /// Customized key-value attributes
+    /// # Usage:
+    /// ```
+    /// let resource = &mut cgroups_rs::Resources::default();
+    /// resource.blkio.attrs.insert("io.cost.weight".to_string(), "10".to_string());
+    /// // apply here
+    /// ```
+    pub attrs: HashMap<String, String>,
 }
 
 /// The resource limits and constraints that will be set on the control group.
@@ -771,7 +825,7 @@ impl fmt::Display for MaxValue {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             MaxValue::Max => write!(f, "max"),
-            MaxValue::Value(num) => write!(f, "{}", num.to_string()),
+            MaxValue::Value(num) => write!(f, "{}", num),
         }
     }
 }
@@ -792,7 +846,7 @@ pub fn parse_max_value(s: &str) -> Result<MaxValue> {
 pub fn flat_keyed_to_vec(mut file: File) -> Result<Vec<(String, i64)>> {
     let mut content = String::new();
     file.read_to_string(&mut content)
-        .map_err(|e| Error::with_cause(ReadFailed, e))?;
+        .map_err(|e| Error::with_cause(ReadFailed("FIXME: read_string_from".to_string()), e))?;
 
     let mut v = Vec::new();
     for line in content.lines() {
@@ -812,7 +866,7 @@ pub fn flat_keyed_to_vec(mut file: File) -> Result<Vec<(String, i64)>> {
 pub fn flat_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, i64>> {
     let mut content = String::new();
     file.read_to_string(&mut content)
-        .map_err(|e| Error::with_cause(ReadFailed, e))?;
+        .map_err(|e| Error::with_cause(ReadFailed("FIXME: read_string_from".to_string()), e))?;
 
     let mut h = HashMap::new();
     for line in content.lines() {
@@ -832,7 +886,7 @@ pub fn flat_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, i64>> {
 pub fn nested_keyed_to_hashmap(mut file: File) -> Result<HashMap<String, HashMap<String, i64>>> {
     let mut content = String::new();
     file.read_to_string(&mut content)
-        .map_err(|e| Error::with_cause(ReadFailed, e))?;
+        .map_err(|e| Error::with_cause(ReadFailed("FIXME: read_string_from".to_string()), e))?;
 
     let mut h = HashMap::new();
     for line in content.lines() {
@@ -866,7 +920,10 @@ where
             .trim()
             .parse::<T>()
             .map_err(|e| Error::with_cause(ParseError, e)),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
+        Err(e) => Err(Error::with_cause(
+            ReadFailed("FIXME: can't get path in fn read_from".to_string()),
+            e,
+        )),
     }
 }
 
@@ -874,7 +931,10 @@ fn read_string_from(mut file: File) -> Result<String> {
     let mut string = String::new();
     match file.read_to_string(&mut string) {
         Ok(_) => Ok(string.trim().to_string()),
-        Err(e) => Err(Error::with_cause(ReadFailed, e)),
+        Err(e) => Err(Error::with_cause(
+            ReadFailed("FIXME: can't get path in fn read_string_from".to_string()),
+            e,
+        )),
     }
 }
 

src/memory.rs

@@ -8,6 +8,7 @@
 //!
 //! See the Kernel's documentation for more information about this subsystem, found at:
 //!  [Documentation/cgroup-v1/memory.txt](https://www.kernel.org/doc/Documentation/cgroup-v1/memory.txt)
+use log::warn;
 use std::collections::HashMap;
 use std::io::Write;
 use std::path::PathBuf;
@@ -561,8 +562,9 @@ impl MemController {
             if let Some(v) = v {
                 let v = v.to_string();
                 self.open_path(f, true).and_then(|mut file| {
-                    file.write_all(v.as_ref())
+                    file.write_all(v.as_ref()).map_err(|e| {
-                        .map_err(|e| Error::with_cause(WriteFailed, e))
+                        Error::with_cause(WriteFailed(f.to_string(), format!("{:?}", v)), e)
+                    })
                 })?;
             }
         }
@@ -768,8 +770,12 @@ impl MemController {
     /// Reset the fail counter
     pub fn reset_fail_count(&self) -> Result<()> {
         self.open_path("memory.failcnt", true).and_then(|mut file| {
-            file.write_all("0".to_string().as_ref())
+            file.write_all("0".to_string().as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(
+                    WriteFailed("memory.failcnt".to_string(), "0".to_string()),
+                    e,
+                )
+            })
         })
     }
 
@@ -782,8 +788,12 @@ impl MemController {
 
         self.open_path("memory.kmem.failcnt", true)
             .and_then(|mut file| {
-                file.write_all("0".to_string().as_ref())
+                file.write_all("0".to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("memory.kmem.failcnt".to_string(), "0".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -796,8 +806,12 @@ impl MemController {
 
         self.open_path("memory.kmem.tcp.failcnt", true)
             .and_then(|mut file| {
-                file.write_all("0".to_string().as_ref())
+                file.write_all("0".to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("memory.kmem.tcp.failcnt".to_string(), "0".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -805,8 +819,12 @@ impl MemController {
     pub fn reset_memswap_fail_count(&self) -> Result<()> {
         self.open_path("memory.memsw.failcnt", true)
             .and_then(|mut file| {
-                file.write_all("0".to_string().as_ref())
+                file.write_all("0".to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("memory.memsw.failcnt".to_string(), "0".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
@@ -814,20 +832,25 @@ impl MemController {
     pub fn reset_max_usage(&self) -> Result<()> {
         self.open_path("memory.max_usage_in_bytes", true)
             .and_then(|mut file| {
-                file.write_all("0".to_string().as_ref())
+                file.write_all("0".to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("memory.max_usage_in_bytes".to_string(), "0".to_string()),
+                        e,
+                    )
+                })
             })
     }
 
     /// Set the memory usage limit of the control group, in bytes.
     pub fn set_limit(&self, limit: i64) -> Result<()> {
-        let mut file = "memory.limit_in_bytes";
+        let mut file_name = "memory.limit_in_bytes";
         if self.v2 {
-            file = "memory.max";
+            file_name = "memory.max";
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(limit.to_string().as_ref())
+            file.write_all(limit.to_string().as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), limit.to_string()), e)
+            })
         })
     }
 
@@ -840,20 +863,31 @@ impl MemController {
 
         self.open_path("memory.kmem.limit_in_bytes", true)
             .and_then(|mut file| {
-                file.write_all(limit.to_string().as_ref())
+                let r = file.write_all(limit.to_string().as_ref());
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                match r {
+                    Ok(()) => Ok(()),
+                    Err(ref e) if e.raw_os_error() == Some(libc::EOPNOTSUPP) => {
+                        warn!("memory.kmem.limit_in_bytes is unsupported by the kernel");
+                        Ok(())
+                    }
+                    Err(e) => Err(Error::with_cause(
+                        WriteFailed("memory.kmem.limit_in_bytes".to_string(), limit.to_string()),
+                        e,
+                    )),
+                }
             })
     }
 
     /// Set the memory+swap limit of the control group, in bytes.
     pub fn set_memswap_limit(&self, limit: i64) -> Result<()> {
-        let mut file = "memory.memsw.limit_in_bytes";
+        let mut file_name = "memory.memsw.limit_in_bytes";
         if self.v2 {
-            file = "memory.swap.max";
+            file_name = "memory.swap.max";
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(limit.to_string().as_ref())
+            file.write_all(limit.to_string().as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), limit.to_string()), e)
+            })
         })
     }
 
@@ -866,8 +900,15 @@ impl MemController {
 
         self.open_path("memory.kmem.tcp.limit_in_bytes", true)
             .and_then(|mut file| {
-                file.write_all(limit.to_string().as_ref())
+                file.write_all(limit.to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed(
+                            "memory.kmem.tcp.limit_in_bytes".to_string(),
+                            limit.to_string(),
+                        ),
+                        e,
+                    )
+                })
             })
     }
 
@@ -876,13 +917,14 @@ impl MemController {
     /// This limit is enforced when the system is nearing OOM conditions. Contrast this with the
     /// hard limit, which is _always_ enforced.
     pub fn set_soft_limit(&self, limit: i64) -> Result<()> {
-        let mut file = "memory.soft_limit_in_bytes";
+        let mut file_name = "memory.soft_limit_in_bytes";
         if self.v2 {
-            file = "memory.low"
+            file_name = "memory.low"
         }
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(limit.to_string().as_ref())
+            file.write_all(limit.to_string().as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), limit.to_string()), e)
+            })
         })
     }
 
@@ -891,22 +933,27 @@ impl MemController {
     ///
     /// Note that a value of zero does not imply that the process will not be swapped out.
     pub fn set_swappiness(&self, swp: u64) -> Result<()> {
-        let mut file = "memory.swappiness";
+        let mut file_name = "memory.swappiness";
         if self.v2 {
-            file = "memory.swap.max"
+            file_name = "memory.swap.max"
         }
 
-        self.open_path(file, true).and_then(|mut file| {
+        self.open_path(file_name, true).and_then(|mut file| {
-            file.write_all(swp.to_string().as_ref())
+            file.write_all(swp.to_string().as_ref()).map_err(|e| {
-                .map_err(|e| Error::with_cause(WriteFailed, e))
+                Error::with_cause(WriteFailed(file_name.to_string(), swp.to_string()), e)
+            })
         })
     }
 
     pub fn disable_oom_killer(&self) -> Result<()> {
         self.open_path("memory.oom_control", true)
             .and_then(|mut file| {
-                file.write_all("1".to_string().as_ref())
+                file.write_all("1".to_string().as_ref()).map_err(|e| {
-                    .map_err(|e| Error::with_cause(WriteFailed, e))
+                    Error::with_cause(
+                        WriteFailed("memory.oom_control".to_string(), "1".to_string()),
+                        e,
+                    )
+                })
             })
     }
 

src/net_cls.rs

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

src/net_prio.rs

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

src/pid.rs

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

src/rdma.rs

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

src/systemd.rs

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

tests/builder.rs

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

tests/cpuset.rs

@@ -83,7 +83,7 @@ fn test_cpuset_set_cpus_add_task() {
     println!("tasks after added: {:?}", tasks);
 
     // remove task
-    let _ = cg.remove_task(CgroupPid::from(pid_i));
+    cg.remove_task(CgroupPid::from(pid_i));
     let tasks = cg.tasks();
     println!("tasks after deleted: {:?}", tasks);
     assert_eq!(0, tasks.len());

tests/hugetlb.rs

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

tests/memory.rs

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