Enum fidl_fuchsia_exception::ProcessLimboRequest

pub enum ProcessLimboRequest {
    SetActive {
        active: bool,
        responder: ProcessLimboSetActiveResponder,
    },
    GetActive {
        responder: ProcessLimboGetActiveResponder,
    },
    WatchActive {
        responder: ProcessLimboWatchActiveResponder,
    },
    ListProcessesWaitingOnException {
        responder: ProcessLimboListProcessesWaitingOnExceptionResponder,
    },
    WatchProcessesWaitingOnException {
        responder: ProcessLimboWatchProcessesWaitingOnExceptionResponder,
    },
    RetrieveException {
        process_koid: u64,
        responder: ProcessLimboRetrieveExceptionResponder,
    },
    ReleaseProcess {
        process_koid: u64,
        responder: ProcessLimboReleaseProcessResponder,
    },
    AppendFilters {
        filters: Vec<String>,
        responder: ProcessLimboAppendFiltersResponder,
    },
    RemoveFilters {
        filters: Vec<String>,
        responder: ProcessLimboRemoveFiltersResponder,
    },
    GetFilters {
        responder: ProcessLimboGetFiltersResponder,
    },
}

Protocol meant for clients interested in obtaining processes that are suspended waiting for an exception handler (in limbo). This is the core feature that enables Just In Time (JIT) debugging.

An example usage of this API would be having a debugger listen on limbo for new processes. Then another component (eg. a CLI tool) could activate the limbo, meaning that the system is now ready to capture crashing processes. As the debugger got a notification that the limbo is now active, it can correctly handle newly excepted processes and do its normal workflow.

Variants

SetActive

Fields

active: bool

responder: ProcessLimboSetActiveResponder

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.

GetActive

Fields

responder: ProcessLimboGetActiveResponder

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.

WatchActive

Fields

responder: ProcessLimboWatchActiveResponder

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

ListProcessesWaitingOnException

Fields

responder: ProcessLimboListProcessesWaitingOnExceptionResponder

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.

WatchProcessesWaitingOnException

Fields

responder: ProcessLimboWatchProcessesWaitingOnExceptionResponder

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.

RetrieveException

Fields

process_koid: u64

responder: ProcessLimboRetrieveExceptionResponder

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.

ReleaseProcess

Fields

process_koid: u64

responder: ProcessLimboReleaseProcessResponder

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.

AppendFilters

Fields

filters: Vec<String>

responder: ProcessLimboAppendFiltersResponder

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.

RemoveFilters

Fields

filters: Vec<String>

responder: ProcessLimboRemoveFiltersResponder

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.

GetFilters

Fields

responder: ProcessLimboGetFiltersResponder

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

Implementations

impl ProcessLimboRequest

pub fn into_set_active(self) -> Option<(bool, ProcessLimboSetActiveResponder)>

pub fn into_get_active(self) -> Option<ProcessLimboGetActiveResponder>

pub fn into_watch_active(self) -> Option<ProcessLimboWatchActiveResponder>

pub fn into_list_processes_waiting_on_exception( self ) -> Option<ProcessLimboListProcessesWaitingOnExceptionResponder>

pub fn into_watch_processes_waiting_on_exception( self ) -> Option<ProcessLimboWatchProcessesWaitingOnExceptionResponder>

pub fn into_retrieve_exception( self ) -> Option<(u64, ProcessLimboRetrieveExceptionResponder)>

pub fn into_release_process( self ) -> Option<(u64, ProcessLimboReleaseProcessResponder)>

pub fn into_append_filters( self ) -> Option<(Vec<String>, ProcessLimboAppendFiltersResponder)>

pub fn into_remove_filters( self ) -> Option<(Vec<String>, ProcessLimboRemoveFiltersResponder)>

pub fn into_get_filters(self) -> Option<ProcessLimboGetFiltersResponder>

pub fn method_name(&self) -> &'static str

Name of the method defined in FIDL

Trait Implementations

impl Debug for ProcessLimboRequest

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

Formats the value using the given formatter.