runtime/dyninst/map_runtime.h - systemtap

Data types defined

Functions defined

Macros defined

Source code

/* -*- linux-c -*-
* Map Runtime Functions
* Copyright (C) 2012 Red Hat Inc.
*
* This file is part of systemtap, and is free software.  You can
* redistribute it and/or modify it under the terms of the GNU General
* Public License (GPL); either version 2, or (at your option) any
* later version.
*/

#ifndef _STAPDYN_MAP_RUNTIME_H_
‌#define _STAPDYN_MAP_RUNTIME_H_

#include <pthread.h>

#ifdef NEED_MAP_LOCKS
‌#define MAP_LOCK(m)    pthread_mutex_lock(&(m)->lock)
‌#define MAP_UNLOCK(m)    pthread_mutex_unlock(&(m)->lock)
#else
‌#define MAP_LOCK(sd)    do {} while (0)
‌#define MAP_UNLOCK(sd)    do {} while (0)
#endif

/* Note that pthread_mutex_trylock()'s return value is opposite of the
* kernel's spin_trylock(), so we invert the return value of
* pthread_mutex_trylock(). */
‌#define MAP_TRYLOCK(m)    (!pthread_mutex_trylock(&(m)->lock))

‌#define MAP_GET_CPU()    STAT_GET_CPU()
‌#define MAP_PUT_CPU()    STAT_PUT_CPU()

‌static int _stp_map_initialize_lock(MAP m)
{
#ifdef NEED_MAP_LOCKS
    int rc;

    if ((rc = stp_pthread_mutex_init_shared(&m->lock)) != 0) {
        _stp_error("Couldn't initialize map mutex: %d\n", rc);
        return rc;
    }
#endif
    return 0;
}

‌static void _stp_map_destroy_lock(MAP m)
{
#ifdef NEED_MAP_LOCKS
    (void)pthread_mutex_destroy(&m->lock);
#endif
}

‌struct pmap {
    offptr_t oagg;    /* aggregation map */
    offptr_t omap[];  /* per-cpu maps */
};

‌static inline MAP _stp_pmap_get_agg(PMAP p)
{
    return offptr_get(&p->oagg);
}

‌static inline void _stp_pmap_set_agg(PMAP p, MAP agg)
{
    offptr_set(&p->oagg, agg);
}

‌static inline MAP _stp_pmap_get_map(PMAP p, unsigned cpu)
{
    if (cpu >= _stp_runtime_num_contexts)
        cpu = 0;
    return offptr_get(&p->omap[cpu]);
}

‌static inline void _stp_pmap_set_map(PMAP p, MAP m, unsigned cpu)
{
    if (cpu >= _stp_runtime_num_contexts)
        cpu = 0;
    offptr_set(&p->omap[cpu], m);
}

‌static void __stp_map_del(MAP map)
{
    if (map == NULL)
        return;

    /* The lock is the only thing to clean up.  */
    _stp_map_destroy_lock(map);
}

/** Deletes a map.
* Deletes a map, freeing all memory in all elements.
* Normally done only when the module exits.
* @param map
*/

‌static void _stp_map_del(MAP map)
{
    if (map == NULL)
        return;

    __stp_map_del(map);
    _stp_shm_free(map);
}

‌static void _stp_pmap_del(PMAP pmap)
{
    int i;

    if (pmap == NULL)
        return;

    /* The pmap is one giant allocation, so do only
     * the basic cleanup for each map.  */
    for_each_possible_cpu(i)
        __stp_map_del(_stp_pmap_get_map (pmap, i));
    __stp_map_del(_stp_pmap_get_agg(pmap));
    _stp_shm_free(pmap);
}

static int
‌_stp_map_init(MAP m, unsigned max_entries, int wrap, int node_size)
{
    unsigned i;

    /* The node memory is allocated right after the map itself.  */
    void *node_mem = m + 1;

    INIT_MLIST_HEAD(&m->pool);
    INIT_MLIST_HEAD(&m->head);
    for (i = 0; i < HASH_TABLE_SIZE; i++)
        INIT_MHLIST_HEAD(&m->hashes[i]);

    m->maxnum = max_entries;
    m->wrap = wrap;

    for (i = 0; i < max_entries; i++) {
        struct map_node *node = node_mem + i * node_size;
        mlist_add(&node->lnode, &m->pool);
        INIT_MHLIST_NODE(&node->hnode);
    }

    if (_stp_map_initialize_lock(m) != 0)
        return -1;

    return 0;
}

/** Create a new map.
* Maps must be created at module initialization time.
* @param max_entries The maximum number of entries allowed. Currently that
* number will be preallocated.If more entries are required, the oldest ones
* will be deleted. This makes it effectively a circular buffer.
* @return A MAP on success or NULL on failure.
* @ingroup map_create
*/

static MAP
‌_stp_map_new(unsigned max_entries, int wrap, int node_size,
        int cpu __attribute((unused)))
{
    MAP m;

    /* NB: Allocate the map in one big chuck.
     * (See _stp_pmap_new for more explanation) */
    size_t map_size = sizeof(struct map_root) + node_size * max_entries;
    m = _stp_shm_zalloc(map_size);
    if (m == NULL)
        return NULL;

    if (_stp_map_init(m, max_entries, wrap, node_size)) {
        _stp_map_del(m);
        return NULL;
    }
    return m;
}

static PMAP
‌_stp_pmap_new(unsigned max_entries, int wrap, int node_size)
{
    int i;
    MAP m;
    PMAP pmap;
    void *map_mem;

    /* Allocate the pmap in one big chuck.
     *
     * The reason for this is that we're allocating in the shared memory
     * mmap, which may have to move locations in order to grow.  If some
     * smaller unit of the pmap allocation were to cause the whole thing to
     * move, then we'd lose track of the prior allocations.
     *
     * Once returned from here, we'll always access the pmap via the global
     * shared memory base.  So if other map/pmap/stat/etc. allocations
     * cause it to move later, that's ok.
     */

    size_t map_size = sizeof(struct map_root) + node_size * max_entries;

    size_t pmap_size = sizeof(struct pmap) +
        sizeof(offptr_t) * _stp_runtime_num_contexts;

    size_t total_size = pmap_size +
        map_size * (_stp_runtime_num_contexts + 1);

    map_mem = pmap = _stp_shm_zalloc(total_size);
    if (pmap == NULL)
        return NULL;
    map_mem += pmap_size;

    for_each_possible_cpu(i)
                _stp_pmap_set_map(pmap, NULL, i);
        _stp_pmap_set_agg(pmap, NULL);

    /* Initialize the per-cpu maps.  */
    for_each_possible_cpu(i) {
        m = map_mem;
        if (_stp_map_init(m, max_entries, wrap, node_size) != 0)
            goto err;
                _stp_pmap_set_map(pmap, m, i);
        map_mem += map_size;
    }

    /* Initialize the aggregate map.  */
    m = map_mem;
    if (_stp_map_init(m, max_entries, wrap, node_size) != 0)
        goto err;
        _stp_pmap_set_agg(pmap, m);

    return pmap;

err:
    _stp_pmap_del(pmap);
    return NULL;
}

#endif /* _STAPDYN_MAP_RUNTIME_H_ */