#![allow(unsafe_code)]
use crate::error::{Error, Result};
use serde::{Deserialize, Serialize};
use std::fmt::Write as _;
const SYS_RCTL_ADD_RULE: libc::c_int = 528;
const SYS_RCTL_REMOVE_RULE: libc::c_int = 529;
const SYS_RCTL_GET_RACCT: libc::c_int = 525;
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct ResourceConfig {
pub memory: Option<String>,
pub vmemory: Option<String>,
pub cpu: Option<String>,
pub maxproc: Option<u32>,
pub maxthreads: Option<u32>,
pub openfiles: Option<u32>,
pub swap: Option<String>,
pub cores: Option<u16>,
pub cpuset: Option<String>,
#[serde(default)]
pub rules: Vec<String>,
}
impl ResourceConfig {
pub const fn is_empty(&self) -> bool {
self.memory.is_none()
&& self.vmemory.is_none()
&& self.cpu.is_none()
&& self.maxproc.is_none()
&& self.maxthreads.is_none()
&& self.openfiles.is_none()
&& self.swap.is_none()
&& self.cores.is_none()
&& self.cpuset.is_none()
&& self.rules.is_empty()
}
pub const fn has_rctl_rules(&self) -> bool {
self.memory.is_some()
|| self.vmemory.is_some()
|| self.cpu.is_some()
|| self.maxproc.is_some()
|| self.maxthreads.is_some()
|| self.openfiles.is_some()
|| self.swap.is_some()
|| !self.rules.is_empty()
}
pub(crate) fn to_rules(&self, jail_name: &str) -> Vec<String> {
let mut rules = Vec::new();
if let Some(ref mem) = self.memory {
rules.push(format!("jail:{jail_name}:memoryuse:deny={mem}"));
}
if let Some(ref vmem) = self.vmemory {
rules.push(format!("jail:{jail_name}:vmemoryuse:deny={vmem}"));
}
if let Some(ref cpu) = self.cpu {
rules.push(format!("jail:{jail_name}:pcpu:deny={cpu}"));
}
if let Some(maxproc) = self.maxproc {
rules.push(format!("jail:{jail_name}:maxproc:deny={maxproc}"));
}
if let Some(maxthreads) = self.maxthreads {
rules.push(format!("jail:{jail_name}:nthr:deny={maxthreads}"));
}
if let Some(openfiles) = self.openfiles {
rules.push(format!("jail:{jail_name}:openfiles:deny={openfiles}"));
}
if let Some(ref swap) = self.swap {
rules.push(format!("jail:{jail_name}:swapuse:deny={swap}"));
}
let own_prefix = format!("jail:{jail_name}:");
for rule in &self.rules {
if rule.starts_with("jail:") {
if !rule.starts_with(&own_prefix) {
eprintln!("Warning: rejecting RCTL rule '{rule}' -- targets a different jail");
continue;
}
rules.push(rule.clone());
} else {
rules.push(format!("jail:{jail_name}:{rule}"));
}
}
rules
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Deserialize, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum QosTransition {
#[default]
Healthy,
Timer,
Manual,
}
#[derive(Debug, Clone, Default, Deserialize, Serialize)]
pub struct QosConfig {
pub startup: ResourceConfig,
#[serde(default)]
pub steady: Option<ResourceConfig>,
#[serde(default)]
pub transition: QosTransition,
#[serde(default)]
pub max_startup_secs: Option<u64>,
}
impl QosConfig {
pub fn profile(&self, phase: crate::scope::QosPhase) -> &ResourceConfig {
match phase {
crate::scope::QosPhase::Steady => self.steady.as_ref().unwrap_or(&self.startup),
_ => &self.startup,
}
}
}
const MANAGED_RESOURCES: [&str; 7] = [
"memoryuse",
"vmemoryuse",
"pcpu",
"maxproc",
"nthr",
"openfiles",
"swapuse",
];
#[cfg_attr(
not(feature = "mcp"),
expect(
dead_code,
reason = "the MCP host_facts tool is this accessor's only caller"
)
)]
pub const fn managed_resources() -> &'static [&'static str] {
&MANAGED_RESOURCES
}
fn split_rules(config: &ResourceConfig, jail_name: &str) -> (Vec<(String, String)>, Vec<String>) {
let prefix = format!("jail:{jail_name}:");
let mut managed = Vec::new();
let mut custom = Vec::new();
for rule in config.to_rules(jail_name) {
let resource = rule
.strip_prefix(&prefix)
.and_then(|rest| rest.split(':').next())
.filter(|resource| MANAGED_RESOURCES.contains(resource))
.map(str::to_string);
match resource {
Some(resource) => managed.push((resource, rule)),
None => custom.push(rule),
}
}
(managed, custom)
}
pub fn phase_diff(
jail_name: &str,
from: &ResourceConfig,
to: &ResourceConfig,
) -> (Vec<String>, Vec<String>) {
let (from_managed, from_custom) = split_rules(from, jail_name);
let (to_managed, to_custom) = split_rules(to, jail_name);
let mut removals = Vec::new();
let mut additions = Vec::new();
for (resource, rule) in &from_managed {
match to_managed.iter().find(|(r, _)| r == resource) {
Some((_, new_rule)) if new_rule == rule => {}
_ => removals.push(format!("jail:{jail_name}:{resource}")),
}
}
for (resource, rule) in &to_managed {
match from_managed.iter().find(|(r, _)| r == resource) {
Some((_, old_rule)) if old_rule == rule => {}
_ => additions.push(rule.clone()),
}
}
for rule in &from_custom {
if !to_custom.contains(rule) {
removals.push(rule.clone());
}
}
for rule in &to_custom {
if !from_custom.contains(rule) {
additions.push(rule.clone());
}
}
(removals, additions)
}
pub fn apply_phase(jail_name: &str, from: &ResourceConfig, to: &ResourceConfig) -> Result<()> {
let (removals, additions) = phase_diff(jail_name, from, to);
if removals.is_empty() && additions.is_empty() {
return Ok(());
}
if !is_enabled() {
return Err(Error::Rctl(
"RCTL not enabled. Set kern.racct.enable=1 in /boot/loader.conf and reboot.".into(),
));
}
for filter in &removals {
if let Err(e) = rctl_remove_rule(filter) {
eprintln!("Warning: {e}");
}
}
for rule in &additions {
rctl_add_rule(rule)?;
}
Ok(())
}
pub fn resolve_cpu_list<'a>(
config: &ResourceConfig,
other_pins: impl Iterator<Item = &'a str>,
) -> Option<String> {
if let Some(list) = &config.cpuset {
return Some(list.clone());
}
let want = config.cores? as usize;
let ncpu = unsafe { libc::sysconf(libc::_SC_NPROCESSORS_ONLN) };
let ncpu = usize::try_from(ncpu).ok().filter(|&n| n > 0).unwrap_or(1);
let mut load = vec![0usize; ncpu];
for pin in other_pins {
for part in pin.split(',') {
if let Ok(core) = part.trim().parse::<usize>()
&& core < ncpu
{
load[core] += 1;
}
}
}
let mut cores: Vec<usize> = (0..ncpu).collect();
cores.sort_by_key(|&c| (load[c], c));
cores.truncate(want.min(ncpu));
cores.sort_unstable();
let mut list = String::with_capacity(cores.len() * 3);
for core in cores {
if !list.is_empty() {
list.push(',');
}
let _ = write!(list, "{core}");
}
Some(list)
}
pub fn apply_cpuset(jid: i32, cpu_list: &str) -> Result<()> {
let status = std::process::Command::new("/usr/bin/cpuset")
.args(["-l", cpu_list, "-j", &jid.to_string()])
.status()
.map_err(|e| Error::Rctl(format!("Failed to run cpuset: {e}")))?;
if !status.success() {
return Err(Error::Rctl(format!("cpuset -l {cpu_list} -j {jid} failed")));
}
Ok(())
}
pub fn is_enabled() -> bool {
let output = std::process::Command::new("/sbin/sysctl")
.args(["-n", "kern.racct.enable"])
.output();
match output {
Ok(out) if out.status.success() => String::from_utf8_lossy(&out.stdout).trim() == "1",
_ => false,
}
}
pub fn apply_limits(jail_name: &str, config: &ResourceConfig) -> Result<()> {
if !config.has_rctl_rules() {
return Ok(());
}
if !is_enabled() {
return Err(Error::Rctl(
"RCTL not enabled. Set kern.racct.enable=1 in /boot/loader.conf and reboot.".into(),
));
}
let rules = config.to_rules(jail_name);
for rule in &rules {
rctl_add_rule(rule)?;
}
if !rules.is_empty() {
println!(" Applied {} resource limit(s)", rules.len());
}
Ok(())
}
pub fn remove_limits(jail_name: &str) {
let filter = format!("jail:{jail_name}");
let _ = rctl_remove_rule(&filter);
}
pub fn get_usage(jail_name: &str) -> Result<std::collections::HashMap<String, u64>> {
let filter = format!("jail:{jail_name}");
rctl_get_racct(&filter)
}
fn rctl_string_syscall(
syscall_num: libc::c_int,
arg: &str,
fail_msg: impl FnOnce(std::io::Error) -> String,
) -> Result<()> {
let arg_bytes = arg.as_bytes();
let ret = unsafe {
libc::syscall(
syscall_num,
arg_bytes.as_ptr().cast::<libc::c_void>(),
arg_bytes.len(),
std::ptr::null_mut::<libc::c_void>(),
0usize,
)
};
if ret != 0 {
return Err(Error::Rctl(fail_msg(std::io::Error::last_os_error())));
}
Ok(())
}
fn rctl_add_rule(rule: &str) -> Result<()> {
rctl_string_syscall(SYS_RCTL_ADD_RULE, rule, |e| {
format!("Failed to add rule '{rule}': {e}")
})
}
fn rctl_remove_rule(filter: &str) -> Result<()> {
rctl_string_syscall(SYS_RCTL_REMOVE_RULE, filter, |e| {
format!("Failed to remove rules for '{filter}': {e}")
})
}
fn rctl_get_racct(filter: &str) -> Result<std::collections::HashMap<String, u64>> {
let filter_bytes = filter.as_bytes();
let mut outbuf = [0u8; 4096];
let ret = unsafe {
libc::syscall(
SYS_RCTL_GET_RACCT,
filter_bytes.as_ptr().cast::<libc::c_void>(),
filter_bytes.len(),
outbuf.as_mut_ptr().cast::<libc::c_void>(),
outbuf.len(),
)
};
if ret != 0 {
return Err(Error::Rctl(format!(
"Failed to get resource usage for '{}': {}",
filter,
std::io::Error::last_os_error()
)));
}
let output = String::from_utf8_lossy(&outbuf);
let output = output.trim_end_matches('\0');
let mut usage = std::collections::HashMap::new();
for pair in output.split(',') {
if let Some((key, val)) = pair.split_once('=')
&& let Ok(v) = val.parse::<u64>()
{
usage.insert(key.to_string(), v);
}
}
Ok(usage)
}
#[cfg(test)]
mod tests;