Struct lldb::SBProcess

pub struct SBProcess {
    pub raw: SBProcessRef,
}

The process associated with the target program.

You get a process by attaching to or launching a target program. See SBTarget for details.

Process State

The OS process ID (pid_t) for the process is available via SBProcess::process_id().

The process state can be obtained via SBProcess::state(). It is common to just check to see if the process SBProcess::is_alive(), SBProcess::is_running() or SBProcess::is_stopped().

Once the process is in the Exited state, the SBProcess::exit_status() and SBProcess::exit_description() are available for inspection.

Execution Control

Once you have a process, you can:

• SBProcess::continue_execution()
• SBProcess::stop()
• SBProcess::kill()
• SBProcess::detach()

Threads

The process contains the threads of execution for the target. The available threads can be iterated over with SBProcess::threads():

// Iterate over the threads...
for thread in process.threads() {
    println!("Hello {}!", thread.thread_id());
}
// Or collect them into a vector!
let threads = process.threads().collect::<Vec<SBThread>>();

Specific individual threads can be looked up via SBProcess::thread_by_id() and SBProcess::thread_by_index_id() methods.

Some functions operate on the ‘currently selected thread’. This can retrieved via SBProcess::selected_thread() and set via SBProcess::set_selected_thread(), SBProcess::set_selected_thread_by_id(), or SBProcess::set_selected_thread_by_index_id().

Queues

A process may also have a set of queues associated with it. This is used on macOS, iOS and other Apple operating systems to support debugger integration with libdispatch, also known as GCD or “Grand Central Dispatch”.

The active queues can be iterated over with SBProcess::queues():

// Iterate over the queues...
for queue in process.queues() {
    println!("Hello {}!", queue.queue_id());
}

Events

… to be written …

Fields

raw: SBProcessRef

The underlying raw SBProcessRef.

Implementations

impl SBProcess

pub fn maybe_wrap(raw: SBProcessRef) -> Option<SBProcess>

Construct a new Some(SBProcess) or None.

pub fn is_valid(&self) -> bool

Check whether or not this is a valid SBProcess value.

pub fn broadcaster_class_name() -> &'static str

pub fn state(&self) -> StateType

The current state of this process (running, stopped, exited, etc.).

pub fn is_alive(&self) -> bool

Returns true if the process is currently alive.

This corresponds to the process being in the Attaching, Launching, Stopped, Running, Stepping, Crashed or Suspended states.

pub fn is_running(&self) -> bool

Returns true if the process is currently running.

This corresponds to the process being in the Running or Stepping states.

pub fn is_stopped(&self) -> bool

Returns true if the process is currently stopped.

This corresponds to the process being in the Stopped, Crashed, or Suspended states.

pub fn exit_status(&self) -> i32

The exit status of the process when the process state is Exited.

pub fn exit_description(&self) -> &str

The exit description of the process when the process state is Exited.

pub fn process_id(&self) -> lldb_pid_t

Returns the process ID of the process.

pub fn unique_id(&self) -> u32

Returns an integer ID that is guaranteed to be unique across all process instances. This is not the process ID, just a unique integer for comparison and caching purposes.

pub fn address_byte_size(&self) -> u32

Get the size, in bytes, of an address.

pub fn destroy(&self) -> Result<(), SBError>

Kills the process and shuts down all threads that were spawned to track and monitor the process.

pub fn continue_execution(&self) -> Result<(), SBError>

pub fn stop(&self) -> Result<(), SBError>

pub fn kill(&self) -> Result<(), SBError>

Same as calling destroy.

pub fn detach(&self) -> Result<(), SBError>

pub fn signal(&self, signal: i32) -> Result<(), SBError>

Send the process a Unix signal.

pub fn broadcaster(&self) -> SBBroadcaster

pub fn threads(&self) -> SBProcessThreadIter<'_>

Get an iterator over the threads known to this process instance.

pub fn queues(&self) -> SBProcessQueueIter<'_>

Get an iterator over the queues known to this process instance.

pub fn thread_by_id(&self, thread_id: lldb_tid_t) -> Option<SBThread>

Returns the thread with the given thread ID.

pub fn thread_by_index_id(&self, thread_index_id: u32) -> Option<SBThread>

Returns the thread with the given thread index ID.

pub fn selected_thread(&self) -> SBThread

Returns the currently selected thread.

pub fn set_selected_thread(&self, thread: &SBThread) -> bool

Set the selected thread.

pub fn set_selected_thread_by_id(&self, thread_id: lldb_tid_t) -> bool

Set the selected thread by ID.

pub fn set_selected_thread_by_index_id(&self, thread_index_id: u32) -> bool

Set the selected thread by index ID.

pub fn event_as_process_event(event: &SBEvent) -> Option<SBProcessEvent<'_>>

pub fn save_core(&self, file_name: &str) -> Result<(), SBError>

Save the state of the process in a core file (or mini dump on Windows).

pub fn process_info(&self) -> SBProcessInfo

Trait Implementations

impl Clone for SBProcess

fn clone(&self) -> SBProcess

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SBProcess

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

Formats the value using the given formatter.

impl Drop for SBProcess

fn drop(&mut self)

Executes the destructor for this type.

impl From<*mut SBProcessOpaque> for SBProcess

fn from(raw: SBProcessRef) -> SBProcess

Performs the conversion.

impl Send for SBProcess

impl Sync for SBProcess