libmultipath/memory.c

   1 /*
   2  * Part:        Memory management framework. This framework is used to
   3  *              find any memory leak.
   4  *
   5  * Version:     $Id: memory.c,v 1.1.11 2005/03/01 01:22:13 acassen Exp $
   6  *
   7  * Authors:     Alexandre Cassen, <acassen@linux-vs.org>
   8  *              Jan Holmberg, <jan@artech.net>
   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.
  13  *              See the GNU General Public License for more details.
  14  *
  15  *              This program is free software; you can redistribute it and/or
  16  *              modify it under the terms of the GNU General Public License
  17  *              as published by the Free Software Foundation; either version
  18  *              2 of the License, or (at your option) any later version.
  19  *
  20  * Copyright (C) 2001-2005 Alexandre Cassen, <acassen@linux-vs.org>
  21  */
  22
  23 #include <assert.h>
  24 #include "memory.h"
  25
  26 /*
  27  * Memory management. in debug mode,
  28  * help finding eventual memory leak.
  29  * Allocation memory types manipulated are :
  30  *
  31  * +type+--------meaning--------+
  32  * ! 0  ! Free slot             !
  33  * ! 1  ! Overrun               !
  34  * ! 2  ! free null             !
  35  * ! 3  ! realloc null          !
  36  * ! 4  ! Not previus allocated !
  37  * ! 8  ! Last free list        !
  38  * ! 9  ! Allocated             !
  39  * +----+-----------------------+
  40  *
  41  * global variabel debug bit 9 ( 512 ) used to
  42  * flag some memory error.
  43  *
  44  */
  45
  46 #ifdef _DEBUG_
  47
  48 typedef struct {
  49         int type;
  50         int line;
  51         char *func;
  52         char *file;
  53         void *ptr;
  54         unsigned long size;
  55         long csum;
  56 } MEMCHECK;
  57
  58 /* Last free pointers */
  59 static MEMCHECK free_list[256];
  60
  61 static MEMCHECK alloc_list[MAX_ALLOC_LIST];
  62 static int number_alloc_list = 0;
  63 static int n = 0;               /* Alloc list pointer */
  64 static int f = 0;               /* Free list pointer */
  65
  66 void *
  67 dbg_malloc(unsigned long size, char *file, char *function, int line)
  68 {
  69         void *buf;
  70         int i = 0;
  71         long check;
  72
  73         buf = zalloc(size + sizeof (long));
  74
  75         check = 0xa5a5 + size;
  76         *(long *) ((char *) buf + size) = check;
  77
  78         while (i < number_alloc_list) {
  79                 if (alloc_list[i].type == 0)
  80                         break;
  81                 i++;
  82         }
  83
  84         if (i == number_alloc_list)
  85                 number_alloc_list++;
  86
  87         assert(number_alloc_list < MAX_ALLOC_LIST);
  88
  89         alloc_list[i].ptr = buf;
  90         alloc_list[i].size = size;
  91         alloc_list[i].file = file;
  92         alloc_list[i].func = function;
  93         alloc_list[i].line = line;
  94         alloc_list[i].csum = check;
  95         alloc_list[i].type = 9;
  96
  97         if (debug & 1)
  98                 printf("zalloc[%3d:%3d], %p, %4ld at %s, %3d, %s\n",
  99                        i, number_alloc_list, buf, size, file, line,
 100                        function);
 101
 102         n++;
 103         return buf;
 104 }
 105
 106 char *
 107 dbg_strdup(char *str, char *file, char *function, int line)
 108 {
 109         void *buf;
 110         int i = 0;
 111         long check;
 112         long size;
 113
 114         size = strlen(str) + 1;
 115         buf = zalloc(size + sizeof (long));
 116         strcat(buf, str);
 117
 118         check = 0xa5a5 + size;
 119         *(long *) ((char *) buf + size) = check;
 120
 121         while (i < number_alloc_list) {
 122                 if (alloc_list[i].type == 0)
 123                         break;
 124                 i++;
 125         }
 126
 127         if (i == number_alloc_list)
 128                 number_alloc_list++;
 129
 130         assert(number_alloc_list < MAX_ALLOC_LIST);
 131
 132         alloc_list[i].ptr = buf;
 133         alloc_list[i].size = size;
 134         alloc_list[i].file = file;
 135         alloc_list[i].func = function;
 136         alloc_list[i].line = line;
 137         alloc_list[i].csum = check;
 138         alloc_list[i].type = 9;
 139
 140         if (debug & 1)
 141                 printf("strdup[%3d:%3d], %p, %4ld at %s, %3d, %s\n",
 142                        i, number_alloc_list, buf, size, file, line,
 143                        function);
 144
 145         n++;
 146         return buf;
 147 }
 148
 149
 150
 151 /* Display a buffer into a HEXA formatted output */
 152 static void
 153 dump_buffer(char *buff, int count)
 154 {
 155         int i, j, c;
 156         int printnext = 1;
 157
 158         if (count % 16)
 159                 c = count + (16 - count % 16);
 160         else
 161                 c = count;
 162
 163         for (i = 0; i < c; i++) {
 164                 if (printnext) {
 165                         printnext--;
 166                         printf("%.4x ", i & 0xffff);
 167                 }
 168                 if (i < count)
 169                         printf("%3.2x", buff[i] & 0xff);
 170                 else
 171                         printf("   ");
 172                 if (!((i + 1) % 8)) {
 173                         if ((i + 1) % 16)
 174                                 printf(" -");
 175                         else {
 176                                 printf("   ");
 177                                 for (j = i - 15; j <= i; j++)
 178                                         if (j < count) {
 179                                                 if ((buff[j] & 0xff) >= 0x20
 180                                                     && (buff[j] & 0xff) <= 0x7e)
 181                                                         printf("%c",
 182                                                                buff[j] & 0xff);
 183                                                 else
 184                                                         printf(".");
 185                                         } else
 186                                                 printf(" ");
 187                                 printf("\n");
 188                                 printnext = 1;
 189                         }
 190                 }
 191         }
 192 }
 193
 194 int
 195 dbg_free(void *buffer, char *file, char *function, int line)
 196 {
 197         int i = 0;
 198         void *buf;
 199
 200         /* If nullpointer remember */
 201         if (buffer == NULL) {
 202                 i = number_alloc_list++;
 203
 204                 assert(number_alloc_list < MAX_ALLOC_LIST);
 205
 206                 alloc_list[i].ptr = buffer;
 207                 alloc_list[i].size = 0;
 208                 alloc_list[i].file = file;
 209                 alloc_list[i].func = function;
 210                 alloc_list[i].line = line;
 211                 alloc_list[i].type = 2;
 212                 if (debug & 1)
 213                         printf("free NULL in %s, %3d, %s\n", file,
 214                                line, function);
 215
 216                 debug |= 512;   /* Memory Error detect */
 217
 218                 return n;
 219         } else
 220                 buf = buffer;
 221
 222         while (i < number_alloc_list) {
 223                 if (alloc_list[i].type == 9 && alloc_list[i].ptr == buf) {
 224                         if (*
 225                             ((long *) ((char *) alloc_list[i].ptr +
 226                                        alloc_list[i].size)) ==
 227                             alloc_list[i].csum)
 228                                 alloc_list[i].type = 0; /* Release */
 229                         else {
 230                                 alloc_list[i].type = 1; /* Overrun */
 231                                 if (debug & 1) {
 232                                         printf("free corrupt, buffer overrun [%3d:%3d], %p, %4ld at %s, %3d, %s\n",
 233                                                i, number_alloc_list,
 234                                                buf, alloc_list[i].size, file,
 235                                                line, function);
 236                                         dump_buffer(alloc_list[i].ptr,
 237                                                     alloc_list[i].size + sizeof (long));
 238                                         printf("Check_sum\n");
 239                                         dump_buffer((char *) &alloc_list[i].csum,
 240                                                     sizeof(long));
 241
 242                                         debug |= 512;   /* Memory Error detect */
 243                                 }
 244                         }
 245                         break;
 246                 }
 247                 i++;
 248         }
 249
 250         /*  Not found */
 251         if (i == number_alloc_list) {
 252                 printf("Free ERROR %p\n", buffer);
 253                 number_alloc_list++;
 254
 255                 assert(number_alloc_list < MAX_ALLOC_LIST);
 256
 257                 alloc_list[i].ptr = buf;
 258                 alloc_list[i].size = 0;
 259                 alloc_list[i].file = file;
 260                 alloc_list[i].func = function;
 261                 alloc_list[i].line = line;
 262                 alloc_list[i].type = 4;
 263                 debug |= 512;
 264
 265                 return n;
 266         }
 267
 268         if (buffer != NULL)
 269                 xfree(buffer);
 270
 271         if (debug & 1)
 272                 printf("free  [%3d:%3d], %p, %4ld at %s, %3d, %s\n",
 273                        i, number_alloc_list, buf,
 274                        alloc_list[i].size, file, line, function);
 275
 276         free_list[f].file = file;
 277         free_list[f].line = line;
 278         free_list[f].func = function;
 279         free_list[f].ptr = buffer;
 280         free_list[f].type = 8;
 281         free_list[f].csum = i;  /* Using this field for row id */
 282
 283         f++;
 284         f &= 255;
 285         n--;
 286
 287         return n;
 288 }
 289
 290 void
 291 dbg_free_final(char *banner)
 292 {
 293         unsigned int sum = 0, overrun = 0, badptr = 0;
 294         int i, j;
 295         i = 0;
 296
 297         printf("\n---[ Memory dump for (%s)]---\n\n", banner);
 298
 299         while (i < number_alloc_list) {
 300                 switch (alloc_list[i].type) {
 301                 case 3:
 302                         badptr++;
 303                         printf
 304                             ("null pointer to realloc(nil,%ld)! at %s, %3d, %s\n",
 305                              alloc_list[i].size, alloc_list[i].file,
 306                              alloc_list[i].line, alloc_list[i].func);
 307                         break;
 308                 case 4:
 309                         badptr++;
 310                         printf
 311                             ("pointer not found in table to free(%p) [%3d:%3d], at %s, %3d, %s\n",
 312                              alloc_list[i].ptr, i, number_alloc_list,
 313                              alloc_list[i].file, alloc_list[i].line,
 314                              alloc_list[i].func);
 315                         for (j = 0; j < 256; j++)
 316                                 if (free_list[j].ptr == alloc_list[i].ptr)
 317                                         if (free_list[j].type == 8)
 318                                                 printf
 319                                                     ("  -> pointer already released at [%3d:%3d], at %s, %3d, %s\n",
 320                                                      (int) free_list[j].csum,
 321                                                      number_alloc_list,
 322                                                      free_list[j].file,
 323                                                      free_list[j].line,
 324                                                      free_list[j].func);
 325                         break;
 326                 case 2:
 327                         badptr++;
 328                         printf("null pointer to free(nil)! at %s, %3d, %s\n",
 329                                alloc_list[i].file, alloc_list[i].line,
 330                                alloc_list[i].func);
 331                         break;
 332                 case 1:
 333                         overrun++;
 334                         printf("%p [%3d:%3d], %4ld buffer overrun!:\n",
 335                                alloc_list[i].ptr, i, number_alloc_list,
 336                                alloc_list[i].size);
 337                         printf(" --> source of malloc: %s, %3d, %s\n",
 338                                alloc_list[i].file, alloc_list[i].line,
 339                                alloc_list[i].func);
 340                         break;
 341                 case 9:
 342                         sum += alloc_list[i].size;
 343                         printf("%p [%3d:%3d], %4ld not released!:\n",
 344                                alloc_list[i].ptr, i, number_alloc_list,
 345                                alloc_list[i].size);
 346                         printf(" --> source of malloc: %s, %3d, %s\n",
 347                                alloc_list[i].file, alloc_list[i].line,
 348                                alloc_list[i].func);
 349                         break;
 350                 }
 351                 i++;
 352         }
 353
 354         printf("\n\n---[ Memory dump summary for (%s) ]---\n", banner);
 355         printf("Total number of bytes not freed...: %d\n", sum);
 356         printf("Number of entries not freed.......: %d\n", n);
 357         printf("Maximum allocated entries.........: %d\n", number_alloc_list);
 358         printf("Number of bad entries.............: %d\n", badptr);
 359         printf("Number of buffer overrun..........: %d\n\n", overrun);
 360
 361         if (sum || n || badptr || overrun)
 362                 printf("=> Program seems to have some memory problem !!!\n\n");
 363         else
 364                 printf("=> Program seems to be memory allocation safe...\n\n");
 365 }
 366
 367 void *
 368 dbg_realloc(void *buffer, unsigned long size, char *file, char *function,
 369                    int line)
 370 {
 371         int i = 0;
 372         void *buf, *buf2;
 373         long check;
 374
 375         if (buffer == NULL) {
 376                 printf("realloc %p %s, %3d %s\n", buffer, file, line, function);
 377                 i = number_alloc_list++;
 378
 379                 assert(number_alloc_list < MAX_ALLOC_LIST);
 380
 381                 alloc_list[i].ptr = NULL;
 382                 alloc_list[i].size = 0;
 383                 alloc_list[i].file = file;
 384                 alloc_list[i].func = function;
 385                 alloc_list[i].line = line;
 386                 alloc_list[i].type = 3;
 387                 return dbg_malloc(size, file, function, line);
 388         }
 389
 390         buf = buffer;
 391
 392         while (i < number_alloc_list) {
 393                 if (alloc_list[i].ptr == buf) {
 394                         buf = alloc_list[i].ptr;
 395                         break;
 396                 }
 397                 i++;
 398         }
 399
 400         /* not found */
 401         if (i == number_alloc_list) {
 402                 printf("realloc ERROR no matching zalloc %p \n", buffer);
 403                 number_alloc_list++;
 404
 405                 assert(number_alloc_list < MAX_ALLOC_LIST);
 406
 407                 alloc_list[i].ptr = buf;
 408                 alloc_list[i].size = 0;
 409                 alloc_list[i].file = file;
 410                 alloc_list[i].func = function;
 411                 alloc_list[i].line = line;
 412                 alloc_list[i].type = 9;
 413                 debug |= 512;   /* Memory Error detect */
 414                 return NULL;
 415         }
 416
 417         buf2 = ((char *) buf) + alloc_list[i].size;
 418
 419         if (*(long *) (buf2) != alloc_list[i].csum) {
 420                 alloc_list[i].type = 1;
 421                 debug |= 512;   /* Memory Error detect */
 422         }
 423         buf = realloc(buffer, size + sizeof (long));
 424
 425         check = 0xa5a5 + size;
 426         *(long *) ((char *) buf + size) = check;
 427         alloc_list[i].csum = check;
 428
 429         if (debug & 1)
 430                 printf("realloc [%3d:%3d] %p, %4ld %s %d %s -> %p %4ld %s %d %s\n",
 431                        i, number_alloc_list, alloc_list[i].ptr,
 432                        alloc_list[i].size, alloc_list[i].file, alloc_list[i].line, alloc_list[i].func,
 433                        buf, size, file, line, function);
 434
 435         alloc_list[i].ptr = buf;
 436         alloc_list[i].size = size;
 437         alloc_list[i].file = file;
 438         alloc_list[i].line = line;
 439         alloc_list[i].func = function;
 440
 441         return buf;
 442 }
 443
 444 #endif