p_cache.c File Reference

#include <rz_io.h>
#include <rz_types.h>
#include <string.h>

Go to the source code of this file.

Functions
static void	pcache_kv_free (HtUPKv *kv)
RZ_API bool	rz_io_desc_cache_init (RzIODesc *desc)
RZ_API int	rz_io_desc_cache_write (RzIODesc *desc, ut64 paddr, const ut8 *buf, int len)
RZ_API int	rz_io_desc_cache_read (RzIODesc *desc, ut64 paddr, ut8 *buf, int len)
static void	__riocache_free (void *user)
static bool	__desc_cache_list_cb (void *user, const ut64 k, const void *v)
RZ_API RzList *	rz_io_desc_cache_list (RzIODesc *desc)
static bool	__desc_cache_commit_cb (void *user, const ut64 k, const void *v)
RZ_API bool	rz_io_desc_cache_commit (RzIODesc *desc)
static bool	__desc_cache_cleanup_cb (void *user, const ut64 k, const void *v)
RZ_API void	rz_io_desc_cache_cleanup (RzIODesc *desc)
static bool	__desc_fini_cb (void *user, void *data, ut32 id)
RZ_API void	rz_io_desc_cache_fini (RzIODesc *desc)
RZ_API void	rz_io_desc_cache_fini_all (RzIO *io)

Variables
const ut64	cleanup_masks []

Function Documentation

__desc_cache_cleanup_cb()

static bool __desc_cache_cleanup_cb ( void *  user, const ut64  k, const void *  v  )

static

Definition at line 321 of file p_cache.c.

                                                                             {
    RzIODesc *desc = (RzIODesc *)user;
    ut64 size, blockaddr;
    int byteaddr;
    if (!desc || !desc->cache) {
        return false;
    }
    RzIODescCache *cache = (RzIODescCache *)v;
    blockaddr = RZ_IO_DESC_CACHE_SIZE * k;
    size = rz_io_desc_size(desc);
    if (size <= blockaddr) {
        ht_up_delete(desc->cache, k);
        return true;
    }
    if (size <= (blockaddr + RZ_IO_DESC_CACHE_SIZE - 1)) {
        // this looks scary, but it isn't
        byteaddr = (int)(size - blockaddr) - 1;
        cache->cached &= cleanup_masks[byteaddr];
    }
    return true;
}

References rz_io_desc_cache_t::cached, cleanup_masks, desc, int, k, RZ_IO_DESC_CACHE_SIZE, rz_io_desc_size(), ut64(), and v.

Referenced by rz_io_desc_cache_cleanup().

__desc_cache_commit_cb()

static bool __desc_cache_commit_cb ( void *  user, const ut64  k, const void *  v  )

static

Definition at line 278 of file p_cache.c.

                                                                            {
    RzIODesc *desc = (RzIODesc *)user;
    int byteaddr, i;
    ut8 buf[RZ_IO_DESC_CACHE_SIZE] = { 0 };
    if (!desc || !desc->io) {
        return false;
    }
    const RzIODescCache *dcache = v;
    ut64 blockaddr = RZ_IO_DESC_CACHE_SIZE * k;
    for (i = byteaddr = 0; byteaddr < RZ_IO_DESC_CACHE_SIZE; byteaddr++) {
        if (dcache->cached & (0x1LL << byteaddr)) {
            buf[i] = dcache->cdata[byteaddr];
            i++;
        } else if (i > 0) {
            rz_io_pwrite_at(desc->io, blockaddr + byteaddr - i, buf, i);
            i = 0;
        }
    }
    if (i > 0) {
        rz_io_pwrite_at(desc->io, blockaddr + RZ_IO_DESC_CACHE_SIZE - i, buf, i);
    }
    return true;
}

References rz_io_desc_cache_t::cached, rz_io_desc_cache_t::cdata, desc, i, k, RZ_IO_DESC_CACHE_SIZE, rz_io_pwrite_at(), ut64(), and v.

Referenced by rz_io_desc_cache_commit().

__desc_cache_list_cb()

static bool __desc_cache_list_cb ( void *  user, const ut64  k, const void *  v  )

static

Definition at line 199 of file p_cache.c.

                                                                          {
    RzList *writes = (RzList *)user;
    RzIOCache *cache = NULL;
    ut64 blockaddr;
    int byteaddr, i;
    if (!writes) {
        return false;
    }
    const RzIODescCache *dcache = v;
    blockaddr = k * RZ_IO_DESC_CACHE_SIZE;
    for (i = byteaddr = 0; byteaddr < RZ_IO_DESC_CACHE_SIZE; byteaddr++) {
        if (dcache->cached & (0x1LL << byteaddr)) {
            if (!cache) {
                cache = RZ_NEW0(RzIOCache);
                if (!cache) {
                    return false;
                }
                cache->data = malloc(RZ_IO_DESC_CACHE_SIZE - byteaddr);
                if (!cache->data) {
                    free(cache);
                    return false;
                }
                cache->itv.addr = blockaddr + byteaddr;
            }
            cache->data[i] = dcache->cdata[byteaddr];
            i++;
        } else if (cache) {
            ut8 *data = realloc(cache->data, i);
            if (!data) {
                __riocache_free((void *)cache);
                return false;
            }
            cache->data = data;
            cache->itv.size = i;
            i = 0;
            rz_list_push(writes, cache);
            cache = NULL;
        }
    }
    if (cache) {
#if 0
        cache->size = i;
        cache->to = blockaddr + RZ_IO_DESC_CACHE_SIZE;
#endif
        cache->itv.size = i;
        rz_list_push(writes, cache);
    }
    return true;
}

References __riocache_free(), rz_interval_t::addr, rz_io_desc_cache_t::cached, rz_io_desc_cache_t::cdata, rz_io_cache_t::data, free(), i, rz_io_cache_t::itv, k, malloc(), NULL, realloc(), RZ_IO_DESC_CACHE_SIZE, rz_list_push(), RZ_NEW0, rz_interval_t::size, ut64(), and v.

Referenced by rz_io_desc_cache_list().

__desc_fini_cb()

static bool __desc_fini_cb ( void *  user, void *  data, ut32  id  )

static

Definition at line 349 of file p_cache.c.

                                                            {
    RzIODesc *desc = (RzIODesc *)data;
    if (desc->cache) {
        ht_up_free(desc->cache);
        desc->cache = NULL;
    }
    return true;
}

References desc, and NULL.

Referenced by rz_io_desc_cache_fini(), and rz_io_desc_cache_fini_all().

__riocache_free()

static void __riocache_free ( void *  user )

static

Definition at line 190 of file p_cache.c.

                                        {
    RzIOCache *cache = (RzIOCache *)user;
    if (cache) {
        free(cache->data);
        free(cache->odata);
    }
    free(cache);
}

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

Referenced by __desc_cache_list_cb(), and rz_io_desc_cache_list().

pcache_kv_free()

static void pcache_kv_free ( HtUPKv *  kv )

static

Definition at line 75 of file p_cache.c.

                                       {
    free(kv->value);
}

References free().

Referenced by rz_io_desc_cache_init().

rz_io_desc_cache_cleanup()

RZ_API void rz_io_desc_cache_cleanup

(

RzIODesc *

desc

)

Definition at line 343 of file p_cache.c.

                                                     {
    if (desc && desc->cache) {
        ht_up_foreach(desc->cache, __desc_cache_cleanup_cb, desc);
    }
}

References __desc_cache_cleanup_cb(), and desc.

Referenced by rz_io_desc_exchange(), and rz_io_desc_resize().

rz_io_desc_cache_commit()

RZ_API bool rz_io_desc_cache_commit

(

RzIODesc *

desc

)

Definition at line 302 of file p_cache.c.

                                                    {
    RzIODesc *current;
    if (!desc || !(desc->perm & RZ_PERM_W) || !desc->io || !desc->io->files || !desc->io->p_cache) {
        return false;
    }
    if (!desc->cache) {
        return true;
    }
    current = desc->io->desc;
    desc->io->desc = desc;
    desc->io->p_cache = false;
    ht_up_foreach(desc->cache, __desc_cache_commit_cb, desc);
    ht_up_free(desc->cache);
    desc->cache = NULL;
    desc->io->p_cache = true;
    desc->io->desc = current;
    return true;
}

References __desc_cache_commit_cb(), desc, NULL, and RZ_PERM_W.

Referenced by rz_write_pcache_commit_handler().

rz_io_desc_cache_fini()

RZ_API void rz_io_desc_cache_fini

(

RzIODesc *

desc

)

Definition at line 358 of file p_cache.c.

                                                  {
    __desc_fini_cb(NULL, (void *)desc, 0);
}

References __desc_fini_cb(), desc, and NULL.

Referenced by rz_io_desc_free().

rz_io_desc_cache_fini_all()

RZ_API void rz_io_desc_cache_fini_all

(

RzIO *

io

)

Definition at line 362 of file p_cache.c.

                                                {
    if (io && io->files) {
        rz_id_storage_foreach(io->files, __desc_fini_cb, NULL);
    }
}

References __desc_fini_cb(), rz_io_t::files, NULL, and rz_id_storage_foreach().

Referenced by cb_iopcache(), cb_iopcacheread(), cb_iopcachewrite(), and rz_io_fini().

rz_io_desc_cache_init()

RZ_API bool rz_io_desc_cache_init

(

RzIODesc *

desc

)

Definition at line 79 of file p_cache.c.

                                                  {
    if (!desc || desc->cache) {
        return false;
    }
    return (desc->cache = ht_up_new(NULL, pcache_kv_free, NULL)) ? true : false;
}

References desc, NULL, pcache_kv_free(), and true.

Referenced by rz_io_desc_cache_write().

rz_io_desc_cache_list()

RZ_API RzList* rz_io_desc_cache_list

(

RzIODesc *

desc

)

Definition at line 249 of file p_cache.c.

                                                     {
    if (!desc || !desc->io || !desc->io->desc || !desc->io->p_cache || !desc->cache) {
        return NULL;
    }
    RzList *writes = rz_list_newf((RzListFree)__riocache_free);
    if (!writes) {
        return NULL;
    }
    ht_up_foreach(desc->cache, __desc_cache_list_cb, writes);
    RzIODesc *current = desc->io->desc;
    desc->io->desc = desc;
    desc->io->p_cache = false;
 
    RzIOCache *c;
    RzListIter *iter;
    rz_list_foreach (writes, iter, c) {
        const ut64 itvSize = rz_itv_size(c->itv);
        c->odata = calloc(1, itvSize);
        if (!c->odata) {
            rz_list_free(writes);
            return NULL;
        }
        rz_io_pread_at(desc->io, rz_itv_begin(c->itv), c->odata, itvSize);
    }
    desc->io->p_cache = true;
    desc->io->desc = current;
    return writes;
}

References __desc_cache_list_cb(), __riocache_free(), c, calloc(), desc, NULL, rz_io_pread_at(), rz_itv_begin(), rz_itv_size(), rz_list_free(), rz_list_newf(), and ut64().

Referenced by rz_core_io_pcache_print().

rz_io_desc_cache_read()

RZ_API int rz_io_desc_cache_read	(	RzIODesc *	desc,
		ut64	paddr,
		ut8 *	buf,
		int	len
	)

Definition at line 142 of file p_cache.c.

                                                                                {
    RzIODescCache *cache;
    ut8 *ptr = buf;
    ut64 caddr, desc_sz = rz_io_desc_size(desc);
    int cbaddr, amount = 0;
    if ((len < 1) || !desc || (desc_sz <= paddr) || !desc->io || !desc->cache) {
        return 0;
    }
    if (len > desc_sz) {
        len = (int)desc_sz;
    }
    if (paddr > (desc_sz - len)) {
        len = (int)(desc_sz - paddr);
    }
    caddr = paddr / RZ_IO_DESC_CACHE_SIZE;
    cbaddr = paddr % RZ_IO_DESC_CACHE_SIZE;
    while (amount < len) {
        // get an existing desc-cache, if it exists
        if (!(cache = (RzIODescCache *)ht_up_find(desc->cache, caddr, NULL))) {
            amount += (RZ_IO_DESC_CACHE_SIZE - cbaddr);
            ptr += (RZ_IO_DESC_CACHE_SIZE - cbaddr);
            goto beach;
        }
        if ((len - amount) > (RZ_IO_DESC_CACHE_SIZE - cbaddr)) {
            amount += (RZ_IO_DESC_CACHE_SIZE - cbaddr);
            for (; cbaddr < RZ_IO_DESC_CACHE_SIZE; cbaddr++) {
                if (cache->cached & (0x1ULL << cbaddr)) {
                    *ptr = cache->cdata[cbaddr];
                }
                ptr++;
            }
        } else {
            do {
                if (cache->cached & (0x1ULL << cbaddr)) {
                    *ptr = cache->cdata[cbaddr];
                }
                ptr++;
                amount++;
                cbaddr++;
            } while (len > amount);
        }
    beach:
        caddr++;
        cbaddr = 0;
    }
    return amount;
}

References rz_io_desc_cache_t::cached, rz_io_desc_cache_t::cdata, desc, int, len, NULL, RZ_IO_DESC_CACHE_SIZE, rz_io_desc_size(), and ut64().

Referenced by rz_io_desc_read().

rz_io_desc_cache_write()

RZ_API int rz_io_desc_cache_write	(	RzIODesc *	desc,
		ut64	paddr,
		const ut8 *	buf,
		int	len
	)

Definition at line 86 of file p_cache.c.

                                                                                       {
    RzIODescCache *cache;
    ut64 caddr, desc_sz = rz_io_desc_size(desc);
    int cbaddr, written = 0;
    if ((len < 1) || !desc || (desc_sz <= paddr) ||
        !desc->io || (!desc->cache && !rz_io_desc_cache_init(desc))) {
        return 0;
    }
    if (len > desc_sz) {
        len = (int)desc_sz;
    }
    if (paddr > (desc_sz - len)) {
        len = (int)(desc_sz - paddr);
    }
    caddr = paddr / RZ_IO_DESC_CACHE_SIZE;
    cbaddr = paddr % RZ_IO_DESC_CACHE_SIZE;
    while (written < len) {
        // get an existing desc-cache, if it exists
        if (!(cache = (RzIODescCache *)ht_up_find(desc->cache, caddr, NULL))) {
            // create new desc-cache
            cache = RZ_NEW0(RzIODescCache);
            if (!cache) {
                return 0;
            }
            // feed ht with the new desc-cache
            ht_up_insert(desc->cache, caddr, cache);
        }
        // check if the remaining data fits into the cache
        if ((len - written) > (RZ_IO_DESC_CACHE_SIZE - cbaddr)) {
            written += (RZ_IO_DESC_CACHE_SIZE - cbaddr);
            // this can be optimized
            for (; cbaddr < RZ_IO_DESC_CACHE_SIZE; cbaddr++) {
                // write to cache
                cache->cdata[cbaddr] = *buf;
                // save, that its cached
                cache->cached |= (0x1ULL << cbaddr);
                buf++;
            }
        } else {
            // XXX this looks like very suspicious
            do {
                cache->cdata[cbaddr] = *buf;
                cache->cached |= (0x1ULL << cbaddr);
                buf++;
                written++;
                cbaddr++;
            } while (len > written);
        }
        caddr++;
        cbaddr = 0;
    }
    RzEventIOWrite iow = { paddr, buf, len };
    rz_event_send(desc->io->event, RZ_EVENT_IO_WRITE, &iow);
    return written;
}

References rz_io_desc_cache_t::cached, rz_io_desc_cache_t::cdata, desc, int, len, NULL, RZ_EVENT_IO_WRITE, rz_event_send(), rz_io_desc_cache_init(), RZ_IO_DESC_CACHE_SIZE, rz_io_desc_size(), RZ_NEW0, and ut64().

Referenced by rz_io_desc_write().

Variable Documentation

cleanup_masks

const ut64 cleanup_masks[]

Definition at line 9 of file p_cache.c.

Referenced by __desc_cache_cleanup_cb().