Enum SchedPolicy 

pub enum SchedPolicy {
    Normal,
    Batch,
    Idle,
    Fifo(u32),
    RoundRobin(u32),
    Deadline {
        runtime: Duration,
        deadline: Duration,
        period: Duration,
    },
    Ext,
}

Linux scheduling policy for a worker process.

Fifo, RoundRobin, and Deadline all require CAP_SYS_NICE (user_check_sched_setscheduler in kernel/sched/syscalls.c routes rt_policy and dl_policy through req_priv). Normal, Batch, and (entering) Idle are unprivileged transitions for fair-policy tasks. Priority values for Fifo/RoundRobin are clamped to 1-99.

Variants

Normal

SCHED_NORMAL (CFS/EEVDF).

Batch

SCHED_BATCH.

Idle

SCHED_IDLE.

Fifo(u32)

SCHED_FIFO with the given priority (1-99).

RoundRobin(u32)

SCHED_RR with the given priority (1-99).

Deadline

SCHED_DEADLINE with explicit runtime, deadline, and period. Applied via sched_setattr(2).

Each field is a Duration — the nanosecond representation the kernel requires is materialised at the syscall site, so callers express intent in idiomatic Rust units (Duration::from_micros(100), Duration::from_millis(1), etc.) and don’t have to thread integer-nanosecond literals through their test fixtures.

Constraints (from __checkparam_dl in kernel/sched/deadline.c):

• deadline != Duration::ZERO.
• runtime must be at least 1024 ns (the kernel’s DL_SCALE floor); shorter runtimes are silently truncated inside the kernel and break bandwidth accounting.
• runtime <= deadline.
• period == Duration::ZERO is legal — the kernel substitutes deadline for the period when zero. When non-zero, deadline <= period.
• The effective period (period if non-zero, else deadline) is checked against /proc/sys/kernel/sched_deadline_period_min_us (default 100us = 100_000 ns) and /proc/sys/kernel/sched_deadline_period_max_us (default 1 << 22 us = 4_194_304_000 ns), inclusive. Both sysctls are runtime-tunable; this crate does not pre-validate the sysctl range and lets the kernel surface out-of-range values as EINVAL.
• The nanosecond count of deadline and period must each fit in 63 bits (< 1 << 63, i.e. <= i64::MAX ns ≈ 292 years) — the kernel uses bit 63 internally. Any longer Duration is rejected at the syscall site.

Transitions to/from Deadline always require CAP_SYS_NICE. Tasks set to Deadline get exclusive bandwidth on the admission-controlled root domain; oversubscription returns EBUSY (see sched_dl_overflow in kernel/sched/deadline.c).

set_sched_policy validates the structural constraints (zero-deadline, DL_SCALE floor, ordering, top-bit) before invoking sched_setattr so a malformed Deadline fails fast in user space rather than tunneling an EINVAL through the syscall.

Fields

runtime: Duration

Runtime budget per period.

deadline: Duration

Relative deadline from period start.

period: Duration

Period. Duration::ZERO means “use deadline as the period” per the kernel’s __checkparam_dl substitution.

Ext

SCHED_EXT — routes the worker through the loaded sched_ext BPF scheduler. Applied via sched_setattr(2) with sched_policy = SCHED_EXT (7); glibc does not wrap SCHED_EXT, so set_sched_policy issues the raw syscall. SCHED_EXT is a valid policy whenever the kernel is built with CONFIG_SCHED_CLASS_EXT, so the syscall SUCCEEDS whether or not a scheduler is attached: attached, the task routes to ext_sched_class; with none attached task_should_scx is false so it silently falls back to fair_sched_class (still policy == SCHED_EXT). It EINVALs only on a kernel built WITHOUT CONFIG_SCHED_CLASS_EXT. scx_check_setscheduler (kernel/sched/ext.c) returns EACCES when the task carries scx.disallow. No priority or deadline parameters apply.

Unlike Normal under a switch-all scheduler — which the kernel reroutes to the ext class via task_should_scx WITHOUT changing the task’s policy — Ext sets policy == SCHED_EXT explicitly, so the task is BPF-scheduled even under a SCX_OPS_SWITCH_PARTIAL scheduler that leaves SCHED_OTHER tasks in fair. That is what makes a SCHED_EXT worker a switch-mode-agnostic “the BPF scheduler dispatched me” probe.

Implementations

impl SchedPolicy

pub const fn fifo(priority: u32) -> Self

SCHED_FIFO with the given priority (1-99).

pub const fn round_robin(priority: u32) -> Self

SCHED_RR with the given priority (1-99).

pub const fn deadline( runtime: Duration, deadline: Duration, period: Duration, ) -> Self

SCHED_DEADLINE with the given runtime / deadline / period. See SchedPolicy::Deadline for parameter constraints.

All three arguments share the same Duration type. The canonical order is (runtime, deadline, period) — runtime budget first, then the relative deadline, then the period. For tests that need to make the order obvious at the call site, prefer the struct-literal form SchedPolicy::Deadline { runtime: ..., deadline: ..., period: ... } which carries the field names through the reader’s eye.

// Convenience constructor — canonical (runtime, deadline, period) order.
let p = SchedPolicy::deadline(
    Duration::from_micros(500), // runtime
    Duration::from_millis(1),   // deadline
    Duration::from_millis(10),  // period
);
// Struct-literal form — names elide positional confusion.
let q = SchedPolicy::Deadline {
    runtime: Duration::from_micros(500),
    deadline: Duration::from_millis(1),
    period: Duration::from_millis(10),
};
assert!(matches!(p, SchedPolicy::Deadline { .. }));
assert!(matches!(q, SchedPolicy::Deadline { .. }));

Trait Implementations

impl Clone for SchedPolicy

fn clone(&self) -> SchedPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SchedPolicy

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

Formats the value using the given formatter.

impl Default for SchedPolicy

fn default() -> SchedPolicy

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for SchedPolicy

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for SchedPolicy

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for SchedPolicy

fn eq(&self, other: &SchedPolicy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SchedPolicy

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for SchedPolicy

impl Eq for SchedPolicy

impl StructuralPartialEq for SchedPolicy