Struct fidl_fuchsia_exception::ProcessLimboProxy

pub struct ProcessLimboProxy { /* private fields */ }

Implementations

impl ProcessLimboProxy

pub fn new(channel: AsyncChannel) -> Self

Create a new Proxy for ProcessLimbo

pub fn take_event_stream(&self) -> ProcessLimboEventStream

Get a Stream of events from the remote end of the ProcessLimbo protocol

Panics

Panics if the event stream was already taken.

pub fn set_active(&self, active: bool) -> QueryResponseFut<()>

Set the active state of the limbo. Will trigger the WatchActive event if there was a change, meaning that any listening components will receive a notification. This includes the caller of SetActive.

When a limbo is inactive, there will not be any processes waiting on it, meaning that any waiting processes will be freed upon deactivating the limbo.

pub fn get_active(&self) -> QueryResponseFut<bool>

Get whether the limbo is currently active. An active limbo could be empty (not have any processes waiting on an exception). When a limbo is inactive, there will not be any processes waiting on it.

pub fn watch_active(&self) -> QueryResponseFut<bool>

Watch for changes determining whether the limbo is currently active, using a Hanging Get pattern.

pub fn list_processes_waiting_on_exception( &self ) -> QueryResponseFut<ProcessLimboListProcessesWaitingOnExceptionResult>

List processes that are waiting on exceptions.

Returns information on all the processes currently waiting on an exception. The information provided will not contain any handle, so that it can be transported over Overnet (see fxbug.dev/99649).

The implementation should ensure that at any time there are no more than MAX_EXCEPTIONS exceptions held in the limbo, so that no pagination is needed.

Returns ZX_ERR_UNAVAILABLE if limbo is not active.

pub fn watch_processes_waiting_on_exception( &self ) -> QueryResponseFut<ProcessLimboWatchProcessesWaitingOnExceptionResult>

Watch for processes that are waiting on exceptions, using a Hanging Get Pattern.

Returns information on all the processes currently waiting on an exception. The information provided is intended to correctly identify an exception and determine whether the caller wants to actually handle it. To retrieve an exception, use the GetException call.

Returns ZX_ERR_UNAVAILABLE if limbo is not active. Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo becomes inactive.

NOTE: The process and thread handle will only have the ZX_RIGHT_READ right, so no modification will be able to be done on them.

pub fn retrieve_exception( &self, process_koid: u64 ) -> QueryResponseFut<ProcessLimboRetrieveExceptionResult>

Removes the process from limbo and retrieves the exception handle and associated metadata from an exception.

Use ListProcessesWaitingOnException to choose a process_koid from the list of available exceptions.

Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception. Returns ZX_ERR_UNAVAILABLE if limbo is not active.

pub fn release_process( &self, process_koid: u64 ) -> QueryResponseFut<ProcessLimboReleaseProcessResult>

Removes the process from limbo, releasing the exception. This will make it “bubble up” beyond the scope of of this limbo, making it unretrievable in the future from here.

pub fn append_filters( &self, filters: &mut dyn ExactSizeIterator<Item = &str> ) -> QueryResponseFut<ProcessLimboAppendFiltersResult>

Adds filters to the limbo. Filters determine what processes the limbo will store when receiving an exception. Repeated filters will be ignored. Filters work by “filtering out” processes. It means that if a filter matches, that process won’t get included.

Filters work by substring matching. This means that a process name has to have the filter as a substring in order to match it. Example:

Filter = “dev”. Process = “process” won’t match. Process = “devcoordinator” will match.

Adding filters is transactional: either all of them go in, or none at all. The maximum amount of filters is determined by MAX_FILTERS_PER_CALL. If the maximum is exceeded, ZX_ERR_NO_RESOURCES is returned.

Changing filters have no effect on processes that are currently waiting on an exception, but rather which future processes that will remain in the limbo.

Returns ZX_ERR_UNAVAILABLE if limbo is not active.

pub fn remove_filters( &self, filters: &mut dyn ExactSizeIterator<Item = &str> ) -> QueryResponseFut<ProcessLimboRemoveFiltersResult>

Removes filters to the limbo. Any filters that are not currently present on the limbo will be ignored.

Returns ZX_ERR_UNAVAILABLE if limbo is not active.

pub fn get_filters(&self) -> QueryResponseFut<Vec<String>>

Returns filters that are currently active within the limbo. If the limbo is inactive, it will return an empty vector.

Trait Implementations

impl Clone for ProcessLimboProxy

fn clone(&self) -> ProcessLimboProxy

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ProcessLimboProxy

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

Formats the value using the given formatter.

impl ProcessLimboProxyInterface for ProcessLimboProxy

type SetActiveResponseFut = QueryResponseFut<()>

fn set_active(&self, active: bool) -> Self::SetActiveResponseFut

type GetActiveResponseFut = QueryResponseFut<bool>

fn get_active(&self) -> Self::GetActiveResponseFut

type WatchActiveResponseFut = QueryResponseFut<bool>

fn watch_active(&self) -> Self::WatchActiveResponseFut

type ListProcessesWaitingOnExceptionResponseFut = QueryResponseFut<Result<Vec<ProcessExceptionInfo, Global>, i32>>

fn list_processes_waiting_on_exception( &self ) -> Self::ListProcessesWaitingOnExceptionResponseFut

type WatchProcessesWaitingOnExceptionResponseFut = QueryResponseFut<Result<Vec<ProcessExceptionMetadata, Global>, i32>>

fn watch_processes_waiting_on_exception( &self ) -> Self::WatchProcessesWaitingOnExceptionResponseFut

type RetrieveExceptionResponseFut = QueryResponseFut<Result<ProcessException, i32>>

fn retrieve_exception( &self, process_koid: u64 ) -> Self::RetrieveExceptionResponseFut

type ReleaseProcessResponseFut = QueryResponseFut<Result<(), i32>>

fn release_process(&self, process_koid: u64) -> Self::ReleaseProcessResponseFut

type AppendFiltersResponseFut = QueryResponseFut<Result<(), i32>>

fn append_filters( &self, filters: &mut dyn ExactSizeIterator<Item = &str> ) -> Self::AppendFiltersResponseFut

type RemoveFiltersResponseFut = QueryResponseFut<Result<(), i32>>

fn remove_filters( &self, filters: &mut dyn ExactSizeIterator<Item = &str> ) -> Self::RemoveFiltersResponseFut

type GetFiltersResponseFut = QueryResponseFut<Vec<String, Global>>

fn get_filters(&self) -> Self::GetFiltersResponseFut

impl Proxy for ProcessLimboProxy

type Protocol = ProcessLimboMarker

The protocol which this Proxy controls.

fn from_channel(inner: AsyncChannel) -> Self

Create a proxy over the given channel.

fn into_channel(self) -> Result<AsyncChannel, Self>

Attempt to convert the proxy back into a channel.

fn as_channel(&self) -> &AsyncChannel

Get a reference to the proxy’s underlying channel.

fn is_closed(&self) -> bool

Returns true if the proxy has received the PEER_CLOSED signal.

fn on_closed<'a>(&'a self) -> OnSignals<'a>

Returns a future that completes when the proxy receives the PEER_CLOSED signal.