Struct runa_orbiter::objects::shm::ShmPool

pub struct ShmPool { /* private fields */ }

A shm memory pool.

Implementations

impl ShmPool

pub unsafe fn map(&self) -> Ref<'_, [u8]>

Map the pool into memory.

This can be called repeatedly to retrieve the slice whenever you need it. The map operation is only performed once.

Safety

The file descriptor MUST be suitable for mapping.

You MUST setup a SIGBUS handler that calls handle_sigbus. Otherwise if the client shrunk the pool after you have mapped it, you will get a SIGBUS when accessing the removed section of memory. handle_sigbus will automatcally map in zero pages in that case.

Trait Implementations

impl Debug for ShmPool

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

Formats the value using the given formatter.

impl MonoObject for ShmPool

type SingletonState = ()

A singleton state associated with the object type. This state is associated with the type, so there is only one instance of the state for all objects of the same type. The lifetime of this state is managed by the object store, and it will be dropped when the last object of the type is dropped.

const INTERFACE: &'static str = wl_shm_pool::NAME

The wayland interface implemented by this object.

fn new_singleton_state() -> Self::SingletonState

Create a new instance of the singleton state.

impl<B, Ctx> Object<Ctx> for ShmPoolwhere Ctx: Client, Ctx::ServerContext: HasBuffer<Buffer = B>, B: From<Buffer<Buffer>> + BufferLike, Ctx::Object: From<Buffer<B>>,

type Request<'a> where Ctx: 'a = Request

The type of wayland messages that this object can receive. This is what the dispatch method accepts.

type Error = Error

Error returned by the dispatch method.

type Fut<'a> where Ctx: 'a = impl Future<Output = (Result<(), <ShmPool as Object<Ctx>>::Error>, usize, usize)> + 'a

The future type returned by the dispatch method.

fn dispatch<'a>( ctx: &'a mut Ctx, object_id: u32, msg: Self::Request<'a> ) -> Self::Fut<'a>

Dispatch a wayland request to this object. Returns a future, that resolves to (Result, usize, usize), which are the result of the request, the number of bytes and file descriptors in the request, respectively.

fn on_disconnect( &mut self, _server_ctx: &mut <Ctx as Client>::ServerContext, _state: &mut (dyn Any + 'static) )

A function that will be called when the client disconnects. It should free up allocated resources if any. This function only gets reference to the server context, because:

impl<B, Ctx> RequestDispatch<Ctx> for ShmPoolwhere Ctx: Client, Ctx::ServerContext: HasBuffer<Buffer = B>, B: From<Buffer<Buffer>> + BufferLike, Ctx::Object: From<Buffer<B>>,

type Error = Error

type CreateBufferFut<'a> where Ctx: 'a = impl Future<Output = Result<(), Error>> + 'a

Type of future returned by create_buffer

type DestroyFut<'a> where Ctx: 'a = impl Future<Output = Result<(), Error>> + 'a

Type of future returned by destroy

type ResizeFut<'a> where Ctx: 'a = impl Future<Output = Result<(), Error>> + 'a

Type of future returned by resize

fn create_buffer( ctx: &mut Ctx, object_id: u32, id: NewId, offset: i32, width: i32, height: i32, stride: i32, format: Format ) -> Self::CreateBufferFut<'_>

create a buffer from the pool

fn destroy(ctx: &mut Ctx, object_id: u32) -> Self::DestroyFut<'_>

destroy the pool

fn resize(ctx: &mut Ctx, object_id: u32, size: i32) -> Self::ResizeFut<'_>

change the size of the pool mapping