opd_image.c

Go to the documentation of this file.

#include "opd_image.h"
#include "opd_printf.h"
#include "opd_sample_files.h"
#include "opd_24_stats.h"
#include "oprofiled.h"

#include "op_file.h"
#include "op_config_24.h"
#include "op_libiberty.h"
#include "op_string.h"

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

/* maintained for statistics purpose only */
static int nr_images;

/* list of images */
#define OPD_IMAGE_HASH_SIZE 2048
static struct list_head opd_images[OPD_IMAGE_HASH_SIZE];


void opd_init_images(void)
{
    int i;
    for (i = 0; i < OPD_IMAGE_HASH_SIZE; ++i)
        list_init(&opd_images[i]);
}


int opd_get_nr_images(void)
{
    return nr_images;
}


void opd_delete_image(struct opd_image * image)
{
    verbprintf(vmisc, "Deleting image: name %s app_name %s, kernel %d, "
               "tid %d, tgid %d ref count %u\n",
               image->name, image->app_name, image->kernel,
               image->tid, image->tgid, (int)image->ref_count);

    if (image->ref_count <= 0) {
        printf("image->ref_count < 0 for image: name %s app_name %s, "
               "kernel %d, tid %d, tgid %d ref count %u\n",
               image->name, image->app_name, image->kernel,
               image->tid, image->tgid, image->ref_count);
        abort();
    }

    if (--image->ref_count != 0)
        return;

    if (image->name)
        free(image->name);
    if (image->app_name)
        free(image->app_name);
    list_del(&image->hash_next);
    opd_close_image_samples_files(image);
    free(image);

    nr_images--;
}


void opd_for_each_image(opd_image_cb image_cb)
{
    struct list_head * pos;
    struct list_head * pos2;
    int i;

    for (i = 0; i < OPD_IMAGE_HASH_SIZE; ++i) {
        list_for_each_safe(pos, pos2, &opd_images[i]) {
            struct opd_image * image =
                list_entry(pos, struct opd_image, hash_next);
            image_cb(image);
        }
    }
}
 

static size_t opd_hash_image(char const * name, pid_t tid, pid_t tgid)
{
    size_t hash = op_hash_string(name);
    if (separate_thread)
        hash += tid + tgid;
    return  hash % OPD_IMAGE_HASH_SIZE;
}


static struct opd_image *
opd_new_image(char const * name, char const * app_name, int kernel,
              pid_t tid, pid_t tgid)
{
    size_t hash_image;
    struct opd_image * image;

    verbprintf(vmisc, "Creating image: %s %s, kernel %d, tid %d, "
               "tgid %d\n", name, app_name, kernel, tid, tgid);

    image = xmalloc(sizeof(struct opd_image));

    list_init(&image->hash_next);
    image->name = xstrdup(name);
    image->kernel = kernel;
    image->tid = tid;
    image->tgid = tgid;
    image->ref_count = 0;
    image->app_name = app_name ? xstrdup(app_name) : NULL;
    image->mtime = op_get_mtime(image->name);

    image->ignored = 1;
    if (separate_lib && app_name)
        image->ignored = is_image_ignored(app_name);
    if (image->ignored)
        image->ignored = is_image_ignored(name);

    memset(image->sfiles, '\0', NR_CPUS * sizeof(struct opd_24_sfile **));

    hash_image = opd_hash_image(name, tid, tgid);
    list_add(&image->hash_next, &opd_images[hash_image]);

    nr_images++;

    return image;
}


static int is_same_image(struct opd_image const * image, char const * app_name,
                         pid_t tid, pid_t tgid)
{
    /* correctness is really important here, if we fail to recognize
     * identical image we will open/mmap multiple time the same samples
     * files which is not supported by the kernel, strange assertion
     * failure in libfd is a typical symptom of that */

    if (separate_thread) {
        if (image->tid != tid || image->tgid != tgid)
            return 1;
    }

    /* if !separate_lib, the comparison made by caller is enough */
    if (!separate_lib)
        return 0;

    if (image->app_name == NULL && app_name == NULL)
        return 0;

    if (image->app_name != NULL && app_name != NULL &&
        !strcmp(image->app_name, app_name))
        return 0;

    /* /proc parsed image come with a non null app_name but notification
     * for application itself come with a null app_name, in this case
     * the test above fail so check for this case. */
    if (image->app_name && !app_name && !strcmp(image->app_name, image->name))
        return 0;

    return 1;
}


static struct opd_image * opd_find_image(char const * name, 
                                char const * app_name, pid_t tid, pid_t tgid)
{
    /* suppress uninitialized use warning */
    struct opd_image * image = 0;
    struct list_head * pos;
    size_t bucket;

    opd_24_stats[OPD_IMAGE_HASH_ACCESS]++;
    bucket = opd_hash_image(name, tid, tgid);
    list_for_each(pos, &opd_images[bucket]) {
        opd_24_stats[OPD_IMAGE_HASH_DEPTH]++;
        image = list_entry(pos, struct opd_image, hash_next);

        if (!strcmp(image->name, name)) {
            if (!is_same_image(image, app_name, tid, tgid))
                break;
        }
    }

    if (pos == &opd_images[bucket])
        return NULL;

    /* The app_name field is always valid */
    return image;
}

 
struct opd_image * opd_get_image(char const * name, char const * app_name,
                                 int kernel, pid_t tid, pid_t tgid)
{
    struct opd_image * image;
    if ((image = opd_find_image(name, app_name, tid, tgid)) == NULL)
        image = opd_new_image(name, app_name, kernel, tid, tgid);

    return image;
}


struct opd_image * opd_get_kernel_image(char const * name,
                               char const * app_name, pid_t tid, pid_t tgid)
{
    return opd_get_image(name, app_name, 1, tid, tgid);
}