malloc-trace.c

/* malloc-trace.c
 *
 * by Wolfram Gloger 1995.
 *
 * $Id$
 * Copyright (C) 2002-2007, The Perl Foundation.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/time.h>
#ifdef __linux__
#  include <signal.h>
#  include <asm/signal.h>
#endif

#include "malloc-trace.h"

#define ACTION_BUF_SIZE 1024
#define TIMESTAMP_FREQ  50
#define LOG_NAME "/tmp/mtrace"

static void malloc_trace_destructor(void);

static ACTION buffer[ACTION_BUF_SIZE+1];
static int buffer_i = 0;
static int fd = -1;
static int tracing = 1;
static int pid = 0;
static char *initial_brk = 0;

static void
open_log_file()
{
    char name[128];
    const unsigned version = MTRACE_VERSION;
#ifdef __linux__
    char cmdline[128], *s;
    int count, fd2;
#endif

    tracing = 0;
    pid = getpid();
#ifdef __linux__
    sprintf(name, "/proc/%d/cmdline", pid);
    fd2 = open(name, O_RDONLY);
    if (fd2>=0 && (count = read(fd2, cmdline, 127)) > 0) {
        close(fd2);
        cmdline[count] = 0;
        for (s=cmdline; *s++;); s--;
        while (--s>cmdline && *s!='/');
        if (*s == '/') s++;
        sprintf(name, LOG_NAME ".%.12s.%d", s, pid);
    }
        else {
        sprintf(name, LOG_NAME ".%d", pid);
    }
#else
    sprintf(name, LOG_NAME ".%d", pid);
#endif
    fd = open(name, O_WRONLY|O_CREAT, 0600);
    if (fd >= 0) {
        write(fd, &version, sizeof (version));
        write(fd, &initial_brk, sizeof (initial_brk));
    }
    tracing = 1;
}

static void
malloc_trace_destructor(void)
{
    struct timeval t;

    /* produce final timestamp */
    gettimeofday(&t, NULL);
    buffer[buffer_i].code = CODE_TIMESTAMP;
    buffer[buffer_i].size = t.tv_sec;
    buffer[buffer_i].ptr = (void *)t.tv_usec;
    buffer[buffer_i].ptr2 = NULL;
    buffer_i++;
    if (fd < 0) open_log_file();
    if (getpid() != pid) { /* Oops, must have forked... */
        if (fd >= 0) close(fd);
        return;
    }
    if (fd >= 0) write(fd, buffer, buffer_i*sizeof (ACTION));
    write(2, "<end malloc trace>\n", 19);
    if (fd >= 0) close(fd);
}

#ifdef __linux__

static void
malloc_segv_handler(int i, struct sigcontext_struct sc)
{
    tracing = 0;
    fprintf(stderr, "malloc-trace: caught SEGV signal.\n");
    fprintf(stderr, "sc.cr2 = %8lx\n", (unsigned long)sc.cr2);
    malloc_trace_destructor();
}

#endif

static void
malloc_record(int code, size_t size, void *ptr, void *ptr2)
{
    static long count = 0;
    struct timeval t;

    if (!tracing) return;
#ifdef __linux__
    if (count == 0) signal(SIGSEGV, (void (*)(int))malloc_segv_handler);
#endif
    if ((count++ % TIMESTAMP_FREQ) == 0) {
        gettimeofday(&t, NULL);
        buffer[buffer_i].code = CODE_TIMESTAMP;
        buffer[buffer_i].size = t.tv_sec;
        buffer[buffer_i].ptr = (void *)t.tv_usec;
        buffer[buffer_i].ptr2 = NULL;
        buffer_i++;
    }
    buffer[buffer_i].code = code;
    buffer[buffer_i].size = size;
    buffer[buffer_i].ptr = ptr;
    buffer[buffer_i].ptr2 = ptr2;
    if (++buffer_i >= ACTION_BUF_SIZE) {
        if (fd < 0) open_log_file();
        if (getpid() != pid) { /* Oops, must have forked... */
            tracing = 0;
            return;
        }
        if (fd >= 0) write(fd, buffer, buffer_i*sizeof (ACTION));
        buffer_i = 0;
    }
}

void* _real_malloc(size_t bytes);
void* malloc(size_t bytes)
{
    void *ptr;

    if (initial_brk == 0) { /* Must be the first time. */
        initial_brk = sbrk(0);
        atexit(malloc_trace_destructor);
    }
    ptr = _real_malloc(bytes);
    malloc_record(CODE_MALLOC, bytes, ptr, 0);
    return ptr;
}
#define malloc _real_malloc

void _real_free(void* mem);
void free(void* mem)
{
    malloc_record(CODE_FREE, 0, mem, 0);
    _real_free(mem);
}
#define free _real_free

void* _real_realloc(void* mem, size_t bytes);
void* realloc(void* mem, size_t bytes)
{
    void *ptr;

    ptr = _real_realloc(mem, bytes);
    malloc_record(CODE_REALLOC, bytes, mem, ptr);
    return ptr;
}
#define realloc _real_realloc

void* _real_memalign(size_t alignment, size_t bytes);
void* memalign(size_t alignment, size_t bytes)
{
    void *ptr;

    if (initial_brk == 0) { /* Must be the first time. */
        initial_brk = sbrk(0);
        atexit(malloc_trace_destructor);
    }
    ptr = _real_memalign(alignment, bytes);
    malloc_record(CODE_MEMALIGN, bytes, ptr, (void*)alignment);
    return ptr;
}
#define memalign _real_memalign

void* _real_calloc(size_t n, size_t elem_size);
void* calloc(size_t n, size_t elem_size)
{
    void *ptr;

    if (initial_brk == 0) { /* Must be the first time. */
        initial_brk = sbrk(0);
        atexit(malloc_trace_destructor);
    }
    ptr = _real_calloc(n, elem_size);
    malloc_record(CODE_CALLOC, n*elem_size, ptr, 0);
    return ptr;
}
#define calloc _real_calloc

void _real_cfree(void *mem);
void cfree(void *mem)
{
    malloc_record(CODE_CFREE, 0, mem, 0);
    _real_cfree(mem);
}
#define cfree _real_cfree

#include "malloc.c"

/*
 * Local variables:
 *   c-file-style: "parrot"
 * End:
 * vim: expandtab shiftwidth=4:
 */