Merge pull request #122 from justxuewei/release-033

release: v0.3.3

.github/workflows/bvt.yaml

@@ -1,7 +1,7 @@
 name: BVT
 on: [pull_request]
 env:
-  RUST_VERSION: 1.52
+  RUST_VERSION: 1.69.0
 jobs:
   build:
     name: Build

.gitignore

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

Cargo.toml

@@ -5,7 +5,7 @@ repository = "https://github.com/kata-containers/cgroups-rs"
 keywords = ["linux", "cgroup", "containers", "isolation"]
 categories = ["os", "api-bindings", "os::unix-apis"]
 license = "MIT OR Apache-2.0"
-version = "0.3.1"
+version = "0.3.3"
 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"

src/cgroup.rs

@@ -16,6 +16,11 @@ use std::convert::From;
 use std::fs;
 use std::path::{Path, PathBuf};
 
+pub const CGROUP_MODE_DOMAIN: &str = "domain";
+pub const CGROUP_MODE_DOMAIN_THREADED: &str = "domain threaded";
+pub const CGROUP_MODE_DOMAIN_INVALID: &str = "domain invalid";
+pub const CGROUP_MODE_THREADED: &str = "threaded";
+
 /// A control group is the central structure to this crate.
 ///
 ///
@@ -68,8 +73,13 @@ impl Cgroup {
         self.hier.v2()
     }
 
+    /// Return the path the cgroup is located at.
+    pub fn path(&self) -> &str {
+        &self.path
+    }
+
     /// Create this control group.
-    fn create(&self) -> Result<()> {
+    pub fn create(&self) -> Result<()> {
         if self.hier.v2() {
             create_v2_cgroup(self.hier.root(), &self.path, &self.specified_controllers)
         } else {
@@ -346,7 +356,18 @@ impl Cgroup {
             let subsystems = self.subsystems();
             if !subsystems.is_empty() {
                 let c = subsystems[0].to_controller();
-                c.add_task(&tid)
+                let cgroup_type = self.get_cgroup_type()?;
+                // In cgroup v2, writing to the cgroup.threads file is only supported in thread mode.
+                if cgroup_type == *CGROUP_MODE_DOMAIN_THREADED
+                    || cgroup_type == *CGROUP_MODE_THREADED
+                {
+                    // It is used to move the threads of a process into a cgroup in thread mode.
+                    c.add_task(&tid)
+                } else {
+                    // When the cgroup type is domain or domain invalid,
+                    // cgroup.threads cannot be written.
+                    Err(Error::new(CgroupMode))
+                }
             } else {
                 Err(Error::new(SubsystemsEmpty))
             }
@@ -363,6 +384,8 @@ impl Cgroup {
             let subsystems = self.subsystems();
             if !subsystems.is_empty() {
                 let c = subsystems[0].to_controller();
+                // It is used to move a thread of the process to a cgroup,
+                // and other threads of the process will also move together.
                 c.add_task_by_tgid(&tgid)
             } else {
                 Err(Error::new(SubsystemsEmpty))
@@ -474,6 +497,13 @@ impl Cgroup {
         v.dedup();
         v
     }
+
+    /// Checks if the cgroup exists.
+    ///
+    /// Returns true if at least one subsystem exists.
+    pub fn exists(&self) -> bool {
+        self.subsystems().iter().any(|e| e.to_controller().exists())
+    }
 }
 
 pub const UNIFIED_MOUNTPOINT: &str = "/sys/fs/cgroup";

src/devices.rs

@@ -46,6 +46,7 @@ pub enum DeviceType {
     Block,
 }
 
+#[allow(clippy::derivable_impls)]
 impl Default for DeviceType {
     fn default() -> Self {
         DeviceType::All
@@ -170,9 +171,9 @@ impl ControllerInternal for DevicesController {
 
         for i in &res.devices {
             if i.allow {
-                let _ = self.allow_device(i.devtype, i.major, i.minor, &i.access);
+                self.allow_device(i.devtype, i.major, i.minor, &i.access)?;
             } else {
-                let _ = self.deny_device(i.devtype, i.major, i.minor, &i.access);
+                self.deny_device(i.devtype, i.major, i.minor, &i.access)?;
             }
         }
 
@@ -238,7 +239,13 @@ impl DevicesController {
         let final_str = format!("{} {}:{} {}", devtype.to_char(), major, minor, perms);
         self.open_path("devices.allow", true).and_then(|mut file| {
             file.write_all(final_str.as_ref()).map_err(|e| {
-                Error::with_cause(WriteFailed("devices.allow".to_string(), final_str), e)
+                Error::with_cause(
+                    WriteFailed(
+                        self.get_path().join("devices.allow").display().to_string(),
+                        final_str,
+                    ),
+                    e,
+                )
             })
         })
     }
@@ -271,7 +278,13 @@ impl DevicesController {
         let final_str = format!("{} {}:{} {}", devtype.to_char(), major, minor, perms);
         self.open_path("devices.deny", true).and_then(|mut file| {
             file.write_all(final_str.as_ref()).map_err(|e| {
-                Error::with_cause(WriteFailed("devices.deny".to_string(), final_str), e)
+                Error::with_cause(
+                    WriteFailed(
+                        self.get_path().join("devices.deny").display().to_string(),
+                        final_str,
+                    ),
+                    e,
+                )
             })
         })
     }

src/error.rs

@@ -59,6 +59,10 @@ pub enum ErrorKind {
     #[error("using method in wrong cgroup version")]
     CgroupVersion,
 
+    /// Using method in wrong cgroup mode.
+    #[error("using method in wrong cgroup mode.")]
+    CgroupMode,
+
     /// Subsystems is empty.
     #[error("subsystems is empty")]
     SubsystemsEmpty,

src/hugetlb.rs

@@ -138,8 +138,11 @@ impl HugeTlbController {
     /// Get the limit (in bytes) of how much memory can be backed by hugepages of a certain size
     /// (`hugetlb_size`).
     pub fn limit_in_bytes(&self, hugetlb_size: &str) -> Result<u64> {
-        self.open_path(&format!("hugetlb.{}.limit_in_bytes", hugetlb_size), false)
-            .and_then(read_u64_from)
+        let mut file_name = format!("hugetlb.{}.limit_in_bytes", hugetlb_size);
+        if self.v2 {
+            file_name = format!("hugetlb.{}.max", hugetlb_size);
+        }
+        self.open_path(&file_name, false).and_then(read_u64_from)
     }
 
     /// Get the current usage of memory that is backed by hugepages of a certain size

src/lib.rs

@@ -879,6 +879,7 @@ pub enum MaxValue {
     Value(i64),
 }
 
+#[allow(clippy::derivable_impls)]
 impl Default for MaxValue {
     fn default() -> Self {
         MaxValue::Max

tests/cgroup.rs

@@ -5,6 +5,10 @@
 //
 
 //! Simple unit tests about the control groups system.
+use cgroups_rs::cgroup::{
+    CGROUP_MODE_DOMAIN, CGROUP_MODE_DOMAIN_INVALID, CGROUP_MODE_DOMAIN_THREADED,
+    CGROUP_MODE_THREADED,
+};
 use cgroups_rs::memory::MemController;
 use cgroups_rs::Controller;
 use cgroups_rs::{Cgroup, CgroupPid, Subsystem};
@@ -36,6 +40,127 @@ fn test_procs_iterator_cgroup() {
     cg.delete().unwrap();
 }
 
+#[test]
+fn test_tasks_iterator_cgroup_v1() {
+    if cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
+        return;
+    }
+    let h = cgroups_rs::hierarchies::auto();
+    let pid = libc::pid_t::from(nix::unistd::getpid()) as u64;
+    let cg = Cgroup::new(h, String::from("test_tasks_iterator_cgroup_v1")).unwrap();
+    {
+        // Add a task to the control group.
+        cg.add_task(CgroupPid::from(pid)).unwrap();
+
+        let mut tasks = cg.tasks().into_iter();
+        // Verify that the task is indeed in the xcontrol group
+        assert_eq!(tasks.next(), Some(CgroupPid::from(pid)));
+        assert_eq!(tasks.next(), None);
+
+        // Now, try removing it.
+        cg.remove_task(CgroupPid::from(pid)).unwrap();
+        tasks = cg.tasks().into_iter();
+
+        // Verify that it was indeed removed.
+        assert_eq!(tasks.next(), None);
+    }
+    cg.delete().unwrap();
+}
+
+#[test]
+fn test_tasks_iterator_cgroup_threaded_mode() {
+    if !cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
+        return;
+    }
+    let pid = libc::pid_t::from(nix::unistd::getpid()) as u64;
+    let cg = Cgroup::new(
+        cgroups_rs::hierarchies::auto(),
+        String::from("test_tasks_iterator_cgroup_threaded_mode"),
+    )
+    .unwrap();
+    let cg_threaded_sub1 = Cgroup::new_with_specified_controllers(
+        cgroups_rs::hierarchies::auto(),
+        String::from("test_tasks_iterator_cgroup_threaded_mode/threaded_sub1"),
+        Some(vec![String::from("cpuset"), String::from("cpu")]),
+    )
+    .unwrap();
+    let cg_threaded_sub2 = Cgroup::new_with_specified_controllers(
+        cgroups_rs::hierarchies::auto(),
+        String::from("test_tasks_iterator_cgroup_threaded_mode/threaded_sub2"),
+        Some(vec![String::from("cpuset"), String::from("cpu")]),
+    )
+    .unwrap();
+    {
+        // Verify that cgroup type of the control group is domain mode.
+        assert_eq!(cg.get_cgroup_type().unwrap(), CGROUP_MODE_DOMAIN);
+
+        // Set cgroup type of the sub-control group is thread mode.
+        cg_threaded_sub1
+            .set_cgroup_type(CGROUP_MODE_THREADED)
+            .unwrap();
+        // Verify that cgroup type of the sub-control group is thread mode.
+        assert_eq!(
+            cg_threaded_sub1.get_cgroup_type().unwrap(),
+            CGROUP_MODE_THREADED
+        );
+        // Verify that the cgroup type of the sub-control group that does
+        // not set the cgroup type is domain invalid mode.
+        assert_eq!(
+            cg_threaded_sub2.get_cgroup_type().unwrap(),
+            CGROUP_MODE_DOMAIN_INVALID
+        );
+        // Verify whether the cgroup type of the parent control group of
+        // the control group whose cgroup type is set to thread mode is
+        // domain thread mode.
+        assert_eq!(cg.get_cgroup_type().unwrap(), CGROUP_MODE_DOMAIN_THREADED);
+
+        // Set cgroup type of the sub-control group is thread mode.
+        cg_threaded_sub2
+            .set_cgroup_type(CGROUP_MODE_THREADED)
+            .unwrap();
+        // Verify that cgroup type of the sub-control group is thread mode.
+        assert_eq!(
+            cg_threaded_sub2.get_cgroup_type().unwrap(),
+            CGROUP_MODE_THREADED
+        );
+
+        // Add a proc to the control group.
+        cg.add_task_by_tgid(CgroupPid::from(pid)).unwrap();
+
+        let mut procs = cg.procs().into_iter();
+        // Verify that the task is indeed in the x control group
+        assert_eq!(procs.next(), Some(CgroupPid::from(pid)));
+        assert_eq!(procs.next(), None);
+
+        // Add a task to the sub control group.
+        cg_threaded_sub1.add_task(CgroupPid::from(pid)).unwrap();
+
+        let mut tasks = cg_threaded_sub1.tasks().into_iter();
+        // Verify that the task is indeed in the xcontrol group
+        assert_eq!(tasks.next(), Some(CgroupPid::from(pid)));
+        assert_eq!(tasks.next(), None);
+
+        // Now, try move it to parent.
+        cg_threaded_sub1
+            .move_task_to_parent(CgroupPid::from(pid))
+            .unwrap();
+        tasks = cg_threaded_sub1.tasks().into_iter();
+
+        // Verify that it was indeed removed.
+        assert_eq!(tasks.next(), None);
+
+        // Now, try removing it.
+        cg.remove_task_by_tgid(CgroupPid::from(pid)).unwrap();
+        procs = cg.procs().into_iter();
+
+        // Verify that it was indeed removed.
+        assert_eq!(procs.next(), None);
+    }
+    cg_threaded_sub1.delete().unwrap();
+    cg_threaded_sub2.delete().unwrap();
+    cg.delete().unwrap();
+}
+
 #[test]
 fn test_kill_cgroup() {
     if !cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
@@ -74,7 +199,7 @@ fn test_kill_cgroup() {
                 }
             }
         };
-        assert!(!status.is_none());
+        assert!(status.is_some());
     }
     cg.delete().unwrap();
 }
@@ -146,57 +271,3 @@ fn test_cgroup_v2() {
 
     cg.delete().unwrap();
 }
-
-#[test]
-fn test_tasks_iterator_cgroup_threaded_mode() {
-    if !cgroups_rs::hierarchies::is_cgroup2_unified_mode() {
-        return;
-    }
-    let h = cgroups_rs::hierarchies::auto();
-    let pid = libc::pid_t::from(nix::unistd::getpid()) as u64;
-    let cg = Cgroup::new(h, String::from("test_tasks_iterator_cgroup_threaded_mode")).unwrap();
-    let h = cgroups_rs::hierarchies::auto();
-    let specified_controllers = vec![String::from("cpuset"), String::from("cpu")];
-    let cg_threaded = Cgroup::new_with_specified_controllers(
-        h,
-        String::from("test_tasks_iterator_cgroup_threaded_mode/threaded"),
-        Some(specified_controllers),
-    )
-    .unwrap();
-    cg_threaded.set_cgroup_type("threaded").unwrap();
-    {
-        // Add a task to the control group.
-        cg.add_task_by_tgid(CgroupPid::from(pid)).unwrap();
-
-        let mut procs = cg.procs().into_iter();
-        // Verify that the task is indeed in the xcontrol group
-        assert_eq!(procs.next(), Some(CgroupPid::from(pid)));
-        assert_eq!(procs.next(), None);
-
-        // Add a task to the sub control group.
-        cg_threaded.add_task(CgroupPid::from(pid)).unwrap();
-
-        let mut tasks = cg_threaded.tasks().into_iter();
-        // Verify that the task is indeed in the xcontrol group
-        assert_eq!(tasks.next(), Some(CgroupPid::from(pid)));
-        assert_eq!(tasks.next(), None);
-
-        // Now, try move it to parent.
-        cg_threaded
-            .move_task_to_parent(CgroupPid::from(pid))
-            .unwrap();
-        tasks = cg_threaded.tasks().into_iter();
-
-        // Verify that it was indeed removed.
-        assert_eq!(tasks.next(), None);
-
-        // Now, try removing it.
-        cg.remove_task_by_tgid(CgroupPid::from(pid)).unwrap();
-        procs = cg.procs().into_iter();
-
-        // Verify that it was indeed removed.
-        assert_eq!(procs.next(), None);
-    }
-    cg_threaded.delete().unwrap();
-    cg.delete().unwrap();
-}