Merge pull request #83 from Furisto/info-cmd

Add info command

src/cgroups/common.rs

@@ -6,7 +6,8 @@ use std::{
  path::{Path, PathBuf},
 };
 
-use anyhow::{anyhow, bail, Context, Result};
+
+use anyhow::{bail, Context, Result};
 use nix::unistd::Pid;
 use oci_spec::LinuxResources;
 use procfs::process::Process;
@@ -67,13 +68,27 @@ pub fn write_cgroup_file<P: AsRef<Path>, T: ToString>(path: P, data: T) -> Resul
  Ok(())
 }
 
-pub fn get_cgroupv1_mount_path(subsystem: &str) -> Result<PathBuf> {
- Process::myself()?
+pub fn get_supported_cgroup_fs() -> Result<Vec<Cgroup>> {
+ let cgroup_mount = Process::myself()?
+ .mountinfo()?
+ .into_iter()
+ .find(|m| m.fs_type == "cgroup");
+
+ let cgroup2_mount = Process::myself()?
  .mountinfo()?
  .into_iter()
- .find(|m| m.fs_type == "cgroup" && m.mount_point.ends_with(subsystem))
- .map(|m| m.mount_point)
- .ok_or_else(|| anyhow!("could not find mountpoint for {}", subsystem))
+ .find(|m| m.fs_type == "cgroup2");
+
+ let mut cgroups = vec![];
+ if cgroup_mount.is_some() {
+ cgroups.push(Cgroup::V1);
+ }
+
+ if cgroup2_mount.is_some() {
+ cgroups.push(Cgroup::V2);
+ }
+
+ Ok(cgroups)
 }
 
 pub fn create_cgroup_manager<P: Into<PathBuf>>(cgroup_path: P) -> Result<Box<dyn CgroupManager>> {

src/cgroups/v1/controller_type.rs

@@ -1,4 +1,4 @@
-use std::string::ToString;
+use std::fmt::Display;
 
 pub enum ControllerType {
  Cpu,
@@ -12,18 +12,32 @@ pub enum ControllerType {
  NetworkClassifier,
 }
 
-impl ToString for ControllerType {
- fn to_string(&self) -> String {
- match self {
- Self::Cpu => "cpu".into(),
- Self::CpuSet => "cpuset".into(),
- Self::Devices => "devices".into(),
- Self::HugeTlb => "hugetlb".into(),
- Self::Pids => "pids".into(),
- Self::Memory => "memory".into(),
- Self::Blkio => "blkio".into(),
- Self::NetworkPriority => "net_prio".into(),
- Self::NetworkClassifier => "net_cls".into(),
- }
+impl Display for ControllerType {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ let print = match *self {
+ Self::Cpu => "cpu",
+ Self::CpuSet => "cpuset",
+ Self::Devices => "devices",
+ Self::HugeTlb => "hugetlb",
+ Self::Pids => "pids",
+ Self::Memory => "memory",
+ Self::Blkio => "blkio",
+ Self::NetworkPriority => "net_prio",
+ Self::NetworkClassifier => "net_cls",
+ };
+
+ write!(f, "{}", print)
  }
 }
+
+pub const CONTROLLERS: &[ControllerType] = &[
+ ControllerType::Cpu,
+ ControllerType::CpuSet,
+ ControllerType::Devices,
+ ControllerType::HugeTlb,
+ ControllerType::Memory,
+ ControllerType::Pids,
+ ControllerType::Blkio,
+ ControllerType::NetworkPriority,
+ ControllerType::NetworkClassifier,
+];

src/cgroups/v1/cpuset.rs

@@ -6,7 +6,7 @@ use oci_spec::{LinuxCpu, LinuxResources};
 
 use crate::cgroups::common::{self, CGROUP_PROCS};
 
-use super::{Controller, ControllerType};
+use super::{util, Controller, ControllerType};
 
 const CGROUP_CPUSET_CPUS: &str = "cpuset.cpus";
 const CGROUP_CPUSET_MEMS: &str = "cpuset.mems";
@@ -34,19 +34,19 @@ impl CpuSet {
  fn apply(cgroup_path: &Path, cpuset: &LinuxCpu) -> Result<()> {
  if let Some(cpus) = &cpuset.cpus {
  common::write_cgroup_file_str(cgroup_path.join(CGROUP_CPUSET_CPUS), cpus)?;
- } 
+ }
 
  if let Some(mems) = &cpuset.mems {
  common::write_cgroup_file_str(cgroup_path.join(CGROUP_CPUSET_MEMS), mems)?;
- } 
+ }
 
  Ok(())
  }
 
  // if a task is moved into the cgroup and a value has not been set for cpus and mems
  // Errno 28 (no space left on device) will be returned. Therefore we set the value from the parent if required.
  fn ensure_not_empty(cgroup_path: &Path, interface_file: &str) -> Result<()> {
- let mut current = common::get_cgroupv1_mount_path(&ControllerType::CpuSet.to_string())?;
+ let mut current = util::get_subsystem_mount_points(&ControllerType::CpuSet.to_string())?;
  let relative_cgroup_path = cgroup_path.strip_prefix(&current)?;
 
  for component in relative_cgroup_path.components() {

src/cgroups/v1/manager.rs

@@ -8,28 +8,15 @@ use nix::unistd::Pid;
 use procfs::process::Process;
 
 use super::{
- blkio::Blkio, cpu::Cpu, cpuset::CpuSet, devices::Devices, hugetlb::Hugetlb, memory::Memory,
- network_classifier::NetworkClassifier, network_priority::NetworkPriority, pids::Pids,
- Controller, ControllerType,
+ blkio::Blkio, controller_type::CONTROLLERS, cpu::Cpu, cpuset::CpuSet, devices::Devices,
+ hugetlb::Hugetlb, memory::Memory, network_classifier::NetworkClassifier,
+ network_priority::NetworkPriority, pids::Pids, util, Controller,
 };
 
 use crate::cgroups::common::CGROUP_PROCS;
 use crate::utils;
 use crate::{cgroups::common::CgroupManager, utils::PathBufExt};
 use oci_spec::LinuxResources;
-
-const CONTROLLERS: &[ControllerType] = &[
- ControllerType::Cpu,
- ControllerType::CpuSet,
- ControllerType::Devices,
- ControllerType::HugeTlb,
- ControllerType::Memory,
- ControllerType::Pids,
- ControllerType::Blkio,
- ControllerType::NetworkPriority,
- ControllerType::NetworkClassifier,
-];
-
 pub struct Manager {
  subsystems: HashMap<String, PathBuf>,
 }
@@ -49,32 +36,7 @@ impl Manager {
 
  fn get_subsystem_path(cgroup_path: &Path, subsystem: &str) -> anyhow::Result<PathBuf> {
  log::debug!("Get path for subsystem: {}", subsystem);
- let mount = Process::myself()?
- .mountinfo()?
- .into_iter()
- .find(|m| {
- if m.fs_type == "cgroup" {
- // Some systems mount net_prio and net_cls in the same directory
- // other systems mount them in their own diretories. This
- // should handle both cases.
- if subsystem == "net_cls" {
- return m.mount_point.ends_with("net_cls,net_prio")
- || m.mount_point.ends_with("net_prio,net_cls")
- || m.mount_point.ends_with("net_cls");
- } else if subsystem == "net_prio" {
- return m.mount_point.ends_with("net_cls,net_prio")
- || m.mount_point.ends_with("net_prio,net_cls")
- || m.mount_point.ends_with("net_prio");
- }
-
- if subsystem == "cpu" {
- return m.mount_point.ends_with("cpu,cpuacct")
- || m.mount_point.ends_with("cpu");
- }
- }
- m.mount_point.ends_with(subsystem)
- })
- .unwrap();
+ let mount_point = util::get_subsystem_mount_points(subsystem)?;
 
  let cgroup = Process::myself()?
  .cgroups()?
@@ -83,13 +45,11 @@ impl Manager {
  .unwrap();
 
  let p = if cgroup_path.to_string_lossy().into_owned().is_empty() {
- mount
- .mount_point
- .join_absolute_path(Path::new(&cgroup.pathname))?
+ mount_point.join_absolute_path(Path::new(&cgroup.pathname))?
  } else if cgroup_path.is_absolute() {
- mount.mount_point.join_absolute_path(&cgroup_path)?
+ mount_point.join_absolute_path(&cgroup_path)?
  } else {
- mount.mount_point.join(cgroup_path)
+ mount_point.join(cgroup_path)
  };
 
  Ok(p)

src/cgroups/v1/mod.rs

@@ -10,6 +10,7 @@ mod memory;
 mod network_classifier;
 mod network_priority;
 mod pids;
+pub mod util;
 pub use controller::Controller;
 pub use controller_type::ControllerType;
 pub use manager::Manager;

src/cgroups/v1/util.rs

@@ -0,0 +1,48 @@
+use std::{collections::HashMap, path::PathBuf};
+
+use anyhow::{anyhow, Result};
+use procfs::process::Process;
+
+use super::controller_type::CONTROLLERS;
+
+pub fn list_subsystem_mount_points() -> Result<HashMap<String, PathBuf>> {
+ let mut mount_paths = HashMap::with_capacity(CONTROLLERS.len());
+
+ for controller in CONTROLLERS {
+ if let Ok(mount_point) = get_subsystem_mount_points(&controller.to_string()) {
+ mount_paths.insert(controller.to_string(), mount_point);
+ }
+ }
+
+ Ok(mount_paths)
+}
+
+pub fn get_subsystem_mount_points(subsystem: &str) -> Result<PathBuf> {
+ Process::myself()?
+ .mountinfo()?
+ .into_iter()
+ .find(|m| {
+ if m.fs_type == "cgroup" {
+ // Some systems mount net_prio and net_cls in the same directory
+ // other systems mount them in their own diretories. This
+ // should handle both cases.
+ if subsystem == "net_cls" {
+ return m.mount_point.ends_with("net_cls,net_prio")
+ || m.mount_point.ends_with("net_prio,net_cls")
+ || m.mount_point.ends_with("net_cls");
+ } else if subsystem == "net_prio" {
+ return m.mount_point.ends_with("net_cls,net_prio")
+ || m.mount_point.ends_with("net_prio,net_cls")
+ || m.mount_point.ends_with("net_prio");
+ }
+
+ if subsystem == "cpu" {
+ return m.mount_point.ends_with("cpu,cpuacct")
+ || m.mount_point.ends_with("cpu");
+ }
+ }
+ m.mount_point.ends_with(&subsystem)
+ })
+ .map(|m| m.mount_point)
+ .ok_or_else(|| anyhow!("could not find mountpoint for {}", subsystem))
+}

src/cgroups/v2/mod.rs

@@ -7,3 +7,4 @@ mod io;
 pub mod manager;
 mod memory;
 mod pids;
+pub mod util;

src/cgroups/v2/util.rs

@@ -0,0 +1,13 @@
+use std::path::PathBuf;
+
+use anyhow::{anyhow, Result};
+use procfs::process::Process;
+
+pub fn get_unified_mount_point() -> Result<PathBuf> {
+ Process::myself()?
+ .mountinfo()?
+ .into_iter()
+ .find(|m| m.fs_type == "cgroup2")
+ .map(|m| m.mount_point)
+ .ok_or_else(|| anyhow!("could not find mountpoint for unified"))
+}

src/main.rs

@@ -2,6 +2,7 @@
 //! Container Runtime written in Rust, inspired by [railcar](https://github.com/oracle/railcar)
 //! This crate provides a container runtime which can be used by a high-level container runtime to run containers.
 
+use procfs;
 use std::fs;
 use std::path::{Path, PathBuf};
 
@@ -66,6 +67,8 @@ enum SubCommand {
  Delete(Delete),
  #[clap(version = "0.0.1", author = "utam0k <[email protected]>")]
  State(StateArgs),
+ #[clap(version = "0.0.1", author = "utam0k <[email protected]>")]
+ Info,
 }
 
 /// This is the entry point in the container runtime. The binary is run by a high-level container runtime,
@@ -162,5 +165,46 @@ fn main() -> Result<()> {
  println!("{}", serde_json::to_string_pretty(&container.state)?);
  std::process::exit(0);
  }
+
+ SubCommand::Info => {
+ let uname = nix::sys::utsname::uname();
+ println!("{:<18}{}", "Kernel-Release", uname.release());
+ println!("{:<18}{}", "Kernel-Version", uname.version());
+ println!("{:<18}{}", "Architecture", uname.machine());
+
+ let cpu_info = procfs::CpuInfo::new()?;
+ println!("{:<18}{}", "Cores", cpu_info.num_cores());
+ let mem_info = procfs::Meminfo::new()?;
+ println!(
+ "{:<18}{}",
+ "Total Memory",
+ mem_info.mem_total / u64::pow(1024, 2)
+ );
+
+ let cgroup_fs: Vec<String> = cgroups::common::get_supported_cgroup_fs()?
+ .into_iter()
+ .map(|c| c.to_string())
+ .collect();
+ println!("{:<18}{}", "cgroup version", cgroup_fs.join(" and "));
+
+ println!("cgroup mounts");
+ let mut cgroup_v1_mounts: Vec<String> =
+ cgroups::v1::util::list_subsystem_mount_points()?
+ .iter()
+ .map(|kv| format!(" {:<16}{:?}", kv.0, kv.1))
+ .collect();
+
+ cgroup_v1_mounts.sort();
+ for cgroup_mount in cgroup_v1_mounts {
+ println!("{}", cgroup_mount);
+ }
+
+ let unified = cgroups::v2::util::get_unified_mount_point();
+ if let Ok(mount_point) = unified {
+ println!(" {:<16}{:?}", "unified", mount_point);
+ }
+
+ Ok(())
+ }
  }
 }