memcheck.c

memory test check for embeded linux

struct meminfo
{
   struct meminfo *next;
   struct meminfo *prev;
   void *ptr;     /* Pointer to memory returned to application.  */
   void *sentry;  /* Sentry to check for under/over runs.  */
                  /* Really a long *, but this loses with gcc -O2 on sparc.  */
   int prot;      /* Current mprotect value.  */
   int inuse;     /* Set on initial allocate, cleared on final free.  */
   size_t size;   /* In bytes.  Doesn't include meminfo page or sentry.  */
   size_t pages;  /* Includes meminfo page and realloc overflow area pages.  */
   size_t count;  /* Count of times reallocated.  */
   struct caller *realloc2; /* Pointer to overflow realloc area.  */
   struct caller alloc;
   struct caller freed;
   struct caller realloc[1];
   long sentry_reserve; /* Reserve space for the sentry to back into.  */
                        /* Only used to calculate space in the meminfo page.  */
                        /* Nothing is ever placed here.  */
};

struct memcheck_config
{
   int underruns;
   int restart;
   int reuse;
   int churn;
   int backtrace;
   int level;
   size_t large;
   size_t limit;
};

static struct memcheck_function memcheck_functions[] =
{
   { "", 0 },
   { "strdup", alloc_type },
   { "malloc", alloc_type },
   { "calloc", alloc_type },
   { "realloc", alloc_type | free_type },
   { "free", free_type },
   { "cfree", free_type },
   { "valloc", alloc_type },
   { "memalign", alloc_type },
   { "posix_memalign", alloc_type }
};

void (cfree)(void *ptr);
void *(memalign)(size_t boundary, size_t size);
int (posix_memalign)(void **memptr, size_t alignment, size_t size);

static char *memcheck_strdup_internal(const char *file,
                                      int line,
                                      const void *addr,
                                      const struct backtrace *trace,
                                      const char *str);
static void *memcheck_malloc_internal(const char *file,
                                      int line,
                                      const void *addr,
                                      const struct backtrace *trace,
                                      size_t size);
static void *memcheck_calloc_internal(const char *file,
                                      int line,
                                      const void *addr,
                                      const struct backtrace *trace,
                                      size_t n,
                                      size_t size);
static void *memcheck_realloc_internal(const char *file,
                                       int line,
                                       const void *addr,
                                       const struct backtrace *trace,
                                       void *ptr,
                                       size_t size);
static void memcheck_free_internal(const char *file,
                                   int line,
                                   const void *addr,
                                   const struct backtrace *trace,
                                   const void *ptr);
static void memcheck_cfree_internal(const char *file,
                                    int line,
                                    const void *addr,
                                    const struct backtrace *trace,
                                    const void *ptr);
static void *memcheck_valloc_internal(const char *file,
                                      int line,
                                      const void *addr,
                                      const struct backtrace *trace,
                                      size_t size);
static void *memcheck_memalign_internal(const char *file,
                                        int line,
                                        const void *addr,
                                        const struct backtrace *trace,
                                        size_t boundary,
                                        size_t size);
static int memcheck_posix_memalign_internal(const char *file,
                                            int line,
                                            const void *addr,
                                            const struct backtrace *trace,
                                            void **memptr,
                                            size_t alignment,
                                            size_t size);
static void *memcheck_allocator(const char *file,
                                int line,
                                int func,
                                const void *addr,
                                const struct backtrace *trace,
                                const void *ptr,
                                size_t nsize);
static int memcheck_check_sentry(struct meminfo *mem);
static void memcheck_place_sentry(struct meminfo *mem);
static size_t memcheck_user_pages(size_t size);
static void memcheck_setup(struct meminfo *mem, size_t pages, size_t size);
static void memcheck_delete(struct meminfo *mem,
                            const struct caller *caller);
static void memcheck_update(struct meminfo *mem,
                            const struct caller *caller);
static void memcheck_insert(struct meminfo *mem,
                            const struct caller *caller);
static void memcheck_log(int level, int flush, const char *fmt, ...);
static void memcheck_log_trace(int level,
                               int flush,
                               const char *message,
                               const struct caller *caller);
static void memcheck_history(int level, int flush, struct meminfo *mem);
static void memcheck_log_info(int level,
                              int flush,
                              const char *message,
                              const void *ptr,
                              const struct caller *caller);
static int memcheck_protect(struct meminfo *mem, int prot);
static int memcheck_unprotect(struct meminfo *mem);
static void memcheck_put(struct meminfo *ptr);
static struct meminfo *memcheck_get(size_t pages);
static void memcheck_initialize(void);
static void memcheck_exit(void);
static void memcheck_error(const char *s);
#ifndef __GNUC__
static void *memcheck_get_return_address(void *stack);
#endif
static const struct backtrace *memcheck_get_backtrace(int skip_frames);
static void memcheck_get_symbols(int level, int flush, const struct backtrace *addr);
#ifdef HAVE_SIGACTION
# if defined(HAVE_SIGACTION_T) || defined(HAVE_STRUCT_SIGACTION)
static void memcheck_reraise(int signum,
                             sa_action_type_arg2 arg2,
                             void *context,
                             void *address);
static RETSIGTYPE memcheck_sig2(int signum,
                                sa_action_type_arg2 arg2,
                                void *context,
                                void *address);
static RETSIGTYPE memcheck_sig(int signum,
                               sa_action_type_arg2 arg2,
                               void *context,
                               void *address);
static sigaction_t memcheck_act_bus[3];
static sigaction_t memcheck_act_segv[3];
# endif
#endif

static struct meminfo *memcheck_head;
static int memcheck_reentered_handler;
static int memcheck_reinstalled_handler;
static struct memcheck_config memcheck_config;
static int memcheck_devzero = -1;  /* -1 == Unopened, closed, or not needed.  */
                                   /* -2 == Tried to open and failed.  */
static int memcheck_file = -1;  /* -1 == Unopened or closed.  */
                                /* -2 == Tried to open and failed.  */
static size_t memcheck_pagesize;
static int memcheck_pages_in_use;
static const long memcheck_sentry = MEMCHECK_SENTRY;

char *(strdup)(const char *str)
{
   return(memcheck_strdup_internal(NULL,
                                   0,
                                   memcheck_return_address(str,str),
                                   memcheck_get_backtrace(2),
                                   str));
}

void *(malloc)(size_t size)
{
   return(memcheck_malloc_internal(NULL,
                                   0,
                                   memcheck_return_address(size,size),
                                   memcheck_get_backtrace(2),
                                   size));
}

void *(calloc)(size_t n, size_t size)
{
   return(memcheck_calloc_internal(NULL,
                                   0,
                                   memcheck_return_address(n,size),
                                   memcheck_get_backtrace(2),
                                   n,
                                   size));
}

void *(realloc)(void *ptr, size_t size)
{
   return(memcheck_realloc_internal(NULL,
                                    0,
                                    memcheck_return_address(ptr,size),
                                    memcheck_get_backtrace(2),
                                    ptr,
                                    size));
}

void (free)(void *ptr)
{
   memcheck_free_internal(NULL,
                          0,
                          memcheck_return_address(ptr,ptr),
                          memcheck_get_backtrace(2),
                          ptr);
}

void (cfree)(void *ptr)
{
   memcheck_cfree_internal(NULL,
                           0,
                           memcheck_return_address(ptr,ptr),
                           memcheck_get_backtrace(2),
                           ptr);
}

void *(valloc)(size_t size)
{
   return(memcheck_valloc_internal(NULL,
                                   0,
                                   memcheck_return_address(size,size),
                                   memcheck_get_backtrace(2),
                                   size));
}

void *(memalign)(size_t boundary, size_t size)
{
   return(memcheck_memalign_internal(NULL,
                                     0,
                                     memcheck_return_address(boundary,size),
                                     memcheck_get_backtrace(2),
                                     boundary,
                                     size));
}

int (posix_memalign)(void **memptr, size_t alignment, size_t size)
{
   return(memcheck_posix_memalign_internal(NULL,
                                           0,
                                           memcheck_return_address(memptr,size),
                                           memcheck_get_backtrace(2),
                                           memptr,
                                           alignment,
                                           size));
}

char *memcheck_strdup(const char *file,
                      int line,
                      const void *addr,
                      const char *str)
{
   (void)addr;
   return(memcheck_strdup_internal(file,
                                   line,
                                   memcheck_return_address(file,str),
                                   memcheck_get_backtrace(2),
                                   str));
}

void *memcheck_malloc(const char *file,
                      int line,
                      const void *addr,
                      size_t size)
{
   (void)addr;
   return(memcheck_malloc_internal(file,
                                   line,
                                   memcheck_return_address(file,size),
                                   memcheck_get_backtrace(2),
                                   size));
}

void *memcheck_calloc(const char *file,
                      int line,
                      const void *addr,
                      size_t n,
                      size_t size)
{
   (void)addr;
   return(memcheck_calloc_internal(file,
                                   line,
                                   memcheck_return_address(file,size),
                                   memcheck_get_backtrace(2),
                                   n,
                                   size));
}

void *memcheck_realloc(const char *file,
                       int line,
                       const void *addr,
                       void *ptr,
                       size_t size)
{
   (void)addr;
   return(memcheck_realloc_internal(file,
                                    line,
                                    memcheck_return_address(file,size),
                                    memcheck_get_backtrace(2),
                                    ptr,
                                    size));
}

void memcheck_free(const char *file,
                   int line,
                   const void *addr,
                   const void *ptr)
{
   (void)addr;
   memcheck_free_internal(file,
                          line,
                          memcheck_return_address(file,ptr),
                          memcheck_get_backtrace(2),
                          ptr);
}

void memcheck_cfree(const char *file,
                    int line,
                    const void *addr,
                    const void *ptr)
{
   (void)addr;
   memcheck_cfree_internal(file,
                           line,
                           memcheck_return_address(file,ptr),
                           memcheck_get_backtrace(2),
                           ptr);
}

void *memcheck_valloc(const char *file,
                      int line,
                      const void *addr,
                      size_t size)
{
   (void)addr;
   return(memcheck_valloc_internal(file,
                                   line,
                                   memcheck_return_address(file,size),
                                   memcheck_get_backtrace(2),
                                   size));
}

void *memcheck_memalign(const char *file,
                        int line,
                        const void *addr,
                        size_t boundary,
                        size_t size)
{
   (void)addr;
   return(memcheck_memalign_internal(file,
                                     line,
                                     memcheck_return_address(file,size),
                                     memcheck_get_backtrace(2),
                                     boundary,
                                     size));
}

int memcheck_posix_memalign(const char *file,
                            int line,
                            const void *addr,
                            void **memptr,
                            size_t alignment,
                            size_t size)
{
   (void)addr;
   return(memcheck_posix_memalign_internal(file,
                                           line,
                                           memcheck_return_address(file,size),
                                           memcheck_get_backtrace(2),
                                           memptr,
                                           alignment,
                                           size));
}

static char *memcheck_strdup_internal(const char *file,
                                      int line,
                                      const void *addr,
                                      const struct backtrace *trace,
                                      const char *str)
{
   char *ptr;

   if(str != NULL)
   {
      size_t len;

      len = strlen(str);
      ptr = memcheck_allocator(file,
                               line,
                               strdup_function,
                               addr,
                               trace,
                               NULL,
                               len + 1);
      if(len != 0)
      {
         memcpy(ptr, str, len);
      }
      ptr[len] = '\0';
   }
   else
   {
      ptr = NULL;
   }
   return ptr;
}

static void *memcheck_malloc_internal(const char *file,
                                      int line,
                                      const void *addr,
                                      const struct backtrace *trace,
                                      size_t size)
{
   return memcheck_allocator(file,
                             line,
                             malloc_function,
                             addr,
                             trace,
                             NULL,
                             size);
}

static void *memcheck_calloc_internal(const char *file,
                                      int line,
                                      const void *addr,
                                      const struct backtrace *trace,
                                      size_t n,
                                      size_t size)
{