bcheck.c

   1 /*
   2  *  Tiny C Memory and bounds checker
   3  *
   4  *  Copyright (c) 2002 Fabrice Bellard
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <stdarg.h>
  23 #include <string.h>
  24 #include <malloc.h>
  25
  26 //#define BOUND_DEBUG
  27
  28 /* define so that bound array is static (faster, but use memory if
  29    bound checking not used) */
  30 //#define BOUND_STATIC
  31
  32 /* use malloc hooks. Currently the code cannot be reliable if no hooks */
  33 #define CONFIG_TCC_MALLOC_HOOKS
  34
  35 #define BOUND_T1_BITS 13
  36 #define BOUND_T2_BITS 11
  37 #define BOUND_T3_BITS (32 - BOUND_T1_BITS - BOUND_T2_BITS)
  38
  39 #define BOUND_T1_SIZE (1 << BOUND_T1_BITS)
  40 #define BOUND_T2_SIZE (1 << BOUND_T2_BITS)
  41 #define BOUND_T3_SIZE (1 << BOUND_T3_BITS)
  42 #define BOUND_E_BITS  4
  43
  44 #define BOUND_T23_BITS (BOUND_T2_BITS + BOUND_T3_BITS)
  45 #define BOUND_T23_SIZE (1 << BOUND_T23_BITS)
  46
  47
  48 /* this pointer is generated when bound check is incorrect */
  49 #define INVALID_POINTER ((void *)(-2))
  50 /* size of an empty region */
  51 #define EMPTY_SIZE        0xffffffff
  52 /* size of an invalid region */
  53 #define INVALID_SIZE      0
  54
  55 typedef struct BoundEntry {
  56     unsigned long start;
  57     unsigned long size;
  58     struct BoundEntry *next;
  59     unsigned long is_invalid; /* true if pointers outside region are invalid */
  60 } BoundEntry;
  61
  62 /* external interface */
  63 void __bound_init(void);
  64 void __bound_new_region(void *p, unsigned long size);
  65 int __bound_delete_region(void *p);
  66
  67 /* currently, tcc cannot compile that because we use unsupported GNU C
  68    extensions */
  69 #if !defined(__TINYC__)
  70 void *__bound_ptr_add(void *p, int offset) __attribute__((regparm(2)));
  71 void *__bound_ptr_indir1(void *p, int offset) __attribute__((regparm(2)));
  72 void *__bound_ptr_indir2(void *p, int offset) __attribute__((regparm(2)));
  73 void *__bound_ptr_indir4(void *p, int offset) __attribute__((regparm(2)));
  74 void *__bound_ptr_indir8(void *p, int offset) __attribute__((regparm(2)));
  75 void *__bound_ptr_indir12(void *p, int offset) __attribute__((regparm(2)));
  76 void *__bound_ptr_indir16(void *p, int offset) __attribute__((regparm(2)));
  77 void __bound_local_new(void *p) __attribute__((regparm(1)));
  78 void __bound_local_delete(void *p) __attribute__((regparm(1)));
  79 #endif
  80
  81 void *__bound_malloc(size_t size, const void *caller);
  82 void *__bound_memalign(size_t size, size_t align, const void *caller);
  83 void __bound_free(void *ptr, const void *caller);
  84 void *__bound_realloc(void *ptr, size_t size, const void *caller);
  85 static void *libc_malloc(size_t size);
  86 static void libc_free(void *ptr);
  87 static void install_malloc_hooks(void);
  88 static void restore_malloc_hooks(void);
  89
  90 #ifdef CONFIG_TCC_MALLOC_HOOKS
  91 static void *saved_malloc_hook;
  92 static void *saved_free_hook;
  93 static void *saved_realloc_hook;
  94 static void *saved_memalign_hook;
  95 #endif
  96
  97 /* linker definitions */
  98 extern char _end;
  99
 100 /* TCC definitions */
 101 extern char __bounds_start; /* start of static bounds table */
 102 /* error message, just for TCC */
 103 const char *__bound_error_msg;
 104
 105 /* runtime error output */
 106 extern void rt_error(unsigned long pc, const char *fmt, ...);
 107
 108 #ifdef BOUND_STATIC
 109 static BoundEntry *__bound_t1[BOUND_T1_SIZE]; /* page table */
 110 #else
 111 static BoundEntry **__bound_t1; /* page table */
 112 #endif
 113 static BoundEntry *__bound_empty_t2;   /* empty page, for unused pages */
 114 static BoundEntry *__bound_invalid_t2; /* invalid page, for invalid pointers */
 115
 116 static BoundEntry *__bound_find_region(BoundEntry *e1, void *p)
 117 {
 118     unsigned long addr, tmp;
 119     BoundEntry *e;
 120
 121     e = e1;
 122     while (e != NULL) {
 123         addr = (unsigned long)p;
 124         addr -= e->start;
 125         if (addr <= e->size) {
 126             /* put region at the head */
 127             tmp = e1->start;
 128             e1->start = e->start;
 129             e->start = tmp;
 130             tmp = e1->size;
 131             e1->size = e->size;
 132             e->size = tmp;
 133             return e1;
 134         }
 135         e = e->next;
 136     }
 137     /* no entry found: return empty entry or invalid entry */
 138     if (e1->is_invalid)
 139         return __bound_invalid_t2;
 140     else
 141         return __bound_empty_t2;
 142 }
 143
 144 /* print a bound error message */
 145 static void bound_error(const char *fmt, ...)
 146 {
 147     __bound_error_msg = fmt;
 148     *(int *)0 = 0; /* force a runtime error */
 149 }
 150
 151 static void bound_alloc_error(void)
 152 {
 153     bound_error("not enough memory for bound checking code");
 154 }
 155
 156 /* currently, tcc cannot compile that because we use GNUC extensions */
 157 #if !defined(__TINYC__)
 158
 159 /* return '(p + offset)' for pointer arithmetic (a pointer can reach
 160    the end of a region in this case */
 161 void *__bound_ptr_add(void *p, int offset)
 162 {
 163     unsigned long addr = (unsigned long)p;
 164     BoundEntry *e;
 165 #if defined(BOUND_DEBUG)
 166     printf("add: 0x%x %d\n", (int)p, offset);
 167 #endif
 168
 169     e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)];
 170     e = (BoundEntry *)((char *)e +
 171                        ((addr >> (BOUND_T3_BITS - BOUND_E_BITS)) &
 172                         ((BOUND_T2_SIZE - 1) << BOUND_E_BITS)));
 173     addr -= e->start;
 174     if (addr > e->size) {
 175         e = __bound_find_region(e, p);
 176         addr = (unsigned long)p - e->start;
 177     }
 178     addr += offset;
 179     if (addr > e->size)
 180         return INVALID_POINTER; /* return an invalid pointer */
 181     return p + offset;
 182 }
 183
 184 /* return '(p + offset)' for pointer indirection (the resulting must
 185    be strictly inside the region */
 186 #define BOUND_PTR_INDIR(dsize)                                          \
 187 void *__bound_ptr_indir ## dsize (void *p, int offset)                  \
 188 {                                                                       \
 189     unsigned long addr = (unsigned long)p;                              \
 190     BoundEntry *e;                                                      \
 191                                                                         \
 192     e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)];            \
 193     e = (BoundEntry *)((char *)e +                                      \
 194                        ((addr >> (BOUND_T3_BITS - BOUND_E_BITS)) &      \
 195                         ((BOUND_T2_SIZE - 1) << BOUND_E_BITS)));        \
 196     addr -= e->start;                                                   \
 197     if (addr > e->size) {                                               \
 198         e = __bound_find_region(e, p);                                  \
 199         addr = (unsigned long)p - e->start;                             \
 200     }                                                                   \
 201     addr += offset + dsize;                                             \
 202     if (addr > e->size)                                                 \
 203         return INVALID_POINTER; /* return an invalid pointer */         \
 204     return p + offset;                                                  \
 205 }
 206
 207 #ifdef __i386__
 208 /* return the frame pointer of the caller */
 209 #define GET_CALLER_FP(fp)\
 210 {\
 211     unsigned long *fp1;\
 212     __asm__ __volatile__ ("movl %%ebp,%0" :"=g" (fp1));\
 213     fp = fp1[0];\
 214 }
 215 #else
 216 #error put code to extract the calling frame pointer
 217 #endif
 218
 219 /* called when entering a function to add all the local regions */
 220 void __bound_local_new(void *p1)
 221 {
 222     unsigned long addr, size, fp, *p = p1;
 223     GET_CALLER_FP(fp);
 224     for(;;) {
 225         addr = p[0];
 226         if (addr == 0)
 227             break;
 228         addr += fp;
 229         size = p[1];
 230         p += 2;
 231         __bound_new_region((void *)addr, size);
 232     }
 233 }
 234
 235 /* called when leaving a function to delete all the local regions */
 236 void __bound_local_delete(void *p1)
 237 {
 238     unsigned long addr, fp, *p = p1;
 239     GET_CALLER_FP(fp);
 240     for(;;) {
 241         addr = p[0];
 242         if (addr == 0)
 243             break;
 244         addr += fp;
 245         p += 2;
 246         __bound_delete_region((void *)addr);
 247     }
 248 }
 249
 250 #else
 251
 252 void __bound_local_new(void *p)
 253 {
 254 }
 255 void __bound_local_delete(void *p)
 256 {
 257 }
 258
 259 void *__bound_ptr_add(void *p, int offset)
 260 {
 261     return p + offset;
 262 }
 263
 264 #define BOUND_PTR_INDIR(dsize)                               \
 265 void *__bound_ptr_indir ## dsize (void *p, int offset)       \
 266 {                                                            \
 267     return p + offset;                                       \
 268 }
 269 #endif
 270
 271 BOUND_PTR_INDIR(1)
 272 BOUND_PTR_INDIR(2)
 273 BOUND_PTR_INDIR(4)
 274 BOUND_PTR_INDIR(8)
 275 BOUND_PTR_INDIR(12)
 276 BOUND_PTR_INDIR(16)
 277
 278 static BoundEntry *__bound_new_page(void)
 279 {
 280     BoundEntry *page;
 281     int i;
 282
 283     page = libc_malloc(sizeof(BoundEntry) * BOUND_T2_SIZE);
 284     if (!page)
 285         bound_alloc_error();
 286     for(i=0;i<BOUND_T2_SIZE;i++) {
 287         /* put empty entries */
 288         page[i].start = 0;
 289         page[i].size = EMPTY_SIZE;
 290         page[i].next = NULL;
 291         page[i].is_invalid = 0;
 292     }
 293     return page;
 294 }
 295
 296 /* currently we use malloc(). Should use bound_new_page() */
 297 static BoundEntry *bound_new_entry(void)
 298 {
 299     BoundEntry *e;
 300     e = libc_malloc(sizeof(BoundEntry));
 301     return e;
 302 }
 303
 304 static void bound_free_entry(BoundEntry *e)
 305 {
 306     libc_free(e);
 307 }
 308
 309 static inline BoundEntry *get_page(int index)
 310 {
 311     BoundEntry *page;
 312     page = __bound_t1[index];
 313     if (page == __bound_empty_t2 || page == __bound_invalid_t2) {
 314         /* create a new page if necessary */
 315         page = __bound_new_page();
 316         __bound_t1[index] = page;
 317     }
 318     return page;
 319 }
 320
 321 /* mark a region as being invalid (can only be used during init) */
 322 static void mark_invalid(unsigned long addr, unsigned long size)
 323 {
 324     unsigned long start, end;
 325     BoundEntry *page;
 326     int t1_start, t1_end, i, j, t2_start, t2_end;
 327
 328     start = addr;
 329     end = addr + size;
 330
 331     t2_start = (start + BOUND_T3_SIZE - 1) >> BOUND_T3_BITS;
 332     if (end != 0)
 333         t2_end = end >> BOUND_T3_BITS;
 334     else
 335         t2_end = 1 << (BOUND_T1_BITS + BOUND_T2_BITS);
 336
 337 #if 0
 338     printf("mark_invalid: start = %x %x\n", t2_start, t2_end);
 339 #endif
 340
 341     /* first we handle full pages */
 342     t1_start = (t2_start + BOUND_T2_SIZE - 1) >> BOUND_T2_BITS;
 343     t1_end = t2_end >> BOUND_T2_BITS;
 344
 345     i = t2_start & (BOUND_T2_SIZE - 1);
 346     j = t2_end & (BOUND_T2_SIZE - 1);
 347
 348     if (t1_start == t1_end) {
 349         page = get_page(t2_start >> BOUND_T2_BITS);
 350         for(; i < j; i++) {
 351             page[i].size = INVALID_SIZE;
 352             page[i].is_invalid = 1;
 353         }
 354     } else {
 355         if (i > 0) {
 356             page = get_page(t2_start >> BOUND_T2_BITS);
 357             for(; i < BOUND_T2_SIZE; i++) {
 358                 page[i].size = INVALID_SIZE;
 359                 page[i].is_invalid = 1;
 360             }
 361         }
 362         for(i = t1_start; i < t1_end; i++) {
 363             __bound_t1[i] = __bound_invalid_t2;
 364         }
 365         if (j != 0) {
 366             page = get_page(t1_end);
 367             for(i = 0; i < j; i++) {
 368                 page[i].size = INVALID_SIZE;
 369                 page[i].is_invalid = 1;
 370             }
 371         }
 372     }
 373 }
 374
 375 void __bound_init(void)
 376 {
 377     int i;
 378     BoundEntry *page;
 379     unsigned long start, size;
 380     int *p;
 381
 382     /* save malloc hooks and install bound check hooks */
 383     install_malloc_hooks();
 384
 385 #ifndef BOUND_STATIC
 386     __bound_t1 = libc_malloc(BOUND_T1_SIZE * sizeof(BoundEntry *));
 387     if (!__bound_t1)
 388         bound_alloc_error();
 389 #endif
 390     __bound_empty_t2 = __bound_new_page();
 391     for(i=0;i<BOUND_T1_SIZE;i++) {
 392         __bound_t1[i] = __bound_empty_t2;
 393     }
 394
 395     page = __bound_new_page();
 396     for(i=0;i<BOUND_T2_SIZE;i++) {
 397         /* put invalid entries */
 398         page[i].start = 0;
 399         page[i].size = INVALID_SIZE;
 400         page[i].next = NULL;
 401         page[i].is_invalid = 1;
 402     }
 403     __bound_invalid_t2 = page;
 404
 405     /* invalid pointer zone */
 406     start = (unsigned long)INVALID_POINTER & ~(BOUND_T23_SIZE - 1);
 407     size = BOUND_T23_SIZE;
 408     mark_invalid(start, size);
 409
 410 #if !defined(__TINYC__) && defined(CONFIG_TCC_MALLOC_HOOKS)
 411     /* malloc zone is also marked invalid. can only use that with
 412        hooks because all libs should use the same malloc. The solution
 413        would be to build a new malloc for tcc. */
 414     start = (unsigned long)&_end;
 415     size = 128 * 0x100000;
 416     mark_invalid(start, size);
 417 #endif
 418
 419     /* add all static bound check values */
 420     p = (int *)&__bounds_start;
 421     while (p[0] != 0) {
 422         __bound_new_region((void *)p[0], p[1]);
 423         p += 2;
 424     }
 425 }
 426
 427 static inline void add_region(BoundEntry *e,
 428                               unsigned long start, unsigned long size)
 429 {
 430     BoundEntry *e1;
 431     if (e->start == 0) {
 432         /* no region : add it */
 433         e->start = start;
 434         e->size = size;
 435     } else {
 436         /* already regions in the list: add it at the head */
 437         e1 = bound_new_entry();
 438         e1->start = e->start;
 439         e1->size = e->size;
 440         e1->next = e->next;
 441         e->start = start;
 442         e->size = size;
 443         e->next = e1;
 444     }
 445 }
 446
 447 /* create a new region. It should not already exist in the region list */
 448 void __bound_new_region(void *p, unsigned long size)
 449 {
 450     unsigned long start, end;
 451     BoundEntry *page, *e, *e2;
 452     int t1_start, t1_end, i, t2_start, t2_end;
 453
 454     start = (unsigned long)p;
 455     end = start + size;
 456     t1_start = start >> (BOUND_T2_BITS + BOUND_T3_BITS);
 457     t1_end = end >> (BOUND_T2_BITS + BOUND_T3_BITS);
 458
 459     /* start */
 460     page = get_page(t1_start);
 461     t2_start = (start >> (BOUND_T3_BITS - BOUND_E_BITS)) &
 462         ((BOUND_T2_SIZE - 1) << BOUND_E_BITS);
 463     t2_end = (end >> (BOUND_T3_BITS - BOUND_E_BITS)) &
 464         ((BOUND_T2_SIZE - 1) << BOUND_E_BITS);
 465 #ifdef BOUND_DEBUG
 466     printf("new %lx %lx %x %x %x %x\n",
 467            start, end, t1_start, t1_end, t2_start, t2_end);
 468 #endif
 469
 470     e = (BoundEntry *)((char *)page + t2_start);
 471     add_region(e, start, size);
 472
 473     if (t1_end == t1_start) {
 474         /* same ending page */
 475         e2 = (BoundEntry *)((char *)page + t2_end);
 476         if (e2 > e) {
 477             e++;
 478             for(;e<e2;e++) {
 479                 e->start = start;
 480                 e->size = size;
 481             }
 482             add_region(e, start, size);
 483         }
 484     } else {
 485         /* mark until end of page */
 486         e2 = page + BOUND_T2_SIZE;
 487         e++;
 488         for(;e<e2;e++) {
 489             e->start = start;
 490             e->size = size;
 491         }
 492         /* mark intermediate pages, if any */
 493         for(i=t1_start+1;i<t1_end;i++) {
 494             page = get_page(i);
 495             e2 = page + BOUND_T2_SIZE;
 496             for(e=page;e<e2;e++) {
 497                 e->start = start;
 498                 e->size = size;
 499             }
 500         }
 501         /* last page */
 502         page = get_page(t1_end);
 503         e2 = (BoundEntry *)((char *)page + t2_end);
 504         for(e=page;e<e2;e++) {
 505             e->start = start;
 506             e->size = size;
 507         }
 508         add_region(e, start, size);
 509     }
 510 }
 511
 512 /* delete a region */
 513 static inline void delete_region(BoundEntry *e,
 514                                  void *p, unsigned long empty_size)
 515 {
 516     unsigned long addr;
 517     BoundEntry *e1;
 518
 519     addr = (unsigned long)p;
 520     addr -= e->start;
 521     if (addr <= e->size) {
 522         /* region found is first one */
 523         e1 = e->next;
 524         if (e1 == NULL) {
 525             /* no more region: mark it empty */
 526             e->start = 0;
 527             e->size = empty_size;
 528         } else {
 529             /* copy next region in head */
 530             e->start = e1->start;
 531             e->size = e1->size;
 532             e->next = e1->next;
 533             bound_free_entry(e1);
 534         }
 535     } else {
 536         /* find the matching region */
 537         for(;;) {
 538             e1 = e;
 539             e = e->next;
 540             /* region not found: do nothing */
 541             if (e == NULL)
 542                 break;
 543             addr = (unsigned long)p - e->start;
 544             if (addr <= e->size) {
 545                 /* found: remove entry */
 546                 e1->next = e->next;
 547                 bound_free_entry(e);
 548                 break;
 549             }
 550         }
 551     }
 552 }
 553
 554 /* WARNING: 'p' must be the starting point of the region. */
 555 /* return non zero if error */
 556 int __bound_delete_region(void *p)
 557 {
 558     unsigned long start, end, addr, size, empty_size;
 559     BoundEntry *page, *e, *e2;
 560     int t1_start, t1_end, t2_start, t2_end, i;
 561
 562     start = (unsigned long)p;
 563     t1_start = start >> (BOUND_T2_BITS + BOUND_T3_BITS);
 564     t2_start = (start >> (BOUND_T3_BITS - BOUND_E_BITS)) &
 565         ((BOUND_T2_SIZE - 1) << BOUND_E_BITS);
 566
 567     /* find region size */
 568     page = __bound_t1[t1_start];
 569     e = (BoundEntry *)((char *)page + t2_start);
 570     addr = start - e->start;
 571     if (addr > e->size)
 572         e = __bound_find_region(e, p);
 573     /* test if invalid region */
 574     if (e->size == EMPTY_SIZE || (unsigned long)p != e->start)
 575         return -1;
 576     /* compute the size we put in invalid regions */
 577     if (e->is_invalid)
 578         empty_size = INVALID_SIZE;
 579     else
 580         empty_size = EMPTY_SIZE;
 581     size = e->size;
 582     end = start + size;
 583
 584     /* now we can free each entry */
 585     t1_end = end >> (BOUND_T2_BITS + BOUND_T3_BITS);
 586     t2_end = (end >> (BOUND_T3_BITS - BOUND_E_BITS)) &
 587         ((BOUND_T2_SIZE - 1) << BOUND_E_BITS);
 588
 589     delete_region(e, p, empty_size);
 590     if (t1_end == t1_start) {
 591         /* same ending page */
 592         e2 = (BoundEntry *)((char *)page + t2_end);
 593         if (e2 > e) {
 594             e++;
 595             for(;e<e2;e++) {
 596                 e->start = 0;
 597                 e->size = empty_size;
 598             }
 599             delete_region(e, p, empty_size);
 600         }
 601     } else {
 602         /* mark until end of page */
 603         e2 = page + BOUND_T2_SIZE;
 604         e++;
 605         for(;e<e2;e++) {
 606             e->start = 0;
 607             e->size = empty_size;
 608         }
 609         /* mark intermediate pages, if any */
 610         /* XXX: should free them */
 611         for(i=t1_start+1;i<t1_end;i++) {
 612             page = get_page(i);
 613             e2 = page + BOUND_T2_SIZE;
 614             for(e=page;e<e2;e++) {
 615                 e->start = 0;
 616                 e->size = empty_size;
 617             }
 618         }
 619         /* last page */
 620         page = get_page(t2_end);
 621         e2 = (BoundEntry *)((char *)page + t2_end);
 622         for(e=page;e<e2;e++) {
 623             e->start = 0;
 624             e->size = empty_size;
 625         }
 626         delete_region(e, p, empty_size);
 627     }
 628     return 0;
 629 }
 630
 631 /* return the size of the region starting at p, or EMPTY_SIZE if non
 632    existant region. */
 633 static unsigned long get_region_size(void *p)
 634 {
 635     unsigned long addr = (unsigned long)p;
 636     BoundEntry *e;
 637
 638     e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)];
 639     e = (BoundEntry *)((char *)e +
 640                        ((addr >> (BOUND_T3_BITS - BOUND_E_BITS)) &
 641                         ((BOUND_T2_SIZE - 1) << BOUND_E_BITS)));
 642     addr -= e->start;
 643     if (addr > e->size)
 644         e = __bound_find_region(e, p);
 645     if (e->start != (unsigned long)p)
 646         return EMPTY_SIZE;
 647     return e->size;
 648 }
 649
 650 /* patched memory functions */
 651
 652 static void install_malloc_hooks(void)
 653 {
 654 #ifdef CONFIG_TCC_MALLOC_HOOKS
 655     saved_malloc_hook = __malloc_hook;
 656     saved_free_hook = __free_hook;
 657     saved_realloc_hook = __realloc_hook;
 658     saved_memalign_hook = __memalign_hook;
 659     __malloc_hook = __bound_malloc;
 660     __free_hook = __bound_free;
 661     __realloc_hook = __bound_realloc;
 662     __memalign_hook = __bound_memalign;
 663 #endif
 664 }
 665
 666 static void restore_malloc_hooks(void)
 667 {
 668 #ifdef CONFIG_TCC_MALLOC_HOOKS
 669     __malloc_hook = saved_malloc_hook;
 670     __free_hook = saved_free_hook;
 671     __realloc_hook = saved_realloc_hook;
 672     __memalign_hook = saved_memalign_hook;
 673 #endif
 674 }
 675
 676 static void *libc_malloc(size_t size)
 677 {
 678     void *ptr;
 679     restore_malloc_hooks();
 680     ptr = malloc(size);
 681     install_malloc_hooks();
 682     return ptr;
 683 }
 684
 685 static void libc_free(void *ptr)
 686 {
 687     restore_malloc_hooks();
 688     free(ptr);
 689     install_malloc_hooks();
 690 }
 691
 692 /* XXX: we should use a malloc which ensure that it is unlikely that
 693    two malloc'ed data have the same address if 'free' are made in
 694    between. */
 695 void *__bound_malloc(size_t size, const void *caller)
 696 {
 697     void *ptr;
 698
 699     /* we allocate one more byte to ensure the regions will be
 700        separated by at least one byte. With the glibc malloc, it may
 701        be in fact not necessary */
 702     ptr = libc_malloc(size + 1);
 703
 704     if (!ptr)
 705         return NULL;
 706     __bound_new_region(ptr, size);
 707     return ptr;
 708 }
 709
 710 void *__bound_memalign(size_t size, size_t align, const void *caller)
 711 {
 712     void *ptr;
 713
 714     restore_malloc_hooks();
 715
 716     /* we allocate one more byte to ensure the regions will be
 717        separated by at least one byte. With the glibc malloc, it may
 718        be in fact not necessary */
 719     ptr = memalign(size + 1, align);
 720
 721     install_malloc_hooks();
 722
 723     if (!ptr)
 724         return NULL;
 725     __bound_new_region(ptr, size);
 726     return ptr;
 727 }
 728
 729 void __bound_free(void *ptr, const void *caller)
 730 {
 731     if (ptr == NULL)
 732         return;
 733     if (__bound_delete_region(ptr) != 0)
 734         bound_error("freeing invalid region");
 735
 736     libc_free(ptr);
 737 }
 738
 739 void *__bound_realloc(void *ptr, size_t size, const void *caller)
 740 {
 741     void *ptr1;
 742     int old_size;
 743
 744     if (size == 0) {
 745         __bound_free(ptr, caller);
 746         return NULL;
 747     } else {
 748         ptr1 = __bound_malloc(size, caller);
 749         if (ptr == NULL || ptr1 == NULL)
 750             return ptr1;
 751         old_size = get_region_size(ptr);
 752         if (old_size == EMPTY_SIZE)
 753             bound_error("realloc'ing invalid pointer");
 754         memcpy(ptr1, ptr, old_size);
 755         __bound_free(ptr, caller);
 756         return ptr1;
 757     }
 758 }
 759
 760 #ifndef CONFIG_TCC_MALLOC_HOOKS
 761 void *__bound_calloc(size_t nmemb, size_t size)
 762 {
 763     void *ptr;
 764     size = size * nmemb;
 765     ptr = __bound_malloc(size);
 766     if (!ptr)
 767         return NULL;
 768     memset(ptr, 0, size);
 769     return ptr;
 770 }
 771 #endif
 772
 773 #if 0
 774 static void bound_dump(void)
 775 {
 776     BoundEntry *page, *e;
 777     int i, j;
 778
 779     printf("region dump:\n");
 780     for(i=0;i<BOUND_T1_SIZE;i++) {
 781         page = __bound_t1[i];
 782         for(j=0;j<BOUND_T2_SIZE;j++) {
 783             e = page + j;
 784             /* do not print invalid or empty entries */
 785             if (e->size != EMPTY_SIZE && e->start != 0) {
 786                 printf("%08x:",
 787                        (i << (BOUND_T2_BITS + BOUND_T3_BITS)) +
 788                        (j << BOUND_T3_BITS));
 789                 do {
 790                     printf(" %08lx:%08lx", e->start, e->start + e->size);
 791                     e = e->next;
 792                 } while (e != NULL);
 793                 printf("\n");
 794             }
 795         }
 796     }
 797 }
 798 #endif
 799
 800 /* some useful checked functions */
 801
 802 /* check that (p ... p + size - 1) lies inside 'p' region, if any */
 803 static void __bound_check(const void *p, size_t size)
 804 {
 805     if (size == 0)
 806         return;
 807     p = __bound_ptr_add((void *)p, size);
 808     if (p == INVALID_POINTER)
 809         bound_error("invalid pointer");
 810 }
 811
 812 void *__bound_memcpy(void *dst, const void *src, size_t size)
 813 {
 814     __bound_check(dst, size);
 815     __bound_check(src, size);
 816     /* check also region overlap */
 817     if (src >= dst && src < dst + size)
 818         bound_error("overlapping regions in memcpy()");
 819     return memcpy(dst, src, size);
 820 }
 821
 822 void *__bound_memmove(void *dst, const void *src, size_t size)
 823 {
 824     __bound_check(dst, size);
 825     __bound_check(src, size);
 826     return memmove(dst, src, size);
 827 }
 828
 829 void *__bound_memset(void *dst, int c, size_t size)
 830 {
 831     __bound_check(dst, size);
 832     return memset(dst, c, size);
 833 }
 834
 835 /* XXX: could be optimized */
 836 int __bound_strlen(const char *s)
 837 {
 838     const char *p;
 839     int len;
 840
 841     len = 0;
 842     for(;;) {
 843         p = __bound_ptr_indir1((char *)s, len);
 844         if (p == INVALID_POINTER)
 845             bound_error("bad pointer in strlen()");
 846         if (*p == '\0')
 847             break;
 848         len++;
 849     }
 850     return len;
 851 }
 852
 853 char *__bound_strcpy(char *dst, const char *src)
 854 {
 855     int len;
 856     len = __bound_strlen(src);
 857     return __bound_memcpy(dst, src, len + 1);
 858 }
 859