Unified · Split
| @@ -0,0 +1,613 @@ | |||
| 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 | |||
| 21 | //#define BOUND_DEBUG | ||
| 22 | |||
| 23 | /* define so that bound array is static (faster, but use memory if | ||
| 24 | bound checking not used) */ | ||
| 25 | //#define BOUND_STATIC | ||
| 26 | |||
| 27 | #define BOUND_T1_BITS 13 | ||
| 28 | #define BOUND_T2_BITS 11 | ||
| 29 | #define BOUND_T3_BITS (32 - BOUND_T1_BITS - BOUND_T2_BITS) | ||
| 30 | |||
| 31 | #define BOUND_T1_SIZE (1 << BOUND_T1_BITS) | ||
| 32 | #define BOUND_T2_SIZE (1 << BOUND_T2_BITS) | ||
| 33 | #define BOUND_T3_SIZE (1 << BOUND_T3_BITS) | ||
| 34 | #define BOUND_E_BITS 4 | ||
| 35 | |||
| 36 | #define BOUND_T23_BITS (BOUND_T2_BITS + BOUND_T3_BITS) | ||
| 37 | #define BOUND_T23_SIZE (1 << BOUND_T23_BITS) | ||
| 38 | |||
| 39 | |||
| 40 | /* this pointer is generated when bound check is incorrect */ | ||
| 41 | #define INVALID_POINTER ((void *)(-2)) | ||
| 42 | /* size of an empty region */ | ||
| 43 | #define EMPTY_SIZE 0xffffffff | ||
| 44 | /* size of an invalid region */ | ||
| 45 | #define INVALID_SIZE 0 | ||
| 46 | |||
| 47 | typedef struct BoundEntry { | ||
| 48 | unsigned long start; | ||
| 49 | unsigned long size; | ||
| 50 | struct BoundEntry *next; | ||
| 51 | unsigned long is_invalid; /* true if pointers outside region are invalid */ | ||
| 52 | } BoundEntry; | ||
| 53 | |||
| 54 | /* external interface */ | ||
| 55 | void __bound_init(void); | ||
| 56 | void __bound_new_region(void *p, unsigned long size); | ||
| 57 | void __bound_delete_region(void *p); | ||
| 58 | |||
| 59 | void *__bound_ptr_add(void *p, int offset) __attribute__((regparm(2))); | ||
| 60 | char __bound_ptr_indir_b(void *p, int offset) __attribute__((regparm(2))); | ||
| 61 | unsigned char __bound_ptr_indir_ub(void *p, int offset) __attribute__((regparm(2))); | ||
| 62 | short __bound_ptr_indir_w(void *p, int offset) __attribute__((regparm(2))); | ||
| 63 | unsigned short __bound_ptr_indir_uw(void *p, int offset) __attribute__((regparm(2))); | ||
| 64 | int __bound_ptr_indir_i(void *p, int offset) __attribute((regparm(2))); | ||
| 65 | |||
| 66 | void *__bound_calloc(size_t nmemb, size_t size); | ||
| 67 | void *__bound_malloc(size_t size); | ||
| 68 | void __bound_free(void *ptr); | ||
| 69 | void *__bound_realloc(void *ptr, size_t size); | ||
| 70 | |||
| 71 | extern char _end; | ||
| 72 | |||
| 73 | #ifdef BOUND_STATIC | ||
| 74 | static BoundEntry *__bound_t1[BOUND_T1_SIZE]; /* page table */ | ||
| 75 | #else | ||
| 76 | static BoundEntry **__bound_t1; /* page table */ | ||
| 77 | #endif | ||
| 78 | static BoundEntry *__bound_empty_t2; /* empty page, for unused pages */ | ||
| 79 | static BoundEntry *__bound_invalid_t2; /* invalid page, for invalid pointers */ | ||
| 80 | |||
| 81 | static BoundEntry *__bound_find_region(BoundEntry *e1, void *p) | ||
| 82 | { | ||
| 83 | unsigned long addr, tmp; | ||
| 84 | BoundEntry *e; | ||
| 85 | |||
| 86 | e = e1; | ||
| 87 | while (e != NULL) { | ||
| 88 | addr = (unsigned long)p; | ||
| 89 | addr -= e->start; | ||
| 90 | if (addr <= e->size) { | ||
| 91 | /* put region at the head */ | ||
| 92 | tmp = e1->start; | ||
| 93 | e1->start = e->start; | ||
| 94 | e->start = tmp; | ||
| 95 | tmp = e1->size; | ||
| 96 | e1->size = e->size; | ||
| 97 | e->size = tmp; | ||
| 98 | return e1; | ||
| 99 | } | ||
| 100 | e = e->next; | ||
| 101 | } | ||
| 102 | /* no entry found: return empty entry or invalid entry */ | ||
| 103 | if (e1->is_invalid) | ||
| 104 | return __bound_invalid_t2; | ||
| 105 | else | ||
| 106 | return __bound_empty_t2; | ||
| 107 | } | ||
| 108 | |||
| 109 | static void bound_error(const char *fmt, ...) | ||
| 110 | { | ||
| 111 | va_list ap; | ||
| 112 | va_start(ap, fmt); | ||
| 113 | fprintf(stderr, "bounds check: "); | ||
| 114 | vfprintf(stderr, fmt, ap); | ||
| 115 | fprintf(stderr, "\n"); | ||
| 116 | exit(1); | ||
| 117 | va_end(ap); | ||
| 118 | } | ||
| 119 | |||
| 120 | static void bound_alloc_error(void) | ||
| 121 | { | ||
| 122 | bound_error("not enough memory for bound checking code\n"); | ||
| 123 | } | ||
| 124 | |||
| 125 | /* do: return (p + offset); */ | ||
| 126 | void *__bound_ptr_add(void *p, int offset) | ||
| 127 | { | ||
| 128 | unsigned long addr = (unsigned long)p; | ||
| 129 | BoundEntry *e; | ||
| 130 | #ifdef BOUND_DEBUG | ||
| 131 | printf("add: 0x%x %d\n", (int)p, offset); | ||
| 132 | #endif | ||
| 133 | |||
| 134 | e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)]; | ||
| 135 | e = (BoundEntry *)((char *)e + | ||
| 136 | ((addr >> (BOUND_T3_BITS - BOUND_E_BITS)) & | ||
| 137 | ((BOUND_T2_SIZE - 1) << BOUND_E_BITS))); | ||
| 138 | addr -= e->start; | ||
| 139 | if (addr > e->size) { | ||
| 140 | e = __bound_find_region(e, p); | ||
| 141 | addr = (unsigned long)p - e->start; | ||
| 142 | } | ||
| 143 | addr += offset; | ||
| 144 | if (addr > e->size) | ||
| 145 | return INVALID_POINTER; /* return an invalid pointer */ | ||
| 146 | return p + offset; | ||
| 147 | } | ||
| 148 | |||
| 149 | /* do: return *(type *)(p + offset); */ | ||
| 150 | #define BOUND_PTR_INDIR(suffix, type) \ | ||
| 151 | type __bound_ptr_indir_ ## suffix (void *p, int offset) \ | ||
| 152 | { \ | ||
| 153 | unsigned long addr = (unsigned long)p; \ | ||
| 154 | BoundEntry *e; \ | ||
| 155 | \ | ||
| 156 | e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)]; \ | ||
| 157 | e = (BoundEntry *)((char *)e + \ | ||
| 158 | ((addr >> (BOUND_T3_BITS - BOUND_E_BITS)) & \ | ||
| 159 | ((BOUND_T2_SIZE - 1) << BOUND_E_BITS))); \ | ||
| 160 | addr -= e->start; \ | ||
| 161 | if (addr > e->size) { \ | ||
| 162 | e = __bound_find_region(e, p); \ | ||
| 163 | addr = (unsigned long)p - e->start; \ | ||
| 164 | } \ | ||
| 165 | addr += offset + sizeof(type); \ | ||
| 166 | if (addr > e->size) \ | ||
| 167 | bound_error("dereferencing invalid pointer"); \ | ||
| 168 | return *(type *)(p + offset); \ | ||
| 169 | } | ||
| 170 | |||
| 171 | BOUND_PTR_INDIR(b, char) | ||
| 172 | BOUND_PTR_INDIR(ub, unsigned char) | ||
| 173 | BOUND_PTR_INDIR(w, short) | ||
| 174 | BOUND_PTR_INDIR(uw, unsigned short) | ||
| 175 | BOUND_PTR_INDIR(i, int) | ||
| 176 | |||
| 177 | static BoundEntry *__bound_new_page(void) | ||
| 178 | { | ||
| 179 | BoundEntry *page; | ||
| 180 | int i; | ||
| 181 | |||
| 182 | page = malloc(sizeof(BoundEntry) * BOUND_T2_SIZE); | ||
| 183 | if (!page) | ||
| 184 | bound_alloc_error(); | ||
| 185 | for(i=0;i<BOUND_T2_SIZE;i++) { | ||
| 186 | /* put empty entries */ | ||
| 187 | page[i].start = 0; | ||
| 188 | page[i].size = EMPTY_SIZE; | ||
| 189 | page[i].next = NULL; | ||
| 190 | page[i].is_invalid = 0; | ||
| 191 | } | ||
| 192 | return page; | ||
| 193 | } | ||
| 194 | |||
| 195 | /* currently we use malloc(). Should use bound_new_page() */ | ||
| 196 | static BoundEntry *bound_new_entry(void) | ||
| 197 | { | ||
| 198 | BoundEntry *e; | ||
| 199 | e = malloc(sizeof(BoundEntry)); | ||
| 200 | return e; | ||
| 201 | } | ||
| 202 | |||
| 203 | static void bound_free_entry(BoundEntry *e) | ||
| 204 | { | ||
| 205 | free(e); | ||
| 206 | } | ||
| 207 | |||
| 208 | static inline BoundEntry *get_page(int index) | ||
| 209 | { | ||
| 210 | BoundEntry *page; | ||
| 211 | page = __bound_t1[index]; | ||
| 212 | if (page == __bound_empty_t2 || page == __bound_invalid_t2) { | ||
| 213 | /* create a new page if necessary */ | ||
| 214 | page = __bound_new_page(); | ||
| 215 | __bound_t1[index] = page; | ||
| 216 | } | ||
| 217 | return page; | ||
| 218 | } | ||
| 219 | |||
| 220 | /* mark a region as being invalid (can only be used during init) */ | ||
| 221 | static void mark_invalid(unsigned long addr, unsigned long size) | ||
| 222 | { | ||
| 223 | unsigned long start, end; | ||
| 224 | BoundEntry *page; | ||
| 225 | int t1_start, t1_end, i, j, t2_start, t2_end; | ||
| 226 | |||
| 227 | start = addr; | ||
| 228 | end = addr + size; | ||
| 229 | |||
| 230 | t2_start = (start + BOUND_T3_SIZE - 1) >> BOUND_T3_BITS; | ||
| 231 | if (end != 0) | ||
| 232 | t2_end = end >> BOUND_T3_BITS; | ||
| 233 | else | ||
| 234 | t2_end = 1 << (BOUND_T1_BITS + BOUND_T2_BITS); | ||
| 235 | |||
| 236 | printf("mark_invalid: start = %x %x\n", t2_start, t2_end); | ||
| 237 | |||
| 238 | /* first we handle full pages */ | ||
| 239 | t1_start = (t2_start + BOUND_T2_SIZE - 1) >> BOUND_T2_BITS; | ||
| 240 | t1_end = t2_end >> BOUND_T2_BITS; | ||
| 241 | |||
| 242 | i = t2_start & (BOUND_T2_SIZE - 1); | ||
| 243 | j = t2_end & (BOUND_T2_SIZE - 1); | ||
| 244 | |||
| 245 | if (t1_start == t1_end) { | ||
| 246 | page = get_page(t2_start >> BOUND_T2_BITS); | ||
| 247 | for(; i < j; i++) { | ||
| 248 | page[i].size = INVALID_SIZE; | ||
| 249 | page[i].is_invalid = 1; | ||
| 250 | } | ||
| 251 | } else { | ||
| 252 | if (i > 0) { | ||
| 253 | page = get_page(t2_start >> BOUND_T2_BITS); | ||
| 254 | for(; i < BOUND_T2_SIZE; i++) { | ||
| 255 | page[i].size = INVALID_SIZE; | ||
| 256 | page[i].is_invalid = 1; | ||
| 257 | } | ||
| 258 | } | ||
| 259 | for(i = t1_start; i < t1_end; i++) { | ||
| 260 | __bound_t1[i] = __bound_invalid_t2; | ||
| 261 | } | ||
| 262 | if (j != 0) { | ||
| 263 | page = get_page(t1_end); | ||
| 264 | for(i = 0; i < j; i++) { | ||
| 265 | page[i].size = INVALID_SIZE; | ||
| 266 | page[i].is_invalid = 1; | ||
| 267 | } | ||
| 268 | } | ||
| 269 | } | ||
| 270 | } | ||
| 271 | |||
| 272 | void __bound_init(void) | ||
| 273 | { | ||
| 274 | int i; | ||
| 275 | BoundEntry *page; | ||
| 276 | unsigned long start, size; | ||
| 277 | |||
| 278 | #ifndef BOUND_STATIC | ||
| 279 | __bound_t1 = malloc(BOUND_T1_SIZE * sizeof(BoundEntry *)); | ||
| 280 | if (!__bound_t1) | ||
| 281 | bound_alloc_error(); | ||
| 282 | #endif | ||
| 283 | __bound_empty_t2 = __bound_new_page(); | ||
| 284 | for(i=0;i<BOUND_T1_SIZE;i++) { | ||
| 285 | __bound_t1[i] = __bound_empty_t2; | ||
| 286 | } | ||
| 287 | |||
| 288 | page = __bound_new_page(); | ||
| 289 | for(i=0;i<BOUND_T2_SIZE;i++) { | ||
| 290 | /* put invalid entries */ | ||
| 291 | page[i].start = 0; | ||
| 292 | page[i].size = INVALID_SIZE; | ||
| 293 | page[i].next = NULL; | ||
| 294 | page[i].is_invalid = 1; | ||
| 295 | } | ||
| 296 | __bound_invalid_t2 = page; | ||
| 297 | |||
| 298 | /* invalid pointer zone */ | ||
| 299 | start = (unsigned long)INVALID_POINTER & ~(BOUND_T23_SIZE - 1); | ||
| 300 | size = BOUND_T23_SIZE; | ||
| 301 | mark_invalid(start, size); | ||
| 302 | |||
| 303 | /* malloc zone is also marked invalid */ | ||
| 304 | start = (unsigned long)&_end; | ||
| 305 | size = 128 * 0x100000; | ||
| 306 | mark_invalid(start, size); | ||
| 307 | } | ||
| 308 | |||
| 309 | static inline void add_region(BoundEntry *e, | ||
| 310 | unsigned long start, unsigned long size) | ||
| 311 | { | ||
| 312 | BoundEntry *e1; | ||
| 313 | if (e->start == 0) { | ||
| 314 | /* no region : add it */ | ||
| 315 | e->start = start; | ||
| 316 | e->size = size; | ||
| 317 | } else { | ||
| 318 | /* already regions in the list: add it at the head */ | ||
| 319 | e1 = bound_new_entry(); | ||
| 320 | e1->start = e->start; | ||
| 321 | e1->size = e->size; | ||
| 322 | e1->next = e->next; | ||
| 323 | e->start = start; | ||
| 324 | e->size = size; | ||
| 325 | e->next = e1; | ||
| 326 | } | ||
| 327 | } | ||
| 328 | |||
| 329 | /* create a new region. It should not already exist in the region list */ | ||
| 330 | void __bound_new_region(void *p, unsigned long size) | ||
| 331 | { | ||
| 332 | unsigned long start, end; | ||
| 333 | BoundEntry *page, *e, *e2; | ||
| 334 | int t1_start, t1_end, i, t2_start, t2_end; | ||
| 335 | |||
| 336 | start = (unsigned long)p; | ||
| 337 | end = start + size; | ||
| 338 | t1_start = start >> (BOUND_T2_BITS + BOUND_T3_BITS); | ||
| 339 | t1_end = end >> (BOUND_T2_BITS + BOUND_T3_BITS); | ||
| 340 | |||
| 341 | /* start */ | ||
| 342 | page = get_page(t1_start); | ||
| 343 | t2_start = (start >> (BOUND_T3_BITS - BOUND_E_BITS)) & | ||
| 344 | ((BOUND_T2_SIZE - 1) << BOUND_E_BITS); | ||
| 345 | t2_end = (end >> (BOUND_T3_BITS - BOUND_E_BITS)) & | ||
| 346 | ((BOUND_T2_SIZE - 1) << BOUND_E_BITS); | ||
| 347 | #ifdef BOUND_DEBUG | ||
| 348 | printf("new %lx %lx %x %x %x %x\n", | ||
| 349 | start, end, t1_start, t1_end, t2_start, t2_end); | ||
| 350 | #endif | ||
| 351 | |||
| 352 | e = (BoundEntry *)((char *)page + t2_start); | ||
| 353 | add_region(e, start, size); | ||
| 354 | |||
| 355 | if (t1_end == t1_start) { | ||
| 356 | /* same ending page */ | ||
| 357 | e2 = (BoundEntry *)((char *)page + t2_end); | ||
| 358 | if (e2 > e) { | ||
| 359 | e++; | ||
| 360 | for(;e<e2;e++) { | ||
| 361 | e->start = start; | ||
| 362 | e->size = size; | ||
| 363 | } | ||
| 364 | add_region(e, start, size); | ||
| 365 | } | ||
| 366 | } else { | ||
| 367 | /* mark until end of page */ | ||
| 368 | e2 = page + BOUND_T2_SIZE; | ||
| 369 | e++; | ||
| 370 | for(;e<e2;e++) { | ||
| 371 | e->start = start; | ||
| 372 | e->size = size; | ||
| 373 | } | ||
| 374 | /* mark intermediate pages, if any */ | ||
| 375 | for(i=t1_start+1;i<t1_end;i++) { | ||
| 376 | page = get_page(i); | ||
| 377 | e2 = page + BOUND_T2_SIZE; | ||
| 378 | for(e=page;e<e2;e++) { | ||
| 379 | e->start = start; | ||
| 380 | e->size = size; | ||
| 381 | } | ||
| 382 | } | ||
| 383 | /* last page */ | ||
| 384 | page = get_page(t2_end); | ||
| 385 | e2 = (BoundEntry *)((char *)page + t2_end); | ||
| 386 | for(e=page;e<e2;e++) { | ||
| 387 | e->start = start; | ||
| 388 | e->size = size; | ||
| 389 | } | ||
| 390 | add_region(e, start, size); | ||
| 391 | } | ||
| 392 | } | ||
| 393 | |||
| 394 | /* delete a region */ | ||
| 395 | static inline void delete_region(BoundEntry *e, | ||
| 396 | void *p, unsigned long empty_size) | ||
| 397 | { | ||
| 398 | unsigned long addr; | ||
| 399 | BoundEntry *e1; | ||
| 400 | |||
| 401 | addr = (unsigned long)p; | ||
| 402 | addr -= e->start; | ||
| 403 | if (addr <= e->size) { | ||
| 404 | /* region found is first one */ | ||
| 405 | e1 = e->next; | ||
| 406 | if (e1 == NULL) { | ||
| 407 | /* no more region: mark it empty */ | ||
| 408 | e->start = 0; | ||
| 409 | e->size = empty_size; | ||
| 410 | } else { | ||
| 411 | /* copy next region in head */ | ||
| 412 | e->start = e1->start; | ||
| 413 | e->size = e1->size; | ||
| 414 | e->next = e1->next; | ||
| 415 | bound_free_entry(e1); | ||
| 416 | } | ||
| 417 | } else { | ||
| 418 | /* find the matching region */ | ||
| 419 | for(;;) { | ||
| 420 | e1 = e; | ||
| 421 | e = e->next; | ||
| 422 | /* region not found: do nothing */ | ||
| 423 | if (e == NULL) | ||
| 424 | break; | ||
| 425 | addr = (unsigned long)p - e->start; | ||
| 426 | if (addr <= e->size) { | ||
| 427 | /* found: remove entry */ | ||
| 428 | e1->next = e->next; | ||
| 429 | bound_free_entry(e); | ||
| 430 | break; | ||
| 431 | } | ||
| 432 | } | ||
| 433 | } | ||
| 434 | } | ||
| 435 | |||
| 436 | /* WARNING: 'p' must be the starting point of the region. */ | ||
| 437 | void __bound_delete_region(void *p) | ||
| 438 | { | ||
| 439 | unsigned long start, end, addr, size, empty_size; | ||
| 440 | BoundEntry *page, *e, *e2; | ||
| 441 | int t1_start, t1_end, t2_start, t2_end, i; | ||
| 442 | |||
| 443 | start = (unsigned long)p; | ||
| 444 | t1_start = start >> (BOUND_T2_BITS + BOUND_T3_BITS); | ||
| 445 | t2_start = (start >> (BOUND_T3_BITS - BOUND_E_BITS)) & | ||
| 446 | ((BOUND_T2_SIZE - 1) << BOUND_E_BITS); | ||
| 447 | |||
| 448 | /* find region size */ | ||
| 449 | page = __bound_t1[t1_start]; | ||
| 450 | e = (BoundEntry *)((char *)page + t2_start); | ||
| 451 | addr = start - e->start; | ||
| 452 | if (addr > e->size) | ||
| 453 | e = __bound_find_region(e, p); | ||
| 454 | /* test if invalid region */ | ||
| 455 | if (e->size == EMPTY_SIZE || (unsigned long)p != e->start) | ||
| 456 | bound_error("deleting invalid region"); | ||
| 457 | /* compute the size we put in invalid regions */ | ||
| 458 | if (e->is_invalid) | ||
| 459 | empty_size = INVALID_SIZE; | ||
| 460 | else | ||
| 461 | empty_size = EMPTY_SIZE; | ||
| 462 | size = e->size; | ||
| 463 | end = start + size; | ||
| 464 | |||
| 465 | /* now we can free each entry */ | ||
| 466 | t1_end = end >> (BOUND_T2_BITS + BOUND_T3_BITS); | ||
| 467 | t2_end = (end >> (BOUND_T3_BITS - BOUND_E_BITS)) & | ||
| 468 | ((BOUND_T2_SIZE - 1) << BOUND_E_BITS); | ||
| 469 | |||
| 470 | delete_region(e, p, empty_size); | ||
| 471 | if (t1_end == t1_start) { | ||
| 472 | /* same ending page */ | ||
| 473 | e2 = (BoundEntry *)((char *)page + t2_end); | ||
| 474 | if (e2 > e) { | ||
| 475 | e++; | ||
| 476 | for(;e<e2;e++) { | ||
| 477 | e->start = 0; | ||
| 478 | e->size = empty_size; | ||
| 479 | } | ||
| 480 | delete_region(e, p, empty_size); | ||
| 481 | } | ||
| 482 | } else { | ||
| 483 | /* mark until end of page */ | ||
| 484 | e2 = page + BOUND_T2_SIZE; | ||
| 485 | e++; | ||
| 486 | for(;e<e2;e++) { | ||
| 487 | e->start = 0; | ||
| 488 | e->size = empty_size; | ||
| 489 | } | ||
| 490 | /* mark intermediate pages, if any */ | ||
| 491 | /* XXX: should free them */ | ||
| 492 | for(i=t1_start+1;i<t1_end;i++) { | ||
| 493 | page = get_page(i); | ||
| 494 | e2 = page + BOUND_T2_SIZE; | ||
| 495 | for(e=page;e<e2;e++) { | ||
| 496 | e->start = 0; | ||
| 497 | e->size = empty_size; | ||
| 498 | } | ||
| 499 | } | ||
| 500 | /* last page */ | ||
| 501 | page = get_page(t2_end); | ||
| 502 | e2 = (BoundEntry *)((char *)page + t2_end); | ||
| 503 | for(e=page;e<e2;e++) { | ||
| 504 | e->start = 0; | ||
| 505 | e->size = empty_size; | ||
| 506 | } | ||
| 507 | delete_region(e, p, empty_size); | ||
| 508 | } | ||
| 509 | } | ||
| 510 | |||
| 511 | /* return the size of the region starting at p, or EMPTY_SIZE if non | ||
| 512 | existant region. */ | ||
| 513 | static unsigned long get_region_size(void *p) | ||
| 514 | { | ||
| 515 | unsigned long addr = (unsigned long)p; | ||
| 516 | BoundEntry *e; | ||
| 517 | |||
| 518 | e = __bound_t1[addr >> (BOUND_T2_BITS + BOUND_T3_BITS)]; | ||
| 519 | e = (BoundEntry *)((char *)e + | ||
| 520 | ((addr >> (BOUND_T3_BITS - BOUND_E_BITS)) & | ||
| 521 | ((BOUND_T2_SIZE - 1) << BOUND_E_BITS))); | ||
| 522 | addr -= e->start; | ||
| 523 | if (addr > e->size) | ||
| 524 | e = __bound_find_region(e, p); | ||
| 525 | if (e->start != (unsigned long)p) | ||
| 526 | return EMPTY_SIZE; | ||
| 527 | return e->size; | ||
| 528 | } | ||
| 529 | |||
| 530 | /* patched memory functions */ | ||
| 531 | |||
| 532 | /* XXX: we should use a malloc which ensure that it is unlikely that | ||
| 533 | two malloc'ed data have the same address if 'free' are made in | ||
| 534 | between. */ | ||
| 535 | void *__bound_malloc(size_t size) | ||
| 536 | { | ||
| 537 | void *ptr; | ||
| 538 | /* we allocate one more byte to ensure the regions will be | ||
| 539 | separated by at least one byte. With the glibc malloc, it may | ||
| 540 | be in fact not necessary */ | ||
| 541 | ptr = malloc(size + 1); | ||
| 542 | if (!ptr) | ||
| 543 | return NULL; | ||
| 544 | __bound_new_region(ptr, size); | ||
| 545 | return ptr; | ||
| 546 | } | ||
| 547 | |||
| 548 | void __bound_free(void *ptr) | ||
| 549 | { | ||
| 550 | if (ptr == NULL) | ||
| 551 | return; | ||
| 552 | __bound_delete_region(ptr); | ||
| 553 | free(ptr); | ||
| 554 | } | ||
| 555 | |||
| 556 | void *__bound_realloc(void *ptr, size_t size) | ||
| 557 | { | ||
| 558 | void *ptr1; | ||
| 559 | int old_size; | ||
| 560 | |||
| 561 | if (size == 0) { | ||
| 562 | __bound_free(ptr); | ||
| 563 | return NULL; | ||
| 564 | } else { | ||
| 565 | ptr1 = __bound_malloc(size); | ||
| 566 | if (ptr == NULL || ptr1 == NULL) | ||
| 567 | return ptr1; | ||
| 568 | old_size = get_region_size(ptr); | ||
| 569 | if (old_size == EMPTY_SIZE) | ||
| 570 | bound_error("realloc'ing invalid pointer"); | ||
| 571 | memcpy(ptr1, ptr, old_size); | ||
| 572 | __bound_free(ptr); | ||
| 573 | return ptr1; | ||
| 574 | } | ||
| 575 | } | ||
| 576 | |||
| 577 | void *__bound_calloc(size_t nmemb, size_t size) | ||
| 578 | { | ||
| 579 | void *ptr; | ||
| 580 | size = size * nmemb; | ||
| 581 | ptr = __bound_malloc(size); | ||
| 582 | if (!ptr) | ||
| 583 | return NULL; | ||
| 584 | memset(ptr, 0, size); | ||
| 585 | return ptr; | ||
| 586 | } | ||
| 587 | |||
| 588 | #if 0 | ||
| 589 | static void bound_dump(void) | ||
| 590 | { | ||
| 591 | BoundEntry *page, *e; | ||
| 592 | int i, j; | ||
| 593 | |||
| 594 | printf("region dump:\n"); | ||
| 595 | for(i=0;i<BOUND_T1_SIZE;i++) { | ||
| 596 | page = __bound_t1[i]; | ||
| 597 | for(j=0;j<BOUND_T2_SIZE;j++) { | ||
| 598 | e = page + j; | ||
| 599 | /* do not print invalid or empty entries */ | ||
| 600 | if (e->size != EMPTY_SIZE && e->start != 0) { | ||
| 601 | printf("%08x:", | ||
| 602 | (i << (BOUND_T2_BITS + BOUND_T3_BITS)) + | ||
| 603 | (j << BOUND_T3_BITS)); | ||
| 604 | do { | ||
| 605 | printf(" %08lx:%08lx", e->start, e->start + e->size); | ||
| 606 | e = e->next; | ||
| 607 | } while (e != NULL); | ||
| 608 | printf("\n"); | ||
| 609 | } | ||
| 610 | } | ||
| 611 | } | ||
| 612 | } | ||
| 613 | #endif | ||