Struct kernel::Kernel

pub struct Kernel {
    pub(crate) inner: KernelInner,
    pub(crate) registry: Mutex<Registry>,
}

Fields

inner: KernelInner

Items that do not require a lock to access, and must only be accessed with shared refs

registry: Mutex<Registry>

The run-time driver registry, accessed via an async Mutex

Implementations

impl Kernel

pub unsafe fn new(settings: KernelSettings) -> Result<Box<Self>, &'static str>

Create a new kernel with the given settings.

The allocator MUST be initialized if required, and be ready to allocate data.

pub(crate) fn inner(&'static self) -> &'static KernelInner

pub fn timer(&'static self) -> &'static Timer

pub fn tick(&'static self) -> Tick

pub fn set_global_timer(&'static self) -> Result<(), AlreadyInitialized>

Initialize the kernel’s maitake timer as the global default timer.

This allows the use of sleep and timeout free functions. TODO(eliza): can the kernel just “do this” once it becomes active? Or, have a “kernel.init()” or something that does this and other global inits?

pub fn initialize<F>( &'static self, fut: F ) -> Result<JoinHandle<F::Output>, &'static str>where F: Future + 'static,

pub async fn spawn<F>(&'static self, fut: F) -> JoinHandle<F::Output>where F: Future + 'static,

pub async fn with_registry<F, R>(&'static self, f: F) -> Rwhere F: FnOnce(&mut Registry) -> R,

pub fn spawn_allocated<F>( &'static self, task: <BoxStorage as Storage<LocalScheduler, F>>::StoredTask ) -> JoinHandle<F::Output>where F: Future + 'static,

pub fn sleep(&'static self, duration: Duration) -> Sleep<'static>

Returns a [Sleep] future that sleeps for the specified Duration.

pub fn timeout<F: Future>( &'static self, duration: Duration, f: F ) -> Timeout<'static, F>

Returns a [Timeout] future that cancels F if the specified Duration has elapsed before it completes.

Trait Implementations

impl Sync for Kernel