dsession.c File Reference

#include <rz_debug.h>
#include <rz_util/rz_json.h>

Go to the source code of this file.

Macros
#define	CMP_CNUM_REG(x, y)   ((x) >= ((RzDebugChangeReg *)y)->cnum ? 1 : -1)
#define	CMP_CNUM_MEM(x, y)   ((x) >= ((RzDebugChangeMem *)y)->cnum ? 1 : -1)
#define	CMP_CNUM_CHKPT(x, y)   ((x) >= ((RzDebugCheckpoint *)y)->cnum ? 1 : -1)
#define	CHECK_TYPE(v, t)
#define	SNAPATTR(ATTR)   sdb_fmt("snaps.a[%u]." ATTR, i)
#define	REGATTR(ATTR)   sdb_fmt("registers.%d." ATTR, i)
#define	SDB_LOAD(fn, ns)
#define	DESERIALIZE(ns, func)

Functions
RZ_API void	rz_debug_session_free (RzDebugSession *session)
static void	rz_debug_checkpoint_fini (void *element, void *user)
static void	htup_vector_free (HtUPKv *kv)
RZ_API RzDebugSession *	rz_debug_session_new (void)
RZ_API bool	rz_debug_add_checkpoint (RzDebug *dbg)
static void	_set_initial_registers (RzDebug *dbg)
static void	_set_register (RzDebug *dbg, RzRegItem *ri, ut32 cnum)
RZ_API void	_restore_registers (RzDebug *dbg, ut32 cnum)
static void	_set_initial_memory (RzDebug *dbg)
static bool	_restore_memory_cb (void *user, const ut64 key, const void *value)
static void	_restore_memory (RzDebug *dbg, ut32 cnum)
static RzDebugCheckpoint *	_get_checkpoint_before (RzDebugSession *session, ut32 cnum)
RZ_API void	rz_debug_session_restore_reg_mem (RzDebug *dbg, ut32 cnum)
RZ_API void	rz_debug_session_list_memory (RzDebug *dbg)
RZ_API bool	rz_debug_session_add_reg_change (RzDebugSession *session, int arena, ut64 offset, ut64 data)
RZ_API bool	rz_debug_session_add_mem_change (RzDebugSession *session, ut64 addr, ut8 data)
static bool	serialize_register_cb (void *db, const ut64 k, const void *v)
static void	serialize_registers (Sdb *db, HtUP *registers)
static bool	serialize_memory_cb (void *db, const ut64 k, const void *v)
static void	serialize_memory (Sdb *db, HtUP *memory)
static void	serialize_checkpoints (Sdb *db, RzVector *checkpoints)
RZ_API void	rz_debug_session_serialize (RzDebugSession *session, Sdb *db)
static bool	session_sdb_save (Sdb *db, const char *path)
RZ_API bool	rz_debug_session_save (RzDebugSession *session, const char *path)
static bool	deserialize_memory_cb (void *user, const char *addr, const char *v)
static void	deserialize_memory (Sdb *db, HtUP *memory)
static bool	deserialize_registers_cb (void *user, const char *addr, const char *v)
static void	deserialize_registers (Sdb *db, HtUP *registers)
static bool	deserialize_checkpoints_cb (void *user, const char *cnum, const char *v)
static void	deserialize_checkpoints (Sdb *db, RzVector *checkpoints)
static bool	session_sdb_load_ns (Sdb *db, const char *nspath, const char *filename)
static Sdb *	session_sdb_load (const char *path)
RZ_API void	rz_debug_session_deserialize (RzDebugSession *session, Sdb *db)
RZ_API bool	rz_debug_session_load (RzDebug *dbg, const char *path)

Macro Definition Documentation

CHECK_TYPE

#define CHECK_TYPE	(		v,
			t
	)

Value:

    if (!v || v->type != t) \
    continue

Definition at line 460 of file dsession.c.

CMP_CNUM_CHKPT

#define CMP_CNUM_CHKPT	(		x,
			y
	)		((x) >= ((RzDebugCheckpoint *)y)->cnum ? 1 : -1)

Definition at line 9 of file dsession.c.

CMP_CNUM_MEM

#define CMP_CNUM_MEM	(		x,
			y
	)		((x) >= ((RzDebugChangeMem *)y)->cnum ? 1 : -1)

Definition at line 8 of file dsession.c.

CMP_CNUM_REG

#define CMP_CNUM_REG	(		x,
			y
	)		((x) >= ((RzDebugChangeReg *)y)->cnum ? 1 : -1)

Definition at line 7 of file dsession.c.

DESERIALIZE

#define DESERIALIZE	(		ns,
			func
	)

Value:

    do { \
        subdb = sdb_ns(db, ns, false); \
        if (!subdb) { \
            eprintf("Error: missing " ns " namespace\n"); \
            return; \
        } \
        func; \
    } while (0)

REGATTR

#define REGATTR

(

ATTR

)

sdb_fmt("registers.%d." ATTR, i)

Definition at line 563 of file dsession.c.

SDB_LOAD

#define SDB_LOAD	(		fn,
			ns
	)

Value:

    do { \
        filename = rz_str_newf("%s%s" fn ".sdb", path, RZ_SYS_DIR); \
        if (!session_sdb_load_ns(db, ns, filename)) { \
            free(filename); \
            goto error; \
        } \
        free(filename); \
    } while (0)

SNAPATTR

#define SNAPATTR

(

ATTR

)

sdb_fmt("snaps.a[%u]." ATTR, i)

Definition at line 562 of file dsession.c.

Function Documentation

_get_checkpoint_before()

static RzDebugCheckpoint* _get_checkpoint_before ( RzDebugSession *  session, ut32  cnum  )

static

Definition at line 163 of file dsession.c.

                                                                                     {
    RzDebugCheckpoint *checkpoint = NULL;
    size_t index;
    rz_vector_upper_bound(session->checkpoints, cnum, index, CMP_CNUM_CHKPT);
    if (index > 0 && index <= session->checkpoints->len) {
        checkpoint = rz_vector_index_ptr(session->checkpoints, index - 1);
    }
    return checkpoint;
}

References rz_debug_session_t::checkpoints, CMP_CNUM_CHKPT, NULL, rz_vector_index_ptr(), and rz_vector_upper_bound.

Referenced by rz_debug_session_restore_reg_mem().

_restore_memory()

static void _restore_memory ( RzDebug *  dbg, ut32  cnum  )

static

Definition at line 158 of file dsession.c.

                                                     {
    _set_initial_memory(dbg);
    ht_up_foreach(dbg->session->memory, _restore_memory_cb, dbg);
}

References _restore_memory_cb(), _set_initial_memory(), dbg, rz_debug_session_t::memory, and rz_debug_t::session.

Referenced by rz_debug_session_restore_reg_mem().

_restore_memory_cb()

static bool _restore_memory_cb ( void *  user, const ut64  key, const void *  value  )

static

Definition at line 143 of file dsession.c.

                                                                              {
    size_t index;
    RzDebug *dbg = user;
    RzVector *vmem = (RzVector *)value;
 
    rz_vector_upper_bound(vmem, dbg->session->cnum, index, CMP_CNUM_MEM);
    if (index > 0 && index <= vmem->len) {
        RzDebugChangeMem *mem = rz_vector_index_ptr(vmem, index - 1);
        if (mem->cnum > dbg->session->cur_chkpt->cnum) {
            dbg->iob.write_at(dbg->iob.io, key, &mem->data, 1);
        }
    }
    return true;
}

References CMP_CNUM_MEM, rz_debug_checkpoint_t::cnum, rz_debug_session_t::cnum, rz_debug_session_t::cur_chkpt, dbg, rz_io_bind_t::io, rz_debug_t::iob, key, len, mem, rz_vector_index_ptr(), rz_vector_upper_bound, rz_debug_t::session, value, and rz_io_bind_t::write_at.

Referenced by _restore_memory().

_restore_registers()

RZ_API void _restore_registers	(	RzDebug *	dbg,
		ut32	cnum
	)

Definition at line 126 of file dsession.c.

                                                        {
    RzListIter *iter;
    RzRegItem *ri;
    _set_initial_registers(dbg);
    rz_list_foreach (dbg->reg->allregs, iter, ri) {
        _set_register(dbg, ri, cnum);
    }
}

References _set_initial_registers(), _set_register(), rz_reg_t::allregs, dbg, and rz_debug_t::reg.

Referenced by rz_debug_session_restore_reg_mem().

_set_initial_memory()

static void _set_initial_memory ( RzDebug *  dbg )

static

Definition at line 135 of file dsession.c.

                                              {
    RzListIter *iter;
    RzDebugSnap *snap;
    rz_list_foreach (dbg->session->cur_chkpt->snaps, iter, snap) {
        dbg->iob.write_at(dbg->iob.io, snap->addr, snap->data, snap->size);
    }
}

References rz_debug_snap_t::addr, rz_debug_session_t::cur_chkpt, rz_debug_snap_t::data, dbg, rz_io_bind_t::io, rz_debug_t::iob, rz_debug_t::session, rz_debug_snap_t::size, rz_debug_checkpoint_t::snaps, and rz_io_bind_t::write_at.

Referenced by _restore_memory().

_set_initial_registers()

static void _set_initial_registers ( RzDebug *  dbg )

static

Definition at line 100 of file dsession.c.

                                                 {
    size_t i;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        RzRegArena *a = dbg->session->cur_chkpt->arena[i];
        RzRegArena *b = dbg->reg->regset[i].arena;
        if (a && b && a->bytes && b->bytes) {
            memcpy(b->bytes, a->bytes, a->size);
        }
    }
}

References a, rz_debug_checkpoint_t::arena, rz_reg_set_t::arena, b, rz_debug_session_t::cur_chkpt, dbg, i, memcpy(), rz_debug_t::reg, rz_reg_t::regset, RZ_REG_TYPE_LAST, and rz_debug_t::session.

Referenced by _restore_registers().

_set_register()

static void _set_register ( RzDebug *  dbg, RzRegItem *  ri, ut32  cnum  )

static

Definition at line 111 of file dsession.c.

                                                                  {
    RzVector *vreg = ht_up_find(dbg->session->registers, ri->offset | (ri->arena << 16), NULL);
    if (!vreg) {
        return;
    }
    size_t index;
    rz_vector_upper_bound(vreg, cnum, index, CMP_CNUM_REG);
    if (index > 0 && index <= vreg->len) {
        RzDebugChangeReg *reg = rz_vector_index_ptr(vreg, index - 1);
        if (reg->cnum > dbg->session->cur_chkpt->cnum) {
            rz_reg_set_value(dbg->reg, ri, reg->data);
        }
    }
}

References rz_reg_item_t::arena, CMP_CNUM_REG, rz_debug_checkpoint_t::cnum, rz_debug_session_t::cur_chkpt, dbg, len, NULL, rz_reg_item_t::offset, reg, rz_debug_t::reg, rz_debug_session_t::registers, rz_reg_set_value(), rz_vector_index_ptr(), rz_vector_upper_bound, and rz_debug_t::session.

Referenced by _restore_registers().

deserialize_checkpoints()

static void deserialize_checkpoints ( Sdb *  db, RzVector *  checkpoints  )

static

Definition at line 663 of file dsession.c.

                                                                    {
    sdb_foreach(db, deserialize_checkpoints_cb, checkpoints);
}

References deserialize_checkpoints_cb(), and sdb_foreach().

Referenced by rz_debug_session_deserialize().

deserialize_checkpoints_cb()

static bool deserialize_checkpoints_cb ( void *  user, const char *  cnum, const char *  v  )

static

Definition at line 565 of file dsession.c.

                                                                                    {
    const RzJson *child;
    char *json_str = strdup(v);
    if (!json_str) {
        return true;
    }
    RzJson *chkpt_json = rz_json_parse(json_str);
    if (!chkpt_json || chkpt_json->type != RZ_JSON_OBJECT) {
        free(json_str);
        return true;
    }
 
    RzVector *checkpoints = user;
    RzDebugCheckpoint checkpoint = { 0 };
    checkpoint.cnum = (int)sdb_atoi(cnum);
 
    // Extract RzRegArena's from "registers"
    const RzJson *regs_json = rz_json_get(chkpt_json, "registers");
    if (!regs_json || regs_json->type != RZ_JSON_ARRAY) {
        free(json_str);
        rz_json_free(chkpt_json);
        return true;
    }
    for (child = regs_json->children.first; child; child = child->next) {
        const RzJson *baby;
        baby = rz_json_get(child, "arena");
        CHECK_TYPE(baby, RZ_JSON_INTEGER);
        int arena = baby->num.s_value;
        if (arena < RZ_REG_TYPE_GPR || arena >= RZ_REG_TYPE_LAST) {
            continue;
        }
        baby = rz_json_get(child, "size");
        CHECK_TYPE(baby, RZ_JSON_INTEGER);
        int size = baby->num.s_value;
        if (size < 0) {
            continue;
        }
        baby = rz_json_get(child, "bytes");
        CHECK_TYPE(baby, RZ_JSON_STRING);
        ut8 *bytes = sdb_decode(baby->str_value, NULL);
 
        RzRegArena *a = rz_reg_arena_new(size);
        if (!a) {
            free(bytes);
            continue;
        }
        memcpy(a->bytes, bytes, a->size);
        checkpoint.arena[arena] = a;
        free(bytes);
    }
 
    // Extract RzDebugSnap's from "snaps"
    checkpoint.snaps = rz_list_newf((RzListFree)rz_debug_snap_free);
    const RzJson *snaps_json = rz_json_get(chkpt_json, "snaps");
    if (!snaps_json || snaps_json->type != RZ_JSON_ARRAY) {
        goto end;
    }
    for (child = snaps_json->children.first; child; child = child->next) {
        const RzJson *namej = rz_json_get(child, "name");
        CHECK_TYPE(namej, RZ_JSON_STRING);
        const RzJson *dataj = rz_json_get(child, "data");
        CHECK_TYPE(dataj, RZ_JSON_STRING);
        const RzJson *sizej = rz_json_get(child, "size");
        CHECK_TYPE(sizej, RZ_JSON_INTEGER);
        const RzJson *addrj = rz_json_get(child, "addr");
        CHECK_TYPE(addrj, RZ_JSON_INTEGER);
        const RzJson *addr_endj = rz_json_get(child, "addr_end");
        CHECK_TYPE(addr_endj, RZ_JSON_INTEGER);
        const RzJson *permj = rz_json_get(child, "perm");
        CHECK_TYPE(permj, RZ_JSON_INTEGER);
        const RzJson *userj = rz_json_get(child, "user");
        CHECK_TYPE(userj, RZ_JSON_INTEGER);
        const RzJson *sharedj = rz_json_get(child, "shared");
        CHECK_TYPE(sharedj, RZ_JSON_BOOLEAN);
 
        RzDebugSnap *snap = RZ_NEW0(RzDebugSnap);
        if (!snap) {
            eprintf("Error: failed to allocate RzDebugSnap snap");
            continue;
        }
        snap->name = strdup(namej->str_value);
        snap->addr = addrj->num.u_value;
        snap->addr_end = addr_endj->num.u_value;
        snap->size = sizej->num.u_value;
        snap->data = sdb_decode(dataj->str_value, NULL);
        snap->perm = permj->num.s_value;
        snap->user = userj->num.s_value;
        snap->shared = sharedj->num.u_value;
 
        rz_list_append(checkpoint.snaps, snap);
    }
end:
    free(json_str);
    rz_json_free(chkpt_json);
    rz_vector_push(checkpoints, &checkpoint);
    return true;
}

References a, rz_debug_snap_t::addr, rz_debug_snap_t::addr_end, rz_debug_checkpoint_t::arena, bytes, CHECK_TYPE, rz_json_t::children, rz_debug_checkpoint_t::cnum, rz_debug_snap_t::data, test_evm::end, eprintf, free(), int, memcpy(), rz_debug_snap_t::name, rz_json_t::next, NULL, rz_json_t::num, rz_debug_snap_t::perm, rz_debug_snap_free(), RZ_JSON_ARRAY, RZ_JSON_BOOLEAN, rz_json_free(), rz_json_get(), RZ_JSON_INTEGER, RZ_JSON_OBJECT, rz_json_parse(), RZ_JSON_STRING, rz_list_append(), rz_list_newf(), RZ_NEW0, rz_reg_arena_new(), RZ_REG_TYPE_LAST, rz_vector_push(), sdb_atoi(), sdb_decode(), rz_debug_snap_t::shared, rz_debug_snap_t::size, rz_debug_checkpoint_t::snaps, rz_json_t::str_value, strdup(), rz_json_t::type, rz_debug_snap_t::user, and v.

Referenced by deserialize_checkpoints().

deserialize_memory()

static void deserialize_memory ( Sdb *  db, HtUP *  memory  )

static

Definition at line 509 of file dsession.c.

                                                      {
    sdb_foreach(db, deserialize_memory_cb, memory);
}

References deserialize_memory_cb(), and sdb_foreach().

Referenced by rz_debug_session_deserialize().

deserialize_memory_cb()

static bool deserialize_memory_cb ( void *  user, const char *  addr, const char *  v  )

static

Definition at line 464 of file dsession.c.

                                                                               {
    RzJson *child;
    char *json_str = strdup(v);
    if (!json_str) {
        return true;
    }
    RzJson *reg_json = rz_json_parse(json_str);
    if (!reg_json || reg_json->type != RZ_JSON_ARRAY) {
        free(json_str);
        return true;
    }
 
    HtUP *memory = user;
    // Insert a new vector into `memory` HtUP at `addr`
    RzVector *vmem = rz_vector_new(sizeof(RzDebugChangeMem), NULL, NULL);
    if (!vmem) {
        eprintf("Error: failed to allocate RzVector vmem.\n");
        free(json_str);
        rz_json_free(reg_json);
        return false;
    }
    ht_up_insert(memory, sdb_atoi(addr), vmem);
 
    // Extract <RzDebugChangeMem>'s into the new vector
    for (child = reg_json->children.first; child; child = child->next) {
        if (child->type != RZ_JSON_OBJECT) {
            continue;
        }
        const RzJson *baby = rz_json_get(child, "cnum");
        CHECK_TYPE(baby, RZ_JSON_INTEGER);
        int cnum = baby->num.s_value;
 
        baby = rz_json_get(child, "data");
        CHECK_TYPE(baby, RZ_JSON_INTEGER);
        ut64 data = baby->num.u_value;
 
        RzDebugChangeMem mem = { cnum, data };
        rz_vector_push(vmem, &mem);
    }
 
    free(json_str);
    rz_json_free(reg_json);
    return true;
}

References addr, CHECK_TYPE, rz_json_t::children, eprintf, free(), mem, rz_json_t::next, NULL, rz_json_t::num, RZ_JSON_ARRAY, rz_json_free(), rz_json_get(), RZ_JSON_INTEGER, RZ_JSON_OBJECT, rz_json_parse(), rz_vector_new(), rz_vector_push(), sdb_atoi(), strdup(), rz_json_t::type, ut64(), and v.

Referenced by deserialize_memory().

deserialize_registers()

static void deserialize_registers ( Sdb *  db, HtUP *  registers  )

static

Definition at line 558 of file dsession.c.

                                                            {
    sdb_foreach(db, deserialize_registers_cb, registers);
}

References deserialize_registers_cb(), and sdb_foreach().

Referenced by rz_debug_session_deserialize().

deserialize_registers_cb()

static bool deserialize_registers_cb ( void *  user, const char *  addr, const char *  v  )

static

Definition at line 513 of file dsession.c.

                                                                                  {
    RzJson *child;
    char *json_str = strdup(v);
    if (!json_str) {
        return true;
    }
    RzJson *reg_json = rz_json_parse(json_str);
    if (!reg_json || reg_json->type != RZ_JSON_ARRAY) {
        free(json_str);
        return true;
    }
 
    // Insert a new vector into `registers` HtUP at `addr`
    HtUP *registers = user;
    RzVector *vreg = rz_vector_new(sizeof(RzDebugChangeReg), NULL, NULL);
    if (!vreg) {
        eprintf("Error: failed to allocate RzVector vreg.\n");
        rz_json_free(reg_json);
        free(json_str);
        return true;
    }
    ht_up_insert(registers, sdb_atoi(addr), vreg);
 
    // Extract <RzDebugChangeReg>'s into the new vector
    for (child = reg_json->children.first; child; child = child->next) {
        if (child->type != RZ_JSON_OBJECT) {
            continue;
        }
        const RzJson *baby = rz_json_get(child, "cnum");
        CHECK_TYPE(baby, RZ_JSON_INTEGER);
        int cnum = baby->num.s_value;
 
        baby = rz_json_get(child, "data");
        CHECK_TYPE(baby, RZ_JSON_INTEGER);
        ut64 data = baby->num.u_value;
 
        RzDebugChangeReg reg = { cnum, data };
        rz_vector_push(vreg, &reg);
    }
 
    rz_json_free(reg_json);
    free(json_str);
    return true;
}

References addr, CHECK_TYPE, rz_json_t::children, eprintf, free(), rz_json_t::next, NULL, rz_json_t::num, reg, RZ_JSON_ARRAY, rz_json_free(), rz_json_get(), RZ_JSON_INTEGER, RZ_JSON_OBJECT, rz_json_parse(), rz_vector_new(), rz_vector_push(), sdb_atoi(), strdup(), rz_json_t::type, ut64(), and v.

Referenced by deserialize_registers().

htup_vector_free()

static void htup_vector_free ( HtUPKv *  kv )

static

Definition at line 29 of file dsession.c.

                                         {
    rz_vector_free(kv->value);
}

References rz_vector_free().

Referenced by rz_debug_session_new().

rz_debug_add_checkpoint()

RZ_API bool rz_debug_add_checkpoint

(

RzDebug *

dbg

)

Definition at line 58 of file dsession.c.

                                                  {
    rz_return_val_if_fail(dbg->session, false);
    size_t i;
    RzDebugCheckpoint checkpoint = { 0 };
 
    // Save current registers arena iter
    rz_debug_reg_sync(dbg, RZ_REG_TYPE_ANY, 0);
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        RzRegArena *a = dbg->reg->regset[i].arena;
        RzRegArena *b = rz_reg_arena_new(a->size);
        rz_mem_copy(b->bytes, b->size, a->bytes, a->size);
        checkpoint.arena[i] = b;
    }
 
    // Save current memory maps
    checkpoint.snaps = rz_list_newf((RzListFree)rz_debug_snap_free);
    if (!checkpoint.snaps) {
        return false;
    }
    RzListIter *iter;
    RzDebugMap *map;
    rz_debug_map_sync(dbg);
    rz_list_foreach (dbg->maps, iter, map) {
        if ((map->perm & RZ_PERM_RW) == RZ_PERM_RW) {
            RzDebugSnap *snap = rz_debug_snap_map(dbg, map);
            if (snap) {
                rz_list_append(checkpoint.snaps, snap);
            }
        }
    }
 
    checkpoint.cnum = dbg->session->cnum;
    rz_vector_push(dbg->session->checkpoints, &checkpoint);
 
    // Add PC register change so we can check for breakpoints when continue [back]
    RzRegItem *ripc = rz_reg_get(dbg->reg, dbg->reg->name[RZ_REG_NAME_PC], RZ_REG_TYPE_GPR);
    ut64 data = rz_reg_get_value(dbg->reg, ripc);
    rz_debug_session_add_reg_change(dbg->session, ripc->arena, ripc->offset, data);
 
    return true;
}

References a, rz_debug_checkpoint_t::arena, rz_reg_item_t::arena, rz_reg_set_t::arena, b, rz_debug_session_t::checkpoints, rz_debug_checkpoint_t::cnum, rz_debug_session_t::cnum, dbg, i, map(), rz_debug_t::maps, rz_reg_t::name, rz_reg_item_t::offset, rz_debug_t::reg, rz_reg_t::regset, rz_debug_map_sync(), rz_debug_reg_sync(), rz_debug_session_add_reg_change(), rz_debug_snap_free(), rz_debug_snap_map(), rz_list_append(), rz_list_newf(), rz_mem_copy(), RZ_PERM_RW, rz_reg_arena_new(), rz_reg_get(), rz_reg_get_value(), RZ_REG_NAME_PC, RZ_REG_TYPE_ANY, RZ_REG_TYPE_GPR, RZ_REG_TYPE_LAST, rz_return_val_if_fail, rz_vector_push(), rz_debug_t::session, rz_debug_checkpoint_t::snaps, and ut64().

Referenced by rz_cmd_debug_start_trace_session_handler(), and rz_debug_continue_kill().

rz_debug_checkpoint_fini()

static void rz_debug_checkpoint_fini ( void *  element, void *  user  )

static

Definition at line 20 of file dsession.c.

                                                                {
    RzDebugCheckpoint *checkpoint = element;
    size_t i;
    for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
        rz_reg_arena_free(checkpoint->arena[i]);
    }
    rz_list_free(checkpoint->snaps);
}

References rz_debug_checkpoint_t::arena, i, rz_list_free(), rz_reg_arena_free(), RZ_REG_TYPE_LAST, and rz_debug_checkpoint_t::snaps.

Referenced by rz_debug_session_new().

rz_debug_session_add_mem_change()

RZ_API bool rz_debug_session_add_mem_change	(	RzDebugSession *	session,
		ut64	addr,
		ut8	data
	)

Definition at line 233 of file dsession.c.

                                                                                          {
    RzVector *vmem = ht_up_find(session->memory, addr, NULL);
    if (!vmem) {
        vmem = rz_vector_new(sizeof(RzDebugChangeMem), NULL, NULL);
        if (!vmem) {
            eprintf("Error: creating a memory vector.\n");
            return false;
        }
        ht_up_insert(session->memory, addr, vmem);
    }
    RzDebugChangeMem mem = { session->cnum, data };
    rz_vector_push(vmem, &mem);
    return true;
}

References addr, rz_debug_session_t::cnum, eprintf, mem, rz_debug_session_t::memory, NULL, rz_vector_new(), and rz_vector_push().

Referenced by rz_debug_trace_ins_after().

rz_debug_session_add_reg_change()

RZ_API bool rz_debug_session_add_reg_change	(	RzDebugSession *	session,
		int	arena,
		ut64	offset,
		ut64	data
	)

Definition at line 218 of file dsession.c.

                                                                                                        {
    RzVector *vreg = ht_up_find(session->registers, offset | (arena << 16), NULL);
    if (!vreg) {
        vreg = rz_vector_new(sizeof(RzDebugChangeReg), NULL, NULL);
        if (!vreg) {
            eprintf("Error: creating a register vector.\n");
            return false;
        }
        ht_up_insert(session->registers, offset | (arena << 16), vreg);
    }
    RzDebugChangeReg reg = { session->cnum, data };
    rz_vector_push(vreg, &reg);
    return true;
}

References rz_debug_session_t::cnum, eprintf, NULL, reg, rz_debug_session_t::registers, rz_vector_new(), and rz_vector_push().

Referenced by rz_debug_add_checkpoint(), and rz_debug_trace_ins_after().

rz_debug_session_deserialize()

RZ_API void rz_debug_session_deserialize	(	RzDebugSession *	session,
		Sdb *	db
	)

Definition at line 707 of file dsession.c.

                                                                           {
    Sdb *subdb;
 
    session->maxcnum = sdb_num_get(db, "maxcnum", 0);
 
#define DESERIALIZE(ns, func) \
    do { \
        subdb = sdb_ns(db, ns, false); \
        if (!subdb) { \
            eprintf("Error: missing " ns " namespace\n"); \
            return; \
        } \
        func; \
    } while (0)
 
    DESERIALIZE("memory", deserialize_memory(subdb, session->memory));
    DESERIALIZE("registers", deserialize_registers(subdb, session->registers));
    DESERIALIZE("checkpoints", deserialize_checkpoints(subdb, session->checkpoints));
}

References rz_debug_session_t::checkpoints, DESERIALIZE, deserialize_checkpoints(), deserialize_memory(), deserialize_registers(), rz_debug_session_t::maxcnum, rz_debug_session_t::memory, rz_debug_session_t::registers, and sdb_num_get().

Referenced by rz_debug_session_load().

rz_debug_session_free()

RZ_API void rz_debug_session_free

(

RzDebugSession *

session

)

Definition at line 11 of file dsession.c.

                                                           {
    if (session) {
        rz_vector_free(session->checkpoints);
        ht_up_free(session->registers);
        ht_up_free(session->memory);
        RZ_FREE(session);
    }
}

References rz_debug_session_t::checkpoints, rz_debug_session_t::memory, rz_debug_session_t::registers, RZ_FREE, and rz_vector_free().

Referenced by rz_cmd_debug_load_trace_session_handler(), rz_cmd_debug_stop_trace_session_handler(), rz_core_debug_process_close(), rz_debug_free(), and rz_debug_session_new().

rz_debug_session_list_memory()

RZ_API void rz_debug_session_list_memory

(

RzDebug *

dbg

)

Definition at line 185 of file dsession.c.

                                                       {
    RzHashSize dsize;
    RzListIter *iter;
    RzDebugMap *map;
    rz_debug_map_sync(dbg);
    rz_list_foreach (dbg->maps, iter, map) {
        if ((map->perm & RZ_PERM_RW) == RZ_PERM_RW) {
            RzDebugSnap *snap = rz_debug_snap_map(dbg, map);
            if (!snap) {
                return;
            }
 
            ut8 *hash = rz_debug_snap_get_hash(dbg, snap, &dsize);
            if (!hash) {
                rz_debug_snap_free(snap);
                return;
            }
 
            char *hexstr = rz_hex_bin2strdup(hash, dsize);
            if (!hexstr) {
                free(hash);
                rz_debug_snap_free(snap);
                return;
            }
            dbg->cb_printf("%s: %s\n", snap->name, hexstr);
 
            free(hexstr);
            free(hash);
            rz_debug_snap_free(snap);
        }
    }
}

References rz_debug_t::cb_printf, dbg, free(), map(), rz_debug_t::maps, rz_debug_snap_t::name, rz_debug_map_sync(), rz_debug_snap_free(), rz_debug_snap_get_hash(), rz_debug_snap_map(), rz_hex_bin2strdup(), and RZ_PERM_RW.

Referenced by rz_cmd_debug_list_trace_session_mmap_handler().

rz_debug_session_load()

RZ_API bool rz_debug_session_load	(	RzDebug *	dbg,
		const char *	path
	)

Definition at line 727 of file dsession.c.

                                                                  {
    Sdb *db = session_sdb_load(path);
    if (!db) {
        return false;
    }
    rz_debug_session_deserialize(dbg->session, db);
    // Restore debugger to the beginning of the session
    rz_debug_session_restore_reg_mem(dbg, 0);
    sdb_free(db);
    return true;
}

References dbg, path, rz_debug_session_deserialize(), rz_debug_session_restore_reg_mem(), sdb_free(), rz_debug_t::session, and session_sdb_load().

Referenced by rz_cmd_debug_load_trace_session_handler().

rz_debug_session_new()

RZ_API RzDebugSession* rz_debug_session_new

(

void

)

Definition at line 33 of file dsession.c.

                                                  {
    RzDebugSession *session = RZ_NEW0(RzDebugSession);
    if (!session) {
        return NULL;
    }
 
    session->checkpoints = rz_vector_new(sizeof(RzDebugCheckpoint), rz_debug_checkpoint_fini, NULL);
    if (!session->checkpoints) {
        rz_debug_session_free(session);
        return NULL;
    }
    session->registers = ht_up_new(NULL, htup_vector_free, NULL);
    if (!session->registers) {
        rz_debug_session_free(session);
        return NULL;
    }
    session->memory = ht_up_new(NULL, htup_vector_free, NULL);
    if (!session->memory) {
        rz_debug_session_free(session);
        return NULL;
    }
 
    return session;
}

References rz_debug_session_t::checkpoints, htup_vector_free(), rz_debug_session_t::memory, NULL, rz_debug_session_t::registers, rz_debug_checkpoint_fini(), rz_debug_session_free(), RZ_NEW0, and rz_vector_new().

Referenced by rz_cmd_debug_load_trace_session_handler(), and rz_cmd_debug_start_trace_session_handler().

rz_debug_session_restore_reg_mem()

RZ_API void rz_debug_session_restore_reg_mem	(	RzDebug *	dbg,
		ut32	cnum
	)

Definition at line 173 of file dsession.c.

                                                                      {
    // Set checkpoint for initial registers and memory
    dbg->session->cur_chkpt = _get_checkpoint_before(dbg->session, cnum);
 
    // Restore registers
    _restore_registers(dbg, cnum);
    rz_debug_reg_sync(dbg, RZ_REG_TYPE_ANY, true);
 
    // Restore memory
    _restore_memory(dbg, cnum);
}

References _get_checkpoint_before(), _restore_memory(), _restore_registers(), rz_debug_session_t::cur_chkpt, dbg, rz_debug_reg_sync(), RZ_REG_TYPE_ANY, and rz_debug_t::session.

Referenced by rz_debug_goto_cnum(), and rz_debug_session_load().

rz_debug_session_save()

RZ_API bool rz_debug_session_save	(	RzDebugSession *	session,
		const char *	path
	)

Definition at line 445 of file dsession.c.

                                                                             {
    Sdb *db = sdb_new0();
    if (!db) {
        return false;
    }
    rz_debug_session_serialize(session, db);
 
    if (!session_sdb_save(db, path)) {
        sdb_free(db);
        return false;
    }
    sdb_free(db);
    return true;
}

References path, rz_debug_session_serialize(), sdb_free(), sdb_new0(), and session_sdb_save().

Referenced by rz_cmd_debug_save_trace_session_handler().

rz_debug_session_serialize()

RZ_API void rz_debug_session_serialize	(	RzDebugSession *	session,
		Sdb *	db
	)

Definition at line 402 of file dsession.c.

                                                                         {
    sdb_num_set(db, "maxcnum", session->maxcnum, 0);
    serialize_registers(sdb_ns(db, "registers", true), session->registers);
    serialize_memory(sdb_ns(db, "memory", true), session->memory);
    serialize_checkpoints(sdb_ns(db, "checkpoints", true), session->checkpoints);
}

References rz_debug_session_t::checkpoints, rz_debug_session_t::maxcnum, rz_debug_session_t::memory, rz_debug_session_t::registers, sdb_ns(), sdb_num_set(), serialize_checkpoints(), serialize_memory(), and serialize_registers().

Referenced by rz_debug_session_save().

serialize_checkpoints()

static void serialize_checkpoints ( Sdb *  db, RzVector *  checkpoints  )

static

Definition at line 304 of file dsession.c.

                                                                  {
    size_t i;
    RzDebugCheckpoint *chkpt;
    RzDebugSnap *snap;
    RzListIter *iter;
 
    rz_vector_foreach(checkpoints, chkpt) {
        // 0x<cnum>={
        //   registers:{"<RzRegisterType>":<RzRegArena>, ...},
        //   snaps:{"size":<size_t>, "a":[<RzDebugSnap>]}
        // }
        PJ *j = pj_new();
        if (!j) {
            return;
        }
        pj_o(j);
 
        // Serialize RzRegArena to "registers"
        // {"size":<int>, "bytes":"<base64>"}
        pj_ka(j, "registers");
        for (i = 0; i < RZ_REG_TYPE_LAST; i++) {
            RzRegArena *arena = chkpt->arena[i];
            if (arena->bytes) {
                pj_o(j);
                pj_kn(j, "arena", i);
                char *ebytes = sdb_encode((const void *)arena->bytes, arena->size);
                pj_ks(j, "bytes", ebytes);
                free(ebytes);
                pj_kn(j, "size", arena->size);
                pj_end(j);
            }
        }
        pj_end(j);
 
        // Serialize RzDebugSnap to "snaps"
        // {"name":<str>, "addr":<ut64>, "addr_end":<ut64>, "size":<ut64>,
        //  "data":"<base64>", "perm":<int>, "user":<int>, "shared":<bool>}
        pj_ka(j, "snaps");
        rz_list_foreach (chkpt->snaps, iter, snap) {
            pj_o(j);
            pj_ks(j, "name", snap->name);
            pj_kn(j, "addr", snap->addr);
            pj_kn(j, "addr_end", snap->addr_end);
            pj_kn(j, "size", snap->size);
            char *edata = sdb_encode((const void *)snap->data, snap->size);
            if (!edata) {
                pj_free(j);
                return;
            }
            pj_ks(j, "data", edata);
            free(edata);
            pj_kn(j, "perm", snap->perm);
            pj_kn(j, "user", snap->user);
            pj_kb(j, "shared", snap->shared);
            pj_end(j);
        }
        pj_end(j);
 
        pj_end(j);
        sdb_set(db, sdb_fmt("0x%x", chkpt->cnum), pj_string(j), 0);
        pj_free(j);
    }
}

References rz_debug_snap_t::addr, rz_debug_snap_t::addr_end, rz_debug_checkpoint_t::arena, rz_reg_arena_t::bytes, rz_debug_checkpoint_t::cnum, rz_debug_snap_t::data, free(), i, rz_debug_snap_t::name, rz_debug_snap_t::perm, pj_end(), pj_free(), pj_ka(), pj_kb(), pj_kn(), pj_ks(), pj_new(), pj_o(), pj_string(), RZ_REG_TYPE_LAST, rz_vector_foreach, sdb_encode(), sdb_fmt(), sdb_set(), rz_debug_snap_t::shared, rz_debug_snap_t::size, rz_reg_arena_t::size, rz_debug_checkpoint_t::snaps, and rz_debug_snap_t::user.

Referenced by rz_debug_session_serialize().

serialize_memory()

static void serialize_memory ( Sdb *  db, HtUP *  memory  )

static

Definition at line 300 of file dsession.c.

                                                    {
    ht_up_foreach(memory, serialize_memory_cb, db);
}

References serialize_memory_cb().

Referenced by rz_debug_session_serialize().

serialize_memory_cb()

static bool serialize_memory_cb ( void *  db, const ut64  k, const void *  v  )

static

Definition at line 278 of file dsession.c.

                                                                       {
    RzDebugChangeMem *mem;
    RzVector *vmem = (RzVector *)v;
    PJ *j = pj_new();
    if (!j) {
        return false;
    }
    pj_a(j);
 
    rz_vector_foreach(vmem, mem) {
        pj_o(j);
        pj_kN(j, "cnum", mem->cnum);
        pj_kn(j, "data", mem->data);
        pj_end(j);
    }
 
    pj_end(j);
    sdb_set(db, sdb_fmt("0x%" PFMT64x, k), pj_string(j), 0);
    pj_free(j);
    return true;
}

References k, mem, PFMT64x, pj_a(), pj_end(), pj_free(), pj_kN(), pj_kn(), pj_new(), pj_o(), pj_string(), rz_vector_foreach, sdb_fmt(), sdb_set(), and v.

Referenced by serialize_memory().

serialize_register_cb()

static bool serialize_register_cb ( void *  db, const ut64  k, const void *  v  )

static

Definition at line 251 of file dsession.c.

                                                                         {
    RzDebugChangeReg *reg;
    RzVector *vreg = (RzVector *)v;
    PJ *j = pj_new();
    if (!j) {
        return false;
    }
    pj_a(j);
 
    rz_vector_foreach(vreg, reg) {
        pj_o(j);
        pj_kN(j, "cnum", reg->cnum);
        pj_kn(j, "data", reg->data);
        pj_end(j);
    }
 
    pj_end(j);
    sdb_set(db, sdb_fmt("0x%" PFMT64x, k), pj_string(j), 0);
    pj_free(j);
    return true;
}

References k, PFMT64x, pj_a(), pj_end(), pj_free(), pj_kN(), pj_kn(), pj_new(), pj_o(), pj_string(), reg, rz_vector_foreach, sdb_fmt(), sdb_set(), and v.

Referenced by serialize_registers().

serialize_registers()

static void serialize_registers ( Sdb *  db, HtUP *  registers  )

static

Definition at line 273 of file dsession.c.

                                                          {
    ht_up_foreach(registers, serialize_register_cb, db);
}

References serialize_register_cb().

Referenced by rz_debug_session_serialize().

session_sdb_load()

static Sdb* session_sdb_load ( const char *  path )

static

Definition at line 680 of file dsession.c.

                                               {
    char *filename;
    Sdb *db = sdb_new0();
    if (!db) {
        return NULL;
    }
 
#define SDB_LOAD(fn, ns) \
    do { \
        filename = rz_str_newf("%s%s" fn ".sdb", path, RZ_SYS_DIR); \
        if (!session_sdb_load_ns(db, ns, filename)) { \
            free(filename); \
            goto error; \
        } \
        free(filename); \
    } while (0)
 
    SDB_LOAD("session", "");
    SDB_LOAD("registers", "registers");
    SDB_LOAD("memory", "memory");
    SDB_LOAD("checkpoints", "checkpoints");
    return db;
error:
    sdb_free(db);
    return NULL;
}

References error(), NULL, sdb_free(), SDB_LOAD, and sdb_new0().

Referenced by rz_debug_session_load().

session_sdb_load_ns()

static bool session_sdb_load_ns ( Sdb *  db, const char *  nspath, const char *  filename  )

static

Definition at line 667 of file dsession.c.

                                                                                   {
    Sdb *tmpdb = sdb_new0();
    if (sdb_open(tmpdb, filename) == -1) {
        eprintf("Error: failed to load %s into sdb\n", filename);
        sdb_free(tmpdb);
        return false;
    }
    Sdb *ns = sdb_ns_path(db, nspath, true);
    sdb_copy(tmpdb, ns);
    sdb_free(tmpdb);
    return true;
}

References eprintf, sdb_copy(), sdb_free(), sdb_new0(), sdb_ns_path(), and sdb_open().

session_sdb_save()

static bool session_sdb_save ( Sdb *  db, const char *  path  )

static

Definition at line 409 of file dsession.c.

                                                        {
    char *filename;
    if (!rz_file_is_directory(path)) {
        eprintf("Error: %s is not a directory\n", path);
        return false;
    }
 
    filename = rz_str_newf("%s%ssession.sdb", path, RZ_SYS_DIR);
    sdb_file(db, filename);
    if (!sdb_sync(db)) {
        eprintf("Failed to sync session to %s\n", filename);
        free(filename);
        sdb_close(db);
        return false;
    }
    free(filename);
    sdb_close(db);
 
    SdbListIter *it;
    SdbNs *ns;
    ls_foreach (db->ns, it, ns) {
        char *filename = rz_str_newf("%s%s%s.sdb", path, RZ_SYS_DIR, ns->name);
        sdb_file(ns->sdb, filename);
        if (!sdb_sync(ns->sdb)) {
            eprintf("Failed to sync %s to %s\n", ns->name, filename);
            free(filename);
            sdb_close(ns->sdb);
            return false;
        }
        free(filename);
        sdb_close(ns->sdb);
    }
 
    return true;
}

References eprintf, free(), ls_foreach, sdb_ns_t::name, sdb_t::ns, path, rz_file_is_directory(), rz_str_newf(), RZ_SYS_DIR, sdb_ns_t::sdb, sdb_close(), sdb_file(), and sdb_sync().

Referenced by rz_debug_session_save().