io_cache.c File Reference

#include <rz_io.h>
#include <rz_skyline.h>

Go to the source code of this file.

Functions
static void	cache_item_free (RzIOCache *cache)
RZ_API bool	rz_io_cache_at (RzIO *io, ut64 addr)
RZ_API void	rz_io_cache_init (RzIO *io)
RZ_API void	rz_io_cache_fini (RzIO *io)
RZ_API void	rz_io_cache_commit (RzIO *io, ut64 from, ut64 to)
RZ_API void	rz_io_cache_reset (RzIO *io, int set)
RZ_API int	rz_io_cache_invalidate (RzIO *io, ut64 from, ut64 to)
RZ_API bool	rz_io_cache_write (RzIO *io, ut64 addr, const ut8 *buf, int len)
RZ_API bool	rz_io_cache_read (RzIO *io, ut64 addr, ut8 *buf, int len)

Function Documentation

cache_item_free()

static void cache_item_free ( RzIOCache *  cache )

static

Definition at line 7 of file io_cache.c.

                                              {
    if (!cache) {
        return;
    }
    free(cache->data);
    free(cache->odata);
    free(cache);
}

References rz_io_cache_t::data, free(), and rz_io_cache_t::odata.

Referenced by rz_io_cache_init().

rz_io_cache_at()

RZ_API bool rz_io_cache_at	(	RzIO *	io,
		ut64	addr
	)

Definition at line 16 of file io_cache.c.

                                                {
    rz_return_val_if_fail(io, false);
    return rz_skyline_contains(&io->cache_skyline, addr);
}

References addr, rz_io_t::cache_skyline, rz_return_val_if_fail, and rz_skyline_contains().

Referenced by rz_io_desc_read().

rz_io_cache_commit()

RZ_API void rz_io_cache_commit	(	RzIO *	io,
		ut64	from,
		ut64	to
	)

Definition at line 35 of file io_cache.c.

                                                             {
    void **iter;
    RzIOCache *c;
    RzInterval range = (RzInterval){ from, to - from };
    rz_return_if_fail(io);
    rz_pvector_foreach (&io->cache, iter) {
        // if (from <= c->to - 1 && c->from <= to - 1) {
        c = *iter;
        if (rz_itv_overlap(c->itv, range)) {
            int cached = io->cached;
            io->cached = 0;
            if (rz_io_write_at(io, rz_itv_begin(c->itv), c->data, rz_itv_size(c->itv))) {
                c->written = true;
            } else {
                eprintf("Error writing change at 0x%08" PFMT64x "\n", rz_itv_begin(c->itv));
            }
            io->cached = cached;
            // break; // XXX old behavior, revisit this
        }
    }
}

References c, rz_io_t::cache, rz_io_t::cached, eprintf, from, PFMT64x, capstone::range, rz_io_write_at(), rz_itv_begin(), rz_itv_overlap(), rz_itv_size(), rz_pvector_foreach, rz_return_if_fail, and to.

Referenced by rz_write_cache_commit_all_handler(), and rz_write_cache_commit_handler().

rz_io_cache_fini()

RZ_API void rz_io_cache_fini

(

RzIO *

io

)

Definition at line 28 of file io_cache.c.

                                       {
    rz_return_if_fail(io);
    rz_pvector_fini(&io->cache);
    rz_skyline_fini(&io->cache_skyline);
    io->cached = 0;
}

References rz_io_t::cache, rz_io_t::cache_skyline, rz_io_t::cached, rz_pvector_fini(), rz_return_if_fail, and rz_skyline_fini().

Referenced by rz_core_disasm_pde(), rz_io_close_all(), and rz_io_fini().

rz_io_cache_init()

RZ_API void rz_io_cache_init

(

RzIO *

io

)

Definition at line 21 of file io_cache.c.

                                       {
    rz_return_if_fail(io);
    rz_pvector_init(&io->cache, (RzPVectorFree)cache_item_free);
    rz_skyline_init(&io->cache_skyline);
    io->cached = 0;
}

References rz_io_t::cache, cache_item_free(), rz_io_t::cache_skyline, rz_io_t::cached, rz_pvector_init(), rz_return_if_fail, and rz_skyline_init().

Referenced by rz_core_disasm_pde(), and rz_io_init().

rz_io_cache_invalidate()

RZ_API int rz_io_cache_invalidate	(	RzIO *	io,
		ut64	from,
		ut64	to
	)

Definition at line 64 of file io_cache.c.

                                                                {
    rz_return_val_if_fail(io, 0);
    int invalidated = 0;
    void **iter;
    RzIOCache *c;
    RzInterval range = (RzInterval){ from, to - from };
    rz_pvector_foreach_prev(&io->cache, iter) {
        c = *iter;
        if (rz_itv_overlap(c->itv, range)) {
            int cached = io->cached;
            io->cached = 0;
            rz_io_write_at(io, rz_itv_begin(c->itv), c->odata, rz_itv_size(c->itv));
            io->cached = cached;
            c->written = false;
            rz_pvector_remove_data(&io->cache, c);
            free(c->data);
            free(c->odata);
            free(c);
            invalidated++;
        }
    }
    rz_skyline_clear(&io->cache_skyline);
    rz_pvector_foreach (&io->cache, iter) {
        c = *iter;
        rz_skyline_add(&io->cache_skyline, c->itv, c);
    }
    return invalidated;
}

References c, rz_io_t::cache, rz_io_t::cache_skyline, rz_io_t::cached, free(), from, capstone::range, rz_io_write_at(), rz_itv_begin(), rz_itv_overlap(), rz_itv_size(), rz_pvector_foreach, rz_pvector_foreach_prev, rz_pvector_remove_data(), rz_return_val_if_fail, rz_skyline_add(), rz_skyline_clear(), and to.

Referenced by rz_write_cache_remove_handler().

rz_io_cache_read()

RZ_API bool rz_io_cache_read	(	RzIO *	io,
		ut64	addr,
		ut8 *	buf,
		int	len
	)

Definition at line 131 of file io_cache.c.

                                                                     {
    rz_return_val_if_fail(io && buf, false);
    RzSkyline *skyline = &io->cache_skyline;
    if (!len) {
        return true;
    }
    if (UT64_ADD_OVFCHK(addr, len)) {
        const ut64 first_len = UT64_MAX - addr;
        rz_io_cache_read(io, 0, buf + first_len, len - first_len);
        len = first_len;
    }
    const RzSkylineItem *iter = rz_skyline_get_item_intersect(skyline, addr, len);
    if (!iter) {
        return false;
    }
    const RzSkylineItem *last = (RzSkylineItem *)skyline->v.a + skyline->v.len;
    bool covered = false;
    while (iter != last) {
        const ut64 begin = rz_itv_begin(iter->itv);
        const st64 addr_offset = begin - addr;
        const ut64 buf_offset = addr_offset > 0 ? addr_offset : 0;
        const ut64 cur_addr = addr + buf_offset;
        const ut64 left = len - buf_offset;
        if (begin > cur_addr + left) {
            break;
        }
        RzIOCache *cache = iter->user;
        const ut64 cache_shift = addr_offset < 0 ? -addr_offset : 0;
        const ut64 cache_offset = begin - rz_itv_begin(cache->itv) + cache_shift;
        const ut64 read = RZ_MIN(left, rz_itv_size(iter->itv) - cache_shift);
        memcpy(buf + buf_offset, cache->data + cache_offset, read);
        covered = true;
        if (left - read <= 0) {
            break;
        }
        iter++;
    }
    return covered;
}

References rz_vector_t::a, addr, rz_io_t::cache_skyline, rz_io_cache_t::data, rz_io_cache_t::itv, len, rz_vector_t::len, memcpy(), read(), rz_io_cache_read(), rz_itv_begin(), rz_itv_size(), RZ_MIN, rz_return_val_if_fail, rz_skyline_get_item_intersect(), st64, ut64(), UT64_ADD_OVFCHK, UT64_MAX, rz_skyline_t::v, and while().

Referenced by rz_io_cache_read(), rz_io_desc_read(), rz_io_nread_at(), rz_io_read_at(), and rz_io_read_at_mapped().

rz_io_cache_reset()

RZ_API void rz_io_cache_reset	(	RzIO *	io,
		int	set
	)

Definition at line 57 of file io_cache.c.

                                                 {
    rz_return_if_fail(io);
    io->cached = set;
    rz_pvector_clear(&io->cache);
    rz_skyline_clear(&io->cache_skyline);
}

References rz_io_t::cache, rz_io_t::cache_skyline, rz_io_t::cached, rz_pvector_clear(), rz_return_if_fail, and rz_skyline_clear().

Referenced by rz_core_link_stroff(), and rz_write_cache_remove_all_handler().

rz_io_cache_write()

RZ_API bool rz_io_cache_write	(	RzIO *	io,
		ut64	addr,
		const ut8 *	buf,
		int	len
	)

Definition at line 93 of file io_cache.c.

                                                                            {
    rz_return_val_if_fail(io && buf, false);
    RzIOCache *ch = RZ_NEW0(RzIOCache);
    if (!ch) {
        return false;
    }
    if (UT64_ADD_OVFCHK(addr, len)) {
        const ut64 first_len = UT64_MAX - addr;
        rz_io_cache_write(io, 0, buf + first_len, len - first_len);
        len = first_len;
    }
    ch->itv = (RzInterval){ addr, len };
    ch->odata = (ut8 *)calloc(1, len + 1);
    if (!ch->odata) {
        free(ch);
        return false;
    }
    ch->data = (ut8 *)calloc(1, len + 1);
    if (!ch->data) {
        free(ch->odata);
        free(ch);
        return false;
    }
    ch->written = false;
    {
        const bool cm = io->cachemode;
        io->cachemode = false;
        rz_io_read_at(io, addr, ch->odata, len);
        io->cachemode = cm;
    }
    memcpy(ch->data, buf, len);
    rz_pvector_push(&io->cache, ch);
    rz_skyline_add(&io->cache_skyline, ch->itv, ch);
    RzEventIOWrite iow = { addr, buf, len };
    rz_event_send(io->event, RZ_EVENT_IO_WRITE, &iow);
    return true;
}

References addr, rz_io_t::cache, rz_io_t::cache_skyline, rz_io_t::cachemode, calloc(), rz_io_cache_t::data, rz_io_t::event, free(), rz_io_cache_t::itv, len, memcpy(), rz_io_cache_t::odata, RZ_EVENT_IO_WRITE, rz_event_send(), rz_io_cache_write(), rz_io_read_at(), RZ_NEW0, rz_pvector_push(), rz_return_val_if_fail, rz_skyline_add(), ut64(), UT64_ADD_OVFCHK, UT64_MAX, and rz_io_cache_t::written.

Referenced by rz_io_cache_write(), rz_io_desc_read(), and rz_io_write_at().