linux_heap_jemalloc.c File Reference

#include "linux_heap_jemalloc.c"

Go to the source code of this file.

Macros
#define	INCLUDE_HEAP_JEMALLOC_STD_C
#define	HEAP32   1
#define	GH(x)   x##_64
#define	GHT   ut64
#define	GHT_MAX   UT64_MAX
#define	PFMTx   PFMT64x
#define	OO(x)   (ut64)(arena + rz_offsetof(arena_t, x))

Functions
static bool GH()	rz_resolve_jemalloc (RzCore *core, char *symname, ut64 *symbol)
static void GH()	jemalloc_get_chunks (RzCore *core, const char *input)
static void GH()	jemalloc_print_narenas (RzCore *core, const char *input)
static void GH()	jemalloc_get_bins (RzCore *core, const char *input)
static int GH()	cmd_dbg_map_jemalloc (RzCore *core, const char *input)

Macro Definition Documentation

GH

#define GH

(

x

)

x##_64

Definition at line 23 of file linux_heap_jemalloc.c.

GHT

#define GHT   ut64

Definition at line 24 of file linux_heap_jemalloc.c.

GHT_MAX

#define GHT_MAX   UT64_MAX

Definition at line 25 of file linux_heap_jemalloc.c.

HEAP32

#define HEAP32   1

Definition at line 6 of file linux_heap_jemalloc.c.

INCLUDE_HEAP_JEMALLOC_STD_C

#define INCLUDE_HEAP_JEMALLOC_STD_C

Definition at line 5 of file linux_heap_jemalloc.c.

OO

#define OO

(

x

)

(ut64)(arena + rz_offsetof(arena_t, x))

PFMTx

#define PFMTx   PFMT64x

Definition at line 26 of file linux_heap_jemalloc.c.

Function Documentation

cmd_dbg_map_jemalloc()

static int GH() cmd_dbg_map_jemalloc ( RzCore *  core, const char *  input  )

static

Definition at line 494 of file linux_heap_jemalloc.c.

                                                                     {
    const char *help_msg[] = {
        "Usage:", "dmx", " # Jemalloc heap parsing commands",
        "dmxa", "[arena_t]", "show all arenas created, or print arena_t structure for given arena",
        "dmxb", "[arena_t]", "show all bins created for given arena",
        "dmxc", "*|[arena_t]", "show all chunks created in all arenas, or show all chunks created for a given arena_t instance",
        // "dmhr", "[arena_chunk_t]", "print all runs created for a given arena_chunk_t instance",
        "dmx?", "", "Show map heap help", NULL
    };
 
    switch (input[0]) {
    case '?':
        rz_core_cmd_help(core, help_msg);
        break;
    case 'a': // dmha
        GH(jemalloc_print_narenas)
        (core, input + 1);
        break;
    case 'b': // dmhb
        GH(jemalloc_get_bins)
        (core, input + 1);
        break;
    case 'c': // dmhc
        GH(jemalloc_get_chunks)
        (core, input + 1);
        break;
        /*
    case 'r': //dmhr
        GH(jemalloc_get_runs) (core, input + 1);
        break;
    */
    }
    return 0;
}

References GH, input(), jemalloc_get_bins(), jemalloc_get_chunks(), jemalloc_print_narenas(), NULL, and rz_core_cmd_help().

jemalloc_get_bins()

static void GH() jemalloc_get_bins ( RzCore *  core, const char *  input  )

static

Definition at line 324 of file linux_heap_jemalloc.c.

                                                                   {
    int i = 0, j;
    ut64 bin_info;
    ut64 arenas;
    GHT arena = GHT_MAX; //, bin = GHT_MAX;
    arena_t *ar = NULL;
    arena_bin_info_t *b = NULL;
    RzConsPrintablePalette *pal = &rz_cons_singleton()->context->pal;
 
    switch (input[0]) {
    case ' ':
        ar = RZ_NEW0(arena_t);
        if (!ar) {
            break;
        }
        b = RZ_NEW0(arena_bin_info_t);
        if (!b) {
            break;
        }
        if (!GH(rz_resolve_jemalloc)(core, "je_arena_bin_info", &bin_info)) {
            RZ_LOG_ERROR("Cannot resolve je_arena_bin_info\n");
            RZ_FREE(b);
            break;
        }
        if (GH(rz_resolve_jemalloc)(core, "je_arenas", &arenas)) {
            rz_io_read_at(core->io, arenas, (ut8 *)&arenas, sizeof(GHT));
            PRINTF_GA("arenas @ 0x%" PFMTx " {\n", (GHT)arenas);
            for (;;) {
                rz_io_read_at(core->io, arenas + i * sizeof(GHT), (ut8 *)&arena, sizeof(GHT));
                if (!arena) {
                    RZ_FREE(b);
                    break;
                }
                PRINTF_YA("   arenas[%d]: ", i++);
                PRINTF_BA("@ 0x%" PFMTx, (GHT)arena);
                PRINT_YA(" {\n");
                rz_io_read_at(core->io, arena, (ut8 *)ar, sizeof(arena_t));
                for (j = 0; j < JM_NBINS; j++) {
                    rz_io_read_at(core->io, (GHT)(bin_info + j * sizeof(arena_bin_info_t)),
                        (ut8 *)b, sizeof(arena_bin_info_t));
                    PRINT_YA("    {\n");
                    PRINT_YA("       regsize : ");
                    PRINTF_BA("0x%zx\n", b->reg_size);
                    PRINT_YA("       redzone size ");
                    PRINTF_BA("0x%zx\n", b->redzone_size);
                    PRINT_YA("       reg_interval : ");
                    PRINTF_BA("0x%zx\n", b->reg_interval);
                    PRINT_YA("       run_size : ");
                    PRINTF_BA("0x%zx\n", b->run_size);
                    PRINT_YA("       nregs : ");
                    PRINTF_BA("0x%x\n", b->nregs);
                    // FIXME: It's a structure of bitmap_info_t
                    // PRINT_YA ("       bitmap_info : ");
                    // PRINTF_BA ("0x%"PFMT64x"\n", b->bitmap_info);
                    PRINT_YA("       reg0_offset : ");
                    PRINTF_BA("0x%" PFMT64x "\n\n", (ut64)b->reg0_offset);
                    // FIXME: It's a structure of malloc_mutex_t
                    // PRINTF_YA ("       bins[%d]->lock ", j);
                    // PRINTF_BA ("= 0x%"PFMT64x"\n", ar->bins[j].lock);
                    // FIXME: It's a structure of arena_run_t*
                    // PRINTF_YA ("       bins[%d]->runcur ", j);
                    // PRINTF_BA ("@ 0x%"PFMT64x"\n", ar->bins[j].runcur);
                    // FIXME: It's a structure of arena_run_heap_t*
                    // PRINTF_YA ("       bins[%d]->runs ", j);
                    // PRINTF_BA ("@ 0x%"PFMTx"\n", ar->bins[j].runs);
                    // FIXME: It's a structure of malloc_bin_stats_t
                    // PRINTF_YA ("       bins[%d]->stats ", j);
                    // PRINTF_BA ("= 0x%"PFMTx"\n", ar->bins[j].stats);
                    PRINT_YA("    }\n");
                }
                PRINT_YA("  }\n");
            }
        }
        PRINT_GA("}\n");
        break;
    }
    free(ar);
    free(b);
}

References ar, arenas, b, rz_cons_t::context, free(), GH, GHT, GHT_MAX, i, input(), NULL, rz_cons_context_t::pal, PFMT64x, PFMTx, PRINT_GA, PRINT_YA, PRINTF_BA, PRINTF_GA, PRINTF_YA, rz_cons_singleton(), RZ_FREE, rz_io_read_at(), RZ_LOG_ERROR, RZ_NEW0, rz_resolve_jemalloc(), and ut64().

Referenced by cmd_dbg_map_jemalloc().

jemalloc_get_chunks()

static void GH() jemalloc_get_chunks ( RzCore *  core, const char *  input  )

static

Definition at line 123 of file linux_heap_jemalloc.c.

                                                                     {
    ut64 cnksz;
    RzConsPrintablePalette *pal = &rz_cons_singleton()->context->pal;
 
    if (!GH(rz_resolve_jemalloc)(core, "je_chunksize", &cnksz)) {
        RZ_LOG_ERROR("Fail at reading symbol je_chunksize\n");
        return;
    }
    rz_io_read_at(core->io, cnksz, (ut8 *)&cnksz, sizeof(GHT));
 
    switch (input[0]) {
    case '\0':
        RZ_LOG_ERROR("need an arena_t to associate chunks");
        break;
    case ' ': {
        GHT arena = GHT_MAX;
        arena_t *ar = RZ_NEW0(arena_t);
        extent_node_t *node = RZ_NEW0(extent_node_t), *head = RZ_NEW0(extent_node_t);
        input += 1;
        arena = rz_num_math(core->num, input);
 
        if (arena) {
            rz_io_read_at(core->io, arena, (ut8 *)ar, sizeof(arena_t));
            rz_io_read_at(core->io, (GHT)(size_t)ar->achunks.qlh_first, (ut8 *)head, sizeof(extent_node_t));
            if (head->en_addr) {
                PRINT_YA("   Chunk - start: ");
                PRINTF_BA("0x%08" PFMT64x, (ut64)(size_t)head->en_addr);
                PRINT_YA(", end: ");
                PRINTF_BA("0x%08" PFMT64x, (ut64)(size_t)((char *)head->en_addr + cnksz));
                PRINT_YA(", size: ");
                PRINTF_BA("0x%08" PFMT64x "\n", (ut64)cnksz);
                rz_io_read_at(core->io, (ut64)(size_t)head->ql_link.qre_next, (ut8 *)node, sizeof(extent_node_t));
                while (node && node->en_addr != head->en_addr) {
                    PRINT_YA("   Chunk - start: ");
                    PRINTF_BA("0x%08" PFMT64x, (ut64)(size_t)node->en_addr);
                    PRINT_YA(", end: ");
                    PRINTF_BA("0x%" PFMT64x, (ut64)(size_t)((char *)node->en_addr + cnksz));
                    PRINT_YA(", size: ");
                    PRINTF_BA("0x%08" PFMT64x "\n", cnksz);
                    rz_io_read_at(core->io, (ut64)(size_t)node->ql_link.qre_next, (ut8 *)node, sizeof(extent_node_t));
                }
            }
        }
        free(ar);
        free(head);
        free(node);
        break;
    }
    case '*': {
        int i = 0;
        ut64 sym;
        GHT arenas = GHT_MAX, arena = GHT_MAX;
        arena_t *ar = RZ_NEW0(arena_t);
        extent_node_t *node = RZ_NEW0(extent_node_t);
        extent_node_t *head = RZ_NEW0(extent_node_t);
 
        if (!node || !head) {
            RZ_LOG_ERROR("Failed to allocate extent_node_t\n");
            free(ar);
            free(node);
            free(head);
            return;
        }
 
        if (GH(rz_resolve_jemalloc)(core, "je_arenas", &sym)) {
            rz_io_read_at(core->io, sym, (ut8 *)&arenas, sizeof(GHT));
            for (;;) {
                rz_io_read_at(core->io, arenas + i * sizeof(GHT), (ut8 *)&arena, sizeof(GHT));
                if (!arena) {
                    break;
                }
                PRINTF_GA("arenas[%d]: @ 0x%" PFMTx " { \n", i++, (GHT)arena);
                rz_io_read_at(core->io, arena, (ut8 *)ar, sizeof(arena_t));
                rz_io_read_at(core->io, (GHT)(size_t)ar->achunks.qlh_first, (ut8 *)head, sizeof(extent_node_t));
                if (head->en_addr != 0) {
                    PRINT_YA("   Chunk - start: ");
                    PRINTF_BA("0x%08" PFMT64x, (ut64)(size_t)head->en_addr);
                    PRINT_YA(", end: ");
                    PRINTF_BA("0x%" PFMT64x, (ut64)(size_t)((char *)head->en_addr + cnksz));
                    PRINT_YA(", size: ");
                    PRINTF_BA("0x%08" PFMT64x "\n", (ut64)cnksz);
                    ut64 addr = (ut64)(size_t)head->ql_link.qre_next;
                    rz_io_read_at(core->io, addr, (ut8 *)node, sizeof(extent_node_t));
                    while (node && head && node->en_addr != head->en_addr) {
                        PRINT_YA("   Chunk - start: ");
                        PRINTF_BA("0x%08" PFMT64x, (ut64)(size_t)node->en_addr);
                        PRINT_YA(", end: ");
                        PRINTF_BA("0x%" PFMT64x, (ut64)(size_t)((char *)node->en_addr + cnksz));
                        PRINT_YA(", size: ");
                        PRINTF_BA("0x%" PFMT64x "\n", cnksz);
                        rz_io_read_at(core->io, (GHT)(size_t)node->ql_link.qre_next, (ut8 *)node, sizeof(extent_node_t));
                    }
                }
                PRINT_GA("}\n");
            }
        }
        free(ar);
        free(head);
        free(node);
    } break;
    }
}

References addr, ar, arenas, rz_cons_t::context, free(), GH, GHT, GHT_MAX, test-lz4-versions::head, i, input(), rz_cons_context_t::pal, PFMT64x, PFMTx, PRINT_GA, PRINT_YA, PRINTF_BA, PRINTF_GA, rz_cons_singleton(), rz_io_read_at(), RZ_LOG_ERROR, RZ_NEW0, rz_num_math(), rz_resolve_jemalloc(), and ut64().

Referenced by cmd_dbg_map_jemalloc().

jemalloc_print_narenas()

static void GH() jemalloc_print_narenas ( RzCore *  core, const char *  input  )

static

Definition at line 226 of file linux_heap_jemalloc.c.

                                                                        {
    ut64 symaddr;
    ut64 arenas;
    GHT arena = GHT_MAX;
    arena_t *ar = RZ_NEW0(arena_t);
    if (!ar) {
        return;
    }
    arena_stats_t *stats = RZ_NEW0(arena_stats_t);
    if (!stats) {
        free(ar);
        return;
    }
    int i = 0;
    GHT narenas = 0;
    RzConsPrintablePalette *pal = &rz_cons_singleton()->context->pal;
 
    switch (input[0]) {
    case '\0':
        if (GH(rz_resolve_jemalloc)(core, "narenas_total", &symaddr)) {
            rz_io_read_at(core->io, symaddr, (ut8 *)&narenas, sizeof(GHT));
            PRINTF_GA("narenas : %" PFMT64d "\n", (ut64)narenas);
        }
        if (narenas == 0) {
            RZ_LOG_ERROR("No arenas allocated.\n");
            free(stats);
            free(ar);
            return;
        }
        if (narenas == GHT_MAX) {
            RZ_LOG_ERROR("Cannot find narenas_total\n");
            free(stats);
            free(ar);
            return;
        }
 
        if (GH(rz_resolve_jemalloc)(core, "je_arenas", &arenas)) {
            rz_io_read_at(core->io, arenas, (ut8 *)&arenas, sizeof(GHT));
            PRINTF_GA("arenas[%" PFMT64d "] @ 0x%" PFMT64x " {\n", (ut64)narenas, (ut64)arenas);
            for (i = 0; i < narenas; i++) {
                ut64 at = arenas + (i * sizeof(GHT));
                rz_io_read_at(core->io, at, (ut8 *)&arena, sizeof(GHT));
                if (!arena) {
                    PRINTF_YA("  arenas[%d]: (empty)\n", i);
                    continue;
                }
                PRINTF_YA("  arenas[%d]: ", i);
                PRINTF_BA("@ 0x%" PFMT64x "\n", at);
            }
        }
        PRINT_GA("}\n");
        break;
    case ' ':
        arena = rz_num_math(core->num, input + 1);
        rz_io_read_at(core->io, (GHT)arena, (ut8 *)ar, sizeof(arena_t));
 
        PRINT_GA("struct arena_s {\n");
#define OO(x) (ut64)(arena + rz_offsetof(arena_t, x))
        PRINTF_BA("  ind = 0x%x\n", ar->ind);
        PRINTF_BA("  nthreads: application allocation = 0x%" PFMT64x "\n", (ut64)ar->nthreads[0]);
        PRINTF_BA("  nthreads: internal metadata allocation = 0x%" PFMT64x "\n", (ut64)ar->nthreads[1]);
        PRINTF_BA("  lock = 0x%" PFMT64x "\n", OO(lock));
        PRINTF_BA("  stats = 0x%" PFMT64x "\n", OO(stats));
        PRINTF_BA("  tcache_ql = 0x%" PFMT64x "\n", OO(tcache_ql));
        PRINTF_BA("  prof_accumbytes = 0x%" PFMT64x "x\n", (ut64)ar->prof_accumbytes);
        PRINTF_BA("  offset_state = 0x%" PFMT64x "\n", (ut64)ar->offset_state);
        PRINTF_BA("  dss_prec_t = 0x%" PFMT64x "\n", OO(dss_prec));
        PRINTF_BA("  achunks = 0x%" PFMT64x "\n", OO(achunks));
        PRINTF_BA("  extent_sn_next = 0x%" PFMT64x "\n", (ut64)(size_t)ar->extent_sn_next);
        PRINTF_BA("  spare = 0x%" PFMT64x "\n", (ut64)(size_t)ar->spare);
        PRINTF_BA("  lg_dirty_mult = 0x%" PFMT64x "\n", (ut64)(ssize_t)ar->lg_dirty_mult);
        PRINTF_BA("  purging = %s\n", rz_str_bool(ar->purging));
        PRINTF_BA("  nactive = 0x%" PFMT64x "\n", (ut64)(size_t)ar->nactive);
        PRINTF_BA("  ndirty = 0x%" PFMT64x "\n", (ut64)(size_t)ar->ndirty);
 
        PRINTF_BA("  runs_dirty = 0x%" PFMT64x "\n", OO(runs_dirty));
        PRINTF_BA("  chunks_cache = 0x%" PFMT64x "\n", OO(chunks_cache));
        PRINTF_BA("  huge = 0x%" PFMT64x "\n", OO(huge));
        PRINTF_BA("  huge_mtx = 0x%" PFMT64x "\n", OO(huge_mtx));
 
        PRINTF_BA("  chunks_szsnad_cached = 0x%" PFMT64x "\n", OO(chunks_szsnad_cached));
        PRINTF_BA("  chunks_ad_cached = 0x%" PFMT64x "\n", OO(chunks_ad_cached));
        PRINTF_BA("  chunks_szsnad_retained = 0x%" PFMT64x "\n", OO(chunks_szsnad_retained));
        PRINTF_BA("  chunks_ad_cached = 0x%" PFMT64x "\n", OO(chunks_ad_retained));
 
        PRINTF_BA("  chunks_mtx = 0x%" PFMT64x "\n", OO(chunks_mtx));
        PRINTF_BA("  node_cache = 0x%" PFMT64x "\n", OO(node_cache));
        PRINTF_BA("  node_cache_mtx = 0x%" PFMT64x "\n", OO(node_cache_mtx));
        PRINTF_BA("  chunks_hooks = 0x%" PFMT64x "\n", OO(chunk_hooks));
        PRINTF_BA("  bins = %d 0x%" PFMT64x "\n", JM_NBINS, OO(bins));
        PRINTF_BA("  runs_avail = %d 0x%" PFMT64x "\n", NPSIZES, OO(runs_avail));
        PRINT_GA("}\n");
        break;
    }
    free(ar);
    free(stats);
}

References ar, arenas, bins, rz_cons_t::context, free(), GH, GHT, GHT_MAX, i, input(), lock(), OO, rz_cons_context_t::pal, PFMT64d, PFMT64x, PRINT_GA, PRINTF_BA, PRINTF_GA, PRINTF_YA, rz_cons_singleton(), rz_io_read_at(), RZ_LOG_ERROR, RZ_NEW0, rz_num_math(), rz_resolve_jemalloc(), rz_str_bool(), and ut64().

Referenced by cmd_dbg_map_jemalloc().

rz_resolve_jemalloc()

static bool GH() rz_resolve_jemalloc ( RzCore *  core, char *  symname, ut64 *  symbol  )

static

Definition at line 67 of file linux_heap_jemalloc.c.

                                                                               {
    RzListIter *iter;
    RzDebugMap *map;
    const char *jemalloc_ver_end = NULL;
    ut64 jemalloc_addr = UT64_MAX;
 
    if (!core || !core->dbg || !core->dbg->maps) {
        return false;
    }
    rz_debug_map_sync(core->dbg);
    rz_list_foreach (core->dbg->maps, iter, map) {
        if (strstr(map->name, "libjemalloc.")) {
            jemalloc_addr = map->addr;
            jemalloc_ver_end = map->name;
            break;
        }
    }
    if (!jemalloc_ver_end) {
        RZ_LOG_WARN("Is jemalloc mapped in memory? (see dm command)\n");
        return false;
    }
#if __linux__
    bool is_debug_file = GH(je_matched)(jemalloc_ver_end, "/usr/local/lib");
 
    if (!is_debug_file) {
        RZ_LOG_WARN("Is libjemalloc.so.2 in /usr/local/lib path?\n");
        return false;
    }
    char *path = rz_str_newf("%s", jemalloc_ver_end);
    if (rz_file_exists(path)) {
        ut64 vaddr = GH(je_get_va_symbol)(core, path, symname);
        if (jemalloc_addr != GHT_MAX && vaddr != 0) {
            *symbol = jemalloc_addr + vaddr;
            free(path);
            return true;
        }
    }
    free(path);
    return false;
#else
    (void)jemalloc_addr;
    RZ_LOG_INFO("Resolving %s from libjemalloc.2... ", symname);
    // this is quite sloooow, we must optimize dmi
    char *va = rz_core_cmd_strf(core, "dmi libjemalloc.2 %s$~[1]", symname);
    ut64 n = rz_num_get(NULL, va);
    if (n && n != UT64_MAX) {
        *symbol = n;
        rz_cons_printf("0x%08" PFMT64x "\n", n);
    } else {
        rz_cons_printf("NOT FOUND\n");
    }
    free(va);
    return true;
#endif
}

References free(), GH, GHT_MAX, map(), n, NULL, path, PFMT64x, rz_cons_printf(), rz_core_cmd_strf(), rz_debug_map_sync(), rz_file_exists(), RZ_LOG_INFO, RZ_LOG_WARN, rz_num_get(), rz_str_newf(), ut64(), and UT64_MAX.

Referenced by jemalloc_get_bins(), jemalloc_get_chunks(), and jemalloc_print_narenas().