io_map.c File Reference

#include <rz_io.h>
#include <stdlib.h>
#include <sdb.h>
#include "rz_util.h"
#include "rz_vector.h"

Go to the source code of this file.

Macros
#define	END_OF_MAP_IDS   UT32_MAX

Functions
void	io_map_calculate_skyline (RzIO *io)
RzIOMap *	io_map_new (RzIO *io, int fd, int perm, ut64 delta, ut64 addr, ut64 size)
RZ_API RzIOMap *	rz_io_map_new (RzIO *io, int fd, int perm, ut64 delta, ut64 addr, ut64 size)
RZ_API bool	rz_io_map_remap (RzIO *io, ut32 id, ut64 addr)
RZ_API bool	rz_io_map_remap_fd (RzIO *io, int fd, ut64 addr)
static void	map_free (void *p)
	Free-only. Be careful to only call this after sending RZ_EVENT_IO_MAP_DEL! (map_del does this) More...
static void	map_del (RzIO *io, RzIOMap *map)
	Free the map, also sending the appropriate event. More...
RZ_API void	rz_io_map_init (RzIO *io)
RZ_API bool	rz_io_map_exists (RzIO *io, RzIOMap *map)
RZ_API bool	rz_io_map_exists_for_id (RzIO *io, ut32 id)
RZ_API RzIOMap *	rz_io_map_resolve (RzIO *io, ut32 id)
RzIOMap *	io_map_add (RzIO *io, int fd, int perm, ut64 delta, ut64 addr, ut64 size)
RZ_API RzIOMap *	rz_io_map_add (RzIO *io, int fd, int perm, ut64 delta, ut64 addr, ut64 size)
RZ_API RzIOMap *	rz_io_map_add_batch (RzIO *io, int fd, int perm, ut64 delta, ut64 addr, ut64 size)
RZ_API void	rz_io_update (RzIO *io)
RZ_API RzIOMap *	rz_io_map_get_paddr (RzIO *io, ut64 paddr)
RZ_API RzIOMap *	rz_io_map_get (RzIO *io, ut64 addr)
RZ_API bool	rz_io_map_is_mapped (RzIO *io, ut64 addr)
RZ_API void	rz_io_map_reset (RzIO *io)
RZ_API bool	rz_io_map_del (RzIO *io, ut32 id)
RZ_API bool	rz_io_map_del_for_fd (RzIO *io, int fd)
RZ_API bool	rz_io_map_priorize (RzIO *io, ut32 id)
RZ_API bool	rz_io_map_depriorize (RzIO *io, ut32 id)
RZ_API bool	rz_io_map_priorize_for_fd (RzIO *io, int fd)
RZ_API void	rz_io_map_cleanup (RzIO *io)
RZ_API void	rz_io_map_fini (RzIO *io)
RZ_API void	rz_io_map_set_name (RzIOMap *map, const char *name)
RZ_API void	rz_io_map_del_name (RzIOMap *map)
RZ_API ut64	rz_io_map_next_available (RzIO *io, ut64 addr, ut64 size, ut64 load_align)
RZ_API ut64	rz_io_map_next_address (RzIO *io, ut64 addr)
RZ_API RzList *	rz_io_map_get_for_fd (RzIO *io, int fd)
RZ_API bool	rz_io_map_resize (RzIO *io, ut32 id, ut64 newsize)
RZ_API ut64	rz_io_map_location (RzIO *io, ut64 size)
	Returns a memory location that can hold enough bytes without overlapping. More...
RZ_API RZ_BORROW RzPVector *	rz_io_maps (RzIO *io)
	Returns the pointer to vector containing maps list. More...

Macro Definition Documentation

END_OF_MAP_IDS

#define END_OF_MAP_IDS   UT32_MAX

Definition at line 11 of file io_map.c.

Function Documentation

io_map_add()

RzIOMap* io_map_add	(	RzIO *	io,
		int	fd,
		int	perm,
		ut64	delta,
		ut64	addr,
		ut64	size
	)

Definition at line 140 of file io_map.c.

                                                                                  {
    // check if desc exists
    RzIODesc *desc = rz_io_desc_get(io, fd);
    if (desc) {
        // a map cannot have higher permissions than the desc belonging to it
        return io_map_new(io, fd, (perm & desc->perm) | (perm & RZ_PERM_X),
            delta, addr, size);
    }
    return NULL;
}

References addr, delta, desc, fd, io_map_new(), NULL, rz_io_desc_get(), and RZ_PERM_X.

Referenced by rz_io_map_add(), and rz_io_map_add_batch().

io_map_calculate_skyline()

void io_map_calculate_skyline

(

RzIO *

io

)

Definition at line 14 of file io_map.c.

                                        {
    rz_skyline_clear(&io->map_skyline);
    // Last map has highest priority (it shadows previous maps)
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = (RzIOMap *)*it;
        rz_skyline_add(&io->map_skyline, map->itv, map);
    }
}

References map(), rz_io_t::map_skyline, rz_io_t::maps, rz_pvector_foreach, rz_skyline_add(), and rz_skyline_clear().

Referenced by rz_io_map_cleanup(), rz_io_map_del(), rz_io_map_del_for_fd(), rz_io_map_depriorize(), rz_io_map_priorize_for_fd(), rz_io_map_remap(), rz_io_map_reset(), rz_io_map_resize(), and rz_io_update().

io_map_new()

RzIOMap* io_map_new	(	RzIO *	io,
		int	fd,
		int	perm,
		ut64	delta,
		ut64	addr,
		ut64	size
	)

XXX: this is leaking a map!!!

Definition at line 24 of file io_map.c.

                                                                                  {
    if (!io || !io->map_ids) {
        return NULL;
    }
    RzIOMap *map = RZ_NEW0(RzIOMap);
    if (!map || !io->map_ids || !rz_id_pool_grab_id(io->map_ids, &map->id)) {
        free(map);
        return NULL;
    }
    map->fd = fd;
    map->delta = delta;
    if (size && (UT64_MAX - size + 1) < addr) {
        io_map_new(io, fd, perm, delta - addr, 0LL, size + addr);
        size = -(st64)addr;
    }
    // RzIOMap describes an interval of addresses (map->from; map->to)
    map->itv = (RzInterval){ addr, size };
    map->perm = perm;
    map->delta = delta;
    // new map lives on the top, being top the list's tail
    rz_pvector_push(&io->maps, map);
    rz_skyline_add(&io->map_skyline, map->itv, map);
    return map;
}

References addr, delta, fd, free(), map(), rz_io_t::map_ids, rz_io_t::map_skyline, rz_io_t::maps, NULL, rz_id_pool_grab_id(), RZ_NEW0, rz_pvector_push(), rz_skyline_add(), st64, and UT64_MAX.

Referenced by io_map_add(), rz_io_map_new(), and rz_io_open_at().

map_del()

static void map_del ( RzIO *  io, RzIOMap *  map  )

static

Free the map, also sending the appropriate event.

Definition at line 93 of file io_map.c.

                                            {
    rz_return_if_fail(io && map);
    RzEventIOMapDel ev = { map };
    rz_event_send(io->event, RZ_EVENT_IO_MAP_DEL, &ev);
    rz_id_pool_kick_id(io->map_ids, map->id);
    map_free(map);
}

References rz_io_t::event, map(), map_free(), rz_io_t::map_ids, RZ_EVENT_IO_MAP_DEL, rz_event_send(), rz_id_pool_kick_id(), and rz_return_if_fail.

Referenced by rz_io_map_cleanup(), rz_io_map_del(), and rz_io_map_del_for_fd().

map_free()

static void map_free ( void *  p )

static

Free-only. Be careful to only call this after sending RZ_EVENT_IO_MAP_DEL! (map_del does this)

Definition at line 84 of file io_map.c.

                              {
    RzIOMap *map = (RzIOMap *)p;
    if (map) {
        free(map->name);
        free(map);
    }
}

References free(), map(), and p.

Referenced by map_del(), and rz_io_map_init().

rz_io_map_add()

RZ_API RzIOMap* rz_io_map_add	(	RzIO *	io,
		int	fd,
		int	perm,
		ut64	delta,
		ut64	addr,
		ut64	size
	)

Definition at line 151 of file io_map.c.

                                                                                            {
    return io_map_add(io, fd, perm, delta, addr, size);
}

References addr, delta, fd, and io_map_add().

Referenced by ds_init(), rz_core_analysis_esil_init_mem(), rz_core_serve(), rz_io_bind(), rz_open_maps_all_fd_handler(), rz_open_maps_map_fd_handler(), and rz_open_maps_map_handler().

rz_io_map_add_batch()

RZ_API RzIOMap* rz_io_map_add_batch	(	RzIO *	io,
		int	fd,
		int	perm,
		ut64	delta,
		ut64	addr,
		ut64	size
	)

Definition at line 155 of file io_map.c.

                                                                                                  {
    return io_map_add(io, fd, perm, delta, addr, size);
}

References addr, delta, fd, and io_map_add().

Referenced by add_map(), and io_create_mem_map().

rz_io_map_cleanup()

RZ_API void rz_io_map_cleanup

(

RzIO *

io

)

Definition at line 287 of file io_map.c.

                                        {
    rz_return_if_fail(io);
    // remove all maps if no descs exist
    if (!io->files) {
        rz_io_map_fini(io);
        rz_io_map_init(io);
        return;
    }
    bool del = false;
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps);) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        if (!map) {
            // remove iter if the map is a null-ptr, this may fix some segfaults. This should never happen.
            rz_warn_if_reached();
            rz_pvector_remove_at(&io->maps, i);
            del = true;
        } else if (!rz_io_desc_get(io, map->fd)) {
            // delete map and iter if no desc exists for map->fd in io->files
            map = rz_pvector_remove_at(&io->maps, i);
            map_del(io, map);
            del = true;
        } else {
            i++;
        }
    }
    if (del) {
        io_map_calculate_skyline(io);
    }
}

References del(), rz_io_t::files, i, io_map_calculate_skyline(), map(), map_del(), rz_io_t::maps, rz_io_desc_get(), rz_io_map_fini(), rz_io_map_init(), rz_pvector_at(), rz_pvector_len(), rz_pvector_remove_at(), rz_return_if_fail, and rz_warn_if_reached.

Referenced by rz_io_desc_close(), rz_io_desc_del(), and rz_io_map_priorize_for_fd().

rz_io_map_del()

RZ_API bool rz_io_map_del	(	RzIO *	io,
		ut32	id
	)

Definition at line 192 of file io_map.c.

                                             {
    rz_return_val_if_fail(io, false);
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps); i++) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        if (map->id == id) {
            rz_pvector_remove_at(&io->maps, i);
            map_del(io, map);
            io_map_calculate_skyline(io);
            return true;
        }
    }
    return false;
}

References i, io_map_calculate_skyline(), map(), map_del(), rz_io_t::maps, rz_pvector_at(), rz_pvector_len(), rz_pvector_remove_at(), and rz_return_val_if_fail.

Referenced by rz_core_file_close(), rz_debug_dmp_init(), and rz_open_maps_remove_handler().

rz_io_map_del_for_fd()

RZ_API bool rz_io_map_del_for_fd	(	RzIO *	io,
		int	fd
	)

Definition at line 208 of file io_map.c.

                                                   {
    rz_return_val_if_fail(io, false);
    bool ret = false;
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps);) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        if (!map) {
            rz_pvector_remove_at(&io->maps, i);
        } else if (map->fd == fd) {
            rz_pvector_remove_at(&io->maps, i);
            map_del(io, map);
            ret = true;
        } else {
            i++;
        }
    }
    if (ret) {
        io_map_calculate_skyline(io);
    }
    return ret;
}

References fd, i, io_map_calculate_skyline(), map(), map_del(), rz_io_t::maps, rz_pvector_at(), rz_pvector_len(), rz_pvector_remove_at(), and rz_return_val_if_fail.

rz_io_map_del_name()

RZ_API void rz_io_map_del_name

(

RzIOMap *

map

)

Definition at line 340 of file io_map.c.

                                             {
    if (map) {
        RZ_FREE(map->name);
    }
}

References map(), and RZ_FREE.

Referenced by rz_open_maps_name_del_handler(), and rz_open_maps_name_id_del_handler().

rz_io_map_depriorize()

RZ_API bool rz_io_map_depriorize	(	RzIO *	io,
		ut32	id
	)

Definition at line 248 of file io_map.c.

                                                    {
    rz_return_val_if_fail(io, false);
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps); i++) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        // search for iter with the correct map
        if (map->id == id) {
            rz_pvector_remove_at(&io->maps, i);
            rz_pvector_push_front(&io->maps, map);
            io_map_calculate_skyline(io);
            return true;
        }
    }
    return false;
}

References i, io_map_calculate_skyline(), map(), rz_io_t::maps, rz_pvector_at(), rz_pvector_len(), rz_pvector_push_front(), rz_pvector_remove_at(), and rz_return_val_if_fail.

Referenced by rz_open_maps_deprioritize_handler().

rz_io_map_exists()

RZ_API bool rz_io_map_exists	(	RzIO *	io,
		RzIOMap *	map
	)

Definition at line 111 of file io_map.c.

                                                     {
    rz_return_val_if_fail(io && map, false);
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *m = *it;
        if (!memcmp(m, map, sizeof(RzIOMap))) {
            return true;
        }
    }
    return false;
}

References regress::m, map(), rz_io_t::maps, rz_pvector_foreach, and rz_return_val_if_fail.

rz_io_map_exists_for_id()

RZ_API bool rz_io_map_exists_for_id	(	RzIO *	io,
		ut32	id
	)

Definition at line 124 of file io_map.c.

                                                       {
    return rz_io_map_resolve(io, id) != NULL;
}

References NULL, and rz_io_map_resolve().

Referenced by rz_open_maps_deprioritize_handler(), and rz_open_maps_prioritize_handler().

rz_io_map_fini()

RZ_API void rz_io_map_fini

(

RzIO *

io

)

Definition at line 318 of file io_map.c.

                                     {
    rz_return_if_fail(io);
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        RzEventIOMapDel ev = { map };
        rz_event_send(io->event, RZ_EVENT_IO_MAP_DEL, &ev);
    }
    rz_pvector_clear(&io->maps);
    rz_id_pool_free(io->map_ids);
    io->map_ids = NULL;
    rz_skyline_clear(&io->map_skyline);
}

References rz_io_t::event, map(), rz_io_t::map_ids, rz_io_t::map_skyline, rz_io_t::maps, NULL, RZ_EVENT_IO_MAP_DEL, rz_event_send(), rz_id_pool_free(), rz_pvector_clear(), rz_pvector_foreach, rz_return_if_fail, and rz_skyline_clear().

Referenced by rz_io_fini(), rz_io_map_cleanup(), and rz_io_map_reset().

rz_io_map_get()

RZ_API RzIOMap* rz_io_map_get	(	RzIO *	io,
		ut64	addr
	)

Definition at line 176 of file io_map.c.

                                                   {
    rz_return_val_if_fail(io, NULL);
    return rz_skyline_get(&io->map_skyline, addr);
}

References addr, rz_io_t::map_skyline, NULL, rz_return_val_if_fail, and rz_skyline_get().

Referenced by __core_analysis_fcn(), __core_visual_gogo(), canWrite(), cmd_print_blocks(), flagbar_foreach(), get_esil_stack_name(), isValidAddress(), meta_for_reloc(), num_callback(), open_maps_list(), print_cmd_analysis_after_traps_print(), rz_analysis_try_get_fcn(), rz_cmd_debug_continue_mapped_io_handler(), rz_core_analysis_get_stats(), rz_core_extend_at(), rz_core_get_boundaries_prot(), rz_core_visual_title(), rz_debug_dmp_init(), rz_io_addr_is_mapped(), rz_io_bind(), rz_io_is_valid_offset(), rz_io_map_is_mapped(), rz_io_v2p(), rz_open_maps_flags_handler(), rz_open_maps_list_cur_handler(), rz_open_maps_name_del_handler(), rz_open_maps_name_handler(), rz_open_maps_relocate_current_handler(), rz_open_show_current_handler(), rz_seek_begin_handler(), and rz_seek_end_handler().

rz_io_map_get_for_fd()

RZ_API RzList* rz_io_map_get_for_fd	(	RzIO *	io,
		int	fd
	)

Definition at line 388 of file io_map.c.

                                                        {
    RzList *map_list = rz_list_newf(NULL);
    if (!map_list) {
        return NULL;
    }
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        if (map && map->fd == fd) {
            rz_list_append(map_list, map);
        }
    }
    return map_list;
}

References fd, map(), rz_io_t::maps, NULL, rz_list_append(), rz_list_newf(), and rz_pvector_foreach.

Referenced by DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), rz_core_cmd_foreach3(), rz_core_raw_file_print(), rz_io_bind(), rz_io_map_remap_fd(), and rz_io_resize().

rz_io_map_get_paddr()

RZ_API RzIOMap* rz_io_map_get_paddr	(	RzIO *	io,
		ut64	paddr
	)

Definition at line 163 of file io_map.c.

                                                          {
    rz_return_val_if_fail(io, NULL);
    void **it;
    rz_pvector_foreach_prev(&io->maps, it) {
        RzIOMap *map = *it;
        if (map->delta <= paddr && paddr <= map->delta + (map->itv.size ? map->itv.size - 1 : 0)) {
            return map;
        }
    }
    return NULL;
}

References delta, map(), rz_io_t::maps, NULL, rz_pvector_foreach_prev, and rz_return_val_if_fail.

Referenced by rz_core_pava(), rz_io_bind(), and rz_io_p2v().

rz_io_map_init()

RZ_API void rz_io_map_init

(

RzIO *

io

)

Definition at line 101 of file io_map.c.

                                     {
    rz_return_if_fail(io);
    rz_pvector_init(&io->maps, map_free);
    if (io->map_ids) {
        rz_id_pool_free(io->map_ids);
    }
    io->map_ids = rz_id_pool_new(1, END_OF_MAP_IDS);
}

References END_OF_MAP_IDS, map_free(), rz_io_t::map_ids, rz_io_t::maps, rz_id_pool_free(), rz_id_pool_new(), rz_pvector_init(), and rz_return_if_fail.

Referenced by rz_io_init(), rz_io_map_cleanup(), and rz_io_map_reset().

rz_io_map_is_mapped()

RZ_API bool rz_io_map_is_mapped	(	RzIO *	io,
		ut64	addr
	)

Definition at line 181 of file io_map.c.

                                                     {
    rz_return_val_if_fail(io, false);
    return (bool)rz_io_map_get(io, addr);
}

References addr, rz_io_map_get(), and rz_return_val_if_fail.

Referenced by bp_is_mapped().

rz_io_map_location()

RZ_API ut64 rz_io_map_location	(	RzIO *	io,
		ut64	size
	)

Returns a memory location that can hold enough bytes without overlapping.

Parameters

io	RzIO instance
size	Size of the section

Definition at line 425 of file io_map.c.

                                                    {
    ut64 base = (io->bits == 64) ? 0x60000000000ULL : 0x60000000ULL;
    return rz_io_map_next_available(io, base, size, 0x200000);
}

References rz_io_t::bits, rz_io_map_next_available(), and ut64().

Referenced by rz_core_bin_load().

rz_io_map_new()

RZ_API RzIOMap* rz_io_map_new	(	RzIO *	io,
		int	fd,
		int	perm,
		ut64	delta,
		ut64	addr,
		ut64	size
	)

Definition at line 50 of file io_map.c.

                                                                                            {
    return io_map_new(io, fd, perm, delta, addr, size);
}

References addr, delta, fd, and io_map_new().

Referenced by handle_tmp_desc(), perform_mapped_file_yank(), rz_core_bin_load(), rz_core_cmd_subst_i(), rz_debug_dmp_init(), rz_io_map_remap(), rz_io_map_resize(), rz_io_open(), rz_io_open_at(), and rz_main_rizin().

rz_io_map_next_address()

RZ_API ut64 rz_io_map_next_address	(	RzIO *	io,
		ut64	addr
	)

Definition at line 371 of file io_map.c.

                                                        {
    ut64 lowest = UT64_MAX;
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        ut64 from = rz_itv_begin(map->itv);
        if (from > addr && addr < lowest) {
            lowest = from;
        }
        ut64 to = rz_itv_end(map->itv);
        if (to > addr && to < lowest) {
            lowest = to;
        }
    }
    return lowest;
}

References addr, from, map(), rz_io_t::maps, rz_itv_begin(), rz_itv_end(), rz_pvector_foreach, to, ut64(), and UT64_MAX.

Referenced by rz_core_search_value_in_range().

rz_io_map_next_available()

RZ_API ut64 rz_io_map_next_available	(	RzIO *	io,
		ut64	addr,
		ut64	size,
		ut64	load_align
	)

Definition at line 347 of file io_map.c.

                                                                                      {
    if (load_align == 0) {
        load_align = 1;
    }
    void **it;
    ut64 next_addr = addr,
         end_addr = next_addr + size;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        if (!rz_itv_size(map->itv)) {
            break;
        }
        ut64 to = rz_itv_end(map->itv);
        next_addr = RZ_MAX(next_addr, to + (load_align - (to % load_align)) % load_align);
        if ((map->itv.addr <= next_addr && next_addr < to) || rz_itv_contain(map->itv, end_addr)) {
            next_addr = to + (load_align - (to % load_align)) % load_align;
            continue;
        }
        break;
    }
    return next_addr;
}

References addr, map(), rz_io_t::maps, rz_itv_contain(), rz_itv_end(), rz_itv_size(), RZ_MAX, rz_pvector_foreach, to, and ut64().

Referenced by get_esil_stack_name(), perform_mapped_file_yank(), and rz_io_map_location().

rz_io_map_priorize()

RZ_API bool rz_io_map_priorize	(	RzIO *	io,
		ut32	id
	)

Definition at line 232 of file io_map.c.

                                                  {
    rz_return_val_if_fail(io, false);
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps); i++) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        // search for iter with the correct map
        if (map->id == id) {
            rz_pvector_remove_at(&io->maps, i);
            rz_pvector_push(&io->maps, map);
            rz_skyline_add(&io->map_skyline, map->itv, map);
            return true;
        }
    }
    return false;
}

References i, map(), rz_io_t::map_skyline, rz_io_t::maps, rz_pvector_at(), rz_pvector_len(), rz_pvector_push(), rz_pvector_remove_at(), rz_return_val_if_fail, and rz_skyline_add().

Referenced by rz_open_maps_prioritize_binid_handler(), and rz_open_maps_prioritize_handler().

rz_io_map_priorize_for_fd()

RZ_API bool rz_io_map_priorize_for_fd	(	RzIO *	io,
		int	fd
	)

Definition at line 264 of file io_map.c.

                                                        {
    rz_return_val_if_fail(io, false);
    // we need a clean list for this, or this becomes a segfault-field
    rz_io_map_cleanup(io);
    RzPVector temp;
    rz_pvector_init(&temp, NULL);
    size_t i;
    for (i = 0; i < rz_pvector_len(&io->maps);) {
        RzIOMap *map = rz_pvector_at(&io->maps, i);
        if (map->fd == fd) {
            rz_pvector_push(&temp, map);
            rz_pvector_remove_at(&io->maps, i);
            continue;
        }
        i++;
    }
    rz_pvector_insert_range(&io->maps, rz_pvector_len(&io->maps), temp.v.a, rz_pvector_len(&temp));
    rz_pvector_clear(&temp);
    io_map_calculate_skyline(io);
    return true;
}

References rz_vector_t::a, fd, i, io_map_calculate_skyline(), map(), rz_io_t::maps, NULL, rz_io_map_cleanup(), rz_pvector_at(), rz_pvector_clear(), rz_pvector_init(), rz_pvector_insert_range(), rz_pvector_len(), rz_pvector_push(), rz_pvector_remove_at(), rz_return_val_if_fail, and rz_pvector_t::v.

Referenced by rz_open_maps_prioritize_fd_handler().

rz_io_map_remap()

RZ_API bool rz_io_map_remap	(	RzIO *	io,
		ut32	id,
		ut64	addr
	)

Definition at line 54 of file io_map.c.

                                                          {
    RzIOMap *map = rz_io_map_resolve(io, id);
    if (map) {
        ut64 size = map->itv.size;
        map->itv.addr = addr;
        if (size && UT64_MAX - size + 1 < addr) {
            map->itv.size = -addr;
            rz_io_map_new(io, map->fd, map->perm, map->delta - addr, 0, size + addr);
        }
        io_map_calculate_skyline(io);
        return true;
    }
    return false;
}

References addr, io_map_calculate_skyline(), map(), rz_io_map_new(), rz_io_map_resolve(), ut64(), and UT64_MAX.

Referenced by rz_debug_dmp_init(), rz_io_map_remap_fd(), rz_open_maps_relocate_current_handler(), and rz_open_maps_relocate_handler().

rz_io_map_remap_fd()

RZ_API bool rz_io_map_remap_fd	(	RzIO *	io,
		int	fd,
		ut64	addr
	)

Definition at line 69 of file io_map.c.

                                                            {
    RzIOMap *map;
    bool retval = false;
    RzList *maps = rz_io_map_get_for_fd(io, fd);
    if (maps) {
        map = rz_list_get_n(maps, 0);
        if (map) {
            retval = rz_io_map_remap(io, map->id, addr);
        }
        rz_list_free(maps);
    }
    return retval;
}

References addr, fd, map(), maps(), rz_io_map_get_for_fd(), rz_io_map_remap(), rz_list_free(), and rz_list_get_n().

Referenced by rz_io_bind().

rz_io_map_reset()

RZ_API void rz_io_map_reset

(

RzIO *

io

)

Definition at line 186 of file io_map.c.

                                      {
    rz_io_map_fini(io);
    rz_io_map_init(io);
    io_map_calculate_skyline(io);
}

References io_map_calculate_skyline(), rz_io_map_fini(), and rz_io_map_init().

Referenced by rz_io_close_all(), and rz_open_maps_remove_all_handler().

rz_io_map_resize()

RZ_API bool rz_io_map_resize	(	RzIO *	io,
		ut32	id,
		ut64	newsize
	)

Definition at line 403 of file io_map.c.

                                                              {
    RzIOMap *map;
    if (!(map = rz_io_map_resolve(io, id))) {
        return false;
    }
    ut64 addr = map->itv.addr;
    if (newsize && UT64_MAX - newsize + 1 < addr) {
        map->itv.size = -addr;
        rz_io_map_new(io, map->fd, map->perm, map->delta - addr, 0, newsize + addr);
        return true;
    }
    map->itv.size = newsize;
    io_map_calculate_skyline(io);
    return true;
}

References addr, io_map_calculate_skyline(), map(), rz_io_map_new(), rz_io_map_resolve(), ut64(), and UT64_MAX.

Referenced by rz_io_resize(), and rz_open_maps_resize_handler().

rz_io_map_resolve()

RZ_API RzIOMap* rz_io_map_resolve	(	RzIO *	io,
		ut32	id
	)

Definition at line 128 of file io_map.c.

                                                     {
    rz_return_val_if_fail(io && id, false);
    void **it;
    rz_pvector_foreach (&io->maps, it) {
        RzIOMap *map = *it;
        if (map->id == id) {
            return map;
        }
    }
    return NULL;
}

References map(), rz_io_t::maps, NULL, rz_pvector_foreach, and rz_return_val_if_fail.

Referenced by rz_io_map_exists_for_id(), rz_io_map_remap(), rz_io_map_resize(), rz_open_maps_flags_handler(), rz_open_maps_name_id_del_handler(), and rz_open_maps_name_id_handler().

rz_io_map_set_name()

RZ_API void rz_io_map_set_name	(	RzIOMap *	map,
		const char *	name
	)

Definition at line 332 of file io_map.c.

                                                               {
    if (!map || !name) {
        return;
    }
    free(map->name);
    map->name = strdup(name);
}

References free(), map(), and strdup().

Referenced by ds_init(), rz_core_analysis_esil_init_mem(), rz_open_maps_all_fd_handler(), rz_open_maps_map_fd_handler(), rz_open_maps_map_handler(), rz_open_maps_name_handler(), and rz_open_maps_name_id_handler().

rz_io_maps()

RZ_API RZ_BORROW RzPVector* rz_io_maps

(

RzIO *

io

)

Returns the pointer to vector containing maps list.

Parameters

io	RzIO instance

Definition at line 435 of file io_map.c.

                                                 {
    rz_return_val_if_fail(io, NULL);
    return &io->maps;
}

References rz_io_t::maps, NULL, and rz_return_val_if_fail.

Referenced by __core_visual_gogo(), get_brks(), open_maps_list(), rz_core_analysis_address(), rz_core_analysis_code_count(), rz_core_analysis_coverage_count(), rz_core_get_boundaries_prot(), rz_core_io_file_reopen(), rz_core_visual_cmd(), rz_heap_resolve_main_arena(), rz_main_rizin(), rz_open_maps_flags_global_handler(), and rz_open_maps_list_ascii_handler().

rz_io_update()

RZ_API void rz_io_update

(

RzIO *

io

)

Definition at line 159 of file io_map.c.

                                   {
    io_map_calculate_skyline(io);
}

References io_map_calculate_skyline().