debug_qnx.c File Reference

#include <rz_debug.h>
#include <libqnxr.h>

Go to the source code of this file.

Classes
struct	RzIOQnx

Functions
RZ_API RzDebugPid *	__r_debug_pid_new (const char *path, int pid, char status, ut64 pc)
RZ_API void *	__r_debug_pid_free (RzDebugPid *pid)
static void	pidlist_cb (void *ctx, pid_t pid, char *name)
static int	rz_debug_qnx_select (RzDebug *dbg, int pid, int tid)
static RzList *	rz_debug_qnx_tids (RzDebug *dbg, int pid)
static RzList *	rz_debug_qnx_pids (RzDebug *dbg, int pid)
static int	rz_debug_qnx_reg_read (RzDebug *dbg, int type, ut8 *buf, int size)
static RzList *	rz_debug_qnx_map_get (RzDebug *dbg)
static int	rz_debug_qnx_reg_write (RzDebug *dbg, int type, const ut8 *buf, int size)
static int	rz_debug_qnx_continue (RzDebug *dbg, int pid, int tid, int sig)
static int	rz_debug_qnx_step (RzDebug *dbg)
static RzDebugReasonType	rz_debug_qnx_wait (RzDebug *dbg, int pid)
static int	rz_debug_qnx_stop (RzDebug *dbg)
static int	rz_debug_qnx_attach (RzDebug *dbg, int pid)
static int	rz_debug_qnx_detach (RzDebug *dbg, int pid)
static const char *	rz_debug_qnx_reg_profile (RzDebug *dbg)
static int	rz_debug_qnx_breakpoint (RzBreakpoint *bp, RzBreakpointItem *b, bool set)

Variables
static libqnxr_t *	desc = NULL
static ut8 *	reg_buf = NULL
static int	buf_size = 0
RzDebugPlugin	rz_debug_plugin_qnx
RZ_API RzLibStruct	rizin_plugin

Function Documentation

__r_debug_pid_free()

RZ_API void* __r_debug_pid_free

(

RzDebugPid *

pid

)

Definition at line 22 of file debug_qnx.c.

                                                 {
    free(pid->path);
    free(pid);
    return NULL;
}

References free(), NULL, and pid.

Referenced by rz_debug_qnx_pids().

__r_debug_pid_new()

RZ_API RzDebugPid* __r_debug_pid_new	(	const char *	path,
		int	pid,
		char	status,
		ut64	pc
	)

Definition at line 10 of file debug_qnx.c.

                                                                                      {
    RzDebugPid *p = RZ_NEW0(RzDebugPid);
    if (!p) {
        return NULL;
    }
    p->path = strdup(path);
    p->pid = pid;
    p->status = status;
    p->runnable = true;
    p->pc = pc;
    return p;
}

References NULL, p, path, pc, pid, RZ_NEW0, status, and strdup().

Referenced by pidlist_cb(), and rz_debug_qnx_pids().

pidlist_cb()

static void pidlist_cb ( void *  ctx, pid_t  pid, char *  name  )

static

Definition at line 37 of file debug_qnx.c.

                                                         {
    RzList *list = ctx;
    rz_list_append(list, __r_debug_pid_new(name, pid, 's', 0));
}

References __r_debug_pid_new(), list(), pid, and rz_list_append().

Referenced by rz_debug_qnx_pids().

rz_debug_qnx_attach()

static int rz_debug_qnx_attach ( RzDebug *  dbg, int  pid  )

static

Definition at line 182 of file debug_qnx.c.

                                                      {
    RzIODesc *d = dbg->iob.io->desc;
    dbg->swstep = false;
 
    if (d && d->plugin && d->plugin->name && d->data) {
        if (!strcmp("qnx", d->plugin->name)) {
            RzIOQnx *g = d->data;
            int arch = rz_sys_arch_id(dbg->arch);
            int bits = dbg->analysis->bits;
            if ((desc = &g->desc)) {
                switch (arch) {
                case RZ_SYS_ARCH_X86:
                    if (bits == 16 || bits == 32) {
                        qnxr_set_architecture(&g->desc, X86_32);
                    } else {
                        eprintf("Not supported register %s %d profile\n", dbg->arch, bits);
                        return false;
                    }
                    break;
                case RZ_SYS_ARCH_ARM:
                    if (bits == 16 || bits == 32) {
                        qnxr_set_architecture(&g->desc, ARM_32);
                    } else {
                        eprintf("Not supported register %s %d profile\n", dbg->arch, bits);
                        return false;
                    }
                    break;
                }
            }
            if (pid) {
                qnxr_attach(desc, pid);
            }
        } else {
            eprintf("%s: error: underlying IO descriptor isn't a QNX one\n", __func__);
            return false;
        }
    }
 
    dbg->pid = 0;
    return true;
}

References rz_debug_t::analysis, rz_debug_t::arch, arch, ARM_32, rz_analysis_t::bits, bits(), d, dbg, desc, rz_io_t::desc, eprintf, g, rz_io_bind_t::io, rz_debug_t::iob, rz_debug_t::pid, pid, qnxr_attach(), qnxr_set_architecture(), RZ_SYS_ARCH_ARM, rz_sys_arch_id(), RZ_SYS_ARCH_X86, rz_debug_t::swstep, and X86_32.

rz_debug_qnx_breakpoint()

static int rz_debug_qnx_breakpoint ( RzBreakpoint *  bp, RzBreakpointItem *  b, bool  set  )

static

Definition at line 330 of file debug_qnx.c.

                                                                                    {
    if (!b) {
        return false;
    }
    int ret = set
        ? b->hw
            ? qnxr_set_hwbp(desc, b->addr, "")
            : qnxr_set_bp(desc, b->addr, "")
        : b->hw
        ? qnxr_remove_hwbp(desc, b->addr)
        : qnxr_remove_bp(desc, b->addr);
    return !ret;
}

References b, desc, qnxr_remove_bp(), qnxr_remove_hwbp(), qnxr_set_bp(), and qnxr_set_hwbp().

rz_debug_qnx_continue()

static int rz_debug_qnx_continue ( RzDebug *  dbg, int  pid, int  tid, int  sig  )

static

Definition at line 158 of file debug_qnx.c.

                                                                          {
    qnxr_continue(desc, -1);
    return true;
}

References desc, and qnxr_continue().

rz_debug_qnx_detach()

static int rz_debug_qnx_detach ( RzDebug *  dbg, int  pid  )

static

Definition at line 224 of file debug_qnx.c.

                                                      {
    qnxr_disconnect(desc);
    free(reg_buf);
    return true;
}

References desc, free(), qnxr_disconnect(), and reg_buf.

rz_debug_qnx_map_get()

static RzList* rz_debug_qnx_map_get ( RzDebug *  dbg )

static

Definition at line 111 of file debug_qnx.c.

                                                  {
    return NULL;
}

References NULL.

rz_debug_qnx_pids()

static RzList* rz_debug_qnx_pids ( RzDebug *  dbg, int  pid  )

static

Definition at line 51 of file debug_qnx.c.

                                                        {
    RzList *list = rz_list_new();
    if (!list) {
        return NULL;
    }
    list->free = (RzListFree)&__r_debug_pid_free;
 
    /* TODO */
    if (pid) {
        rz_list_append(list, __r_debug_pid_new("(current)", pid, 's', 0));
    } else {
        qnxr_pidlist(desc, list, &pidlist_cb);
    }
 
    return list;
}

References __r_debug_pid_free(), __r_debug_pid_new(), desc, list(), NULL, pid, pidlist_cb(), qnxr_pidlist(), rz_list_append(), and rz_list_new().

rz_debug_qnx_reg_profile()

static const char* rz_debug_qnx_reg_profile ( RzDebug *  dbg )

static

Definition at line 230 of file debug_qnx.c.

                                                          {
    int arch = rz_sys_arch_id(dbg->arch);
    int bits = dbg->analysis->bits;
    switch (arch) {
    case RZ_SYS_ARCH_X86:
        return strdup(
            "=PC    eip\n"
            "=SP    esp\n"
            "=BP    ebp\n"
            "=A0    eax\n"
            "=A1    ebx\n"
            "=A2    ecx\n"
            "=A3    edi\n"
            "gpr    eax .32 0   0\n"
            "gpr    ecx .32 4   0\n"
            "gpr    edx .32 8   0\n"
            "gpr    ebx .32 12  0\n"
            "gpr    esp .32 16  0\n"
            "gpr    ebp .32 20  0\n"
            "gpr    esi .32 24  0\n"
            "gpr    edi .32 28  0\n"
            "gpr    eip .32 32  0\n"
            "gpr    eflags  .32 36  0\n"
            "seg    cs  .32 40  0\n"
            "seg    ss  .32 44  0\n"
#if 0
            "seg    ds  .32 48  0\n"
            "seg    es  .32 52  0\n"
            "seg    fs  .32 56  0\n"
            "seg    gs  .32 60  0\n"
#endif
        );
    case RZ_SYS_ARCH_ARM:
        if (bits == 32) {
            return strdup(
                "=PC    r15\n"
                "=SP    r14\n" // XXX
                "=A0    r0\n"
                "=A1    r1\n"
                "=A2    r2\n"
                "=A3    r3\n"
                "gpr    r0  .32 0   0\n"
                "gpr    r1  .32 4   0\n"
                "gpr    r2  .32 8   0\n"
                "gpr    r3  .32 12  0\n"
                "gpr    r4  .32 16  0\n"
                "gpr    r5  .32 20  0\n"
                "gpr    r6  .32 24  0\n"
                "gpr    r7  .32 28  0\n"
                "gpr    r8  .32 32  0\n"
                "gpr    r9  .32 36  0\n"
                "gpr    r10 .32 40  0\n"
                "gpr    r11 .32 44  0\n"
                "gpr    r12 .32 48  0\n"
                "gpr    sp  .32 52  0\n" // r13
                "gpr    lr  .32 56  0\n" // r14
                "gpr    pc  .32 60  0\n" // r15
                "gpr    r13 .32 52  0\n"
                "gpr    r14 .32 56  0\n"
                "gpr    r15 .32 60  0\n"
                "gpr    cpsr    .96 64  0\n"
                "mmx    d0  .64 68  0\n" // neon
                "mmx    d1  .64 76  0\n" // neon
                "mmx    d2  .64 84  0\n" // neon
                "mmx    d3  .64 92  0\n" // neon
                "mmx    d4  .64 100 0\n" // neon
                "mmx    d5  .64 108 0\n" // neon
                "mmx    d6  .64 116 0\n" // neon
                "mmx    d7  .64 124 0\n" // neon
                "mmx    d8  .64 132 0\n" // neon
                "mmx    d9  .64 140 0\n" // neon
                "mmx    d10 .64 148 0\n" // neon
                "mmx    d11 .64 156 0\n" // neon
                "mmx    d12 .64 164 0\n" // neon
                "mmx    d13 .64 172 0\n" // neon
                "mmx    d14 .64 180 0\n" // neon
                "mmx    d15 .64 188 0\n" // neon
                "mmx    d16 .64 196 0\n" // neon
                "mmx    d17 .64 204 0\n" // neon
                "mmx    d18 .64 212 0\n" // neon
                "mmx    d19 .64 220 0\n" // neon
                "mmx    d20 .64 228 0\n" // neon
                "mmx    d21 .64 236 0\n" // neon
                "mmx    d22 .64 244 0\n" // neon
                "mmx    d23 .64 252 0\n" // neon
                "mmx    d24 .64 260 0\n" // neon
                "mmx    d25 .64 268 0\n" // neon
                "mmx    d26 .64 276 0\n" // neon
                "mmx    d27 .64 284 0\n" // neon
                "mmx    d28 .64 292 0\n" // neon
                "mmx    d29 .64 300 0\n" // neon
                "mmx    d30 .64 308 0\n" // neon
                "mmx    d31 .64 316 0\n" // neon
                "mmx    fpscr   .32 324 0\n" // neon
            );
        }
    }
    return NULL;
}

References rz_debug_t::analysis, rz_debug_t::arch, arch, rz_analysis_t::bits, bits(), dbg, NULL, RZ_SYS_ARCH_ARM, rz_sys_arch_id(), RZ_SYS_ARCH_X86, and strdup().

rz_debug_qnx_reg_read()

static int rz_debug_qnx_reg_read ( RzDebug *  dbg, int  type, ut8 *  buf, int  size  )

static

Definition at line 68 of file debug_qnx.c.

                                                                             {
    int copy_size;
    int buflen = 0;
    if (!desc) {
        return -1;
    }
    int len = qnxr_read_registers(desc);
    if (len <= 0) {
        return -1;
    }
    // read the len of the current area
    free(rz_reg_get_bytes(dbg->reg, type, &buflen));
    if (size < len) {
        eprintf("rz_debug_qnx_reg_read: small buffer %d vs %d\n",
            (int)size, (int)len);
    }
    copy_size = RZ_MIN(len, size);
    buflen = RZ_MAX(len, buflen);
    if (reg_buf) {
        if (buf_size < copy_size) {
            ut8 *new_buf = realloc(reg_buf, copy_size);
            if (!new_buf) {
                return -1;
            }
            reg_buf = new_buf;
            buflen = copy_size;
            buf_size = len;
        }
    } else {
        reg_buf = calloc(buflen, 1);
        if (!reg_buf) {
            return -1;
        }
        buf_size = buflen;
    }
    memset((void *)(volatile void *)buf, 0, size);
    memcpy((void *)(volatile void *)buf, desc->recv.data, copy_size);
    memset((void *)(volatile void *)reg_buf, 0, buflen);
    memcpy((void *)(volatile void *)reg_buf, desc->recv.data, copy_size);
 
    return len;
}

References buf_size, buflen, calloc(), libqnxr_t::data, dbg, desc, eprintf, free(), len, memcpy(), memset(), qnxr_read_registers(), realloc(), libqnxr_t::recv, rz_debug_t::reg, reg_buf, RZ_MAX, RZ_MIN, rz_reg_get_bytes(), and type.

rz_debug_qnx_reg_write()

static int rz_debug_qnx_reg_write ( RzDebug *  dbg, int  type, const ut8 *  buf, int  size  )

static

Definition at line 115 of file debug_qnx.c.

                                                                                    {
    int buflen = 0;
    int bits = dbg->analysis->bits;
    const char *pcname = rz_reg_get_name(dbg->analysis->reg, RZ_REG_NAME_PC);
    RzRegItem *reg = rz_reg_get(dbg->analysis->reg, pcname, 0);
    if (!reg_buf) {
        // we cannot write registers before we once read them
        return -1;
    }
    if (reg) {
        if (dbg->analysis->bits != reg->size) {
            bits = reg->size;
        }
    }
    free(rz_reg_get_bytes(dbg->reg, type, &buflen));
    // some implementations of the gdb protocol are acting weird.
    // so winedbg is not able to write registers through the <G> packet
    // and also it does not return the whole gdb register profile after
    // calling <g>
    // so this workaround resizes the small register profile buffer
    // to the whole set and fills the rest with 0
    if (buf_size < buflen) {
        ut8 *new_buf = realloc(reg_buf, buflen * sizeof(ut8));
        if (!new_buf) {
            return -1;
        }
        reg_buf = new_buf;
        memset(new_buf + buf_size, 0, buflen - buf_size);
    }
 
    RzRegItem *current = NULL;
    for (;;) {
        current = rz_reg_next_diff(dbg->reg, type, reg_buf, buflen, current, bits);
        if (!current) {
            break;
        }
        ut64 val = rz_reg_get_value(dbg->reg, current);
        int bytes = bits / 8;
        qnxr_write_reg(desc, current->name, (char *)&val, bytes);
    }
    return true;
}

References rz_debug_t::analysis, rz_analysis_t::bits, bits(), buf_size, buflen, bytes, dbg, desc, free(), memset(), rz_reg_item_t::name, NULL, qnxr_write_reg(), realloc(), reg, rz_analysis_t::reg, rz_debug_t::reg, reg_buf, rz_reg_get(), rz_reg_get_bytes(), rz_reg_get_name(), rz_reg_get_value(), RZ_REG_NAME_PC, rz_reg_next_diff(), type, ut64(), and val.

rz_debug_qnx_select()

static int rz_debug_qnx_select ( RzDebug *  dbg, int  pid, int  tid  )

static

Definition at line 42 of file debug_qnx.c.

                                                               {
    return qnxr_select(desc, pid, tid);
}

References desc, pid, and qnxr_select().

rz_debug_qnx_step()

static int rz_debug_qnx_step ( RzDebug *  dbg )

static

Definition at line 163 of file debug_qnx.c.

                                           {
    qnxr_step(desc, -1);
    return true;
}

References desc, and qnxr_step().

rz_debug_qnx_stop()

static int rz_debug_qnx_stop ( RzDebug *  dbg )

static

Definition at line 177 of file debug_qnx.c.

                                           {
    qnxr_stop(desc);
    return true;
}

References desc, and qnxr_stop().

rz_debug_qnx_tids()

static RzList* rz_debug_qnx_tids ( RzDebug *  dbg, int  pid  )

static

Definition at line 46 of file debug_qnx.c.

                                                        {
    eprintf("%s: TODO: Threads\n", __func__);
    return NULL;
}

References eprintf, and NULL.

rz_debug_qnx_wait()

static RzDebugReasonType rz_debug_qnx_wait ( RzDebug *  dbg, int  pid  )

static

Definition at line 168 of file debug_qnx.c.

                                                                  {
    ptid_t ptid = qnxr_wait(desc, pid);
    if (!ptid_equal(ptid, null_ptid)) {
        dbg->reason.signum = desc->signal;
        return desc->notify_type;
    }
    return RZ_DEBUG_REASON_NONE;
}

References dbg, desc, libqnxr_t::notify_type, null_ptid, pid, ptid_equal(), qnxr_wait(), rz_debug_t::reason, RZ_DEBUG_REASON_NONE, libqnxr_t::signal, and rz_debug_reason_t::signum.

Variable Documentation

buf_size

int buf_size = 0

static

Definition at line 35 of file debug_qnx.c.

Referenced by copy_fh(), do_section_search(), entries(), escape_utf8_for_json(), fs__sendfile(), get_whole_buf(), load_omf_content(), load_omf_data(), load_omf_lnames(), load_omf_pubdef(), load_omf_segdef(), load_omf_symb(), load_record_omf(), LoadCentralDirectoryRecord(), module_match_buffer(), node_match_buffer(), omf_get_idx(), parse_line_raw(), rz_bin_checksum_omf_ok(), rz_bin_file_compute_hashes(), rz_buf_fwd_scan(), rz_config_node_value_format_i(), rz_debug_qnx_reg_read(), rz_debug_qnx_reg_write(), rz_str_escape_mutf8_for_json(), rz_str_escape_utf(), rz_str_escape_utf16be(), rz_str_escape_utf16le(), rz_str_escape_utf32be(), rz_str_escape_utf32le(), rz_str_escape_utf8_for_json(), rz_subprocess_stdin_write(), sections(), and slurp().

desc

libqnxr_t* desc = NULL

static

Definition at line 33 of file debug_qnx.c.

Referenced by rz_debug_qnx_attach(), rz_debug_qnx_breakpoint(), rz_debug_qnx_continue(), rz_debug_qnx_detach(), rz_debug_qnx_pids(), rz_debug_qnx_reg_read(), rz_debug_qnx_reg_write(), rz_debug_qnx_select(), rz_debug_qnx_step(), rz_debug_qnx_stop(), and rz_debug_qnx_wait().

reg_buf

ut8* reg_buf = NULL

static

Definition at line 34 of file debug_qnx.c.

Referenced by rz_debug_qnx_detach(), rz_debug_qnx_reg_read(), and rz_debug_qnx_reg_write().

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_DBG,
    .data = &rz_debug_plugin_qnx,
    .version = RZ_VERSION
}

Definition at line 367 of file debug_qnx.c.

rz_debug_plugin_qnx

RzDebugPlugin rz_debug_plugin_qnx

Initial value:

= {
    .name = "qnx",
    .license = "LGPL3",
    .arch = "x86,arm",
    .bits = RZ_SYS_BITS_32,
    .step = rz_debug_qnx_step,
    .cont = rz_debug_qnx_continue,
    .attach = &rz_debug_qnx_attach,
    .detach = &rz_debug_qnx_detach,
    .pids = &rz_debug_qnx_pids,
    .tids = &rz_debug_qnx_tids,
    .select = &rz_debug_qnx_select,
    .stop = &rz_debug_qnx_stop,
    .canstep = 1,
    .wait = &rz_debug_qnx_wait,
    .map_get = rz_debug_qnx_map_get,
    .breakpoint = rz_debug_qnx_breakpoint,
    .reg_read = &rz_debug_qnx_reg_read,
    .reg_write = &rz_debug_qnx_reg_write,
    .reg_profile = (void *)rz_debug_qnx_reg_profile,
}

Definition at line 344 of file debug_qnx.c.