change *limit* in memory from u64 to i64

Signed-off-by: bin liu <bin@hyper.sh>

tests/builder.rs

@@ -11,8 +11,9 @@ use cgroups::cgroup_builder::*;
 
 #[test]
 pub fn test_cpu_res_build() {
-    let v1 = crate::hierarchies::V1::new();
-    let cg: Cgroup = CgroupBuilder::new("test_cpu_res_build", &v1)
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg: Cgroup = CgroupBuilder::new("test_cpu_res_build", h)
         .cpu()
             .shares(85)
             .done()
@@ -29,8 +30,9 @@ pub fn test_cpu_res_build() {
 
 #[test]
 pub fn test_memory_res_build() {
-    let v1 = crate::hierarchies::V1::new();
-    let cg: Cgroup = CgroupBuilder::new("test_memory_res_build", &v1)
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg: Cgroup = CgroupBuilder::new("test_memory_res_build", h)
         .memory()
             .kernel_memory_limit(128 * 1024 * 1024)
             .swappiness(70)
@@ -50,17 +52,18 @@ pub fn test_memory_res_build() {
 
 #[test]
 pub fn test_pid_res_build() {
-    let v1 = crate::hierarchies::V1::new();
-    let cg: Cgroup = CgroupBuilder::new("test_pid_res_build", &v1)
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg: Cgroup = CgroupBuilder::new("test_pid_res_build", h)
         .pid()
-            .maximum_number_of_processes(PidMax::Value(123))
+            .maximum_number_of_processes(MaxValue::Value(123))
             .done()
         .build();
 
     {
         let c: &PidController = cg.controller_of().unwrap();
         assert!(c.get_pid_max().is_ok());
-        assert_eq!(c.get_pid_max().unwrap(), PidMax::Value(123));
+        assert_eq!(c.get_pid_max().unwrap(), MaxValue::Value(123));
     }
 
     cg.delete();
@@ -69,8 +72,9 @@ 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 v1 = crate::hierarchies::V1::new();
-    let cg: Cgroup = CgroupBuilder::new("test_devices_res_build", &v1)
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg: Cgroup = CgroupBuilder::new("test_devices_res_build", h)
         .devices()
             .device(1, 6, DeviceType::Char, true,
                     vec![DevicePermissions::Read])
@@ -95,8 +99,13 @@ pub fn test_devices_res_build() {
 
 #[test]
 pub fn test_network_res_build() {
-    let v1 = crate::hierarchies::V1::new();
-    let cg: Cgroup = CgroupBuilder::new("test_network_res_build", &v1)
+    let h = cgroups::hierarchies::auto();
+    if h.v2() {
+        // FIXME
+        return
+    }
+    let h = Box::new(&*h);
+    let cg: Cgroup = CgroupBuilder::new("test_network_res_build", h)
         .network()
             .class_id(1337)
             .done()
@@ -112,8 +121,13 @@ pub fn test_network_res_build() {
 
 #[test]
 pub fn test_hugepages_res_build() {
-    let v1 = crate::hierarchies::V1::new();
-    let cg: Cgroup = CgroupBuilder::new("test_hugepages_res_build", &v1)
+    let h = cgroups::hierarchies::auto();
+    if h.v2() {
+        // FIXME
+        return
+    }
+    let h = Box::new(&*h);
+    let cg: Cgroup = CgroupBuilder::new("test_hugepages_res_build", h)
         .hugepages()
             .limit("2MB".to_string(), 4 * 2 * 1024 * 1024)
             .done()
@@ -129,8 +143,9 @@ pub fn test_hugepages_res_build() {
 
 #[test]
 pub fn test_blkio_res_build() {
-    let v1 = crate::hierarchies::V1::new();
-    let cg: Cgroup = CgroupBuilder::new("test_blkio_res_build", &v1)
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg: Cgroup = CgroupBuilder::new("test_blkio_res_build", h)
         .blkio()
             .weight(100)
             .done()

tests/cgroup.rs

@@ -1,11 +1,12 @@
 //! Simple unit tests about the control groups system.
-use cgroups::{Cgroup, CgroupPid};
+use cgroups::{Cgroup, CgroupPid, Hierarchy};
 
 #[test]
 fn test_tasks_iterator() {
-    let hier = cgroups::hierarchies::V1::new();
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
     let pid = libc::pid_t::from(nix::unistd::getpid()) as u64;
-    let cg = Cgroup::new(&hier, String::from("test_tasks_iterator"));
+    let cg = Cgroup::new(h, String::from("test_tasks_iterator"));
     {
         // Add a task to the control group.
         cg.add_task(CgroupPid::from(pid));

tests/cpuset.rs

@@ -1,11 +1,12 @@
 use cgroups::cpuset::CpuSetController;
 use cgroups::error::ErrorKind;
-use cgroups::Cgroup;
+use cgroups::{Cgroup, CpuResources, Hierarchy, Resources};
 
 #[test]
 fn test_cpuset_memory_pressure_root_cg() {
-    let hier = cgroups::hierarchies::V1::new();
-    let cg = Cgroup::new(&hier, String::from("test_cpuset_memory_pressure_root_cg"));
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("test_cpuset_memory_pressure_root_cg"));
     {
         let cpuset: &CpuSetController = cg.controller_of().unwrap();
 
@@ -15,3 +16,39 @@ fn test_cpuset_memory_pressure_root_cg() {
     }
     cg.delete();
 }
+
+
+#[test]
+fn test_cpuset_set_cpus() {
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("test_cpuset_set_cpus"));
+    {
+        let cpuset: &CpuSetController = cg.controller_of().unwrap();
+
+        let set = cpuset.cpuset();
+        assert_eq!(0, set.cpus.len());
+
+        // 0
+        let r = cpuset.set_cpus("0");
+        assert_eq!(true, r.is_ok());
+
+        let set = cpuset.cpuset();
+        assert_eq!(1, set.cpus.len());
+        assert_eq!((0,0), set.cpus[0]);
+
+
+        // 0-1
+        // FIXME need two cores
+        let r = cpuset.set_cpus("0-1");
+        assert_eq!(true, r.is_ok());
+
+        let set = cpuset.cpuset();
+        assert_eq!(1, set.cpus.len());
+        assert_eq!((0,1), set.cpus[0]);
+
+
+
+    }
+    cg.delete();
+}

tests/devices.rs

@@ -1,12 +1,13 @@
 //! Integration tests about the devices subsystem
 
 use cgroups::devices::{DevicePermissions, DeviceType, DevicesController};
-use cgroups::{Cgroup, DeviceResource};
+use cgroups::{Cgroup, DeviceResource, Hierarchy};
 
 #[test]
 fn test_devices_parsing() {
-    let hier = cgroups::hierarchies::V1::new();
-    let cg = Cgroup::new(&hier, String::from("test_devices_parsing"));
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("test_devices_parsing"));
     {
         let devices: &DevicesController = cg.controller_of().unwrap();
 

tests/hugetlb.rs

@@ -1,6 +1,6 @@
 //! Integration tests about the hugetlb subsystem
 use cgroups::hugetlb::HugeTlbController;
-use cgroups::Cgroup;
+use cgroups::{Cgroup, Hierarchy};
 use cgroups::Controller;
 
 use cgroups::error::ErrorKind::*;
@@ -8,8 +8,9 @@ use cgroups::error::*;
 
 #[test]
 fn test_hugetlb_sizes() {
-    let hier = cgroups::hierarchies::V1::new();
-    let cg = Cgroup::new(&hier, String::from("test_hugetlb_sizes"));
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("test_hugetlb_sizes"));
     {
         let hugetlb_controller: &HugeTlbController = cg.controller_of().unwrap();
         let sizes = hugetlb_controller.get_sizes();

tests/memory.rs

@@ -1,6 +1,6 @@
 //! Integration tests about the hugetlb subsystem
-use cgroups::memory::MemController;
-use cgroups::Cgroup;
+use cgroups::memory::{MemController, SetMemory};
+use cgroups::{Cgroup, Hierarchy, MaxValue};
 use cgroups::Controller;
 
 use cgroups::error::ErrorKind::*;
@@ -8,8 +8,9 @@ use cgroups::error::*;
 
 #[test]
 fn test_disable_oom_killer() {
-    let hier = cgroups::hierarchies::V1::new();
-    let cg = Cgroup::new(&hier, String::from("test_disable_oom_killer"));
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("test_disable_oom_killer"));
     {
         let mem_controller: &MemController = cg.controller_of().unwrap();
 
@@ -17,13 +18,77 @@ fn test_disable_oom_killer() {
         let m = mem_controller.memory_stat();
         assert_eq!(m.oom_control.oom_kill_disable, false);
 
-        // disable oom killer
-        let r = mem_controller.disable_oom_killer();
-        assert_eq!(r.is_err(), false);
+        // FIXME only v1
+        if !mem_controller.v2(){
+            // disable oom killer
+            let r = mem_controller.disable_oom_killer();
+            assert_eq!(r.is_err(), false);
+
+            // after disable
+            let m = mem_controller.memory_stat();
+            assert_eq!(m.oom_control.oom_kill_disable, true);
+        }
 
-        // after disable
-        let m = mem_controller.memory_stat();
-        assert_eq!(m.oom_control.oom_kill_disable, true);
     }
     cg.delete();
 }
+
+#[test]
+fn set_mem_v2() {
+    let h = cgroups::hierarchies::auto();
+    if !h.v2() {
+        return
+    }
+
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("set_mem_v2"));
+    {
+        let mem_controller: &MemController = cg.controller_of().unwrap();
+
+        // before disable
+        let m = mem_controller.get_mem().unwrap();
+        // case 1: get default value
+        assert_eq!(m.low, Some(MaxValue::Value(0)));
+        assert_eq!(m.min, Some(MaxValue::Value(0)));
+        assert_eq!(m.high, Some(MaxValue::Max));
+        assert_eq!(m.max, Some(MaxValue::Max));
+
+        // case 2: set parts
+        let m = SetMemory{
+            low: Some(MaxValue::Value(1024*1024* 2)),
+            high: Some(MaxValue::Value(1024*1024*1024* 2)),
+            min: Some(MaxValue::Value(1024*1024* 3)),
+            max: None,
+        };
+        let r = mem_controller.set_mem(m);
+        assert_eq!(true, r.is_ok());
+
+        let m = mem_controller.get_mem().unwrap();
+        // get
+        assert_eq!(m.low, Some(MaxValue::Value(1024*1024* 2)));
+        assert_eq!(m.min, Some(MaxValue::Value(1024*1024* 3)));
+        assert_eq!(m.high, Some(MaxValue::Value(1024*1024*1024* 2)));
+        assert_eq!(m.max, Some(MaxValue::Max));
+
+
+
+        // case 3: set parts
+        let m = SetMemory{
+            max: Some(MaxValue::Value(1024*1024*1024* 2)),
+            min: Some(MaxValue::Value(1024*1024* 4)),
+            high: Some(MaxValue::Max),
+            low: None,
+        };
+        let r = mem_controller.set_mem(m);
+        assert_eq!(true, r.is_ok());
+
+        let m = mem_controller.get_mem().unwrap();
+        // get
+        assert_eq!(m.low, Some(MaxValue::Value(1024*1024* 2)));
+        assert_eq!(m.min, Some(MaxValue::Value(1024*1024* 4)));
+        assert_eq!(m.max, Some(MaxValue::Value(1024*1024*1024* 2)));
+        assert_eq!(m.high, Some(MaxValue::Max));
+    }
+
+    cg.delete();
+}

tests/pids.rs

@@ -1,7 +1,7 @@
 //! Integration tests about the pids subsystem
-use cgroups::pid::{PidController, PidMax};
+use cgroups::pid::{PidController};
 use cgroups::Controller;
-use cgroups::{Cgroup, CgroupPid, PidResources, Resources};
+use cgroups::{Cgroup, CgroupPid, Hierarchy, MaxValue, PidResources, Resources};
 
 use nix::sys::wait::{waitpid, WaitStatus};
 use nix::unistd::{fork, ForkResult, Pid};
@@ -12,22 +12,24 @@ use std::thread;
 
 #[test]
 fn create_and_delete_cgroup() {
-    let hier = cgroups::hierarchies::V1::new();
-    let cg = Cgroup::new(&hier, String::from("create_and_delete_cgroup"));
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("create_and_delete_cgroup"));
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
-        pidcontroller.set_pid_max(PidMax::Value(1337));
+        pidcontroller.set_pid_max(MaxValue::Value(1337));
         let max = pidcontroller.get_pid_max();
         assert!(max.is_ok());
-        assert_eq!(max.unwrap(), PidMax::Value(1337));
+        assert_eq!(max.unwrap(), MaxValue::Value(1337));
     }
     cg.delete();
 }
 
 #[test]
 fn test_pids_current_is_zero() {
-    let hier = cgroups::hierarchies::V1::new();
-    let cg = Cgroup::new(&hier, String::from("test_pids_current_is_zero"));
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("test_pids_current_is_zero"));
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
         let current = pidcontroller.get_pid_current();
@@ -38,8 +40,9 @@ fn test_pids_current_is_zero() {
 
 #[test]
 fn test_pids_events_is_zero() {
-    let hier = cgroups::hierarchies::V1::new();
-    let cg = Cgroup::new(&hier, String::from("test_pids_events_is_zero"));
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("test_pids_events_is_zero"));
     {
         let pidcontroller: &PidController = cg.controller_of().unwrap();
         let events = pidcontroller.get_pid_events();
@@ -51,8 +54,9 @@ fn test_pids_events_is_zero() {
 
 #[test]
 fn test_pid_events_is_not_zero() {
-    let hier = cgroups::hierarchies::V1::new();
-    let cg = Cgroup::new(&hier, String::from("test_pid_events_is_not_zero"));
+    let h = cgroups::hierarchies::auto();
+    let h = Box::new(&*h);
+    let cg = Cgroup::new(h, String::from("test_pid_events_is_not_zero"));
     {
         let pids: &PidController = cg.controller_of().unwrap();
         let before = pids.get_pid_events();
@@ -66,7 +70,7 @@ fn test_pid_events_is_not_zero() {
                 println!("added task to cg: {:?}", child);
 
                 // Set limit to one
-                pids.set_pid_max(PidMax::Value(1));
+                pids.set_pid_max(MaxValue::Value(1));
                 println!("err = {:?}", pids.get_pid_max());
 
                 // wait on the child
@@ -84,7 +88,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() == PidMax::Value(1) {
+                if pids_max.is_ok() && pids_max.unwrap() == MaxValue::Value(1) {
                     if let Err(_) = fork() {
                         unsafe { libc::exit(0) };
                     } else {

tests/resources.rs

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