Struct Subsystem

pub struct Subsystem { /* private fields */ }

Handler of a HugeTLB subsystem.

Implementations

impl Subsystem

pub fn size_supported(&self, size: HugepageSize) -> bool

Returns whether the system supports hugepage in size.

Note that this method returns false if the directory of this cgroup is not created yet.

Example

use std::path::PathBuf;
use controlgroup::v1::{hugetlb::{self, HugepageSize}, Cgroup, CgroupPath, SubsystemKind};

let mut cgroup = hugetlb::Subsystem::new(
    CgroupPath::new(SubsystemKind::HugeTlb, PathBuf::from("students/charlie")));
cgroup.create()?;

let support_2mb = cgroup.size_supported(HugepageSize::Mb2);
let support_1gb = cgroup.size_supported(HugepageSize::Gb1);

pub fn limit_in_bytes(&self, size: HugepageSize) -> Result<u64>

Reads the limit of hugepage TLB usage in bytes from hugetlb.<hugepage size>.limit_in_bytes file.

See the kernel’s documentation for more information about this field.

Errors

Returns an error if failed to read and parse hugetlb.<hugepage size>.limit_in_bytes file of this cgroup.

Examples

use std::path::PathBuf;
use controlgroup::v1::{hugetlb, Cgroup, CgroupPath, SubsystemKind};

let cgroup = hugetlb::Subsystem::new(
    CgroupPath::new(SubsystemKind::HugeTlb, PathBuf::from("students/charlie")));

let limit_in_bytes = cgroup.limit_in_bytes(hugetlb :: HugepageSize :: Mb2)?;

pub fn limit_in_pages(&self, size: HugepageSize) -> Result<u64>

Reads the limit of hugepage TLB usage in bytes in pages. See limit_in_bytes method for more information.

pub fn set_limit(&mut self, size: HugepageSize, limit: Limit) -> Result<()>

Sets a limit of hugepage TLB usage by writing to hugetlb.<hugepage size>.limit_in_bytes file.

See the kernel’s documentation for more information about this field.

Errors

Returns an error if failed to write to hugetlb.<hugepage size>.limit_in_bytes file of this cgroup.

Examples

use std::path::PathBuf;
use controlgroup::v1::{hugetlb, Cgroup, CgroupPath, SubsystemKind};

let mut cgroup = hugetlb::Subsystem::new(
    CgroupPath::new(SubsystemKind::HugeTlb, PathBuf::from("students/charlie")));

cgroup.set_limit(hugetlb::HugepageSize::Mb2, hugetlb::Limit::Pages(4))?;

pub fn set_limit_in_bytes( &mut self, size: HugepageSize, bytes: u64, ) -> Result<()>

Sets a limit of hugepage TLB usage in bytes. See set_limit method for more information.

pub fn set_limit_in_pages( &mut self, size: HugepageSize, pages: u64, ) -> Result<()>

Sets a limit of hugepage TLB usage in pages. See set_limit method for more information.

pub fn usage_in_bytes(&self, size: HugepageSize) -> Result<u64>

Reads the current usage of hugepage TLB in bytes from hugetlb.<hugepage size>.usage_in_bytes file.

See the kernel’s documentation for more information about this field.

Errors

Returns an error if failed to read and parse hugetlb.<hugepage size>.usage_in_bytes file of this cgroup.

Examples

use std::path::PathBuf;
use controlgroup::v1::{hugetlb, Cgroup, CgroupPath, SubsystemKind};

let cgroup = hugetlb::Subsystem::new(
    CgroupPath::new(SubsystemKind::HugeTlb, PathBuf::from("students/charlie")));

let usage_in_bytes = cgroup.usage_in_bytes(hugetlb :: HugepageSize :: Mb2)?;

pub fn usage_in_pages(&self, size: HugepageSize) -> Result<u64>

Reads the current usage of hugepage TLB in bytes in pages. See usage_in_bytes method for more information.

pub fn max_usage_in_bytes(&self, size: HugepageSize) -> Result<u64>

Reads the maximum recorded usage of hugepage TLB in bytes from hugetlb.<hugepage size>.max_usage_in_bytes file.

See the kernel’s documentation for more information about this field.

Errors

Returns an error if failed to read and parse hugetlb.<hugepage size>.max_usage_in_bytes file of this cgroup.

Examples

use std::path::PathBuf;
use controlgroup::v1::{hugetlb, Cgroup, CgroupPath, SubsystemKind};

let cgroup = hugetlb::Subsystem::new(
    CgroupPath::new(SubsystemKind::HugeTlb, PathBuf::from("students/charlie")));

let max_usage_in_bytes = cgroup.max_usage_in_bytes(hugetlb :: HugepageSize :: Mb2)?;

pub fn max_usage_in_pages(&self, size: HugepageSize) -> Result<u64>

Reads the maximum recorded usage of hugepage TLB in bytes in pages. See max_usage_in_bytes method for more information.

pub fn failcnt(&self, size: HugepageSize) -> Result<u64>

Reads the number of allocation failure due to the limit, from hugetlb.<hugepage size>.failcnt file.

See the kernel’s documentation for more information about this field.

Errors

Returns an error if failed to read and parse hugetlb.<hugepage size>.failcnt file of this cgroup.

Examples

use std::path::PathBuf;
use controlgroup::v1::{hugetlb, Cgroup, CgroupPath, SubsystemKind};

let cgroup = hugetlb::Subsystem::new(
    CgroupPath::new(SubsystemKind::HugeTlb, PathBuf::from("students/charlie")));

let failcnt = cgroup.failcnt(hugetlb::HugepageSize::Mb2)?;

Trait Implementations

impl Cgroup for Subsystem

fn apply(&mut self, resources: &Resources) -> Result<()>

Applies resources.hugetlb.limits if it is not empty.

fn new(path: CgroupPath) -> Self

Defines a new cgroup with a path.

fn subsystem(&self) -> SubsystemKind

Returns the subsystem to which this cgroup belongs.

fn path(&self) -> PathBuf

Returns the absolute path to this cgroup.

fn is_root(&self) -> bool

Returns whether this cgroup is the root cgroup of a subsystem.

fn root_cgroup(&self) -> Box<Self>

Returns the definition of the root cgroup for the subsystem of this cgroup.

fn create(&mut self) -> Result<()>

Creates a new directory for this cgroup.

fn delete(&mut self) -> Result<()>

Deletes the directory of this cgroup.

fn tasks(&self) -> Result<Vec<Pid>>

Reads a list of tasks attached to this cgroup, from tasks file. The resulting tasks are represented by their thread IDs.

fn add_task(&mut self, pid: impl Into<Pid>) -> Result<()>

Attaches a task to this cgroup by writing a thread ID to tasks file.

fn remove_task(&mut self, pid: impl Into<Pid>) -> Result<()>

Removes a task from this cgroup by writing a thread ID to tasks file of the root cgroup.

fn procs(&self) -> Result<Vec<Pid>>

Reads a list of processes attached to this cgroup, from cgroup.procs file. The resulting tasks are represented by their PIDs.

fn add_proc(&mut self, pid: impl Into<Pid>) -> Result<()>

Attaches a process to this cgroup, with all threads in the same thread group at once, by writing a PID to cgroup.procs file.

fn remove_proc(&mut self, pid: impl Into<Pid>) -> Result<()>

Removes a process from this cgroup, with all threads in the same thread group at once, by writing a PID to cgroup.procs file of the root cgroup.

fn notify_on_release(&self) -> Result<bool>

Reads whether the system executes the executable written in release_agent file when this cgroup no longer has any task, from notify_on_release file.

fn set_notify_on_release(&mut self, enable: bool) -> Result<()>

Sets whether the system executes the executable written in release_agent file when this cgroup no longer has any task, by writing to notify_on_release file.

fn release_agent(&self) -> Result<String>

Reads the command to be executed when “notify on release” is triggered, i.e. this cgroup is emptied of all tasks, from release_agent file.

fn set_release_agent(&mut self, agent_path: impl AsRef<[u8]>) -> Result<()>

Sets a command to be executed when “notify on release” is triggered, i.e. this cgroup is emptied of all tasks, by writing to release_agent file.

fn sane_behavior(&self) -> Result<bool>

Reads whether the subsystem of this cgroup is forced to follow “sane behavior”, from cgroup.sane_behavior file.

fn file_exists(&self, name: &str) -> bool

Returns whether a file with the given name exists in this cgroup.

fn open_file_read(&self, name: &str) -> Result<File>

Low-level API that opens a file with read access.

fn open_file_write(&mut self, name: &str) -> Result<File>

Low-level API that opens a file with write access.

impl Debug for Subsystem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.