Struct uhyvelib::linux::gdb::CmdHandler

pub struct CmdHandler<'a> { /* fields omitted */ }

Implementations

impl<'a> CmdHandler<'a>

pub fn new(
    cpu: &'a mut UhyveCPU,
    state: &'a RefCell<State>,
    signal: VcpuExit<'a>
) -> CmdHandler<'a>

pub fn continue_execution(&self, reason: VCont)

Trait Implementations

impl<'a> Handler for CmdHandler<'a>

pub fn should_cont(&self) -> Option<VCont>

Return true when the gdb-event-loop should be exited.

pub fn attached(&self, _pid: Option<u64>) -> Result<ProcessType, Error>

Indicate whether the process in question already existed, and was attached to; or whether it was created by this server.

pub fn halt_reason(&self) -> Result<StopReason, Error>

Return the reason that the inferior has halted.

pub fn query_supported_features(&self) -> Vec<String>

Return a vector of additional features supported by this handler. Note that there currently is no way to override the built-in features that are always handled by the protocol implementation.

pub fn query_supported_vcont(
    &self
) -> Result<Cow<'static, [VContFeature]>, Error>

Query for a list of supported vCont features.

pub fn set_current_thread(&self, id: ThreadId) -> Result<(), Error>

TODO: actually implement thread switching for multithread support

pub fn current_thread(&self) -> Result<Option<ThreadId>, Error>

Return the identifier of the current thread.

pub fn read_general_registers(&self) -> Result<Vec<u8>, Error>

Return the general registers. The registers are returned as a vector of bytes, with the registers appearing contiguously in a target-specific order, with the bytes laid out in the target byte order.

pub fn write_general_registers(&self, contents: &[u8]) -> Result<(), Error>

Write the general registers. The registers are specified as a vector of bytes, with the registers appearing contiguously in a target-specific order, with the bytes laid out in the target byte order.

pub fn read_memory(&self, mem: MemoryRegion) -> Result<Vec<u8>, Error>

Read a memory region.

pub fn write_memory(&self, address: u64, bytes: &[u8]) -> Result<(), Error>

Write the provided bytes to memory at the given address.

pub fn insert_software_breakpoint(&self, bp: Breakpoint) -> Result<(), Error>

Insert a software breakpoint.

pub fn remove_software_breakpoint(
    &self,
    breakpoint: Breakpoint
) -> Result<(), Error>

Remove a software breakpoint.

pub fn insert_hardware_breakpoint(&self, bp: Breakpoint) -> Result<(), Error>

Insert a hardware breakpoint.

pub fn remove_hardware_breakpoint(&self, bp: Breakpoint) -> Result<(), Error>

Remove a hardware breakpoint.

pub fn insert_write_watchpoint(
    &self,
    watchpoint: Watchpoint
) -> Result<(), Error>

Insert a write watchpoint.

pub fn insert_read_watchpoint(
    &self,
    watchpoint: Watchpoint
) -> Result<(), Error>

Insert a read watchpoint.

pub fn insert_access_watchpoint(
    &self,
    watchpoint: Watchpoint
) -> Result<(), Error>

Insert an access watchpoint.

pub fn remove_write_watchpoint(
    &self,
    watchpoint: Watchpoint
) -> Result<(), Error>

Remove a write watchpoint.

pub fn remove_read_watchpoint(
    &self,
    watchpoint: Watchpoint
) -> Result<(), Error>

Remove a read watchpoint.

pub fn remove_access_watchpoint(
    &self,
    watchpoint: Watchpoint
) -> Result<(), Error>

Remove an access watchpoint.

pub fn vcont(
    &self,
    actions: Vec<(VCont, Option<ThreadId>)>
) -> Result<StopReason, Error>

TODO: currently ignores tid/pid, and just continues/steps currently running cpu according to first command At most apply one action per thread. GDB likes to send default action for other threads, even if it knows only about 1: "vCont;s:1;c" (step thread 1, continue others)

pub fn thread_list(&self, reset: bool) -> Result<Vec<ThreadId>, Error>

TODO: return actual number of threads, not just one

pub fn process_list(&self, reset: bool) -> Result<Vec<ProcessInfo>, Error>

Return a list of all active processes for LLDB. Called in a paging fashion: First query has reset set to true and should reply with the first chunk of threads. Further queries have reset set to false and should respond with a chunk of remaining threads, until completion which should return an empty list to signify it's the end.

pub fn read_feature(
    &self,
    name: String,
    offset: u64,
    length: u64
) -> Result<FileData, Error>

pub fn host_info(&self) -> Result<String, Error>

Get target triple etc.

pub fn detach(&self, _pid: Option<u64>) -> Result<(), Error>

Detach from the process.

pub fn kill(&self, _pid: Option<u64>) -> Result<(), Error>

Kill the indicated process. If no process is given, then the precise effect is unspecified; but killing any or all processes, or even rebooting an entire bare-metal target, would be appropriate.

pub fn ping_thread(&self, _id: ThreadId) -> Result<(), Error>

Check whether the indicated thread is alive. If alive, return (). Otherwise, return an error.

pub fn read_register(&self, _register: u64) -> Result<Vec<u8>, Error>

Read the contents of the indicated register. The results should be in target byte order. Note that a value-based API is not provided here because on some architectures, there are registers wider than ordinary integer types.

pub fn write_register(
    &self,
    _register: u64,
    _contents: &[u8]
) -> Result<(), Error>

Set the contents of the indicated register to the given contents. The contents are in target byte order. Note that a value-based API is not provided here because on some architectures, there are registers wider than ordinary integer types.

pub fn search_memory(
    &self,
    _address: u64,
    _length: u64,
    _bytes: &[u8]
) -> Result<Option<u64>, Error>

Search memory. The search begins at the given address, and ends after length bytes have been searched. If the provided bytes are not seen, None should be returned; otherwise, the address at which the bytes were found should be returned.

pub fn invoke(&self, _: &[u8]) -> Result<String, Error>

Invoke a command. The command is just a sequence of bytes (typically ASCII characters), to be interpreted by the server in any way it likes. The result is output to send back to the client. This is used to implement gdb's monitor command.

pub fn set_address_randomization(&self, _enable: bool) -> Result<(), Error>

Enable or disable address space randomization. This setting should be used when launching a new process.

pub fn catch_syscalls(&self, _syscalls: Option<Vec<u64>>) -> Result<(), Error>

Start or stop catching syscalls. If the argument is None, then stop catching syscalls. Otherwise, start catching syscalls. If any syscalls are specified, then only those need be caught; however, it is ok to report syscall stops that aren't in the list if that is convenient.

pub fn set_pass_signals(&self, _signals: Vec<u64>) -> Result<(), Error>

Set the list of "pass signals". A signal marked as a pass signal can be delivered to the inferior. No stopping or notification of the client is required.

pub fn set_program_signals(&self, _signals: Vec<u64>) -> Result<(), Error>

Set the list of "program signals". A signal marked as a program signal can be delivered to the inferior; other signals should be silently discarded.

pub fn thread_info(&self, _thread: ThreadId) -> Result<String, Error>

Return information about a given thread. The returned information is just a string description that can be presented to the user.