mirror of
https://github.com/radareorg/radare2.git
synced 2024-12-09 05:54:57 +00:00
179 lines
3.9 KiB
C
179 lines
3.9 KiB
C
/* radare - LGPL - Copyright 2010 pancake<nopcode.org> */
|
|
|
|
// TODO: use r_range here??
|
|
#include <r_bp.h>
|
|
#include <r_list.h>
|
|
|
|
R_API void r_bp_traptrace_free(void *ptr) {
|
|
RBreakpointTrace *trace = ptr;
|
|
free (trace->buffer);
|
|
free (trace->traps);
|
|
free (trace->bits);
|
|
free (trace);
|
|
}
|
|
|
|
R_API RList *r_bp_traptrace_new() {
|
|
RList *list = r_list_new();
|
|
if (!list) {
|
|
return NULL;
|
|
}
|
|
list->free = &r_bp_traptrace_free;
|
|
return list;
|
|
}
|
|
|
|
R_API void r_bp_traptrace_enable(RBreakpoint *bp, int enable) {
|
|
RListIter *iter;
|
|
RBreakpointTrace *trace;
|
|
r_list_foreach (bp->traces, iter, trace) {
|
|
ut8 *buf = (enable)?trace->traps:trace->buffer;
|
|
bp->iob.write_at (bp->iob.io, trace->addr, buf, trace->length);
|
|
}
|
|
}
|
|
|
|
R_API void r_bp_traptrace_reset(RBreakpoint *bp, int hard) {
|
|
RListIter *iter;
|
|
RBreakpointTrace *trace;
|
|
r_list_foreach (bp->traces, iter, trace) {
|
|
if (hard) {
|
|
r_bp_traptrace_free (trace);
|
|
// XXX: This segfaults
|
|
//r_list_delete (bp->traces, r_list_iter_cur (iter));
|
|
} else {
|
|
memset (trace->bits, 0x00, trace->bitlen);
|
|
}
|
|
}
|
|
if (hard) {
|
|
// XXX: traces not freed correctly (memleak)
|
|
bp->traces = r_list_new ();
|
|
bp->traces->free = r_bp_traptrace_free;
|
|
}
|
|
}
|
|
|
|
// FIX: efficiency
|
|
R_API ut64 r_bp_traptrace_next(RBreakpoint *bp, ut64 addr) {
|
|
int i, delta;
|
|
RListIter *iter;
|
|
RBreakpointTrace *trace;
|
|
r_list_foreach (bp->traces, iter, trace) {
|
|
if (addr>=trace->addr && addr<=trace->addr_end) {
|
|
delta = (int)(addr-trace->addr);
|
|
for (i=delta; i<trace->length; i++) {
|
|
if (R_BIT_CHK (trace->bits, i)) {
|
|
return addr + i;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0LL;
|
|
}
|
|
|
|
R_API int r_bp_traptrace_add(RBreakpoint *bp, ut64 from, ut64 to) {
|
|
RBreakpointTrace *trace;
|
|
ut8 *buf, *trap, *bits;
|
|
ut64 len;
|
|
int bitlen;
|
|
/* cannot map addr 0 */
|
|
if (from == 0LL) {
|
|
return false;
|
|
}
|
|
if (from > to) {
|
|
return false;
|
|
}
|
|
len = to-from;
|
|
if (len >= ST32_MAX) {
|
|
return false;
|
|
}
|
|
buf = (ut8*) malloc ((int)len);
|
|
if (!buf) {
|
|
return false;
|
|
}
|
|
trap = (ut8*) malloc ((int)len+4);
|
|
if (!trap) {
|
|
free (buf);
|
|
return false;
|
|
}
|
|
bitlen = (len>>4)+1;
|
|
bits = malloc (bitlen);
|
|
if (!bits) {
|
|
free (buf);
|
|
free (trap);
|
|
return false;
|
|
}
|
|
// TODO: check return value
|
|
bp->iob.read_at (bp->iob.io, from, buf, len);
|
|
memset (bits, 0x00, bitlen);
|
|
r_bp_get_bytes (bp, trap, len, bp->endian, 0);
|
|
|
|
trace = R_NEW (RBreakpointTrace);
|
|
if (!trace) {
|
|
free (buf);
|
|
free (trap);
|
|
free (bits);
|
|
return false;
|
|
}
|
|
trace->addr = from;
|
|
trace->addr_end = to;
|
|
trace->bits = bits;
|
|
trace->traps = trap;
|
|
trace->buffer = buf;
|
|
trace->length = len;
|
|
if (!r_list_append (bp->traces, trace)){
|
|
free (buf);
|
|
free (trap);
|
|
free (trace);
|
|
return false;
|
|
}
|
|
// read a memory, overwrite it as breakpointing area
|
|
// everytime it is hitted, instruction is restored
|
|
return true;
|
|
}
|
|
|
|
R_API int r_bp_traptrace_free_at(RBreakpoint *bp, ut64 from) {
|
|
int ret = false;
|
|
RListIter *iter, *iter_tmp;
|
|
RBreakpointTrace *trace;
|
|
r_list_foreach_safe (bp->traces, iter, iter_tmp, trace) {
|
|
if (from>=trace->addr && from<=trace->addr_end) {
|
|
bp->iob.write_at (bp->iob.io, trace->addr,
|
|
trace->buffer, trace->length);
|
|
r_bp_traptrace_free (trace);
|
|
r_list_delete (bp->traces, iter);
|
|
ret = true;
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
R_API void r_bp_traptrace_list(RBreakpoint *bp) {
|
|
int i;
|
|
RListIter *iter;
|
|
RBreakpointTrace *trace;
|
|
r_list_foreach (bp->traces, iter, trace) {
|
|
for (i = 0; i < trace->bitlen; i++) {
|
|
if (R_BIT_CHK (trace->bits, i)) {
|
|
eprintf (" - 0x%08" PFMT64x "\n", trace->addr + (i << 4));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
R_API int r_bp_traptrace_at(RBreakpoint *bp, ut64 from, int len) {
|
|
int delta;
|
|
RListIter *iter;
|
|
RBreakpointTrace *trace;
|
|
r_list_foreach (bp->traces, iter, trace) {
|
|
// TODO: do we really need len?
|
|
if (from>=trace->addr && from+len<=trace->addr_end) {
|
|
delta = (int) (from-trace->addr);
|
|
if (R_BIT_CHK (trace->bits, delta)) {
|
|
if (trace->traps[delta] == 0x00) {
|
|
return false; // already traced..debugger should stop
|
|
}
|
|
}
|
|
R_BIT_SET (trace->bits, delta);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|