io.c

   1 #include "imager.h"
   2 #include <stdlib.h>
   3 #ifndef _MSC_VER
   4 #include <unistd.h>
   5 #endif
   6
   7
   8 /* FIXME: make allocation dynamic */
   9
  10
  11 #ifdef IMAGER_DEBUG_MALLOC
  12
  13 #define MAXMAL 102400
  14 #define MAXDESC 65
  15
  16 #define UNDRRNVAL 10
  17 #define OVERRNVAL 10
  18
  19 #define PADBYTE 0xaa
  20
  21
  22 static int malloc_need_init = 1;
  23
  24 typedef struct {
  25   void* ptr;
  26   size_t size;
  27   char comm[MAXDESC];
  28 } malloc_entry;
  29
  30 malloc_entry malloc_pointers[MAXMAL];
  31
  32
  33
  34
  35 /* Utility functions */
  36
  37
  38 static
  39 void
  40 malloc_init(void) {
  41   int i;
  42   for(i=0; i<MAXMAL; i++) malloc_pointers[i].ptr = NULL;
  43   malloc_need_init = 0;
  44   atexit(malloc_state);
  45 }
  46
  47
  48 static
  49 int
  50 find_ptr(void *p) {
  51   int i;
  52   for(i=0;i<MAXMAL;i++)
  53     if (malloc_pointers[i].ptr == p)
  54       return i;
  55   return -1;
  56 }
  57
  58
  59 /* Takes a pointer to real start of array,
  60  * sets the entries in the table, returns
  61  * the offset corrected pointer */
  62
  63 static
  64 void *
  65 set_entry(int i, char *buf, size_t size, char *file, int line) {
  66   memset( buf, PADBYTE, UNDRRNVAL );
  67   memset( &buf[UNDRRNVAL+size], PADBYTE, OVERRNVAL );
  68   buf += UNDRRNVAL;
  69   malloc_pointers[i].ptr  = buf;
  70   malloc_pointers[i].size = size;
  71   sprintf(malloc_pointers[i].comm,"%s (%d)", file, line);
  72   return buf;
  73 }
  74
  75 void
  76 malloc_state(void) {
  77   int i, total = 0;
  78
  79   i_clear_error();
  80   mm_log((0,"malloc_state()\n"));
  81   bndcheck_all();
  82   for(i=0; i<MAXMAL; i++) if (malloc_pointers[i].ptr != NULL) {
  83     mm_log((0,"%d: %d (0x%x) : %s\n", i, malloc_pointers[i].size, malloc_pointers[i].ptr, malloc_pointers[i].comm));
  84     total += malloc_pointers[i].size;
  85   }
  86   if (total == 0) mm_log((0,"No memory currently used!\n"))
  87                     else mm_log((0,"total: %d\n",total));
  88 }
  89
  90
  91
  92 void*
  93 mymalloc_file_line(size_t size, char* file, int line) {
  94   char *buf;
  95   int i;
  96   if (malloc_need_init) malloc_init();
  97
  98   /* bndcheck_all(); Uncomment for LOTS OF THRASHING */
  99
 100   if ( (i = find_ptr(NULL)) < 0 ) {
 101     mm_log((0,"more than %d segments allocated at %s (%d)\n", MAXMAL, file, line));
 102     exit(3);
 103   }
 104
 105   if ( (buf = malloc(size+UNDRRNVAL+OVERRNVAL)) == NULL ) {
 106     mm_log((1,"Unable to allocate %i for %s (%i)\n", size, file, line));
 107     exit(3);
 108   }
 109
 110   buf = set_entry(i, buf, size, file, line);
 111   mm_log((1,"mymalloc_file_line: slot <%d> %d bytes allocated at %p for %s (%d)\n", i, size, buf, file, line));
 112   return buf;
 113 }
 114
 115 void *
 116 (mymalloc)(int size) {
 117   return mymalloc_file_line(size, "unknown", 0);
 118 }
 119
 120 void*
 121 myrealloc_file_line(void *ptr, size_t newsize, char* file, int line) {
 122   char *buf;
 123   int i;
 124
 125   if (malloc_need_init) malloc_init();
 126   /* bndcheck_all(); ACTIVATE FOR LOTS OF THRASHING */
 127
 128   if (!ptr) {
 129     mm_log((1, "realloc called with ptr = NULL, sending request to malloc\n"));
 130     return mymalloc_file_line(newsize, file, line);
 131   }
 132
 133   if (!newsize) {
 134     mm_log((1, "newsize = 0, sending request to free\n"));
 135     myfree_file_line(ptr, file, line);
 136     return NULL;
 137   }
 138
 139   if ( (i = find_ptr(ptr)) == -1) {
 140     mm_log((0, "Unable to find %p in realloc for %s (%i)\n", ptr, file, line));
 141     exit(3);
 142   }
 143
 144   if ( (buf = realloc(((char *)ptr)-UNDRRNVAL, UNDRRNVAL+OVERRNVAL+newsize)) == NULL ) {
 145     mm_log((1,"Unable to reallocate %i bytes at %p for %s (%i)\n", newsize, ptr, file, line));
 146     exit(3);
 147   }
 148
 149   buf = set_entry(i, buf, newsize, file, line);
 150   mm_log((1,"realloc_file_line: slot <%d> %d bytes allocated at %p for %s (%d)\n", i, newsize, buf, file, line));
 151   return buf;
 152 }
 153
 154 void *
 155 (myrealloc)(void *ptr, size_t newsize) {
 156   return myrealloc_file_line(ptr, newsize, "unknown", 0);
 157 }
 158
 159 static
 160 void
 161 bndcheck(int idx) {
 162   int i;
 163   size_t s = malloc_pointers[idx].size;
 164   unsigned char *pp = malloc_pointers[idx].ptr;
 165   if (!pp) {
 166     mm_log((1, "bndcheck: No pointer in slot %d\n", idx));
 167     return;
 168   }
 169
 170   for(i=0;i<UNDRRNVAL;i++)
 171      if (pp[-(1+i)] != PADBYTE)
 172      mm_log((1,"bndcheck: UNDERRUN OF %d bytes detected: slot = %d, point = %p, size = %d\n", i+1, idx, pp, s ));
 173
 174      for(i=0;i<OVERRNVAL;i++)
 175     if (pp[s+i] != PADBYTE)
 176       mm_log((1,"bndcheck: OVERRUN OF %d bytes detected: slot = %d, point = %p, size = %d\n", i+1, idx, pp, s ));
 177 }
 178
 179 void
 180 bndcheck_all() {
 181   int idx;
 182   mm_log((1, "bndcheck_all()\n"));
 183   for(idx=0; idx<MAXMAL; idx++)
 184     if (malloc_pointers[idx].ptr)
 185       bndcheck(idx);
 186 }
 187
 188 void
 189 myfree_file_line(void *p, char *file, int line) {
 190   char  *pp = p;
 191   int match = 0;
 192   int i;
 193
 194   for(i=0; i<MAXMAL; i++) if (malloc_pointers[i].ptr == p) {
 195     mm_log((1,"myfree_file_line: pointer %i (%s) freed at %s (%i)\n", i, malloc_pointers[i].comm, file, line));
 196     bndcheck(i);
 197     malloc_pointers[i].ptr = NULL;
 198     match++;
 199   }
 200
 201   mm_log((1, "myfree_file_line: freeing address %p (real %p)\n", pp, pp-UNDRRNVAL));
 202
 203   if (match != 1) {
 204     mm_log((1, "myfree_file_line: INCONSISTENT REFCOUNT %d at %s (%i)\n", match, file, line));
 205     fprintf(stderr, "myfree_file_line: INCONSISTENT REFCOUNT %d at %s (%i)\n", match, file, line);
 206                 exit(255);
 207   }
 208
 209
 210   free(pp-UNDRRNVAL);
 211 }
 212
 213 void
 214 (myfree)(void *block) {
 215   myfree_file_line(block, "unknown", 0);
 216 }
 217
 218 #else
 219
 220 #define malloc_comm(a,b) (mymalloc(a))
 221
 222 void
 223 malloc_state() {
 224   printf("malloc_state: not in debug mode\n");
 225 }
 226
 227 void*
 228 mymalloc(int size) {
 229   void *buf;
 230
 231   if (size < 0) {
 232     fprintf(stderr, "Attempt to allocate size %d\n", size);
 233     exit(3);
 234   }
 235
 236   if ( (buf = malloc(size)) == NULL ) {
 237     mm_log((1, "mymalloc: unable to malloc %d\n", size));
 238     fprintf(stderr,"Unable to malloc %d.\n", size); exit(3);
 239   }
 240   mm_log((1, "mymalloc(size %d) -> %p\n", size, buf));
 241   return buf;
 242 }
 243
 244 void *
 245 mymalloc_file_line(size_t size, char *file, int line) {
 246   return mymalloc(size);
 247 }
 248
 249 void
 250 myfree(void *p) {
 251   mm_log((1, "myfree(p %p)\n", p));
 252   free(p);
 253 }
 254
 255 void
 256 myfree_file_line(void *p, char *file, int line) {
 257   myfree(p);
 258 }
 259
 260 void *
 261 myrealloc(void *block, size_t size) {
 262   void *result;
 263
 264   mm_log((1, "myrealloc(block %p, size %u)\n", block, size));
 265   if ((result = realloc(block, size)) == NULL) {
 266     mm_log((1, "myrealloc: out of memory\n"));
 267     fprintf(stderr, "Out of memory.\n");
 268     exit(3);
 269   }
 270   return result;
 271 }
 272
 273 void *
 274 myrealloc_file_line(void *block, size_t newsize, char *file, int size) {
 275   return myrealloc(block, newsize);
 276 }
 277
 278 #endif /* IMAGER_MALLOC_DEBUG */
 279
 280
 281
 282
 283 /* memory pool implementation */
 284
 285 void
 286 i_mempool_init(i_mempool *mp) {
 287   mp->alloc = 10;
 288   mp->used  = 0;
 289   mp->p = mymalloc(sizeof(void*)*mp->alloc);
 290 }
 291
 292 void
 293 i_mempool_extend(i_mempool *mp) {
 294   mp->p = myrealloc(mp->p, mp->alloc * 2);
 295   mp->alloc *=2;
 296 }
 297
 298 void *
 299 i_mempool_alloc(i_mempool *mp, size_t size) {
 300   if (mp->used == mp->alloc) i_mempool_extend(mp);
 301   mp->p[mp->used] = mymalloc(size);
 302   mp->used++;
 303   return mp->p[mp->used-1];
 304 }
 305
 306
 307 void
 308 i_mempool_destroy(i_mempool *mp) {
 309   unsigned int i;
 310   for(i=0; i<mp->used; i++) myfree(mp->p[i]);
 311   myfree(mp->p);
 312 }
 313
 314
 315
 316 /* Should these really be here? */
 317
 318 #undef min
 319 #undef max
 320
 321 int
 322 i_min(int a,int b) {
 323   if (a<b) return a; else return b;
 324 }
 325
 326 int
 327 i_max(int a,int b) {
 328   if (a>b) return a; else return b;
 329 }
 330
 331
 332 struct utf8_size {
 333   int mask, expect;
 334   int size;
 335 };
 336
 337 struct utf8_size utf8_sizes[] =
 338 {
 339   { 0x80, 0x00, 1 },
 340   { 0xE0, 0xC0, 2 },
 341   { 0xF0, 0xE0, 3 },
 342   { 0xF8, 0xF0, 4 },
 343 };
 344
 345 /*
 346 =item utf8_advance(char **p, int *len)
 347
 348 Retreive a UTF8 character from the stream.
 349
 350 Modifies *p and *len to indicate the consumed characters.
 351
 352 This doesn't support the extended UTF8 encoding used by later versions
 353 of Perl.
 354
 355 =cut
 356 */
 357
 358 unsigned long i_utf8_advance(char const **p, int *len) {
 359   unsigned char c;
 360   int i, ci, clen = 0;
 361   unsigned char codes[3];
 362   if (*len == 0)
 363     return ~0UL;
 364   c = *(*p)++; --*len;
 365
 366   for (i = 0; i < sizeof(utf8_sizes)/sizeof(*utf8_sizes); ++i) {
 367     if ((c & utf8_sizes[i].mask) == utf8_sizes[i].expect) {
 368       clen = utf8_sizes[i].size;
 369     }
 370   }
 371   if (clen == 0 || *len < clen-1) {
 372     --*p; ++*len;
 373     return ~0UL;
 374   }
 375
 376   /* check that each character is well formed */
 377   i = 1;
 378   ci = 0;
 379   while (i < clen) {
 380     if (((*p)[ci] & 0xC0) != 0x80) {
 381       --*p; ++*len;
 382       return ~0UL;
 383     }
 384     codes[ci] = (*p)[ci];
 385     ++ci; ++i;
 386   }
 387   *p += clen-1; *len -= clen-1;
 388   if (c & 0x80) {
 389     if ((c & 0xE0) == 0xC0) {
 390       return ((c & 0x1F) << 6) + (codes[0] & 0x3F);
 391     }
 392     else if ((c & 0xF0) == 0xE0) {
 393       return ((c & 0x0F) << 12) | ((codes[0] & 0x3F) << 6) | (codes[1] & 0x3f);
 394     }
 395     else if ((c & 0xF8) == 0xF0) {
 396       return ((c & 0x07) << 18) | ((codes[0] & 0x3F) << 12)
 397               | ((codes[1] & 0x3F) << 6) | (codes[2] & 0x3F);
 398     }
 399     else {
 400       *p -= clen; *len += clen;
 401       return ~0UL;
 402     }
 403   }
 404   else {
 405     return c;
 406   }
 407 }
 408