Module zircon_object::object

Expand description

Kernel object basis.

Create new kernel object

Create a new struct.
Make sure it has a field named base with type KObjectBase.
Implement KernelObject trait with impl_kobject macro.

Example

use zircon_object::object::*;
extern crate alloc;

pub struct SampleObject {
   base: KObjectBase,
}
impl_kobject!(SampleObject);

Implement methods for kernel object

Constructor

Each kernel object should have a constructor returns Arc<Self> (or a pair of them, e.g. Channel).

Don’t return Self since it must be created on heap.

Example

use zircon_object::object::*;
use std::sync::Arc;

pub struct SampleObject {
    base: KObjectBase,
}
impl SampleObject {
    pub fn new() -> Arc<Self> {
        Arc::new(SampleObject {
            base: KObjectBase::new(),
        })
    }
}

Interior mutability

All kernel objects use the interior mutability pattern : each method takes either &self or &Arc<Self> as the first argument.

To handle mutable variable, create another inner structure, and put it into the object with a lock wrapped.

Example

use zircon_object::object::*;
use std::sync::Arc;
use lock::Mutex;

pub struct SampleObject {
    base: KObjectBase,
    inner: Mutex<SampleObjectInner>,
}
struct SampleObjectInner {
    x: usize,
}

impl SampleObject {
    pub fn set_x(&self, x: usize) {
        let mut inner = self.inner.lock();
        inner.x = x;
    }
}

Downcast trait to concrete type

KernelObject inherit downcast_rs::DowncastSync trait. You can use downcast_arc method to downcast Arc<dyn KernelObject> to Arc<T: KernelObject>.

Example

use zircon_object::object::*;
use std::sync::Arc;

let object: Arc<dyn KernelObject> = DummyObject::new();
let concrete = object.downcast_arc::<DummyObject>().unwrap();