malloc.c revision 1.37
1 1.37 christos /* $NetBSD: malloc.c,v 1.37 2001/05/03 15:35:12 christos Exp $ */ 2 1.18 thorpej 3 1.1 cgd /* 4 1.17 tls * ---------------------------------------------------------------------------- 5 1.17 tls * "THE BEER-WARE LICENSE" (Revision 42): 6 1.17 tls * <phk (at) FreeBSD.ORG> wrote this file. As long as you retain this notice you 7 1.17 tls * can do whatever you want with this stuff. If we meet some day, and you think 8 1.17 tls * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp 9 1.17 tls * ---------------------------------------------------------------------------- 10 1.1 cgd * 11 1.17 tls * From FreeBSD: malloc.c,v 1.43 1998/09/30 06:13:59 jb 12 1.1 cgd * 13 1.17 tls */ 14 1.17 tls 15 1.17 tls /* 16 1.19 thorpej * Defining MALLOC_EXTRA_SANITY will enable extra checks which are related 17 1.17 tls * to internal conditions and consistency in malloc.c. This has a 18 1.17 tls * noticeable runtime performance hit, and generally will not do you 19 1.17 tls * any good unless you fiddle with the internals of malloc or want 20 1.17 tls * to catch random pointer corruption as early as possible. 21 1.17 tls */ 22 1.17 tls #ifndef MALLOC_EXTRA_SANITY 23 1.17 tls #undef MALLOC_EXTRA_SANITY 24 1.5 thorpej #endif 25 1.1 cgd 26 1.1 cgd /* 27 1.17 tls * What to use for Junk. This is the byte value we use to fill with 28 1.17 tls * when the 'J' option is enabled. 29 1.17 tls */ 30 1.17 tls #define SOME_JUNK 0xd0 /* as in "Duh" :-) */ 31 1.17 tls 32 1.17 tls /* 33 1.17 tls * The basic parameters you can tweak. 34 1.17 tls * 35 1.17 tls * malloc_minsize minimum size of an allocation in bytes. 36 1.17 tls * If this is too small it's too much work 37 1.17 tls * to manage them. This is also the smallest 38 1.17 tls * unit of alignment used for the storage 39 1.17 tls * returned by malloc/realloc. 40 1.1 cgd * 41 1.1 cgd */ 42 1.1 cgd 43 1.17 tls #if defined(__FreeBSD__) 44 1.17 tls # if defined(__i386__) 45 1.17 tls # define malloc_minsize 16U 46 1.17 tls # endif 47 1.17 tls # if defined(__alpha__) 48 1.17 tls # define malloc_minsize 16U 49 1.17 tls # endif 50 1.35 jdolecek # define HAS_UTRACE 51 1.35 jdolecek # define UTRACE_LABEL 52 1.35 jdolecek 53 1.35 jdolecek #include <sys/cdefs.h> 54 1.35 jdolecek void utrace __P((struct ut *, int)); 55 1.35 jdolecek 56 1.17 tls /* 57 1.17 tls * Make malloc/free/realloc thread-safe in libc for use with 58 1.17 tls * kernel threads. 59 1.17 tls */ 60 1.17 tls # include "libc_private.h" 61 1.17 tls # include "spinlock.h" 62 1.17 tls static spinlock_t thread_lock = _SPINLOCK_INITIALIZER; 63 1.17 tls # define THREAD_LOCK() if (__isthreaded) _SPINLOCK(&thread_lock); 64 1.17 tls # define THREAD_UNLOCK() if (__isthreaded) _SPINUNLOCK(&thread_lock); 65 1.17 tls #endif /* __FreeBSD__ */ 66 1.17 tls 67 1.17 tls #if defined(__NetBSD__) 68 1.17 tls # define malloc_minsize 16U 69 1.35 jdolecek # define HAS_UTRACE 70 1.35 jdolecek # define UTRACE_LABEL "malloc", 71 1.35 jdolecek #include <sys/cdefs.h> 72 1.35 jdolecek #include <sys/types.h> 73 1.35 jdolecek int utrace __P((const char *, void *, size_t)); 74 1.17 tls #endif /* __NetBSD__ */ 75 1.17 tls 76 1.17 tls #if defined(__sparc__) && defined(sun) 77 1.17 tls # define malloc_minsize 16U 78 1.17 tls # define MAP_ANON (0) 79 1.17 tls static int fdzero; 80 1.17 tls # define MMAP_FD fdzero 81 1.17 tls # define INIT_MMAP() \ 82 1.17 tls { if ((fdzero=open("/dev/zero", O_RDWR, 0000)) == -1) \ 83 1.17 tls wrterror("open of /dev/zero"); } 84 1.17 tls #endif /* __sparc__ */ 85 1.17 tls 86 1.17 tls /* Insert your combination here... */ 87 1.17 tls #if defined(__FOOCPU__) && defined(__BAROS__) 88 1.17 tls # define malloc_minsize 16U 89 1.17 tls #endif /* __FOOCPU__ && __BAROS__ */ 90 1.17 tls 91 1.17 tls 92 1.17 tls /* 93 1.17 tls * No user serviceable parts behind this point. 94 1.17 tls */ 95 1.25 kleink #include "namespace.h" 96 1.16 kleink #include <sys/types.h> 97 1.17 tls #include <sys/mman.h> 98 1.17 tls #include <errno.h> 99 1.17 tls #include <fcntl.h> 100 1.17 tls #include <stddef.h> 101 1.9 christos #include <stdio.h> 102 1.1 cgd #include <stdlib.h> 103 1.1 cgd #include <string.h> 104 1.1 cgd #include <unistd.h> 105 1.1 cgd 106 1.17 tls /* 107 1.17 tls * This structure describes a page worth of chunks. 108 1.17 tls */ 109 1.17 tls 110 1.17 tls struct pginfo { 111 1.17 tls struct pginfo *next; /* next on the free list */ 112 1.17 tls void *page; /* Pointer to the page */ 113 1.17 tls u_short size; /* size of this page's chunks */ 114 1.17 tls u_short shift; /* How far to shift for this size chunks */ 115 1.17 tls u_short free; /* How many free chunks */ 116 1.17 tls u_short total; /* How many chunk */ 117 1.17 tls u_int bits[1]; /* Which chunks are free */ 118 1.17 tls }; 119 1.1 cgd 120 1.1 cgd /* 121 1.17 tls * This structure describes a number of free pages. 122 1.17 tls */ 123 1.17 tls 124 1.17 tls struct pgfree { 125 1.17 tls struct pgfree *next; /* next run of free pages */ 126 1.17 tls struct pgfree *prev; /* prev run of free pages */ 127 1.17 tls void *page; /* pointer to free pages */ 128 1.17 tls void *end; /* pointer to end of free pages */ 129 1.17 tls size_t size; /* number of bytes free */ 130 1.1 cgd }; 131 1.1 cgd 132 1.17 tls /* 133 1.17 tls * How many bits per u_int in the bitmap. 134 1.17 tls * Change only if not 8 bits/byte 135 1.17 tls */ 136 1.17 tls #define MALLOC_BITS (8*sizeof(u_int)) 137 1.17 tls 138 1.17 tls /* 139 1.17 tls * Magic values to put in the page_directory 140 1.17 tls */ 141 1.17 tls #define MALLOC_NOT_MINE ((struct pginfo*) 0) 142 1.17 tls #define MALLOC_FREE ((struct pginfo*) 1) 143 1.17 tls #define MALLOC_FIRST ((struct pginfo*) 2) 144 1.17 tls #define MALLOC_FOLLOW ((struct pginfo*) 3) 145 1.17 tls #define MALLOC_MAGIC ((struct pginfo*) 4) 146 1.17 tls 147 1.20 thorpej /* 148 1.20 thorpej * Page size related parameters, computed at run-time. 149 1.20 thorpej */ 150 1.20 thorpej static size_t malloc_pagesize; 151 1.20 thorpej static size_t malloc_pageshift; 152 1.20 thorpej static size_t malloc_pagemask; 153 1.17 tls 154 1.17 tls #ifndef malloc_minsize 155 1.17 tls #define malloc_minsize 16U 156 1.17 tls #endif 157 1.17 tls 158 1.17 tls #ifndef malloc_maxsize 159 1.17 tls #define malloc_maxsize ((malloc_pagesize)>>1) 160 1.17 tls #endif 161 1.17 tls 162 1.17 tls #define pageround(foo) (((foo) + (malloc_pagemask))&(~(malloc_pagemask))) 163 1.33 christos #define ptr2idx(foo) (((size_t)(u_long)(foo) >> malloc_pageshift)-malloc_origo) 164 1.1 cgd 165 1.17 tls #ifndef THREAD_LOCK 166 1.17 tls #define THREAD_LOCK() 167 1.17 tls #endif 168 1.1 cgd 169 1.17 tls #ifndef THREAD_UNLOCK 170 1.17 tls #define THREAD_UNLOCK() 171 1.16 kleink #endif 172 1.16 kleink 173 1.17 tls #ifndef MMAP_FD 174 1.17 tls #define MMAP_FD (-1) 175 1.1 cgd #endif 176 1.1 cgd 177 1.17 tls #ifndef INIT_MMAP 178 1.17 tls #define INIT_MMAP() 179 1.18 thorpej #endif 180 1.18 thorpej 181 1.18 thorpej #ifndef MADV_FREE 182 1.18 thorpej #define MADV_FREE MADV_DONTNEED 183 1.9 christos #endif 184 1.9 christos 185 1.17 tls /* Set when initialization has been done */ 186 1.17 tls static unsigned malloc_started; 187 1.17 tls 188 1.17 tls /* Recusion flag for public interface. */ 189 1.17 tls static int malloc_active; 190 1.17 tls 191 1.17 tls /* Number of free pages we cache */ 192 1.17 tls static unsigned malloc_cache = 16; 193 1.17 tls 194 1.17 tls /* The offset from pagenumber to index into the page directory */ 195 1.30 enami static size_t malloc_origo; 196 1.17 tls 197 1.17 tls /* The last index in the page directory we care about */ 198 1.30 enami static size_t last_idx; 199 1.17 tls 200 1.17 tls /* Pointer to page directory. Allocated "as if with" malloc */ 201 1.17 tls static struct pginfo **page_dir; 202 1.17 tls 203 1.17 tls /* How many slots in the page directory */ 204 1.17 tls static unsigned malloc_ninfo; 205 1.17 tls 206 1.17 tls /* Free pages line up here */ 207 1.17 tls static struct pgfree free_list; 208 1.17 tls 209 1.17 tls /* Abort(), user doesn't handle problems. */ 210 1.17 tls static int malloc_abort; 211 1.17 tls 212 1.17 tls /* Are we trying to die ? */ 213 1.17 tls static int suicide; 214 1.17 tls 215 1.17 tls /* always realloc ? */ 216 1.17 tls static int malloc_realloc; 217 1.9 christos 218 1.17 tls /* pass the kernel a hint on free pages ? */ 219 1.32 simonb static int malloc_hint = 0; 220 1.17 tls 221 1.17 tls /* xmalloc behaviour ? */ 222 1.17 tls static int malloc_xmalloc; 223 1.17 tls 224 1.17 tls /* sysv behaviour for malloc(0) ? */ 225 1.17 tls static int malloc_sysv; 226 1.17 tls 227 1.17 tls /* zero fill ? */ 228 1.17 tls static int malloc_zero; 229 1.17 tls 230 1.17 tls /* junk fill ? */ 231 1.17 tls static int malloc_junk; 232 1.17 tls 233 1.17 tls #ifdef HAS_UTRACE 234 1.17 tls 235 1.17 tls /* utrace ? */ 236 1.17 tls static int malloc_utrace; 237 1.17 tls 238 1.17 tls struct ut { void *p; size_t s; void *r; }; 239 1.17 tls 240 1.17 tls #define UTRACE(a, b, c) \ 241 1.35 jdolecek if (malloc_utrace) { \ 242 1.35 jdolecek struct ut u; \ 243 1.35 jdolecek u.p=a; u.s = b; u.r=c; \ 244 1.35 jdolecek utrace(UTRACE_LABEL (void *) &u, sizeof u); \ 245 1.35 jdolecek } 246 1.17 tls #else /* !HAS_UTRACE */ 247 1.17 tls #define UTRACE(a,b,c) 248 1.17 tls #endif /* HAS_UTRACE */ 249 1.17 tls 250 1.17 tls /* my last break. */ 251 1.17 tls static void *malloc_brk; 252 1.17 tls 253 1.17 tls /* one location cache for free-list holders */ 254 1.17 tls static struct pgfree *px; 255 1.17 tls 256 1.17 tls /* compile-time options */ 257 1.17 tls char *malloc_options; 258 1.17 tls 259 1.17 tls /* Name of the current public function */ 260 1.22 thorpej static char *malloc_func; 261 1.17 tls 262 1.17 tls /* Macro for mmap */ 263 1.17 tls #define MMAP(size) \ 264 1.17 tls mmap(0, (size), PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, \ 265 1.30 enami MMAP_FD, (off_t)0); 266 1.9 christos 267 1.16 kleink /* 268 1.17 tls * Necessary function declarations 269 1.16 kleink */ 270 1.30 enami static int extend_pgdir(size_t idx); 271 1.17 tls static void *imalloc(size_t size); 272 1.17 tls static void ifree(void *ptr); 273 1.17 tls static void *irealloc(void *ptr, size_t size); 274 1.17 tls 275 1.17 tls static void 276 1.22 thorpej wrterror(char *p) 277 1.17 tls { 278 1.36 cgd const char *progname = getprogname(); 279 1.22 thorpej char *q = " error: "; 280 1.36 cgd write(STDERR_FILENO, progname, strlen(progname)); 281 1.17 tls write(STDERR_FILENO, malloc_func, strlen(malloc_func)); 282 1.17 tls write(STDERR_FILENO, q, strlen(q)); 283 1.17 tls write(STDERR_FILENO, p, strlen(p)); 284 1.17 tls suicide = 1; 285 1.17 tls abort(); 286 1.17 tls } 287 1.17 tls 288 1.16 kleink static void 289 1.22 thorpej wrtwarning(char *p) 290 1.1 cgd { 291 1.36 cgd const char *progname = getprogname(); 292 1.22 thorpej char *q = " warning: "; 293 1.17 tls if (malloc_abort) 294 1.17 tls wrterror(p); 295 1.36 cgd write(STDERR_FILENO, progname, strlen(progname)); 296 1.17 tls write(STDERR_FILENO, malloc_func, strlen(malloc_func)); 297 1.17 tls write(STDERR_FILENO, q, strlen(q)); 298 1.17 tls write(STDERR_FILENO, p, strlen(p)); 299 1.17 tls } 300 1.17 tls 301 1.16 kleink 302 1.17 tls /* 303 1.17 tls * Allocate a number of pages from the OS 304 1.17 tls */ 305 1.17 tls static void * 306 1.30 enami map_pages(size_t pages) 307 1.17 tls { 308 1.17 tls caddr_t result, tail; 309 1.16 kleink 310 1.34 christos result = (caddr_t)pageround((size_t)(u_long)sbrk((intptr_t)0)); 311 1.17 tls tail = result + (pages << malloc_pageshift); 312 1.17 tls 313 1.17 tls if (brk(tail)) { 314 1.19 thorpej #ifdef MALLOC_EXTRA_SANITY 315 1.17 tls wrterror("(ES): map_pages fails\n"); 316 1.19 thorpej #endif /* MALLOC_EXTRA_SANITY */ 317 1.17 tls return 0; 318 1.17 tls } 319 1.23 thorpej last_idx = ptr2idx(tail) - 1; 320 1.17 tls malloc_brk = tail; 321 1.17 tls 322 1.23 thorpej if ((last_idx+1) >= malloc_ninfo && !extend_pgdir(last_idx)) 323 1.17 tls return 0;; 324 1.16 kleink 325 1.17 tls return result; 326 1.1 cgd } 327 1.1 cgd 328 1.17 tls /* 329 1.17 tls * Extend page directory 330 1.17 tls */ 331 1.17 tls static int 332 1.30 enami extend_pgdir(size_t idx) 333 1.1 cgd { 334 1.17 tls struct pginfo **new, **old; 335 1.30 enami size_t newlen, oldlen; 336 1.37 christos 337 1.37 christos /* check for overflow */ 338 1.37 christos if ((((~(1UL << ((sizeof(size_t) * NBBY) - 1)) / sizeof(*page_dir)) + 1) 339 1.37 christos + (malloc_pagesize / sizeof *page_dir)) < idx) { 340 1.37 christos errno = ENOMEM; 341 1.37 christos return 0; 342 1.37 christos } 343 1.1 cgd 344 1.17 tls /* Make it this many pages */ 345 1.30 enami newlen = pageround(idx * sizeof *page_dir) + malloc_pagesize; 346 1.17 tls 347 1.17 tls /* remember the old mapping size */ 348 1.17 tls oldlen = malloc_ninfo * sizeof *page_dir; 349 1.17 tls 350 1.17 tls /* 351 1.17 tls * NOTE: we allocate new pages and copy the directory rather than tempt 352 1.17 tls * fate by trying to "grow" the region.. There is nothing to prevent 353 1.17 tls * us from accidently re-mapping space that's been allocated by our caller 354 1.17 tls * via dlopen() or other mmap(). 355 1.17 tls * 356 1.17 tls * The copy problem is not too bad, as there is 4K of page index per 357 1.17 tls * 4MB of malloc arena. 358 1.17 tls * 359 1.17 tls * We can totally avoid the copy if we open a file descriptor to associate 360 1.17 tls * the anon mappings with. Then, when we remap the pages at the new 361 1.17 tls * address, the old pages will be "magically" remapped.. But this means 362 1.17 tls * keeping open a "secret" file descriptor..... 363 1.17 tls */ 364 1.17 tls 365 1.17 tls /* Get new pages */ 366 1.30 enami new = (struct pginfo**) MMAP(newlen); 367 1.17 tls if (new == (struct pginfo **)-1) 368 1.17 tls return 0; 369 1.17 tls 370 1.17 tls /* Copy the old stuff */ 371 1.30 enami memcpy(new, page_dir, oldlen); 372 1.17 tls 373 1.17 tls /* register the new size */ 374 1.30 enami malloc_ninfo = newlen / sizeof *page_dir; 375 1.17 tls 376 1.17 tls /* swap the pointers */ 377 1.17 tls old = page_dir; 378 1.17 tls page_dir = new; 379 1.17 tls 380 1.17 tls /* Now free the old stuff */ 381 1.17 tls munmap(old, oldlen); 382 1.17 tls return 1; 383 1.17 tls } 384 1.16 kleink 385 1.17 tls /* 386 1.17 tls * Initialize the world 387 1.17 tls */ 388 1.17 tls static void 389 1.17 tls malloc_init (void) 390 1.17 tls { 391 1.17 tls char *p, b[64]; 392 1.17 tls int i, j; 393 1.17 tls int errnosave; 394 1.20 thorpej 395 1.20 thorpej /* 396 1.20 thorpej * Compute page-size related variables. 397 1.20 thorpej */ 398 1.30 enami malloc_pagesize = (size_t)sysconf(_SC_PAGESIZE); 399 1.20 thorpej malloc_pagemask = malloc_pagesize - 1; 400 1.20 thorpej for (malloc_pageshift = 0; 401 1.20 thorpej (1UL << malloc_pageshift) != malloc_pagesize; 402 1.20 thorpej malloc_pageshift++) 403 1.20 thorpej /* nothing */ ; 404 1.17 tls 405 1.17 tls INIT_MMAP(); 406 1.17 tls 407 1.19 thorpej #ifdef MALLOC_EXTRA_SANITY 408 1.17 tls malloc_junk = 1; 409 1.19 thorpej #endif /* MALLOC_EXTRA_SANITY */ 410 1.17 tls 411 1.17 tls for (i = 0; i < 3; i++) { 412 1.17 tls if (i == 0) { 413 1.17 tls errnosave = errno; 414 1.17 tls j = readlink("/etc/malloc.conf", b, sizeof b - 1); 415 1.17 tls errno = errnosave; 416 1.17 tls if (j <= 0) 417 1.17 tls continue; 418 1.17 tls b[j] = '\0'; 419 1.17 tls p = b; 420 1.17 tls } else if (i == 1) { 421 1.17 tls p = getenv("MALLOC_OPTIONS"); 422 1.17 tls } else { 423 1.17 tls p = malloc_options; 424 1.1 cgd } 425 1.17 tls for (; p && *p; p++) { 426 1.17 tls switch (*p) { 427 1.17 tls case '>': malloc_cache <<= 1; break; 428 1.17 tls case '<': malloc_cache >>= 1; break; 429 1.17 tls case 'a': malloc_abort = 0; break; 430 1.17 tls case 'A': malloc_abort = 1; break; 431 1.17 tls case 'h': malloc_hint = 0; break; 432 1.17 tls case 'H': malloc_hint = 1; break; 433 1.17 tls case 'r': malloc_realloc = 0; break; 434 1.17 tls case 'R': malloc_realloc = 1; break; 435 1.17 tls case 'j': malloc_junk = 0; break; 436 1.17 tls case 'J': malloc_junk = 1; break; 437 1.17 tls #ifdef HAS_UTRACE 438 1.17 tls case 'u': malloc_utrace = 0; break; 439 1.17 tls case 'U': malloc_utrace = 1; break; 440 1.17 tls #endif 441 1.17 tls case 'v': malloc_sysv = 0; break; 442 1.17 tls case 'V': malloc_sysv = 1; break; 443 1.17 tls case 'x': malloc_xmalloc = 0; break; 444 1.17 tls case 'X': malloc_xmalloc = 1; break; 445 1.17 tls case 'z': malloc_zero = 0; break; 446 1.17 tls case 'Z': malloc_zero = 1; break; 447 1.17 tls default: 448 1.17 tls j = malloc_abort; 449 1.17 tls malloc_abort = 0; 450 1.17 tls wrtwarning("unknown char in MALLOC_OPTIONS\n"); 451 1.17 tls malloc_abort = j; 452 1.17 tls break; 453 1.17 tls } 454 1.1 cgd } 455 1.17 tls } 456 1.17 tls 457 1.17 tls UTRACE(0, 0, 0); 458 1.17 tls 459 1.17 tls /* 460 1.17 tls * We want junk in the entire allocation, and zero only in the part 461 1.17 tls * the user asked for. 462 1.17 tls */ 463 1.17 tls if (malloc_zero) 464 1.17 tls malloc_junk=1; 465 1.17 tls 466 1.17 tls /* 467 1.17 tls * If we run with junk (or implicitly from above: zero), we want to 468 1.17 tls * force realloc() to get new storage, so we can DTRT with it. 469 1.17 tls */ 470 1.17 tls if (malloc_junk) 471 1.17 tls malloc_realloc=1; 472 1.17 tls 473 1.17 tls /* Allocate one page for the page directory */ 474 1.17 tls page_dir = (struct pginfo **) MMAP(malloc_pagesize); 475 1.17 tls 476 1.17 tls if (page_dir == (struct pginfo **) -1) 477 1.17 tls wrterror("mmap(2) failed, check limits.\n"); 478 1.17 tls 479 1.17 tls /* 480 1.17 tls * We need a maximum of malloc_pageshift buckets, steal these from the 481 1.17 tls * front of the page_directory; 482 1.17 tls */ 483 1.34 christos malloc_origo = pageround((size_t)(u_long)sbrk((intptr_t)0)) 484 1.34 christos >> malloc_pageshift; 485 1.17 tls malloc_origo -= malloc_pageshift; 486 1.17 tls 487 1.17 tls malloc_ninfo = malloc_pagesize / sizeof *page_dir; 488 1.17 tls 489 1.17 tls /* Recalculate the cache size in bytes, and make sure it's nonzero */ 490 1.17 tls 491 1.17 tls if (!malloc_cache) 492 1.17 tls malloc_cache++; 493 1.17 tls 494 1.17 tls malloc_cache <<= malloc_pageshift; 495 1.17 tls 496 1.17 tls /* 497 1.17 tls * This is a nice hack from Kaleb Keithly (kaleb (at) x.org). 498 1.17 tls * We can sbrk(2) further back when we keep this on a low address. 499 1.17 tls */ 500 1.17 tls px = (struct pgfree *) imalloc (sizeof *px); 501 1.17 tls 502 1.17 tls /* Been here, done that */ 503 1.17 tls malloc_started++; 504 1.17 tls } 505 1.17 tls 506 1.17 tls /* 507 1.17 tls * Allocate a number of complete pages 508 1.17 tls */ 509 1.17 tls static void * 510 1.17 tls malloc_pages(size_t size) 511 1.17 tls { 512 1.17 tls void *p, *delay_free = 0; 513 1.17 tls int i; 514 1.17 tls struct pgfree *pf; 515 1.30 enami size_t idx; 516 1.17 tls 517 1.17 tls size = pageround(size); 518 1.17 tls 519 1.17 tls p = 0; 520 1.17 tls 521 1.17 tls /* Look for free pages before asking for more */ 522 1.17 tls for(pf = free_list.next; pf; pf = pf->next) { 523 1.17 tls 524 1.19 thorpej #ifdef MALLOC_EXTRA_SANITY 525 1.17 tls if (pf->size & malloc_pagemask) 526 1.17 tls wrterror("(ES): junk length entry on free_list\n"); 527 1.17 tls if (!pf->size) 528 1.17 tls wrterror("(ES): zero length entry on free_list\n"); 529 1.17 tls if (pf->page == pf->end) 530 1.17 tls wrterror("(ES): zero entry on free_list\n"); 531 1.17 tls if (pf->page > pf->end) 532 1.17 tls wrterror("(ES): sick entry on free_list\n"); 533 1.17 tls if ((void*)pf->page >= (void*)sbrk(0)) 534 1.17 tls wrterror("(ES): entry on free_list past brk\n"); 535 1.23 thorpej if (page_dir[ptr2idx(pf->page)] != MALLOC_FREE) 536 1.17 tls wrterror("(ES): non-free first page on free-list\n"); 537 1.23 thorpej if (page_dir[ptr2idx(pf->end)-1] != MALLOC_FREE) 538 1.17 tls wrterror("(ES): non-free last page on free-list\n"); 539 1.19 thorpej #endif /* MALLOC_EXTRA_SANITY */ 540 1.17 tls 541 1.17 tls if (pf->size < size) 542 1.17 tls continue; 543 1.17 tls 544 1.17 tls if (pf->size == size) { 545 1.17 tls p = pf->page; 546 1.17 tls if (pf->next) 547 1.17 tls pf->next->prev = pf->prev; 548 1.17 tls pf->prev->next = pf->next; 549 1.17 tls delay_free = pf; 550 1.17 tls break; 551 1.17 tls } 552 1.17 tls 553 1.17 tls p = pf->page; 554 1.17 tls pf->page = (char *)pf->page + size; 555 1.17 tls pf->size -= size; 556 1.17 tls break; 557 1.17 tls } 558 1.17 tls 559 1.19 thorpej #ifdef MALLOC_EXTRA_SANITY 560 1.23 thorpej if (p && page_dir[ptr2idx(p)] != MALLOC_FREE) 561 1.17 tls wrterror("(ES): allocated non-free page on free-list\n"); 562 1.19 thorpej #endif /* MALLOC_EXTRA_SANITY */ 563 1.17 tls 564 1.17 tls size >>= malloc_pageshift; 565 1.17 tls 566 1.17 tls /* Map new pages */ 567 1.17 tls if (!p) 568 1.17 tls p = map_pages(size); 569 1.17 tls 570 1.17 tls if (p) { 571 1.17 tls 572 1.23 thorpej idx = ptr2idx(p); 573 1.23 thorpej page_dir[idx] = MALLOC_FIRST; 574 1.17 tls for (i=1;i<size;i++) 575 1.23 thorpej page_dir[idx+i] = MALLOC_FOLLOW; 576 1.17 tls 577 1.17 tls if (malloc_junk) 578 1.17 tls memset(p, SOME_JUNK, size << malloc_pageshift); 579 1.17 tls } 580 1.17 tls 581 1.17 tls if (delay_free) { 582 1.17 tls if (!px) 583 1.17 tls px = delay_free; 584 1.17 tls else 585 1.17 tls ifree(delay_free); 586 1.17 tls } 587 1.17 tls 588 1.17 tls return p; 589 1.17 tls } 590 1.17 tls 591 1.17 tls /* 592 1.17 tls * Allocate a page of fragments 593 1.17 tls */ 594 1.17 tls 595 1.17 tls static __inline__ int 596 1.17 tls malloc_make_chunks(int bits) 597 1.17 tls { 598 1.17 tls struct pginfo *bp; 599 1.17 tls void *pp; 600 1.31 enami int i, k, l; 601 1.17 tls 602 1.17 tls /* Allocate a new bucket */ 603 1.17 tls pp = malloc_pages(malloc_pagesize); 604 1.17 tls if (!pp) 605 1.17 tls return 0; 606 1.17 tls 607 1.17 tls /* Find length of admin structure */ 608 1.33 christos l = (int)offsetof(struct pginfo, bits[0]); 609 1.17 tls l += sizeof bp->bits[0] * 610 1.17 tls (((malloc_pagesize >> bits)+MALLOC_BITS-1) / MALLOC_BITS); 611 1.17 tls 612 1.17 tls /* Don't waste more than two chunks on this */ 613 1.17 tls if ((1<<(bits)) <= l+l) { 614 1.17 tls bp = (struct pginfo *)pp; 615 1.17 tls } else { 616 1.31 enami bp = (struct pginfo *)imalloc((size_t)l); 617 1.17 tls if (!bp) { 618 1.17 tls ifree(pp); 619 1.17 tls return 0; 620 1.1 cgd } 621 1.17 tls } 622 1.17 tls 623 1.17 tls bp->size = (1<<bits); 624 1.17 tls bp->shift = bits; 625 1.17 tls bp->total = bp->free = malloc_pagesize >> bits; 626 1.17 tls bp->page = pp; 627 1.17 tls 628 1.17 tls /* set all valid bits in the bitmap */ 629 1.17 tls k = bp->total; 630 1.17 tls i = 0; 631 1.17 tls 632 1.17 tls /* Do a bunch at a time */ 633 1.17 tls for(;k-i >= MALLOC_BITS; i += MALLOC_BITS) 634 1.30 enami bp->bits[i / MALLOC_BITS] = ~0U; 635 1.17 tls 636 1.17 tls for(; i < k; i++) 637 1.17 tls bp->bits[i/MALLOC_BITS] |= 1<<(i%MALLOC_BITS); 638 1.17 tls 639 1.17 tls if (bp == bp->page) { 640 1.17 tls /* Mark the ones we stole for ourselves */ 641 1.17 tls for(i=0;l > 0;i++) { 642 1.17 tls bp->bits[i/MALLOC_BITS] &= ~(1<<(i%MALLOC_BITS)); 643 1.17 tls bp->free--; 644 1.17 tls bp->total--; 645 1.17 tls l -= (1 << bits); 646 1.1 cgd } 647 1.17 tls } 648 1.17 tls 649 1.17 tls /* MALLOC_LOCK */ 650 1.17 tls 651 1.23 thorpej page_dir[ptr2idx(pp)] = bp; 652 1.17 tls 653 1.17 tls bp->next = page_dir[bits]; 654 1.17 tls page_dir[bits] = bp; 655 1.17 tls 656 1.17 tls /* MALLOC_UNLOCK */ 657 1.17 tls 658 1.17 tls return 1; 659 1.1 cgd } 660 1.1 cgd 661 1.1 cgd /* 662 1.17 tls * Allocate a fragment 663 1.1 cgd */ 664 1.17 tls static void * 665 1.17 tls malloc_bytes(size_t size) 666 1.1 cgd { 667 1.30 enami size_t i; 668 1.30 enami int j; 669 1.17 tls u_int u; 670 1.17 tls struct pginfo *bp; 671 1.17 tls int k; 672 1.17 tls u_int *lp; 673 1.17 tls 674 1.17 tls /* Don't bother with anything less than this */ 675 1.17 tls if (size < malloc_minsize) 676 1.17 tls size = malloc_minsize; 677 1.17 tls 678 1.17 tls /* Find the right bucket */ 679 1.17 tls j = 1; 680 1.17 tls i = size-1; 681 1.17 tls while (i >>= 1) 682 1.17 tls j++; 683 1.17 tls 684 1.17 tls /* If it's empty, make a page more of that size chunks */ 685 1.17 tls if (!page_dir[j] && !malloc_make_chunks(j)) 686 1.17 tls return 0; 687 1.17 tls 688 1.17 tls bp = page_dir[j]; 689 1.17 tls 690 1.17 tls /* Find first word of bitmap which isn't empty */ 691 1.17 tls for (lp = bp->bits; !*lp; lp++) 692 1.17 tls ; 693 1.17 tls 694 1.17 tls /* Find that bit, and tweak it */ 695 1.17 tls u = 1; 696 1.17 tls k = 0; 697 1.17 tls while (!(*lp & u)) { 698 1.17 tls u += u; 699 1.17 tls k++; 700 1.17 tls } 701 1.17 tls *lp ^= u; 702 1.17 tls 703 1.17 tls /* If there are no more free, remove from free-list */ 704 1.17 tls if (!--bp->free) { 705 1.17 tls page_dir[j] = bp->next; 706 1.17 tls bp->next = 0; 707 1.17 tls } 708 1.17 tls 709 1.17 tls /* Adjust to the real offset of that chunk */ 710 1.17 tls k += (lp-bp->bits)*MALLOC_BITS; 711 1.17 tls k <<= bp->shift; 712 1.17 tls 713 1.17 tls if (malloc_junk) 714 1.30 enami memset((u_char*)bp->page + k, SOME_JUNK, (size_t)bp->size); 715 1.1 cgd 716 1.17 tls return (u_char *)bp->page + k; 717 1.1 cgd } 718 1.1 cgd 719 1.17 tls /* 720 1.17 tls * Allocate a piece of memory 721 1.17 tls */ 722 1.17 tls static void * 723 1.17 tls imalloc(size_t size) 724 1.17 tls { 725 1.17 tls void *result; 726 1.17 tls 727 1.17 tls if (suicide) 728 1.17 tls abort(); 729 1.17 tls 730 1.17 tls if ((size + malloc_pagesize) < size) /* Check for overflow */ 731 1.17 tls result = 0; 732 1.17 tls else if (size <= malloc_maxsize) 733 1.17 tls result = malloc_bytes(size); 734 1.17 tls else 735 1.17 tls result = malloc_pages(size); 736 1.17 tls 737 1.17 tls if (malloc_abort && !result) 738 1.17 tls wrterror("allocation failed.\n"); 739 1.17 tls 740 1.17 tls if (malloc_zero && result) 741 1.17 tls memset(result, 0, size); 742 1.17 tls 743 1.17 tls return result; 744 1.1 cgd } 745 1.1 cgd 746 1.1 cgd /* 747 1.17 tls * Change the size of an allocation. 748 1.1 cgd */ 749 1.17 tls static void * 750 1.17 tls irealloc(void *ptr, size_t size) 751 1.17 tls { 752 1.17 tls void *p; 753 1.30 enami size_t osize, idx; 754 1.17 tls struct pginfo **mp; 755 1.30 enami size_t i; 756 1.17 tls 757 1.17 tls if (suicide) 758 1.17 tls abort(); 759 1.17 tls 760 1.23 thorpej idx = ptr2idx(ptr); 761 1.1 cgd 762 1.23 thorpej if (idx < malloc_pageshift) { 763 1.17 tls wrtwarning("junk pointer, too low to make sense.\n"); 764 1.17 tls return 0; 765 1.17 tls } 766 1.17 tls 767 1.23 thorpej if (idx > last_idx) { 768 1.17 tls wrtwarning("junk pointer, too high to make sense.\n"); 769 1.17 tls return 0; 770 1.17 tls } 771 1.17 tls 772 1.23 thorpej mp = &page_dir[idx]; 773 1.17 tls 774 1.17 tls if (*mp == MALLOC_FIRST) { /* Page allocation */ 775 1.17 tls 776 1.17 tls /* Check the pointer */ 777 1.33 christos if ((size_t)(u_long)ptr & malloc_pagemask) { 778 1.17 tls wrtwarning("modified (page-) pointer.\n"); 779 1.17 tls return 0; 780 1.17 tls } 781 1.17 tls 782 1.17 tls /* Find the size in bytes */ 783 1.17 tls for (osize = malloc_pagesize; *++mp == MALLOC_FOLLOW;) 784 1.17 tls osize += malloc_pagesize; 785 1.17 tls 786 1.17 tls if (!malloc_realloc && /* unless we have to, */ 787 1.17 tls size <= osize && /* .. or are too small, */ 788 1.17 tls size > (osize - malloc_pagesize)) { /* .. or can free a page, */ 789 1.17 tls return ptr; /* don't do anything. */ 790 1.6 jtc } 791 1.17 tls 792 1.17 tls } else if (*mp >= MALLOC_MAGIC) { /* Chunk allocation */ 793 1.17 tls 794 1.17 tls /* Check the pointer for sane values */ 795 1.33 christos if (((size_t)(u_long)ptr & ((*mp)->size-1))) { 796 1.17 tls wrtwarning("modified (chunk-) pointer.\n"); 797 1.17 tls return 0; 798 1.1 cgd } 799 1.17 tls 800 1.17 tls /* Find the chunk index in the page */ 801 1.33 christos i = ((size_t)(u_long)ptr & malloc_pagemask) >> (*mp)->shift; 802 1.17 tls 803 1.17 tls /* Verify that it isn't a free chunk already */ 804 1.17 tls if ((*mp)->bits[i/MALLOC_BITS] & (1<<(i%MALLOC_BITS))) { 805 1.17 tls wrtwarning("chunk is already free.\n"); 806 1.17 tls return 0; 807 1.16 kleink } 808 1.17 tls 809 1.17 tls osize = (*mp)->size; 810 1.17 tls 811 1.17 tls if (!malloc_realloc && /* Unless we have to, */ 812 1.17 tls size < osize && /* ..or are too small, */ 813 1.17 tls (size > osize/2 || /* ..or could use a smaller size, */ 814 1.17 tls osize == malloc_minsize)) { /* ..(if there is one) */ 815 1.17 tls return ptr; /* ..Don't do anything */ 816 1.1 cgd } 817 1.17 tls 818 1.17 tls } else { 819 1.17 tls wrtwarning("pointer to wrong page.\n"); 820 1.17 tls return 0; 821 1.17 tls } 822 1.17 tls 823 1.17 tls p = imalloc(size); 824 1.17 tls 825 1.17 tls if (p) { 826 1.17 tls /* copy the lesser of the two sizes, and free the old one */ 827 1.17 tls if (!size || !osize) 828 1.17 tls ; 829 1.17 tls else if (osize < size) 830 1.17 tls memcpy(p, ptr, osize); 831 1.17 tls else 832 1.17 tls memcpy(p, ptr, size); 833 1.17 tls ifree(ptr); 834 1.17 tls } 835 1.17 tls return p; 836 1.1 cgd } 837 1.1 cgd 838 1.1 cgd /* 839 1.17 tls * Free a sequence of pages 840 1.1 cgd */ 841 1.17 tls 842 1.17 tls static __inline__ void 843 1.30 enami free_pages(void *ptr, size_t idx, struct pginfo *info) 844 1.17 tls { 845 1.30 enami size_t i; 846 1.17 tls struct pgfree *pf, *pt=0; 847 1.30 enami size_t l; 848 1.17 tls void *tail; 849 1.17 tls 850 1.17 tls if (info == MALLOC_FREE) { 851 1.17 tls wrtwarning("page is already free.\n"); 852 1.17 tls return; 853 1.17 tls } 854 1.17 tls 855 1.17 tls if (info != MALLOC_FIRST) { 856 1.17 tls wrtwarning("pointer to wrong page.\n"); 857 1.17 tls return; 858 1.17 tls } 859 1.17 tls 860 1.33 christos if ((size_t)(u_long)ptr & malloc_pagemask) { 861 1.17 tls wrtwarning("modified (page-) pointer.\n"); 862 1.17 tls return; 863 1.17 tls } 864 1.17 tls 865 1.17 tls /* Count how many pages and mark them free at the same time */ 866 1.23 thorpej page_dir[idx] = MALLOC_FREE; 867 1.23 thorpej for (i = 1; page_dir[idx+i] == MALLOC_FOLLOW; i++) 868 1.23 thorpej page_dir[idx + i] = MALLOC_FREE; 869 1.17 tls 870 1.17 tls l = i << malloc_pageshift; 871 1.17 tls 872 1.17 tls if (malloc_junk) 873 1.17 tls memset(ptr, SOME_JUNK, l); 874 1.17 tls 875 1.17 tls if (malloc_hint) 876 1.17 tls madvise(ptr, l, MADV_FREE); 877 1.17 tls 878 1.17 tls tail = (char *)ptr+l; 879 1.17 tls 880 1.17 tls /* add to free-list */ 881 1.17 tls if (!px) 882 1.17 tls px = imalloc(sizeof *pt); /* This cannot fail... */ 883 1.17 tls px->page = ptr; 884 1.17 tls px->end = tail; 885 1.17 tls px->size = l; 886 1.17 tls if (!free_list.next) { 887 1.17 tls 888 1.17 tls /* Nothing on free list, put this at head */ 889 1.17 tls px->next = free_list.next; 890 1.17 tls px->prev = &free_list; 891 1.17 tls free_list.next = px; 892 1.17 tls pf = px; 893 1.17 tls px = 0; 894 1.17 tls 895 1.17 tls } else { 896 1.17 tls 897 1.17 tls /* Find the right spot, leave pf pointing to the modified entry. */ 898 1.17 tls tail = (char *)ptr+l; 899 1.17 tls 900 1.17 tls for(pf = free_list.next; pf->end < ptr && pf->next; pf = pf->next) 901 1.17 tls ; /* Race ahead here */ 902 1.17 tls 903 1.17 tls if (pf->page > tail) { 904 1.17 tls /* Insert before entry */ 905 1.17 tls px->next = pf; 906 1.17 tls px->prev = pf->prev; 907 1.17 tls pf->prev = px; 908 1.17 tls px->prev->next = px; 909 1.17 tls pf = px; 910 1.17 tls px = 0; 911 1.17 tls } else if (pf->end == ptr ) { 912 1.17 tls /* Append to the previous entry */ 913 1.17 tls pf->end = (char *)pf->end + l; 914 1.17 tls pf->size += l; 915 1.17 tls if (pf->next && pf->end == pf->next->page ) { 916 1.17 tls /* And collapse the next too. */ 917 1.17 tls pt = pf->next; 918 1.17 tls pf->end = pt->end; 919 1.17 tls pf->size += pt->size; 920 1.17 tls pf->next = pt->next; 921 1.17 tls if (pf->next) 922 1.17 tls pf->next->prev = pf; 923 1.17 tls } 924 1.17 tls } else if (pf->page == tail) { 925 1.17 tls /* Prepend to entry */ 926 1.17 tls pf->size += l; 927 1.17 tls pf->page = ptr; 928 1.17 tls } else if (!pf->next) { 929 1.17 tls /* Append at tail of chain */ 930 1.17 tls px->next = 0; 931 1.17 tls px->prev = pf; 932 1.17 tls pf->next = px; 933 1.17 tls pf = px; 934 1.17 tls px = 0; 935 1.17 tls } else { 936 1.17 tls wrterror("freelist is destroyed.\n"); 937 1.1 cgd } 938 1.17 tls } 939 1.17 tls 940 1.17 tls /* Return something to OS ? */ 941 1.17 tls if (!pf->next && /* If we're the last one, */ 942 1.17 tls pf->size > malloc_cache && /* ..and the cache is full, */ 943 1.17 tls pf->end == malloc_brk && /* ..and none behind us, */ 944 1.34 christos malloc_brk == sbrk((intptr_t)0)) { /* ..and it's OK to do... */ 945 1.17 tls 946 1.17 tls /* 947 1.17 tls * Keep the cache intact. Notice that the '>' above guarantees that 948 1.17 tls * the pf will always have at least one page afterwards. 949 1.17 tls */ 950 1.17 tls pf->end = (char *)pf->page + malloc_cache; 951 1.17 tls pf->size = malloc_cache; 952 1.17 tls 953 1.17 tls brk(pf->end); 954 1.17 tls malloc_brk = pf->end; 955 1.17 tls 956 1.23 thorpej idx = ptr2idx(pf->end); 957 1.23 thorpej last_idx = idx - 1; 958 1.17 tls 959 1.23 thorpej for(i=idx;i <= last_idx;) 960 1.17 tls page_dir[i++] = MALLOC_NOT_MINE; 961 1.17 tls 962 1.17 tls /* XXX: We could realloc/shrink the pagedir here I guess. */ 963 1.17 tls } 964 1.17 tls if (pt) 965 1.17 tls ifree(pt); 966 1.1 cgd } 967 1.1 cgd 968 1.1 cgd /* 969 1.17 tls * Free a chunk, and possibly the page it's on, if the page becomes empty. 970 1.1 cgd */ 971 1.17 tls 972 1.17 tls static __inline__ void 973 1.30 enami free_bytes(void *ptr, size_t idx, struct pginfo *info) 974 1.17 tls { 975 1.30 enami size_t i; 976 1.17 tls struct pginfo **mp; 977 1.17 tls void *vp; 978 1.17 tls 979 1.17 tls /* Find the chunk number on the page */ 980 1.33 christos i = ((size_t)(u_long)ptr & malloc_pagemask) >> info->shift; 981 1.17 tls 982 1.33 christos if (((size_t)(u_long)ptr & (info->size-1))) { 983 1.17 tls wrtwarning("modified (chunk-) pointer.\n"); 984 1.17 tls return; 985 1.17 tls } 986 1.17 tls 987 1.17 tls if (info->bits[i/MALLOC_BITS] & (1<<(i%MALLOC_BITS))) { 988 1.17 tls wrtwarning("chunk is already free.\n"); 989 1.17 tls return; 990 1.17 tls } 991 1.17 tls 992 1.17 tls if (malloc_junk) 993 1.30 enami memset(ptr, SOME_JUNK, (size_t)info->size); 994 1.17 tls 995 1.17 tls info->bits[i/MALLOC_BITS] |= 1<<(i%MALLOC_BITS); 996 1.17 tls info->free++; 997 1.17 tls 998 1.17 tls mp = page_dir + info->shift; 999 1.17 tls 1000 1.17 tls if (info->free == 1) { 1001 1.17 tls 1002 1.17 tls /* Page became non-full */ 1003 1.17 tls 1004 1.17 tls mp = page_dir + info->shift; 1005 1.17 tls /* Insert in address order */ 1006 1.17 tls while (*mp && (*mp)->next && (*mp)->next->page < info->page) 1007 1.17 tls mp = &(*mp)->next; 1008 1.17 tls info->next = *mp; 1009 1.17 tls *mp = info; 1010 1.17 tls return; 1011 1.17 tls } 1012 1.17 tls 1013 1.17 tls if (info->free != info->total) 1014 1.17 tls return; 1015 1.17 tls 1016 1.17 tls /* Find & remove this page in the queue */ 1017 1.17 tls while (*mp != info) { 1018 1.17 tls mp = &((*mp)->next); 1019 1.19 thorpej #ifdef MALLOC_EXTRA_SANITY 1020 1.17 tls if (!*mp) 1021 1.17 tls wrterror("(ES): Not on queue\n"); 1022 1.19 thorpej #endif /* MALLOC_EXTRA_SANITY */ 1023 1.17 tls } 1024 1.17 tls *mp = info->next; 1025 1.17 tls 1026 1.17 tls /* Free the page & the info structure if need be */ 1027 1.30 enami page_dir[idx] = MALLOC_FIRST; 1028 1.17 tls vp = info->page; /* Order is important ! */ 1029 1.17 tls if(vp != (void*)info) 1030 1.17 tls ifree(info); 1031 1.17 tls ifree(vp); 1032 1.17 tls } 1033 1.17 tls 1034 1.17 tls static void 1035 1.17 tls ifree(void *ptr) 1036 1.17 tls { 1037 1.17 tls struct pginfo *info; 1038 1.30 enami size_t idx; 1039 1.17 tls 1040 1.17 tls /* This is legal */ 1041 1.17 tls if (!ptr) 1042 1.17 tls return; 1043 1.17 tls 1044 1.17 tls if (!malloc_started) { 1045 1.17 tls wrtwarning("malloc() has never been called.\n"); 1046 1.17 tls return; 1047 1.17 tls } 1048 1.17 tls 1049 1.17 tls /* If we're already sinking, don't make matters any worse. */ 1050 1.17 tls if (suicide) 1051 1.17 tls return; 1052 1.17 tls 1053 1.23 thorpej idx = ptr2idx(ptr); 1054 1.17 tls 1055 1.23 thorpej if (idx < malloc_pageshift) { 1056 1.17 tls wrtwarning("junk pointer, too low to make sense.\n"); 1057 1.17 tls return; 1058 1.17 tls } 1059 1.17 tls 1060 1.23 thorpej if (idx > last_idx) { 1061 1.17 tls wrtwarning("junk pointer, too high to make sense.\n"); 1062 1.17 tls return; 1063 1.17 tls } 1064 1.17 tls 1065 1.23 thorpej info = page_dir[idx]; 1066 1.17 tls 1067 1.17 tls if (info < MALLOC_MAGIC) 1068 1.23 thorpej free_pages(ptr, idx, info); 1069 1.17 tls else 1070 1.23 thorpej free_bytes(ptr, idx, info); 1071 1.17 tls return; 1072 1.17 tls } 1073 1.17 tls 1074 1.17 tls /* 1075 1.17 tls * These are the public exported interface routines. 1076 1.17 tls */ 1077 1.17 tls 1078 1.17 tls 1079 1.17 tls void * 1080 1.17 tls malloc(size_t size) 1081 1.17 tls { 1082 1.17 tls register void *r; 1083 1.17 tls 1084 1.17 tls THREAD_LOCK(); 1085 1.17 tls malloc_func = " in malloc():"; 1086 1.17 tls if (malloc_active++) { 1087 1.17 tls wrtwarning("recursive call.\n"); 1088 1.17 tls malloc_active--; 1089 1.17 tls return (0); 1090 1.17 tls } 1091 1.17 tls if (!malloc_started) 1092 1.17 tls malloc_init(); 1093 1.17 tls if (malloc_sysv && !size) 1094 1.17 tls r = 0; 1095 1.17 tls else 1096 1.17 tls r = imalloc(size); 1097 1.17 tls UTRACE(0, size, r); 1098 1.17 tls malloc_active--; 1099 1.17 tls THREAD_UNLOCK(); 1100 1.26 kleink if (r == NULL && (size != 0 || !malloc_sysv)) { 1101 1.24 thorpej if (malloc_xmalloc) 1102 1.24 thorpej wrterror("out of memory.\n"); 1103 1.24 thorpej errno = ENOMEM; 1104 1.24 thorpej } 1105 1.17 tls return (r); 1106 1.17 tls } 1107 1.17 tls 1108 1.9 christos void 1109 1.17 tls free(void *ptr) 1110 1.1 cgd { 1111 1.17 tls THREAD_LOCK(); 1112 1.17 tls malloc_func = " in free():"; 1113 1.17 tls if (malloc_active++) { 1114 1.17 tls wrtwarning("recursive call.\n"); 1115 1.17 tls malloc_active--; 1116 1.17 tls return; 1117 1.17 tls } else { 1118 1.17 tls ifree(ptr); 1119 1.17 tls UTRACE(ptr, 0, 0); 1120 1.17 tls } 1121 1.17 tls malloc_active--; 1122 1.17 tls THREAD_UNLOCK(); 1123 1.17 tls return; 1124 1.17 tls } 1125 1.17 tls 1126 1.17 tls void * 1127 1.17 tls realloc(void *ptr, size_t size) 1128 1.17 tls { 1129 1.17 tls register void *r; 1130 1.17 tls 1131 1.17 tls THREAD_LOCK(); 1132 1.17 tls malloc_func = " in realloc():"; 1133 1.17 tls if (malloc_active++) { 1134 1.17 tls wrtwarning("recursive call.\n"); 1135 1.17 tls malloc_active--; 1136 1.17 tls return (0); 1137 1.17 tls } 1138 1.17 tls if (ptr && !malloc_started) { 1139 1.17 tls wrtwarning("malloc() has never been called.\n"); 1140 1.17 tls ptr = 0; 1141 1.17 tls } 1142 1.17 tls if (!malloc_started) 1143 1.17 tls malloc_init(); 1144 1.17 tls if (malloc_sysv && !size) { 1145 1.17 tls ifree(ptr); 1146 1.17 tls r = 0; 1147 1.17 tls } else if (!ptr) { 1148 1.17 tls r = imalloc(size); 1149 1.17 tls } else { 1150 1.17 tls r = irealloc(ptr, size); 1151 1.17 tls } 1152 1.17 tls UTRACE(ptr, size, r); 1153 1.17 tls malloc_active--; 1154 1.17 tls THREAD_UNLOCK(); 1155 1.26 kleink if (r == NULL && (size != 0 || !malloc_sysv)) { 1156 1.24 thorpej if (malloc_xmalloc) 1157 1.24 thorpej wrterror("out of memory.\n"); 1158 1.24 thorpej errno = ENOMEM; 1159 1.24 thorpej } 1160 1.17 tls return (r); 1161 1.1 cgd } 1162
Indexes created Sat Sep 20 22:09:52 GMT 2025