commands.h File Reference

#include "../libgdbr.h"
#include "rz_types_base.h"
#include <rz_util.h>

Go to the source code of this file.

Functions
bool	gdbr_lock_enter (libgdbr_t *g)
	Acquires the gdbr lock and sets up breaking. More...
void	gdbr_lock_leave (libgdbr_t *g)
	Releases the gdbr lock. More...
int	gdbr_connect (libgdbr_t *g, const char *server, int port)
	Function connects to a gdbserver instance. More...
int	gdbr_disconnect (libgdbr_t *g)
	disconnects the lib More...
void	gdbr_invalidate_reg_cache (void)
	invalidates the reg cache More...
int	gdbr_stop_reason (libgdbr_t *g)
	gets reason why remote target stopped More...
int	gdbr_check_extended_mode (libgdbr_t *g)
	checks for extended mode availability More...
int	gdbr_check_vcont (libgdbr_t *g)
	checks which subcommands of the vCont packet are supported More...
int	gdbr_send_qRcmd (libgdbr_t *g, const char *cmd, PrintfCallback cb_printf)
	sends a qRcmd packet which basically passes a command to the remote target's interpreter. More...
int	gdbr_attach (libgdbr_t *g, int pid)
	attaches to a process More...
int	gdbr_detach (libgdbr_t *g)
	detaches from a process More...
int	gdbr_detach_pid (libgdbr_t *g, int pid)
int	gdbr_kill (libgdbr_t *g)
	kills the process the remote gdbserver is debugging (TODO: handle pid) More...
int	gdbr_kill_pid (libgdbr_t *g, int pid)
int	gdbr_continue (libgdbr_t *g, int pid, int tid, int sig)
int	gdbr_step (libgdbr_t *g, int thread_id)
int	gdbr_read_registers (libgdbr_t *g)
int	gdbr_write_bin_registers (libgdbr_t *g, const char *regs, int len)
	Function writes general purpose registers. More...
int	gdbr_write_reg (libgdbr_t *g, const char *name, char *value, int len)
int	gdbr_write_register (libgdbr_t *g, int index, char *value, int len)
int	gdbr_write_registers (libgdbr_t *g, char *registers)
int	gdbr_read_memory (libgdbr_t *g, ut64 address, ut8 *buf, int len)
int	gdbr_write_memory (libgdbr_t *g, ut64 address, const uint8_t *data, ut64 len)
int	test_command (libgdbr_t *g, const char *command)
int	gdbr_set_bp (libgdbr_t *g, ut64 address, const char *conditions, int sizebp)
	Function sets normal breakpoint (0xcc, int3) More...
int	gdbr_set_hwbp (libgdbr_t *g, ut64 address, const char *conditions, int sizebp)
int	gdbr_set_hww (libgdbr_t *g, ut64 address, const char *conditions, int sizebp)
int	gdbr_set_hwr (libgdbr_t *g, ut64 address, const char *conditions, int sizebp)
int	gdbr_set_hwa (libgdbr_t *g, ut64 address, const char *conditions, int sizebp)
int	gdbr_remove_bp (libgdbr_t *g, ut64 address, int sizebp)
int	gdbr_remove_hwbp (libgdbr_t *g, ut64 address, int sizebp)
int	gdbr_remove_hww (libgdbr_t *g, ut64 address, int sizebp)
int	gdbr_remove_hwr (libgdbr_t *g, ut64 address, int sizebp)
int	gdbr_remove_hwa (libgdbr_t *g, ut64 address, int sizebp)
int	gdbr_open_file (libgdbr_t *g, const char *filename, int flags, int mode)
int	gdbr_read_file (libgdbr_t *g, ut8 *buf, ut64 max_len)
int	gdbr_close_file (libgdbr_t *g)
RzList *	gdbr_threads_list (libgdbr_t *g, int pid)
	get list of threads for given pid More...
RzList *	gdbr_pids_list (libgdbr_t *g, int pid)
	get a list of the child processes of the given pid More...
char *	gdbr_exec_file_read (libgdbr_t *g, int pid)
ut64	gdbr_get_baddr (libgdbr_t *g)
int	gdbr_select (libgdbr_t *g, int pid, int tid)

Function Documentation

gdbr_attach()

int gdbr_attach	(	libgdbr_t *	g,
		int	pid
	)

attaches to a process

Parameters

pid	of the process to attach to

Returns

a failure code (currently -1) or 0 if call successfully

Definition at line 439 of file core.c.

                                       {
    int ret = -1;
    char *cmd = NULL;
    size_t buffer_size;
 
    if (!g || !g->sock) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    g->stop_reason.is_valid = false;
    reg_cache.valid = false;
 
    if (g->stub_features.extended_mode == -1) {
        gdbr_check_extended_mode(g);
    }
 
    if (!g->stub_features.extended_mode) {
        // vAttach needs extended mode to do anything.
        ret = -2;
        goto end;
    }
 
    buffer_size = strlen(CMD_ATTACH) + (sizeof(int) * 2) + 1;
    cmd = calloc(buffer_size, sizeof(char));
    if (!cmd) {
        ret = -1;
        goto end;
    }
 
    ret = snprintf(cmd, buffer_size, "%s%x", CMD_ATTACH, pid);
    if (ret < 0) {
        goto end;
    }
 
    ret = send_msg(g, cmd);
    if (ret < 0) {
        goto end;
    }
 
    if (read_packet(g, false) < 0) {
        ret = -1;
        goto end;
    }
 
    ret = handle_attach(g);
end:
    if (cmd) {
        free(cmd);
    }
    gdbr_lock_leave(g);
    return ret;
}

References buffer_size, calloc(), cmd, CMD_ATTACH, test_evm::end, free(), g, gdbr_check_extended_mode(), gdbr_lock_enter(), gdbr_lock_leave(), handle_attach(), int, NULL, pid, read_packet(), reg_cache, send_msg(), and snprintf.

Referenced by __open().

gdbr_check_extended_mode()

int gdbr_check_extended_mode

(

libgdbr_t *

g

)

checks for extended mode availability

Returns

a failure code (currently -1) or 0 if call successfully

Definition at line 406 of file core.c.

                                           {
    int ret = -1;
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    g->stop_reason.is_valid = false;
    reg_cache.valid = false;
    // Activate extended mode if possible.
    ret = send_msg(g, "!");
    if (ret < 0) {
        g->stub_features.extended_mode = 0;
        goto end;
    }
    read_packet(g, false);
    ret = send_ack(g);
    if (ret < 0) {
        g->stub_features.extended_mode = 0;
        goto end;
    }
    if (strncmp(g->data, "OK", 2)) {
        g->stub_features.extended_mode = 0;
        ret = -1;
        goto end;
    }
    g->stub_features.extended_mode = 1;
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    return ret;
}

References test_evm::end, g, gdbr_lock_enter(), gdbr_lock_leave(), read_packet(), reg_cache, send_ack(), and send_msg().

Referenced by gdbr_attach().

gdbr_check_vcont()

int gdbr_check_vcont

(

libgdbr_t *

g

)

checks which subcommands of the vCont packet are supported

Definition at line 335 of file core.c.

                                   {
    int ret = -1;
    char *ptr = NULL;
 
    if (!g) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    if (send_msg(g, "vCont?") < 0 || read_packet(g, false) < 0 || send_ack(g) < 0) {
        ret = -1;
        goto end;
    }
    if (g->data_len == 0) {
        g->stub_features.vContSupported = false;
        ret = 0;
        goto end;
    }
    g->data[g->data_len] = '\0';
    if (!(ptr = strtok(g->data + strlen("vCont;"), ";"))) {
        ret = 0;
        goto end;
    }
    while (ptr) {
        switch (*ptr) {
        case 's':
            g->stub_features.vcont.s = true;
            break;
        case 'S':
            g->stub_features.vcont.S = true;
            break;
        case 'c':
            g->stub_features.vcont.c = true;
            break;
        case 'C':
            g->stub_features.vcont.C = true;
            break;
        case 't':
            g->stub_features.vcont.t = true;
            break;
        case 'r':
            g->stub_features.vcont.r = true;
            break;
        }
        g->stub_features.vContSupported = true;
        ptr = strtok(NULL, ";");
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    return ret;
}

References test_evm::end, g, gdbr_lock_enter(), gdbr_lock_leave(), NULL, read_packet(), send_ack(), and send_msg().

Referenced by gdbr_connect().

gdbr_close_file()

int gdbr_close_file

(

libgdbr_t *

g

)

Definition at line 1539 of file core.c.

                                  {
    int ret = -1;
    char buf[64];
 
    if (!g) {
        return -1;
    }
    if (g->remote_file_fd < 0) {
        eprintf("%s: No remote file opened\n", __func__);
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    snprintf(buf, sizeof(buf) - 1, "vFile:close:%x", g->remote_file_fd);
    if ((ret = send_msg(g, buf)) < 0) {
        goto end;
    }
    read_packet(g, false);
    if ((ret = handle_vFile_close(g)) < 0) {
        goto end;
    }
    g->remote_file_fd = -1;
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    return ret;
}

References test_evm::end, eprintf, g, gdbr_lock_enter(), gdbr_lock_leave(), handle_vFile_close(), read_packet(), send_msg(), and snprintf.

Referenced by gdbr_parse_processes_xml(), and rz_debug_gdb_map_get().

gdbr_connect()

int gdbr_connect	(	libgdbr_t *	g,
		const char *	server,
		int	port
	)

Function connects to a gdbserver instance.

Parameters

server	string that represents the host
number	that represents the port

Returns

a failure code (currently -1) or 0 if call successfully

Definition at line 155 of file core.c.

                                                           {
    const char *message = "qSupported:multiprocess+;qRelocInsn+;xmlRegisters=i386";
    int i;
    int ret = -1;
    void *bed = NULL;
 
    if (!g || !host) {
        return -1;
    }
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    // Initial max_packet_size for remote target (minimum so far for AVR = 64)
    g->stub_features.pkt_sz = 64;
    char *env_pktsz_str;
    ut32 env_pktsz = 0;
    if ((env_pktsz_str = rz_sys_getenv("RZ_GDB_PKTSZ"))) {
        if ((env_pktsz = (ut32)strtoul(env_pktsz_str, NULL, 10))) {
            g->stub_features.pkt_sz = RZ_MAX(env_pktsz, GDB_MAX_PKTSZ);
        }
    }
    // Use the default break handler for rz_socket_connect to send a signal
    rz_cons_break_pop();
    bed = rz_cons_sleep_begin();
    if (*host == '/') {
        ret = rz_socket_connect_serial(g->sock, host, port, 1);
    } else {
        ret = rz_socket_connect_tcp(g->sock, host, sdb_fmt("%d", port), 1);
    }
    rz_cons_sleep_end(bed);
    rz_cons_break_push(gdbr_break_process, g);
    if (!ret) {
        ret = -1;
        goto end;
    }
    if ((ret = send_ack(g)) < 0) {
        goto end;
    }
    read_packet(g, true); // vcont=true lets us skip if we get no reply
    g->connected = 1;
    bed = rz_cons_sleep_begin();
    // TODO add config possibility here
    for (i = 0; i < QSUPPORTED_MAX_RETRIES && !g->isbreaked; i++) {
        ret = send_msg(g, message);
        if (ret < 0) {
            continue;
        }
        ret = read_packet(g, false);
        if (ret < 0) {
            continue;
        }
        ret = handle_qSupported(g);
        if (ret < 0) {
            continue;
        }
        break;
    }
    rz_cons_sleep_end(bed);
    if (g->isbreaked) {
        g->isbreaked = false;
        ret = -1;
        goto end;
    }
    if (ret < 0) {
        goto end;
    }
    if (env_pktsz > 0) {
        g->stub_features.pkt_sz = RZ_MAX(RZ_MIN(env_pktsz, g->stub_features.pkt_sz), GDB_MAX_PKTSZ);
    }
    // If no-ack supported, enable no-ack mode (should speed up things)
    if (g->stub_features.QStartNoAckMode) {
        if ((ret = send_msg(g, "QStartNoAckMode")) < 0) {
            goto end;
        }
        read_packet(g, false);
        if (!strncmp(g->data, "OK", 2)) {
            // Just in case, send ack
            send_ack(g);
            g->no_ack = true;
        }
    }
    if (g->remote_type == GDB_REMOTE_TYPE_LLDB) {
        if ((ret = gdbr_connect_lldb(g)) < 0) {
            goto end;
        }
    }
    // Query the thread / process id
    g->stub_features.qC = true;
    g->pid = g->tid = 0;
    if ((ret = send_msg(g, "qC")) < 0) {
        goto end;
    }
    read_packet(g, false);
    if (handle_qC(g) < 0) {
        g->stub_features.qC = false;
    }
    // Check if vCont is supported
    gdbr_check_vcont(g);
    // Set pid/thread for operations other than "step" and "continue"
    if (gdbr_select(g, g->pid, g->tid) < 0) {
        // return -1;
    }
    // Set thread for "step" and "continue" operations
    if ((ret = send_msg(g, "Hc-1")) < 0) {
        goto end;
    }
    read_packet(g, false);
    ret = send_ack(g);
    if (ret < 0) {
        goto end;
    }
    if (strcmp(g->data, "OK")) {
        // return -1;
    }
    if (g->stub_features.qXfer_features_read) {
        gdbr_read_target_xml(g);
    }
    reg_cache_init(g);
 
    ret = 0;
end:
    if (ret != 0) {
        rz_socket_close(g->sock);
    }
    gdbr_lock_leave(g);
    return ret;
}

References test_evm::end, g, GDB_MAX_PKTSZ, GDB_REMOTE_TYPE_LLDB, gdbr_break_process(), gdbr_check_vcont(), gdbr_connect_lldb(), gdbr_lock_enter(), gdbr_lock_leave(), gdbr_read_target_xml(), gdbr_select(), handle_qC(), handle_qSupported(), i, message, NULL, QSUPPORTED_MAX_RETRIES, read_packet(), reg_cache_init(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_sleep_begin(), rz_cons_sleep_end(), RZ_MAX, RZ_MIN, rz_socket_close(), rz_socket_connect_serial(), rz_socket_connect_tcp, rz_sys_getenv(), sdb_fmt(), send_ack(), and send_msg().

Referenced by __open().

gdbr_continue()

int gdbr_continue	(	libgdbr_t *	g,
		int	pid,
		int	tid,
		int	sig
	)

Definition at line 950 of file core.c.

                                                           {
    char thread_id[64] = { 0 };
    char command[16] = { 0 };
    int ret = -1;
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    if (sig <= 0) {
        strncpy(command, CMD_C_CONT, sizeof(command) - 1);
    } else {
        snprintf(command, sizeof(command) - 1, "%s%02x", CMD_C_CONT_SIG, sig);
    }
    if (tid <= 0 || write_thread_id(thread_id, sizeof(thread_id) - 1, g->pid, tid, g->stub_features.multiprocess) < 0) {
        ret = send_vcont(g, command, NULL);
        goto end;
    }
 
    ret = send_vcont(g, command, thread_id);
end:
    gdbr_lock_leave(g);
    return ret;
}

References CMD_C_CONT, CMD_C_CONT_SIG, command, test_evm::end, g, gdbr_lock_enter(), gdbr_lock_leave(), NULL, send_vcont(), snprintf, and write_thread_id().

Referenced by rz_debug_gdb_continue().

gdbr_detach()

int gdbr_detach

(

libgdbr_t *

g

)

detaches from a process

Parameters

pid	of the process to detach from (only the multiprocess/pid variant)

Returns

a failure code (currently -1) or 0 if call successfully

Definition at line 495 of file core.c.

                              {
    int ret = -1;
 
    if (!g || !g->sock) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    reg_cache.valid = false;
    g->stop_reason.is_valid = false;
    ret = send_msg(g, "D");
    if (ret < 0) {
        ret = -1;
        goto end;
    }
    // Disconnect
    ret = gdbr_disconnect(g);
end:
    gdbr_lock_leave(g);
    return ret;
}

References test_evm::end, g, gdbr_disconnect(), gdbr_lock_enter(), gdbr_lock_leave(), reg_cache, and send_msg().

Referenced by __system(), and rz_debug_gdb_detach().

gdbr_detach_pid()

int gdbr_detach_pid	(	libgdbr_t *	g,
		int	pid
	)

Definition at line 520 of file core.c.

                                           {
    char *cmd = NULL;
    int ret = -1;
    size_t buffer_size;
 
    if (!g || !g->sock || !g->stub_features.multiprocess) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    reg_cache.valid = false;
    g->stop_reason.is_valid = false;
 
    buffer_size = strlen(CMD_DETACH_MP) + (sizeof(pid) * 2) + 1;
    cmd = calloc(buffer_size, sizeof(char));
    if (!cmd) {
        ret = -1;
        goto end;
    }
 
    if ((snprintf(cmd, buffer_size, "%s%x", CMD_DETACH_MP, g->pid)) < 0) {
        ret = -1;
        goto end;
    }
 
    ret = send_msg(g, cmd);
    if (ret < 0) {
        goto end;
    }
 
    read_packet(g, false);
    if ((ret = send_ack(g)) < 0) {
        goto end;
    }
 
    if (strncmp(g->data, "OK", 2)) {
        ret = -1;
        goto end;
    }
 
    ret = 0;
end:
    if (cmd) {
        free(cmd);
    }
    gdbr_lock_leave(g);
    return ret;
}

References buffer_size, calloc(), cmd, CMD_DETACH_MP, test_evm::end, free(), g, gdbr_lock_enter(), gdbr_lock_leave(), NULL, pid, read_packet(), reg_cache, send_ack(), send_msg(), and snprintf.

Referenced by __system(), and rz_debug_gdb_detach().

gdbr_disconnect()

int gdbr_disconnect

(

libgdbr_t *

g

)

disconnects the lib

Returns

a failure code (currently -1) or 0 if call successfully

Definition at line 283 of file core.c.

                                  {
    // TODO Disconnect maybe send something to gdbserver
    if (!g || !rz_socket_close(g->sock)) {
        return -1;
    }
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    reg_cache.valid = false;
    g->stop_reason.is_valid = false;
    free(reg_cache.buf);
    if (g->target.valid) {
        free(g->target.regprofile);
        free(g->registers);
    }
    g->connected = 0;
end:
    gdbr_lock_leave(g);
    return 0;
}

References test_evm::end, free(), g, gdbr_lock_enter(), gdbr_lock_leave(), reg_cache, and rz_socket_close().

Referenced by __close(), gdbr_detach(), stop_reason_exit(), and stop_reason_terminated().

gdbr_exec_file_read()

char* gdbr_exec_file_read	(	libgdbr_t *	g,
		int	pid
	)

Get absolute name of file executed to create a process

Definition at line 1635 of file core.c.

                                                 {
    char msg[128], pidstr[16];
    char *path = NULL;
    ut64 len, off = 0;
    int ret = -1;
 
    if (!g) {
        return NULL;
    }
 
    len = g->stub_features.pkt_sz;
    memset(pidstr, 0, sizeof(pidstr));
    if (g->stub_features.multiprocess && pid > 0) {
        snprintf(pidstr, sizeof(pidstr), "%x", pid);
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    while (1) {
        if (snprintf(msg, sizeof(msg) - 1,
                "qXfer:exec-file:read:%s:%" PFMT64x ",%" PFMT64x,
                pidstr, off, len) < 0) {
            ret = -1;
            goto end;
        }
        if (send_msg(g, msg) < 0 || read_packet(g, false) < 0 || send_ack(g) < 0 || g->data_len == 0) {
            ret = -1;
            goto end;
        }
        g->data[g->data_len] = '\0';
        if (g->data[0] == 'l') {
            if (g->data_len == 1) {
                break;
            }
            path = rz_str_append(path, g->data + 1);
            break;
        }
        if (g->data[0] != 'm') {
            ret = -1;
            goto end;
        }
        off += strlen(g->data + 1);
        if (!(path = rz_str_append(path, g->data + 1))) {
            ret = -1;
            goto end;
        }
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    if (ret != 0) {
        if (path) {
            free(path);
        }
        return NULL;
    }
    return path;
}

References test_evm::end, free(), g, gdbr_lock_enter(), gdbr_lock_leave(), len, memset(), msg, NULL, off, path, PFMT64x, pid, read_packet(), rz_str_append(), send_ack(), send_msg(), snprintf, and ut64().

Referenced by __open(), __system(), gdbr_pids_list(), gdbr_threads_list(), and rz_debug_gdb_info().

gdbr_get_baddr()

ut64 gdbr_get_baddr

(

libgdbr_t *

g

)

Get offset of lowest segment returned by 'qOffsets'

Definition at line 1931 of file core.c.

                                  {
    ut64 off, min = UINT64_MAX;
    char *ptr;
    if (!g) {
        return UINT64_MAX;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    if (send_msg(g, "qOffsets") < 0 || read_packet(g, false) < 0 || send_ack(g) < 0 || g->data_len == 0) {
        min = UINT64_MAX;
        goto end;
    }
    if (rz_str_startswith(g->data, "TextSeg=")) {
        ptr = g->data + strlen("TextSeg=");
        if (!isxdigit(*ptr)) {
            goto end;
        }
        off = strtoull(ptr, NULL, 16);
        if (off < min) {
            min = off;
        }
        if (!(ptr = strchr(ptr, ';'))) {
            goto end;
        }
        ptr++;
        if (*ptr && rz_str_startswith(ptr, "DataSeg=")) {
            ptr += strlen("DataSeg=");
            if (!isxdigit(*ptr)) {
                goto end;
            }
            off = strtoull(ptr, NULL, 16);
            if (off < min) {
                min = off;
            }
        }
        goto end;
    }
    if (!rz_str_startswith(g->data, "Text=")) {
        goto end;
    }
    ptr = g->data + strlen("Text=");
    if (!isxdigit(*ptr)) {
        goto end;
    }
    off = strtoull(ptr, NULL, 16);
    if (off < min) {
        min = off;
    }
    if (!(ptr = strchr(ptr, ';')) || !rz_str_startswith(ptr + 1, "Data=")) {
        min = UINT64_MAX;
        goto end;
    }
    ptr += strlen(";Data=");
    if (!isxdigit(*ptr)) {
        min = UINT64_MAX;
        goto end;
    }
    off = strtoull(ptr, NULL, 16);
    if (off < min) {
        min = off;
    }
    if (!(ptr = strchr(ptr, ';'))) {
        goto end;
    }
    ptr++;
    if (rz_str_startswith(ptr, "Bss=")) {
        ptr += strlen("Bss=");
        if (!isxdigit(*ptr)) {
            goto end;
        }
        off = strtoull(ptr, NULL, 16);
        if (off < min) {
            min = off;
        }
    }
end:
    gdbr_lock_leave(g);
    return min;
}

References test_evm::end, g, gdbr_lock_enter(), gdbr_lock_leave(), isxdigit, min, NULL, off, read_packet(), rz_str_startswith(), send_ack(), send_msg(), UINT64_MAX, and ut64().

Referenced by rz_debug_gdb_map_get().

gdbr_invalidate_reg_cache()

void gdbr_invalidate_reg_cache

(

void

)

invalidates the reg cache

Definition at line 1570 of file core.c.

                                 {
    reg_cache.valid = false;
}

References reg_cache.

Referenced by __system().

gdbr_kill()

int gdbr_kill

(

libgdbr_t *

g

)

kills the process the remote gdbserver is debugging (TODO: handle pid)

Parameters

pid	of the process to detach from (only the multiprocess/pid variant) \retuns a failure code (currently -1) or 0 if call successfully

Definition at line 572 of file core.c.

                            {
    int ret = -1;
 
    if (!g || !g->sock) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    reg_cache.valid = false;
    g->stop_reason.is_valid = false;
 
    if (g->stub_features.multiprocess) {
        if (g->pid <= 0) {
            ret = -1;
            goto end;
        }
        ret = gdbr_kill_pid(g, g->pid);
        goto end;
    }
 
    if ((ret = send_msg(g, "k")) < 0) {
        goto end;
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    return ret;
}

References test_evm::end, g, gdbr_kill_pid(), gdbr_lock_enter(), gdbr_lock_leave(), reg_cache, and send_msg().

Referenced by rz_debug_gdb_kill().

gdbr_kill_pid()

int gdbr_kill_pid	(	libgdbr_t *	g,
		int	pid
	)

Definition at line 605 of file core.c.

                                         {
    char *cmd = NULL;
    int ret = -1;
    size_t buffer_size;
 
    if (!g || !g->sock || !g->stub_features.multiprocess) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    reg_cache.valid = false;
    g->stop_reason.is_valid = false;
 
    buffer_size = strlen(CMD_KILL_MP) + (sizeof(pid) * 2) + 1;
    cmd = calloc(buffer_size, sizeof(char));
    if (!cmd) {
        ret = -1;
        goto end;
    }
 
    if ((snprintf(cmd, buffer_size, "%s%x", CMD_KILL_MP, g->pid)) < 0) {
        ret = -1;
        goto end;
    }
    if ((ret = send_msg(g, cmd)) < 0) {
        goto end;
    }
 
    read_packet(g, false);
    if ((ret = send_ack(g)) < 0) {
        goto end;
    }
    if (strncmp(g->data, "OK", 2)) {
        ret = -1;
        goto end;
    }
 
end:
    if (cmd) {
        free(cmd);
    }
    gdbr_lock_leave(g);
    return ret;
}

References buffer_size, calloc(), cmd, CMD_KILL_MP, test_evm::end, free(), g, gdbr_lock_enter(), gdbr_lock_leave(), NULL, pid, read_packet(), reg_cache, send_ack(), send_msg(), and snprintf.

Referenced by gdbr_kill().

gdbr_lock_enter()

bool gdbr_lock_enter

(

libgdbr_t *

g

)

Acquires the gdbr lock and sets up breaking.

Returns

true on success, false on failure

Definition at line 105 of file core.c.

                                   {
    rz_cons_break_push(gdbr_break_process, g);
    void *bed = rz_cons_sleep_begin();
    rz_th_lock_enter(g->gdbr_lock);
    g->gdbr_lock_depth++;
    rz_cons_sleep_end(bed);
    if (g->isbreaked) {
        return false;
    }
    return true;
}

References g, gdbr_break_process(), rz_cons_break_push(), rz_cons_sleep_begin(), rz_cons_sleep_end(), and rz_th_lock_enter().

Referenced by __system(), gdbr_attach(), gdbr_check_extended_mode(), gdbr_check_vcont(), gdbr_close_file(), gdbr_connect(), gdbr_connect_lldb(), gdbr_continue(), gdbr_detach(), gdbr_detach_pid(), gdbr_disconnect(), gdbr_exec_file_read(), gdbr_get_baddr(), gdbr_is_thread_dead(), gdbr_kill(), gdbr_kill_pid(), gdbr_open_file(), gdbr_pids_list(), gdbr_read_file(), gdbr_read_memory(), gdbr_read_memory_page(), gdbr_read_registers_lldb(), gdbr_select(), gdbr_send_qRcmd(), gdbr_step(), gdbr_stop_reason(), gdbr_threads_list(), gdbr_write_bin_registers(), gdbr_write_memory(), gdbr_write_reg(), gdbr_write_register(), gdbr_write_registers(), remove_bp(), send_vcont(), set_bp(), and test_command().

gdbr_lock_leave()

void gdbr_lock_leave

(

libgdbr_t *

g

)

Releases the gdbr lock.

Definition at line 117 of file core.c.

                                   {
    rz_cons_break_pop();
    assert(g->gdbr_lock_depth > 0);
    bool last_leave = g->gdbr_lock_depth == 1;
    g->gdbr_lock_depth--;
    rz_th_lock_leave(g->gdbr_lock);
    // if this is the last lock this thread holds make sure that we disable the break
    if (last_leave) {
        g->isbreaked = false;
    }
}

References assert(), g, rz_cons_break_pop(), and rz_th_lock_leave().

Referenced by __system(), gdbr_attach(), gdbr_check_extended_mode(), gdbr_check_vcont(), gdbr_close_file(), gdbr_connect(), gdbr_connect_lldb(), gdbr_continue(), gdbr_detach(), gdbr_detach_pid(), gdbr_disconnect(), gdbr_exec_file_read(), gdbr_get_baddr(), gdbr_is_thread_dead(), gdbr_kill(), gdbr_kill_pid(), gdbr_open_file(), gdbr_pids_list(), gdbr_read_file(), gdbr_read_memory(), gdbr_read_memory_page(), gdbr_read_registers(), gdbr_read_registers_lldb(), gdbr_select(), gdbr_send_qRcmd(), gdbr_step(), gdbr_stop_reason(), gdbr_threads_list(), gdbr_write_bin_registers(), gdbr_write_memory(), gdbr_write_reg(), gdbr_write_register(), gdbr_write_registers(), remove_bp(), send_vcont(), set_bp(), and test_command().

gdbr_open_file()

int gdbr_open_file	(	libgdbr_t *	g,
		const char *	filename,
		int	flags,
		int	mode
	)

File read from remote target (only one file open at a time for now)

Definition at line 1445 of file core.c.

                                                                            {
    int ret = -1;
    char *buf;
    size_t buf_len;
 
    if (!g || !filename || !*filename) {
        return -1;
    }
    if (g->remote_file_fd >= 0) {
        eprintf("%s: Remote file already open\n", __func__);
        return -1;
    }
    buf_len = (strlen(filename) * 2) + strlen("vFile:open:") + 30;
    if (!(buf = calloc(buf_len, sizeof(char)))) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    strcpy(buf, "vFile:open:");
    pack_hex(filename, strlen(filename), buf + strlen(buf));
    snprintf(buf + strlen(buf), buf_len - strlen(buf) - 1, ",%x,%x", flags, mode);
    if ((ret = send_msg(g, buf)) < 0) {
        goto end;
    }
    read_packet(g, false);
    if ((ret = handle_vFile_open(g)) < 0) {
        goto end;
    }
 
    ret = 0;
end:
    if (buf) {
        free(buf);
    }
    gdbr_lock_leave(g);
    return ret;
}

References buf, buf_len, calloc(), test_evm::end, eprintf, flags, free(), g, gdbr_lock_enter(), gdbr_lock_leave(), handle_vFile_open(), pack_hex(), read_packet(), send_msg(), and snprintf.

Referenced by gdbr_parse_processes_xml(), and rz_debug_gdb_map_get().

gdbr_pids_list()

RzList* gdbr_pids_list	(	libgdbr_t *	g,
		int	pid
	)

get a list of the child processes of the given pid

Definition at line 1731 of file core.c.

                                              {
    int ret = -1;
    RzList *list = NULL;
    int tpid = -1, ttid = -1;
    char *ptr, *ptr2, *exec_file;
    RzDebugPid *dpid = NULL;
    RzListIter *iter = NULL;
 
    if (!g) {
        return NULL;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    if (!(list = rz_list_new())) {
        ret = -1;
        goto end;
    }
    // Use qfThreadInfo as a fallback since it doesn't actually show all children
    if (g->stub_features.qXfer_threads_read) {
        if (gdbr_read_processes_xml(g, pid, list) == 0) {
            ret = 0;
            goto end;
        }
    }
    // Child processes will only show up in ThreadInfo if gdbr is currently processing a
    // fork/vfork/exec event or if the children weren't detached yet. This is intended
    // gdb `info inferiors` behavior that can only be avoided using xml.
    eprintf("WARNING: Showing possibly incomplete pid list due to xml protocol failure\n");
 
    if (!g->stub_features.qXfer_exec_file_read || !(exec_file = gdbr_exec_file_read(g, pid))) {
        exec_file = "";
    }
    if (send_msg(g, "qfThreadInfo") < 0 || read_packet(g, false) < 0 || send_ack(g) < 0 || g->data_len == 0 || g->data[0] != 'm') {
        ret = -1;
        goto end;
    }
    while (1) {
        g->data[g->data_len] = '\0';
        ptr = g->data + 1;
        while (ptr) {
            if ((ptr2 = strchr(ptr, ','))) {
                *ptr2 = '\0';
                ptr2++;
            }
            if (read_thread_id(ptr, &tpid, &ttid, g->stub_features.multiprocess) < 0) {
                ptr = ptr2;
                continue;
            }
            // Avoid adding the same pid twice(could show more than once if it has threads)
            rz_list_foreach (list, iter, dpid) {
                if (tpid == dpid->pid) {
                    continue;
                }
            }
            if (!(dpid = RZ_NEW0(RzDebugPid)) || !(dpid->path = strdup(exec_file))) {
                ret = -1;
                goto end;
            }
            dpid->pid = tpid;
            // If the pid isn't the debugged pid it must be a child pid
            if (tpid != g->pid) {
                dpid->ppid = g->pid;
            }
            dpid->uid = dpid->gid = -1;
            dpid->runnable = true;
            dpid->status = RZ_DBG_PROC_STOP;
            rz_list_append(list, dpid);
            ptr = ptr2;
        }
        if (send_msg(g, "qsThreadInfo") < 0 || read_packet(g, false) < 0 || send_ack(g) < 0 || g->data_len == 0 || (g->data[0] != 'm' && g->data[0] != 'l')) {
            ret = -1;
            goto end;
        }
        if (g->data[0] == 'l') {
            break;
        }
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    if (ret != 0) {
        if (dpid) {
            free(dpid);
        }
        // We can't use rz_debug_pid_free here
        if (list) {
            rz_list_foreach (list, iter, dpid) {
                if (dpid->path) {
                    free(dpid->path);
                }
                free(dpid);
            }
            rz_list_free(list);
        }
        return NULL;
    }
    return list;
}

References test_evm::end, eprintf, free(), g, gdbr_exec_file_read(), gdbr_lock_enter(), gdbr_lock_leave(), gdbr_read_processes_xml(), rz_debug_pid_t::gid, list(), NULL, rz_debug_pid_t::path, rz_debug_pid_t::pid, pid, rz_debug_pid_t::ppid, read_packet(), read_thread_id(), rz_debug_pid_t::runnable, RZ_DBG_PROC_STOP, rz_list_append(), rz_list_free(), rz_list_new(), RZ_NEW0, send_ack(), send_msg(), rz_debug_pid_t::status, strdup(), and rz_debug_pid_t::uid.

Referenced by rz_debug_gdb_pids().

gdbr_read_file()

int gdbr_read_file	(	libgdbr_t *	g,
		ut8 *	buf,
		ut64	max_len
	)

Definition at line 1485 of file core.c.

                                                         {
    int ret, ret1;
    char command[64];
    ut64 data_sz;
    ret = 0;
    if (!g || !buf || !max_len) {
        return -1;
    }
    if (max_len >= INT32_MAX) {
        eprintf("%s: Too big a file read requested: %" PFMT64d, __func__, max_len);
        return -1;
    }
    if (g->remote_file_fd < 0) {
        eprintf("%s: No remote file opened\n", __func__);
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    g->stub_features.pkt_sz = RZ_MAX(g->stub_features.pkt_sz, GDB_MAX_PKTSZ);
    data_sz = g->stub_features.pkt_sz / 2;
    ret = 0;
    while (ret < max_len) {
        if (snprintf(command, sizeof(command) - 1,
                "vFile:pread:%x,%" PFMT64x ",%" PFMT64x,
                (int)g->remote_file_fd, (ut64)RZ_MIN(data_sz, max_len - ret),
                (ut64)ret) < 0) {
            ret = -1;
            goto end;
        }
        if (send_msg(g, command) < 0) {
            ret = -1;
            goto end;
        }
        if (read_packet(g, false) < 0) {
            ret = -1;
            goto end;
        }
        if ((ret1 = handle_vFile_pread(g, buf + ret)) < 0) {
            ret = ret1;
            goto end;
        }
        if (ret1 == 0) {
            goto end;
        }
        ret += ret1;
    }
 
end:
    gdbr_lock_leave(g);
    return ret;
}

References command, test_evm::end, eprintf, g, GDB_MAX_PKTSZ, gdbr_lock_enter(), gdbr_lock_leave(), handle_vFile_pread(), INT32_MAX, PFMT64d, PFMT64x, read_packet(), RZ_MAX, RZ_MIN, send_msg(), snprintf, and ut64().

Referenced by gdbr_parse_processes_xml(), and rz_debug_gdb_map_get().

gdbr_read_memory()

int gdbr_read_memory	(	libgdbr_t *	g,
		ut64	address,
		ut8 *	buf,
		int	len
	)

Definition at line 812 of file core.c.

                                                                    {
    int ret_len, ret, tmp;
    int page_size = g->page_size;
    ret_len = 0;
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    // Read and round up to page size
    tmp = page_size - (address & (page_size - 1));
    if (tmp >= len) {
        ret_len = gdbr_read_memory_page(g, address, buf, len);
        goto end;
    }
    if ((ret = gdbr_read_memory_page(g, address, buf, tmp)) != tmp) {
        ret_len = ret;
        goto end;
    }
    len -= tmp;
    address += tmp;
    buf += tmp;
    ret_len += ret;
    // Read complete pages
    while (len > page_size) {
        if ((ret = gdbr_read_memory_page(g, address, buf, page_size)) != page_size) {
            if (ret < 1) {
                goto end;
            }
            ret_len += ret;
            goto end;
        }
        len -= page_size;
        address += page_size;
        buf += page_size;
        ret_len += page_size;
    }
    // Read left-overs
    if ((ret = gdbr_read_memory_page(g, address, buf, len)) < 0) {
        goto end;
    }
 
    ret_len += ret;
end:
    gdbr_lock_leave(g);
    return ret_len;
}

References test_evm::end, g, gdbr_lock_enter(), gdbr_lock_leave(), gdbr_read_memory_page(), len, and autogen_x86imm::tmp.

Referenced by debug_gdb_read_at().

gdbr_read_registers()

int gdbr_read_registers

(

libgdbr_t *

g

)

Definition at line 685 of file core.c.

                                      {
    int ret = -1;
 
    if (!g || !g->data) {
        return -1;
    }
    if (reg_cache.init && reg_cache.valid) {
        g->data_len = reg_cache.buflen;
        memcpy(g->data, reg_cache.buf, reg_cache.buflen);
        return 0;
    }
    // Don't wait on the lock in read_registers since it's frequently called, including
    // each time "enter" is pressed. Otherwise the user will be forced to interrupt exit
    // read_registers constantly while another task is in progress
    if (!gdbr_lock_tryenter(g)) {
        return -1;
    }
 
    if (g->remote_type == GDB_REMOTE_TYPE_LLDB && !g->stub_features.lldb.g) {
        ret = gdbr_read_registers_lldb(g);
        goto end;
    }
    if ((ret = send_msg(g, CMD_READREGS)) < 0) {
        goto end;
    }
    if (read_packet(g, false) < 0 || handle_g(g) < 0) {
        ret = -1;
        goto end;
    }
    if (reg_cache.init) {
        reg_cache.buflen = g->data_len;
        memset(reg_cache.buf, 0, reg_cache.buflen);
        memcpy(reg_cache.buf, g->data, reg_cache.buflen);
        reg_cache.valid = true;
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    return ret;
}

References CMD_READREGS, test_evm::end, g, GDB_REMOTE_TYPE_LLDB, gdbr_lock_leave(), gdbr_lock_tryenter(), gdbr_read_registers_lldb(), handle_g(), memcpy(), memset(), read_packet(), reg_cache, and send_msg().

Referenced by gdbr_write_reg(), gdbr_write_registers(), and rz_debug_gdb_reg_read().

gdbr_remove_bp()

int gdbr_remove_bp	(	libgdbr_t *	g,
		ut64	address,
		int	sizebp
	)

Definition at line 1377 of file core.c.

                                                           {
    return remove_bp(g, address, BREAKPOINT, sizebp);
}

References BREAKPOINT, g, and remove_bp().

Referenced by rz_debug_gdb_breakpoint().

gdbr_remove_hwa()

int gdbr_remove_hwa	(	libgdbr_t *	g,
		ut64	address,
		int	sizebp
	)

Definition at line 1392 of file core.c.

                                                            {
    return remove_bp(g, address, ACCESS_WATCHPOINT, sizebp);
}

References ACCESS_WATCHPOINT, g, and remove_bp().

Referenced by rz_debug_gdb_breakpoint().

gdbr_remove_hwbp()

int gdbr_remove_hwbp	(	libgdbr_t *	g,
		ut64	address,
		int	sizebp
	)

Definition at line 1380 of file core.c.

                                                             {
    return remove_bp(g, address, HARDWARE_BREAKPOINT, sizebp);
}

References g, HARDWARE_BREAKPOINT, and remove_bp().

Referenced by rz_debug_gdb_breakpoint().

gdbr_remove_hwr()

int gdbr_remove_hwr	(	libgdbr_t *	g,
		ut64	address,
		int	sizebp
	)

Definition at line 1388 of file core.c.

                                                            {
    return remove_bp(g, address, READ_WATCHPOINT, sizebp);
}

References g, READ_WATCHPOINT, and remove_bp().

Referenced by rz_debug_gdb_breakpoint().

gdbr_remove_hww()

int gdbr_remove_hww	(	libgdbr_t *	g,
		ut64	address,
		int	sizebp
	)

Definition at line 1384 of file core.c.

                                                            {
    return remove_bp(g, address, WRITE_WATCHPOINT, sizebp);
}

References g, remove_bp(), and WRITE_WATCHPOINT.

Referenced by rz_debug_gdb_breakpoint().

gdbr_select()

int gdbr_select	(	libgdbr_t *	g,
		int	pid,
		int	tid
	)

Select pid-tid

Definition at line 304 of file core.c.

                                                {
    char cmd[64] = { 0 };
    int ret = -1;
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    reg_cache.valid = false;
    g->pid = pid;
    g->tid = tid;
    strcpy(cmd, "Hg");
    if ((ret = write_thread_id(cmd + 2, sizeof(cmd) - 3, pid, tid,
             g->stub_features.multiprocess)) < 0) {
        goto end;
    }
    g->stop_reason.is_valid = false;
    if (send_msg(g, cmd) < 0 || read_packet(g, false) < 0 || send_ack(g) < 0) {
        ret = -1;
        goto end;
    }
    if (strcmp(g->data, "OK")) {
        ret = -1;
        goto end;
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    return ret;
}

References cmd, test_evm::end, g, gdbr_lock_enter(), gdbr_lock_leave(), pid, read_packet(), reg_cache, send_ack(), send_msg(), and write_thread_id().

Referenced by gdbr_connect(), rz_debug_gdb_select(), and rz_debug_gdb_wait().

gdbr_send_qRcmd()

int gdbr_send_qRcmd	(	libgdbr_t *	g,
		const char *	cmd,
		PrintfCallback	cb_printf
	)

sends a qRcmd packet which basically passes a command to the remote target's interpreter.

Returns

0 on success and -1 on failure

Definition at line 1574 of file core.c.

                                                                             {
    int ret = -1;
    char *buf;
    size_t len;
 
    if (!g || !cmd) {
        return -1;
    }
    len = strlen(cmd) * 2 + 8;
    if (!(buf = calloc(len, sizeof(char)))) {
        return -1;
    }
    strcpy(buf, "qRcmd,");
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    g->stop_reason.is_valid = false;
    reg_cache.valid = false;
    pack_hex(cmd, strlen(cmd), buf + 6);
    if ((ret = send_msg(g, buf)) < 0) {
        goto end;
    }
    if ((ret = read_packet(g, false)) < 0) {
        goto end;
    }
    while (1) {
        if ((ret = send_ack(g)) < 0) {
            goto end;
        }
        if (g->data_len == 0) {
            ret = -1;
            goto end;
        }
        if (g->data_len == 3 && g->data[0] == 'E' && isxdigit(g->data[1]) && isxdigit(g->data[2])) {
            ret = -1;
            goto end;
        }
        if (!strncmp(g->data, "OK", 2)) {
            break;
        }
        if (g->data[0] == 'O' && g->data_len % 2 == 1) {
            // Console output from gdbserver
            unpack_hex(g->data + 1, g->data_len - 1, g->data + 1);
            g->data[g->data_len - 1] = '\0';
            cb_printf("%s", g->data + 1);
        }
        if ((ret = read_packet(g, false)) < 0) {
            goto end;
        }
    }
 
    ret = 0;
end:
    if (buf) {
        free(buf);
    }
    gdbr_lock_leave(g);
    return ret;
}

References buf, calloc(), cmd, test_evm::end, free(), g, gdbr_lock_enter(), gdbr_lock_leave(), isxdigit, len, pack_hex(), read_packet(), reg_cache, send_ack(), send_msg(), and unpack_hex().

Referenced by __system().

gdbr_set_bp()

int gdbr_set_bp	(	libgdbr_t *	g,
		ut64	address,
		const char *	conditions,
		int	sizebp
	)

Function sets normal breakpoint (0xcc, int3)

Parameters

gdbr	instance that contains the current context
addrress	at this position the breakpoint will be added
conditions	TODO: examine how this condition string should look like

Returns

a failure code (currently -1) or 0 if call successfully

Definition at line 1357 of file core.c.

                                                                                {
    return set_bp(g, address, conditions, BREAKPOINT, sizebp);
}

References BREAKPOINT, conditions, g, and set_bp().

Referenced by rz_debug_gdb_breakpoint().

gdbr_set_hwa()

int gdbr_set_hwa	(	libgdbr_t *	g,
		ut64	address,
		const char *	conditions,
		int	sizebp
	)

Definition at line 1373 of file core.c.

                                                                                 {
    return set_bp(g, address, conditions, ACCESS_WATCHPOINT, sizebp);
}

References ACCESS_WATCHPOINT, conditions, g, and set_bp().

Referenced by rz_debug_gdb_breakpoint().

gdbr_set_hwbp()

int gdbr_set_hwbp	(	libgdbr_t *	g,
		ut64	address,
		const char *	conditions,
		int	sizebp
	)

Definition at line 1361 of file core.c.

                                                                                  {
    return set_bp(g, address, conditions, HARDWARE_BREAKPOINT, sizebp);
}

References conditions, g, HARDWARE_BREAKPOINT, and set_bp().

Referenced by rz_debug_gdb_breakpoint().

gdbr_set_hwr()

int gdbr_set_hwr	(	libgdbr_t *	g,
		ut64	address,
		const char *	conditions,
		int	sizebp
	)

Definition at line 1369 of file core.c.

                                                                                 {
    return set_bp(g, address, conditions, READ_WATCHPOINT, sizebp);
}

References conditions, g, READ_WATCHPOINT, and set_bp().

Referenced by rz_debug_gdb_breakpoint().

gdbr_set_hww()

int gdbr_set_hww	(	libgdbr_t *	g,
		ut64	address,
		const char *	conditions,
		int	sizebp
	)

Definition at line 1365 of file core.c.

                                                                                 {
    return set_bp(g, address, conditions, WRITE_WATCHPOINT, sizebp);
}

References conditions, g, set_bp(), and WRITE_WATCHPOINT.

Referenced by rz_debug_gdb_breakpoint().

gdbr_step()

int gdbr_step	(	libgdbr_t *	g,
		int	thread_id
	)

Definition at line 929 of file core.c.

                                     {
    int ret = -1;
    char thread_id[64] = { 0 };
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    if (tid <= 0 || write_thread_id(thread_id, sizeof(thread_id) - 1, g->pid, tid, g->stub_features.multiprocess) < 0) {
        send_vcont(g, "vCont?", NULL);
        send_vcont(g, sdb_fmt("Hc%d", tid), NULL);
        ret = send_vcont(g, CMD_C_STEP, NULL);
        goto end;
    }
 
    ret = send_vcont(g, CMD_C_STEP, thread_id);
end:
    gdbr_lock_leave(g);
    return ret;
}

References CMD_C_STEP, test_evm::end, g, gdbr_lock_enter(), gdbr_lock_leave(), NULL, sdb_fmt(), send_vcont(), and write_thread_id().

Referenced by rz_debug_gdb_step().

gdbr_stop_reason()

int gdbr_stop_reason

(

libgdbr_t *

g

)

gets reason why remote target stopped

Definition at line 391 of file core.c.

                                   {
    int ret = -1;
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    if (!g || send_msg(g, "?") < 0 || read_packet(g, false) < 0) {
        ret = -1;
        goto end;
    }
    ret = handle_stop_reason(g);
end:
    gdbr_lock_leave(g);
    return ret;
}

References test_evm::end, g, gdbr_lock_enter(), gdbr_lock_leave(), handle_stop_reason(), read_packet(), and send_msg().

Referenced by rz_debug_gdb_info(), and rz_debug_gdb_wait().

gdbr_threads_list()

RzList* gdbr_threads_list	(	libgdbr_t *	g,
		int	pid
	)

get list of threads for given pid

Definition at line 1833 of file core.c.

                                                 {
    int ret = -1;
    RzList *list = NULL;
    int tpid = -1, ttid = -1;
    char *ptr, *ptr2, *exec_file;
    RzDebugPid *dpid = NULL;
    RzListIter *iter = NULL;
 
    if (!g) {
        return NULL;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
    if (!g->stub_features.qXfer_exec_file_read || !(exec_file = gdbr_exec_file_read(g, pid))) {
        exec_file = "";
    }
    if (g->stub_features.qXfer_threads_read) {
        // XML thread description is supported
        // TODO: Handle this case
    }
    if (send_msg(g, "qfThreadInfo") < 0 || read_packet(g, false) < 0 || send_ack(g) < 0 || g->data_len == 0 || g->data[0] != 'm') {
        ret = -1;
        goto end;
    }
    if (!(list = rz_list_new())) {
        ret = -1;
        goto end;
    }
    while (1) {
        g->data[g->data_len] = '\0';
        ptr = g->data + 1;
        while (ptr) {
            if ((ptr2 = strchr(ptr, ','))) {
                *ptr2 = '\0';
                ptr2++;
            }
            if (read_thread_id(ptr, &tpid, &ttid,
                    g->stub_features.multiprocess) < 0) {
                ptr = ptr2;
                continue;
            }
            if (g->stub_features.multiprocess && tpid != pid) {
                ptr = ptr2;
                continue;
            }
            if (!(dpid = RZ_NEW0(RzDebugPid)) || !(dpid->path = strdup(exec_file))) {
                ret = -1;
                goto end;
            }
            dpid->uid = dpid->gid = -1; // TODO
            dpid->pid = ttid;
            dpid->runnable = true;
            // This is what linux native does as fallback, but
            // probably not correct.
            // TODO: Implement getting correct thread status from GDB
            dpid->status = RZ_DBG_PROC_STOP;
            rz_list_append(list, dpid);
            ptr = ptr2;
        }
        if (send_msg(g, "qsThreadInfo") < 0 || read_packet(g, false) < 0 || send_ack(g) < 0 || g->data_len == 0 || (g->data[0] != 'm' && g->data[0] != 'l')) {
            ret = -1;
            goto end;
        }
        if (g->data[0] == 'l') {
            break;
        }
    }
    // This is the all I've been able to extract from gdb so far
    rz_list_foreach (list, iter, dpid) {
        if (gdbr_is_thread_dead(g, pid, dpid->pid)) {
            dpid->status = RZ_DBG_PROC_DEAD;
        }
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    if (ret != 0) {
        if (dpid) {
            free(dpid);
        }
        // We can't use rz_debug_pid_free here
        if (list) {
            rz_list_foreach (list, iter, dpid) {
                if (dpid->path) {
                    free(dpid->path);
                }
                free(dpid);
            }
            rz_list_free(list);
        }
        return NULL;
    }
    return list;
}

References test_evm::end, free(), g, gdbr_exec_file_read(), gdbr_is_thread_dead(), gdbr_lock_enter(), gdbr_lock_leave(), rz_debug_pid_t::gid, list(), NULL, rz_debug_pid_t::path, rz_debug_pid_t::pid, pid, read_packet(), read_thread_id(), rz_debug_pid_t::runnable, RZ_DBG_PROC_DEAD, RZ_DBG_PROC_STOP, rz_list_append(), rz_list_free(), rz_list_new(), RZ_NEW0, send_ack(), send_msg(), rz_debug_pid_t::status, strdup(), and rz_debug_pid_t::uid.

Referenced by rz_debug_gdb_threads().

gdbr_write_bin_registers()

int gdbr_write_bin_registers	(	libgdbr_t *	g,
		const char *	regs,
		int	len
	)

Function writes general purpose registers.

Parameters

gdbr	instance that contains the current context
reg	contains the registers that should be written reg contains a comma separated string that uses <regname>=value,<regname>=value i.e. eax=0x123,ebx=0x234

Returns

a failurre code (currently -1) or 0 if call successfully

Definition at line 975 of file core.c.

                                                                      {
    int ret = -1;
    uint64_t buffer_size = 0;
    char *command = NULL;
 
    if (!g) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    buffer_size = len * 2 + 8;
    reg_cache.valid = false;
 
    command = calloc(buffer_size, sizeof(char));
    if (!command) {
        ret = -1;
        goto end;
    }
    snprintf(command, buffer_size, "%s", CMD_WRITEREGS);
    pack_hex(regs, len, command + 1);
    if (send_msg(g, command) < 0) {
        ret = -1;
        goto end;
    }
    if (read_packet(g, false) >= 0) {
        handle_G(g);
    } else {
        ret = -1;
        goto end;
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    if (command) {
        free(command);
    }
    return ret;
}

References buffer_size, calloc(), CMD_WRITEREGS, command, test_evm::end, free(), g, gdbr_lock_enter(), gdbr_lock_leave(), handle_G(), len, NULL, pack_hex(), read_packet(), reg_cache, regs, send_msg(), and snprintf.

Referenced by gdbr_write_reg().

gdbr_write_memory()

int gdbr_write_memory	(	libgdbr_t *	g,
		ut64	address,
		const uint8_t *	data,
		ut64	len
	)

Definition at line 860 of file core.c.

                                                                                 {
    int ret = -1;
    int command_len, pkt, max_cmd_len = 64;
    ut64 num_pkts, last, data_sz;
    char *tmp;
    if (!g || !data) {
        return -1;
    }
    g->stub_features.pkt_sz = RZ_MAX(g->stub_features.pkt_sz, GDB_MAX_PKTSZ);
    data_sz = g->stub_features.pkt_sz / 2;
    if (data_sz < 1) {
        return -1;
    }
    num_pkts = len / data_sz;
    last = len % data_sz;
    if (!(tmp = calloc(max_cmd_len + g->stub_features.pkt_sz, sizeof(char)))) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    for (pkt = num_pkts - 1; pkt >= 0; pkt--) {
        if ((command_len = snprintf(tmp, max_cmd_len,
                 "%s%016" PFMT64x ",%" PFMT64x ":", CMD_WRITEMEM,
                 address + (pkt * data_sz), data_sz)) < 0) {
            ret = -1;
            goto end;
        }
        pack_hex((char *)data + (pkt * data_sz), data_sz, (tmp + command_len));
        if ((ret = send_msg(g, tmp)) < 0) {
            goto end;
        }
        if ((ret = read_packet(g, false)) < 0) {
            goto end;
        }
        if ((ret = handle_M(g)) < 0) {
            goto end;
        }
    }
    if (last) {
        if ((command_len = snprintf(tmp, max_cmd_len,
                 "%s%016" PFMT64x ",%" PFMT64x ":", CMD_WRITEMEM,
                 address + (num_pkts * data_sz), last)) < 0) {
            ret = -1;
            goto end;
        }
        pack_hex((char *)data + (num_pkts * data_sz), last, (tmp + command_len));
        if ((ret = send_msg(g, tmp)) < 0) {
            goto end;
        }
        if ((ret = read_packet(g, false)) < 0) {
            goto end;
        }
        if ((ret = handle_M(g)) < 0) {
            goto end;
        }
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    if (tmp) {
        free(tmp);
    }
    return ret;
}

References calloc(), CMD_WRITEMEM, test_evm::end, free(), g, GDB_MAX_PKTSZ, gdbr_lock_enter(), gdbr_lock_leave(), handle_M(), len, pack_hex(), PFMT64x, read_packet(), RZ_MAX, send_msg(), snprintf, autogen_x86imm::tmp, and ut64().

Referenced by debug_gdb_write_at().

gdbr_write_reg()

int gdbr_write_reg	(	libgdbr_t *	g,
		const char *	name,
		char *	value,
		int	len
	)

Definition at line 1058 of file core.c.

                                                                         {
    int i = 0;
    int ret = -1;
    if (!g) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    reg_cache.valid = false;
    while (g->registers[i].size > 0) {
        if (!strcmp(g->registers[i].name, name)) {
            break;
        }
        i++;
    }
    if (g->registers[i].size == 0) {
        eprintf("Error registername <%s> not found in profile\n", name);
        ret = -1;
        goto end;
    }
    if (g->stub_features.P && (ret = gdbr_write_register(g, i, value, len)) == 0) {
        goto end;
    }
 
    // Use 'G' if write_register failed/isn't supported
    gdbr_read_registers(g);
    memcpy(g->data + (g->registers[i].offset / 8), value, len);
    gdbr_write_bin_registers(g, g->data, g->data_len);
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    return ret;
}

References test_evm::end, eprintf, g, gdbr_lock_enter(), gdbr_lock_leave(), gdbr_read_registers(), gdbr_write_bin_registers(), gdbr_write_register(), i, len, memcpy(), reg_cache, and value.

Referenced by rz_debug_gdb_reg_write().

gdbr_write_register()

int gdbr_write_register	(	libgdbr_t *	g,
		int	index,
		char *	value,
		int	len
	)

Definition at line 1018 of file core.c.

                                                                       {
    int ret = -1;
    char command[255] = { 0 };
    if (!g || !g->stub_features.P) {
        return -1;
    }
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    reg_cache.valid = false;
    ret = snprintf(command, sizeof(command) - 1, "%s%x=", CMD_WRITEREG, index);
    if (len + ret >= sizeof(command)) {
        eprintf("command is too small\n");
        ret = -1;
        goto end;
    }
    // Pad with zeroes
    memset(command + ret, atoi("0"), len);
    pack_hex(value, len, (command + ret));
    if (send_msg(g, command) < 0) {
        ret = -1;
        goto end;
    }
    if (read_packet(g, false) < 0 || handle_P(g) < 0) {
        ret = -1;
        goto end;
    }
    if (g->last_code == MSG_NOT_SUPPORTED) {
        g->stub_features.P = false;
        ret = -1;
        goto end;
    }
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    return ret;
}

References CMD_WRITEREG, command, test_evm::end, eprintf, g, gdbr_lock_enter(), gdbr_lock_leave(), handle_P(), len, memset(), MSG_NOT_SUPPORTED, pack_hex(), read_packet(), reg_cache, send_msg(), snprintf, and value.

Referenced by gdbr_write_reg().

gdbr_write_registers()

int gdbr_write_registers	(	libgdbr_t *	g,
		char *	registers
	)

Definition at line 1096 of file core.c.

                                                        {
    uint64_t buffer_size;
    int i = 0;
    int ret = -1;
    unsigned int x, len;
    char *command, *reg, *buff, *value;
    // read current register set
 
    command = buff = value = NULL;
 
    if (!g) {
        return -1;
    }
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    gdbr_read_registers(g);
    reg_cache.valid = false;
    len = strlen(registers);
    buff = calloc(len, sizeof(char));
    if (!buff) {
        ret = -1;
        goto end;
    }
    memcpy(buff, registers, len);
    reg = strtok(buff, ",");
    while (reg) {
        char *name_end = strchr(reg, '=');
        if (name_end == NULL) {
            eprintf("Malformed argument: %s\n", reg);
            ret = -1;
            goto end;
        }
        *name_end = '\0'; // change '=' to '\0'
 
        // time to find the current register
        while (g->registers[i].size > 0) {
            if (strcmp(g->registers[i].name, reg) == 0) {
                const ut64 register_size = g->registers[i].size;
                const ut64 offset = g->registers[i].offset;
                value = calloc(register_size + 1, 2);
                if (!value) {
                    ret = -1;
                    goto end;
                }
 
                memset(value, '0', register_size * 2);
                name_end++;
                // be able to take hex with and without 0x
                if (name_end[1] == 'x' || name_end[1] == 'X') {
                    name_end += 2;
                }
                const int val_len = strlen(name_end); // size of the rest
                strcpy(value + (register_size * 2 - val_len), name_end);
 
                for (x = 0; x < register_size; x++) {
                    g->data[offset + register_size - x - 1] = hex2char(&value[x * 2]);
                }
                RZ_FREE(value);
            }
            i++;
        }
        reg = strtok(NULL, " ,");
    }
 
    buffer_size = g->data_len * 2 + 8;
    command = calloc(buffer_size, sizeof(char));
    if (!command) {
        ret = -1;
        goto end;
    }
    snprintf(command, buffer_size, "%s", CMD_WRITEREGS);
    pack_hex(g->data, g->data_len, command + 1);
    ret = send_msg(g, command);
    if (ret < 0) {
        goto end;
    }
    read_packet(g, false);
    handle_G(g);
 
    ret = 0;
end:
    if (command) {
        free(command);
    }
    if (buff) {
        free(buff);
    }
    if (value) {
        free(value);
    }
    gdbr_lock_leave(g);
    return ret;
}

References buffer_size, calloc(), CMD_WRITEREGS, command, test_evm::end, eprintf, free(), g, gdbr_lock_enter(), gdbr_lock_leave(), gdbr_read_registers(), handle_G(), hex2char(), i, len, memcpy(), memset(), NULL, pack_hex(), read_packet(), reg, reg_cache, RZ_FREE, send_msg(), snprintf, ut64(), value, and x.

test_command()

int test_command	(	libgdbr_t *	g,
		const char *	command
	)

Definition at line 1193 of file core.c.

                                                    {
    int ret = -1;
 
    if (!gdbr_lock_enter(g)) {
        goto end;
    }
 
    if ((ret = send_msg(g, command)) < 0) {
        goto end;
    }
    read_packet(g, false);
    hexdump(g->read_buff, g->data_len, 0);
 
    ret = 0;
end:
    gdbr_lock_leave(g);
    return ret;
}

References command, test_evm::end, g, gdbr_lock_enter(), gdbr_lock_leave(), hexdump(), read_packet(), and send_msg().