buf_sparse.c File Reference

#include <rz_util.h>

Go to the source code of this file.

Classes
struct	sparse_init_config_t
struct	buf_sparse_priv

Typedefs
typedef struct sparse_init_config_t	SparseInitConfig
typedef struct buf_sparse_priv	SparsePriv

Functions
static void	chunk_fini (void *a, void *user)
static bool	sparse_limits (SparsePriv *priv, ut64 *max)
static int	chunk_cmp (ut64 addr, void *a)
static size_t	chunk_index_in (SparsePriv *priv, ut64 addr)
static st64	sparse_write (SparsePriv *priv, ut64 addr, const ut8 *data, ut64 len)
static struct buf_sparse_priv *	get_priv_sparse (RzBuffer *b)
static bool	buf_sparse_init (RzBuffer *b, const void *user)
static bool	buf_sparse_fini (RzBuffer *b)
static bool	buf_sparse_resize (RzBuffer *b, ut64 newsize)
static ut64	buf_sparse_size (RzBuffer *b)
static st64	buf_sparse_read (RzBuffer *b, ut8 *buf, ut64 len)
static st64	buf_sparse_write (RzBuffer *b, const ut8 *buf, ut64 len)
static st64	buf_sparse_seek (RzBuffer *b, st64 addr, int whence)
RZ_API const RzBufferSparseChunk *	rz_buf_sparse_get_chunks (RzBuffer *b, RZ_NONNULL size_t *count)
	Only for sparse RzBuffers, get all sparse data chunks currently populated. More...
RZ_API void	rz_buf_sparse_set_write_mode (RzBuffer *b, RzBufferSparseWriteMode mode)
	Only for sparse RzBuffers. More...
RZ_API bool	rz_buf_sparse_populated_in (RzBuffer *b, ut64 from, ut64 to)

Variables
static const RzBufferMethods	buffer_sparse_methods

Typedef Documentation

SparseInitConfig

typedef struct sparse_init_config_t SparseInitConfig

SparsePriv

typedef struct buf_sparse_priv SparsePriv

Function Documentation

buf_sparse_fini()

static bool buf_sparse_fini ( RzBuffer *  b )

static

Definition at line 144 of file buf_sparse.c.

                                         {
    struct buf_sparse_priv *priv = get_priv_sparse(b);
    rz_vector_fini(&priv->chunks);
    rz_buf_free(priv->base);
    RZ_FREE(b->priv);
    return true;
}

References b, buf_sparse_priv::base, buf_sparse_priv::chunks, get_priv_sparse(), rz_buf_free(), RZ_FREE, and rz_vector_fini().

buf_sparse_init()

static bool buf_sparse_init ( RzBuffer *  b, const void *  user  )

static

Definition at line 123 of file buf_sparse.c.

                                                           {
    SparsePriv *priv = RZ_NEW0(struct buf_sparse_priv);
    if (!priv) {
        return false;
    }
    if (user) {
        SparseInitConfig *cfg = (void *)user;
        priv->base = cfg->base;
        if (priv->base) {
            rz_buf_ref(priv->base);
        }
        priv->write_mode = cfg->write_mode;
    } else {
        priv->write_mode = RZ_BUF_SPARSE_WRITE_MODE_SPARSE;
    }
    rz_vector_init(&priv->chunks, sizeof(RzBufferSparseChunk), chunk_fini, NULL);
    priv->offset = 0;
    b->priv = priv;
    return true;
}

References b, sparse_init_config_t::base, buf_sparse_priv::base, chunk_fini(), buf_sparse_priv::chunks, NULL, buf_sparse_priv::offset, rz_buf_ref(), RZ_BUF_SPARSE_WRITE_MODE_SPARSE, RZ_NEW0, rz_vector_init(), sparse_init_config_t::write_mode, and buf_sparse_priv::write_mode.

buf_sparse_read()

static st64 buf_sparse_read ( RzBuffer *  b, ut8 *  buf, ut64  len  )

static

Definition at line 202 of file buf_sparse.c.

                                                             {
    if (!len) {
        return 0;
    }
    SparsePriv *priv = get_priv_sparse(b);
    ut64 max = priv->offset + len - 1;
    if (max < priv->offset) {
        max = UT64_MAX;
        len = max - priv->offset + 1;
    }
    // first inside-chunk is special because we might start inside of it
    size_t r = 0;
    size_t i = chunk_index_in(priv, priv->offset);
    if (i) {
        RzBufferSparseChunk *c = rz_vector_index_ptr(&priv->chunks, i - 1);
        if (priv->offset <= c->to) {
            ut64 to = RZ_MIN(c->to, max);
            ut64 rsz = to - priv->offset + 1;
            memcpy(buf, c->data + (priv->offset - c->from), rsz);
            priv->offset += rsz;
            buf += rsz;
            r += rsz;
        }
    }
    // non-chunk/chunk alternating
    while (priv->offset <= max) {
        // in each iteration, write one part like [0xff, 0xff, 0xff][some chunk]
        ut64 empty_to = max; // inclusive offset to which to fill with 0xff
        ut64 next_off = empty_to + 1; // offset to start at in the next iteration
        if (i < rz_vector_len(&priv->chunks)) {
            RzBufferSparseChunk *c = rz_vector_index_ptr(&priv->chunks, i);
            if (c->from <= empty_to) {
                next_off = RZ_MIN(c->to + 1, next_off);
                empty_to = c->from - 1;
                memcpy(buf + empty_to - priv->offset + 1, c->data, next_off - empty_to - 1);
                r += next_off - priv->offset;
            }
            i++;
        }
        if (empty_to >= priv->offset) {
            // fill non-chunk part with 0xff or base file
            if (priv->base) {
                rz_buf_read_at(priv->base, priv->offset, buf, empty_to - priv->offset + 1);
            } else {
                memset(buf, b->Oxff_priv, empty_to - priv->offset + 1);
            }
        }
        buf += next_off - priv->offset;
        priv->offset = next_off;
    }
    return priv->base ? len : r; // if there is a base file, read always fills the entire buffer (to keep the 0xff of the base)
}

References b, buf_sparse_priv::base, c, chunk_index_in(), buf_sparse_priv::chunks, get_priv_sparse(), i, len, max, memcpy(), memset(), buf_sparse_priv::offset, r, rz_buf_read_at(), RZ_MIN, rz_vector_index_ptr(), rz_vector_len(), to, ut64(), and UT64_MAX.

buf_sparse_resize()

static bool buf_sparse_resize ( RzBuffer *  b, ut64  newsize  )

static

Definition at line 152 of file buf_sparse.c.

                                                         {
    SparsePriv *priv = get_priv_sparse(b);
    size_t n;
    rz_vector_lower_bound(&priv->chunks, newsize, n, chunk_cmp);
    // now n == index of the first chunk to be thrown away entirely
    if (n < rz_vector_len(&priv->chunks)) {
        // remove all excessive chunks if shrinking
        for (size_t i = n; i < rz_vector_len(&priv->chunks); i++) {
            chunk_fini(rz_vector_index_ptr(&priv->chunks, i), NULL);
        }
        rz_vector_remove_range(&priv->chunks, n, rz_vector_len(&priv->chunks) - n, NULL);
    }
    // now n == rz_vector_len(&priv->chunks)
    bool must_extend = false; // whether we must add another artificial chunk to reach exactly the size
    if (n) {
        RzBufferSparseChunk *c = rz_vector_index_ptr(&priv->chunks, n - 1);
        if (newsize <= c->to) {
            // must chop the now-last block
            assert(newsize); // newsize > 0 is guaranteed when n > 0, otherwise the lower bound above would have returned 0.
            c->to = newsize - 1;
            ut8 *tmp = realloc(c->data, c->to - c->from + 1);
            if (tmp) {
                c->data = tmp;
            }
        } else {
            must_extend = newsize && c->to < newsize - 1;
        }
    } else {
        must_extend = !!newsize;
    }
    if (must_extend) {
        // if necessary, add a byte to reach exactly the desired size
        return !!sparse_write(priv, newsize - 1, &b->Oxff_priv, 1);
    }
    return true;
}

References assert(), b, c, chunk_cmp(), chunk_fini(), buf_sparse_priv::chunks, get_priv_sparse(), i, n, NULL, realloc(), rz_vector_index_ptr(), rz_vector_len(), rz_vector_lower_bound, rz_vector_remove_range(), sparse_write(), autogen_x86imm::tmp, and to.

buf_sparse_seek()

static st64 buf_sparse_seek ( RzBuffer *  b, st64  addr, int  whence  )

static

Definition at line 275 of file buf_sparse.c.

                                                                {
    struct buf_sparse_priv *priv = get_priv_sparse(b);
    ut64 max;
    if (addr < 0 && (-addr) > (st64)priv->offset) {
        return -1;
    }
 
    switch (whence) {
    case RZ_BUF_CUR:
        priv->offset += addr;
        break;
    case RZ_BUF_SET:
        priv->offset = addr;
        break;
    case RZ_BUF_END:
        if (!sparse_limits(priv, &max)) {
            max = 0;
        }
        priv->offset = max + addr;
        break;
    default:
        rz_warn_if_reached();
        return -1;
    }
    return priv->offset;
}

References addr, b, get_priv_sparse(), max, buf_sparse_priv::offset, RZ_BUF_CUR, RZ_BUF_END, RZ_BUF_SET, rz_warn_if_reached, sparse_limits(), st64, and ut64().

buf_sparse_size()

static ut64 buf_sparse_size ( RzBuffer *  b )

static

Definition at line 189 of file buf_sparse.c.

                                         {
    SparsePriv *priv = get_priv_sparse(b);
    ut64 max;
    ut64 r = sparse_limits(priv, &max) ? max : 0;
    if (priv->base) {
        ut64 base_sz = rz_buf_size(priv->base);
        if (base_sz > r) {
            r = base_sz;
        }
    }
    return r;
}

References b, buf_sparse_priv::base, get_priv_sparse(), max, r, rz_buf_size(), sparse_limits(), and ut64().

buf_sparse_write()

static st64 buf_sparse_write ( RzBuffer *  b, const ut8 *  buf, ut64  len  )

static

Definition at line 255 of file buf_sparse.c.

                                                                    {
    SparsePriv *priv = get_priv_sparse(b);
    st64 r = -1;
    switch (priv->write_mode) {
    case RZ_BUF_SPARSE_WRITE_MODE_SPARSE:
        r = sparse_write(priv, priv->offset, buf, len);
        break;
    case RZ_BUF_SPARSE_WRITE_MODE_THROUGH:
        if (!priv->base) {
            break;
        }
        r = rz_buf_write_at(priv->base, priv->offset, buf, len);
        break;
    }
    if (r >= 0) {
        priv->offset += r;
    }
    return r;
}

References b, buf_sparse_priv::base, get_priv_sparse(), len, buf_sparse_priv::offset, r, RZ_BUF_SPARSE_WRITE_MODE_SPARSE, RZ_BUF_SPARSE_WRITE_MODE_THROUGH, rz_buf_write_at(), sparse_write(), st64, and buf_sparse_priv::write_mode.

chunk_cmp()

static int chunk_cmp ( ut64  addr, void *  a  )

static

Definition at line 33 of file buf_sparse.c.

                                         {
    RzBufferSparseChunk *c = a;
    return RZ_NUM_CMP(addr, c->from);
}

References a, addr, c, and RZ_NUM_CMP.

Referenced by buf_sparse_resize(), and chunk_index_in().

chunk_fini()

static void chunk_fini ( void *  a, void *  user  )

static

Definition at line 19 of file buf_sparse.c.

                                            {
    RzBufferSparseChunk *s = (RzBufferSparseChunk *)a;
    free(s->data);
}

References a, free(), and s.

Referenced by buf_sparse_init(), buf_sparse_resize(), and sparse_write().

chunk_index_in()

static size_t chunk_index_in ( SparsePriv *  priv, ut64  addr  )

static

Returns

index of the chunk AFTER the one that might contain the addr (so 0 means there is none)

Definition at line 41 of file buf_sparse.c.

                                                          {
    size_t i;
    rz_vector_upper_bound(&priv->chunks, addr, i, chunk_cmp);
    return i;
}

References addr, chunk_cmp(), buf_sparse_priv::chunks, i, and rz_vector_upper_bound.

Referenced by buf_sparse_read(), rz_buf_sparse_populated_in(), and sparse_write().

get_priv_sparse()

static struct buf_sparse_priv* get_priv_sparse ( RzBuffer *  b )

inlinestatic

Definition at line 117 of file buf_sparse.c.

                                                                   {
    struct buf_sparse_priv *priv = (struct buf_sparse_priv *)b->priv;
    rz_warn_if_fail(priv);
    return priv;
}

References b, and rz_warn_if_fail.

Referenced by buf_sparse_fini(), buf_sparse_read(), buf_sparse_resize(), buf_sparse_seek(), buf_sparse_size(), buf_sparse_write(), rz_buf_sparse_get_chunks(), rz_buf_sparse_populated_in(), and rz_buf_sparse_set_write_mode().

rz_buf_sparse_get_chunks()

RZ_API const RzBufferSparseChunk* rz_buf_sparse_get_chunks	(	RzBuffer *	b,
		RZ_NONNULL size_t *	count
	)

Only for sparse RzBuffers, get all sparse data chunks currently populated.

Definition at line 313 of file buf_sparse.c.

                                                                                                  {
    rz_return_val_if_fail(b && count, NULL);
    if (b->methods != &buffer_sparse_methods) {
        *count = 0;
        return NULL;
    }
    SparsePriv *priv = get_priv_sparse(b);
    *count = rz_vector_len(&priv->chunks);
    return rz_vector_index_ptr(&priv->chunks, 0);
}

References b, buffer_sparse_methods, buf_sparse_priv::chunks, count, get_priv_sparse(), NULL, rz_return_val_if_fail, rz_vector_index_ptr(), and rz_vector_len().

Referenced by __write(), and ihex_write().

rz_buf_sparse_populated_in()

RZ_API bool rz_buf_sparse_populated_in	(	RzBuffer *	b,
		ut64	from,
		ut64	to
	)

Parameters

from	inclusive
to	inclusive

Returns

whether the given interval contains chunks populated in the sparse buffer

Definition at line 339 of file buf_sparse.c.

                                                                        {
    rz_return_val_if_fail(b, false);
    if (b->methods != &buffer_sparse_methods) {
        return false;
    }
    SparsePriv *priv = get_priv_sparse(b);
    size_t from_i = chunk_index_in(priv, from);
    if (from_i) {
        RzBufferSparseChunk *c = rz_vector_index_ptr(&priv->chunks, from_i - 1);
        if (from <= c->to) {
            return true;
        }
    }
    size_t to_i = chunk_index_in(priv, to);
    return to_i > from_i;
}

References b, buffer_sparse_methods, c, chunk_index_in(), buf_sparse_priv::chunks, from, get_priv_sparse(), rz_return_val_if_fail, rz_vector_index_ptr(), and to.

Referenced by rz_bin_relocs_patch_maps().

rz_buf_sparse_set_write_mode()

RZ_API void rz_buf_sparse_set_write_mode	(	RzBuffer *	b,
		RzBufferSparseWriteMode	mode
	)

Only for sparse RzBuffers.

Definition at line 325 of file buf_sparse.c.

                                                                                    {
    rz_return_if_fail(b);
    if (b->methods != &buffer_sparse_methods) {
        return;
    }
    SparsePriv *priv = get_priv_sparse(b);
    priv->write_mode = mode;
}

References b, buffer_sparse_methods, get_priv_sparse(), rz_return_if_fail, and buf_sparse_priv::write_mode.

Referenced by bflt_patch_relocs(), patch_relocs(), and rz_coff_get_patched_buf().

sparse_limits()

static bool sparse_limits ( SparsePriv *  priv, ut64 *  max  )

static

Definition at line 24 of file buf_sparse.c.

                                                       {
    if (rz_vector_empty(&priv->chunks)) {
        return false;
    }
    RzBufferSparseChunk *c = rz_vector_index_ptr(&priv->chunks, rz_vector_len(&priv->chunks) - 1);
    *max = c->to + 1;
    return true;
}

References c, buf_sparse_priv::chunks, max, rz_vector_empty(), rz_vector_index_ptr(), and rz_vector_len().

Referenced by buf_sparse_seek(), and buf_sparse_size().

sparse_write()

static st64 sparse_write ( SparsePriv *  priv, ut64  addr, const ut8 *  data, ut64  len  )

static

Returns

-1 if failed; # of bytes copied if success

Definition at line 50 of file buf_sparse.c.

                                                                                 {
    if (!len) {
        return -1;
    }
    if (addr + len < addr) {
        // clamp to UT64_MAX (inclusive)
        len = 0 - addr;
    }
    size_t in_start_index = chunk_index_in(priv, addr);
    size_t in_end_index = chunk_index_in(priv, addr + len < addr ? UT64_MAX : addr + len);
    RzBufferSparseChunk *c = NULL; // the chunk where we will write into
    if (in_start_index) {
        // if we start writing inside an existing chunk, use it.
        c = rz_vector_index_ptr(&priv->chunks, in_start_index - 1);
        if (addr > c->to) {
            // already after it
            c = NULL;
        } else {
            // inside of it, our start index is the index of this chunk
            in_start_index--;
        }
    }
    if (!c) {
        c = rz_vector_insert(&priv->chunks, in_start_index, NULL);
        if (in_end_index) {
            // adjust after insertion
            in_end_index++;
        }
        c->from = addr;
        c->to = c->from;
        c->data = NULL;
    }
    // (re)alloc buffer and fill with appropriate data
    ut64 newto = addr + len - 1;
    RzBufferSparseChunk *in_end_chunk = NULL;
    if (in_end_index) {
        in_end_chunk = rz_vector_index_ptr(&priv->chunks, in_end_index - 1);
        if (in_end_chunk->to > newto) {
            newto = in_end_chunk->to;
        } else {
            // completely swallowed this chunk, nothing to copy
            in_end_chunk = NULL;
        }
    }
    ut8 *newbuf = realloc(c->data, newto - c->from + 1);
    if (!newbuf) {
        return -1;
    }
    c->data = newbuf;
    c->to = newto;
    memcpy(c->data + (addr - c->from), data, len);
    if (in_end_chunk && in_end_chunk != c) {
        memcpy(c->data + (addr - c->from) + len,
            in_end_chunk->data + (addr + len - in_end_chunk->from),
            in_end_chunk->to - (addr + len) + 1);
    }
    // remove all chunks that are now overlapped and overwritten
    if (in_end_index && in_start_index < in_end_index - 1) {
        // remove_range does not free by design
        for (size_t i = in_start_index + 1; i <= in_end_index - 1; i++) {
            chunk_fini(rz_vector_index_ptr(&priv->chunks, i), NULL);
        }
        rz_vector_remove_range(&priv->chunks, in_start_index + 1, in_end_index - (in_start_index + 1), NULL);
    }
    return len;
}

References addr, c, chunk_fini(), chunk_index_in(), buf_sparse_priv::chunks, rz_buf_sparse_chunk_t::data, rz_buf_sparse_chunk_t::from, i, len, memcpy(), NULL, realloc(), rz_vector_index_ptr(), rz_vector_insert(), rz_vector_remove_range(), rz_buf_sparse_chunk_t::to, ut64(), and UT64_MAX.

Referenced by buf_sparse_resize(), and buf_sparse_write().

Variable Documentation

buffer_sparse_methods

const RzBufferMethods buffer_sparse_methods

static

Initial value:

= {
    .init = buf_sparse_init,
    .fini = buf_sparse_fini,
    .read = buf_sparse_read,
    .write = buf_sparse_write,
    .get_size = buf_sparse_size,
    .resize = buf_sparse_resize,
    .seek = buf_sparse_seek
}

Definition at line 302 of file buf_sparse.c.

Referenced by new_buffer(), rz_buf_sparse_get_chunks(), rz_buf_sparse_populated_in(), and rz_buf_sparse_set_write_mode().