src/mem.c

   1 /* vim:tw=78:ts=8:sw=4:set ft=c:  */
   2 /*
   3     Copyright (C) 2006-2009 Ben Kibbey <bjk@luxsci.net>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02110-1301  USA
  18 */
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <unistd.h>
  22 #include <string.h>
  23 #include <assert.h>
  24 #include <err.h>
  25 #include <pthread.h>
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include <config.h>
  29 #endif
  30
  31 #include "gettext.h"
  32 #define N_(msgid)       gettext(msgid)
  33
  34 #include "mem.h"
  35
  36 static struct memlist_s *memlist;
  37 static pthread_mutex_t mem_mutex;
  38 #ifdef DEBUG
  39 static size_t allocations, deallocations;
  40 #endif
  41
  42 void xmem_init()
  43 {
  44     static int init;
  45
  46     if (!init)
  47         pthread_mutex_init(&mem_mutex, NULL);
  48
  49     init = 1;
  50 }
  51
  52 void xmem_deinit()
  53 {
  54     pthread_mutex_destroy(&mem_mutex);
  55 }
  56
  57 static int memlist_remove(void *ptr, const char *func)
  58 {
  59     struct memlist_s *m, *last = NULL, *p;
  60     int found = 0;
  61
  62     for (m = memlist; m; m = m->next) {
  63         if (m->ptr == ptr) {
  64 #ifdef DEBUG
  65             fprintf(stderr, "%s: %p %i\n", func, ptr, m->size);
  66 #endif
  67             found = 1;
  68             memset(m->ptr, 0, m->size);
  69             free(m->ptr);
  70
  71             p = m->next;
  72             free(m);
  73 #ifdef DEBUG
  74             deallocations++;
  75 #endif
  76
  77             if (last) {
  78                 if (p)
  79                     last->next = p;
  80                 else
  81                     last->next = NULL;
  82             }
  83             else if (p)
  84                 memlist = p;
  85             else
  86                 memlist = NULL;
  87
  88             break;
  89         }
  90
  91         last = m;
  92     }
  93
  94     return found;
  95 }
  96
  97 static void memlist_prepend(struct memlist_s *new)
  98 {
  99 #ifdef DEBUG
 100     allocations++;
 101 #endif
 102     new->next = memlist;
 103     memlist = new;
 104 }
 105
 106 void xfree(void *ptr)
 107 {
 108     pthread_mutex_lock(&mem_mutex);
 109
 110     if (!ptr) {
 111         pthread_mutex_unlock(&mem_mutex);
 112         return;
 113     }
 114
 115     if (!memlist_remove(ptr, __FUNCTION__)) {
 116         warnx(N_("%s: %p not found"), __FUNCTION__, ptr);
 117         pthread_mutex_unlock(&mem_mutex);
 118         assert(0);
 119     }
 120
 121     pthread_mutex_unlock(&mem_mutex);
 122 }
 123
 124 void *xmalloc(size_t size)
 125 {
 126     void *p;
 127     struct memlist_s *m;
 128
 129     pthread_mutex_lock(&mem_mutex);
 130
 131     if (size <= 0) {
 132         pthread_mutex_unlock(&mem_mutex);
 133         return NULL;
 134     }
 135
 136     if ((m = (struct memlist_s *)malloc(sizeof(struct memlist_s))) == NULL) {
 137         pthread_mutex_unlock(&mem_mutex);
 138         return NULL;
 139     }
 140
 141     if ((p = (void *)malloc(size)) == NULL) {
 142         free(m);
 143         pthread_mutex_unlock(&mem_mutex);
 144         return NULL;
 145     }
 146
 147     m->ptr = p;
 148     m->size = size;
 149     memlist_prepend(m);
 150 #ifdef DEBUG
 151     fprintf(stderr, "%s: %p %i\n", __FUNCTION__, p, size);
 152 #endif
 153     pthread_mutex_unlock(&mem_mutex);
 154     return m->ptr;
 155 }
 156
 157 void *xcalloc(size_t nmemb, size_t size)
 158 {
 159     void *p;
 160     struct memlist_s *m;
 161
 162     pthread_mutex_lock(&mem_mutex);
 163
 164     if (size <= 0) {
 165         pthread_mutex_unlock(&mem_mutex);
 166         return NULL;
 167     }
 168
 169     if ((m = (struct memlist_s *)malloc(sizeof(struct memlist_s))) == NULL) {
 170         pthread_mutex_unlock(&mem_mutex);
 171         return NULL;
 172     }
 173
 174     if ((p = calloc(nmemb, size)) == NULL) {
 175         free(m);
 176         pthread_mutex_unlock(&mem_mutex);
 177         return NULL;
 178     }
 179
 180     m->ptr = p;
 181     m->size = nmemb * size;
 182     memlist_prepend(m);
 183 #ifdef DEBUG
 184     fprintf(stderr, "%s: %p %i\n", __FUNCTION__, p, nmemb * size);
 185 #endif
 186     pthread_mutex_unlock(&mem_mutex);
 187     return m->ptr;
 188 }
 189
 190 void *xrealloc(void *ptr, size_t size)
 191 {
 192     void *p;
 193     struct memlist_s *m;
 194
 195     if (size <= 0)
 196         return ptr;
 197
 198     if (!ptr)
 199         return xmalloc(size);
 200
 201     pthread_mutex_lock(&mem_mutex);
 202
 203     for (m = memlist; m; m = m->next) {
 204         if (m->ptr == ptr) {
 205             if ((p = (void *)malloc(size)) == NULL) {
 206                 pthread_mutex_unlock(&mem_mutex);
 207                 return NULL;
 208             }
 209
 210             memcpy(p, m->ptr, size < m->size ? size : m->size);
 211             memset(m->ptr, 0, m->size);
 212             free(m->ptr);
 213             m->ptr = p;
 214             m->size = size;
 215 #ifdef DEBUG
 216             fprintf(stderr, "%s: %p %i\n", __FUNCTION__, p, size);
 217 #endif
 218             pthread_mutex_unlock(&mem_mutex);
 219             return m->ptr;
 220         }
 221     }
 222
 223     warnx(N_("%s: %p not found"), __FUNCTION__, ptr);
 224     pthread_mutex_unlock(&mem_mutex);
 225     assert(0);
 226     return NULL;
 227 }
 228
 229 char *xstrdup(const char *str)
 230 {
 231     char *t, *tp;
 232     size_t len;
 233     const char *p;
 234
 235     if (!str)
 236         return NULL;
 237
 238     len = strlen(str) + 1;
 239
 240     if ((t = (char *)xmalloc(len * sizeof(char))) == NULL)
 241         return NULL;
 242
 243     for (p = str, tp = t; *p; p++)
 244         *tp++ = *p;
 245
 246     *tp = 0;
 247 #ifdef DEBUG
 248     fprintf(stderr, "%s: %p\n", __FUNCTION__, t);
 249 #endif
 250     return t;
 251 }
 252
 253 void xpanic(void)
 254 {
 255     struct memlist_s *m;
 256
 257     pthread_mutex_lock(&mem_mutex);
 258
 259     for (m = memlist; m; m = memlist)
 260        xfree(m->ptr);
 261
 262     pthread_mutex_unlock(&mem_mutex);
 263 }
 264
 265 #ifdef DEBUG
 266 void xdump(void)
 267 {
 268     struct memlist_s *m;
 269     size_t total = 0;
 270
 271     pthread_mutex_lock(&mem_mutex);
 272
 273     for (m = memlist; m; m = m->next) {
 274         fprintf(stderr, "%s: %p %i\n", __FUNCTION__, m->ptr, m->size);
 275         total += m->size;
 276     }
 277
 278     fprintf(stderr, "Total unfreed: %i bytes, allocations: %i, deallocations: %i\n", total,
 279             allocations, deallocations);
 280     pthread_mutex_unlock(&mem_mutex);
 281 }
 282 #endif