Struct EndpointSynchronousProxy 

pub struct EndpointSynchronousProxy { /* private fields */ }

Implementations

impl EndpointSynchronousProxy

pub fn new(channel: Channel) -> Self

pub fn into_channel(self) -> Channel

pub fn wait_for_event( &self, deadline: MonotonicInstant, ) -> Result<EndpointEvent, Error>

Waits until an event arrives and returns it. It is safe for other threads to make concurrent requests while waiting for an event.

pub fn get_info( &self, ___deadline: MonotonicInstant, ) -> Result<EndpointGetInfoResult, Error>

Gets endpoint information

pub fn register_vmos( &self, vmo_ids: &[VmoInfo], ___deadline: MonotonicInstant, ) -> Result<Vec<VmoHandle>, Error>

Registers and pins VMOs to the vmo_ids. Returns

• vmo: Handles to successfully registered vmo_ids. VMO IDs that are already are registered to will fail.

pub fn unregister_vmos( &self, vmo_ids: &[u64], ___deadline: MonotonicInstant, ) -> Result<(Vec<u64>, Vec<i32>), Error>

Unregisters the VMOs corresponding to the vmo_ids. Returns

• failed_vmo_ids: vmo_ids that failed to unregister.
• errors: Error values that correspond 1:1 to failed_vmo_ids above.

pub fn queue_requests(&self, req: Vec<Request>) -> Result<(), Error>

Submit Requests to queue. Processed starting with the 0th Request. Submitting a vector of Requests allows for pre-buffering.

Clients are responsible for cache management and ensuring cache coherency. The explanation to follow concerns VMOs that have been previously registered via RegisterVmos. The following rules must be followed:

1. After writing to VMO-backed buffers, the caller must call zx_cache_flush with ZX_CACHE_FLUSH_DATA before invoking QueueRequests, causing the hardware to DMA-process the buffer. This avoids both stale buffer data being DMA-read, and a concurrent race between the hardware and CPU to update the same addresses.

2. Before reading from VMO-backed buffers, the caller must call zx_cache_flush with ZX_CACHE_FLUSH_DATA | ZX_CACHE_FLUSH_INVALIDATE after the buffer contents have been DMA-written by the hardware. This implies a non-dirty cache (see #1 above) and ensures any subsequent CPU-reads fetch the previously DMA-written data from RAM.

Failing to adhere to these rules will result in the exchange of corrupted and/or stale data. If the VMO is not virtually mapped (uncommon), zx_vmo_op_range should be used in lieu of zx_cache_flush. If the usb::FidlRequest types are in use, they contain helpers for these operations.

Requests may be pre-buffered. In other words, requests may be queued for data that is not present/ready in the buffer yet. The USB Endpoint Server consuming requests does not care if the data in the buffer is ready or not and will always process requests on schedule. It is the responsibility of the USB Endpoint Client that submits requests to ensure that data is ready on schedule (taking into consideration cache management above).

• Definition of “on schedule” varies for different endpoints and controllers. In general, this will be communicated by the lead_time parameter returned by GetInfo.

pub fn cancel_all( &self, ___deadline: MonotonicInstant, ) -> Result<EndpointCancelAllResult, Error>

Cancels all requests. Returns

• ZX_ERR_IO_NOT_PRESENT: If device is not running, disconnected, or inactive.
• ZX_ERR_IO: If cancel failed due to an unsuccessful request.

Trait Implementations

impl Debug for EndpointSynchronousProxy

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

Formats the value using the given formatter.

impl From<Channel> for EndpointSynchronousProxy

Available on Fuchsia only.

fn from(value: Channel) -> Self

Converts to this type from the input type.

impl From<EndpointSynchronousProxy> for NullableHandle

Available on Fuchsia only.

fn from(value: EndpointSynchronousProxy) -> Self

Converts to this type from the input type.

impl FromClient for EndpointSynchronousProxy

Available on Fuchsia only.

type Protocol = EndpointMarker

The protocol.

fn from_client(value: ClientEnd<EndpointMarker>) -> Self

Converts from a client.

impl SynchronousProxy for EndpointSynchronousProxy

Available on Fuchsia only.

type Proxy = EndpointProxy

The async proxy for the same protocol.

type Protocol = EndpointMarker

The protocol which this Proxy controls.

fn from_channel(inner: Channel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Channel

Convert the proxy back into a channel.

fn as_channel(&self) -> &Channel

Get a reference to the proxy’s underlying channel.

fn is_closed(&self) -> Result<bool, Status>

Returns true if the proxy has received the PEER_CLOSED signal.