1 /*********************************************************************** 2 * * 3 * This software is part of the ast package * 4 * Copyright (c) 1985-2010 AT&T Intellectual Property * 5 * and is licensed under the * 6 * Common Public License, Version 1.0 * 7 * by AT&T Intellectual Property * 8 * * 9 * A copy of the License is available at * 10 * http://www.opensource.org/licenses/cpl1.0.txt * 11 * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) * 12 * * 13 * Information and Software Systems Research * 14 * AT&T Research * 15 * Florham Park NJ * 16 * * 17 * Glenn Fowler <gsf@research.att.com> * 18 * David Korn <dgk@research.att.com> * 19 * Phong Vo <kpv@research.att.com> * 20 * * 21 ***********************************************************************/ 22 #if defined(_UWIN) && defined(_BLD_ast) 23 24 void _STUB_vmdebug(){} 25 26 #else 27 28 #include "vmhdr.h" 29 30 /* Method to help with debugging. This does rigorous checks on 31 ** addresses and arena integrity. 32 ** 33 ** Written by Kiem-Phong Vo, kpv@research.att.com, 01/16/94. 34 */ 35 36 /* structure to keep track of file names */ 37 typedef struct _dbfile_s Dbfile_t; 38 struct _dbfile_s 39 { Dbfile_t* next; 40 char file[1]; 41 }; 42 static Dbfile_t* Dbfile; 43 44 /* global watch list */ 45 #define S_WATCH 32 46 static int Dbnwatch; 47 static Void_t* Dbwatch[S_WATCH]; 48 49 /* types of warnings reported by dbwarn() */ 50 #define DB_CHECK 0 51 #define DB_ALLOC 1 52 #define DB_FREE 2 53 #define DB_RESIZE 3 54 #define DB_WATCH 4 55 #define DB_RESIZED 5 56 57 #define LONGV(x) ((Vmulong_t)(x)) 58 59 static int Dbinit = 0; 60 #define DBINIT() (Dbinit ? 0 : (dbinit(), Dbinit=1) ) 61 static void dbinit() 62 { int fd; 63 if((fd = vmtrace(-1)) >= 0) 64 vmtrace(fd); 65 } 66 67 static int Dbfd = 2; /* default warning file descriptor */ 68 #if __STD_C 69 int vmdebug(int fd) 70 #else 71 int vmdebug(fd) 72 int fd; 73 #endif 74 { 75 int old = Dbfd; 76 Dbfd = fd; 77 return old; 78 } 79 80 /* just an entry point to make it easy to set break point */ 81 #if __STD_C 82 static void vmdbwarn(Vmalloc_t* vm, char* mesg, int n) 83 #else 84 static void vmdbwarn(vm, mesg, n) 85 Vmalloc_t* vm; 86 char* mesg; 87 int n; 88 #endif 89 { 90 reg Vmdata_t* vd = vm->data; 91 92 write(Dbfd,mesg,n); 93 if(vd->mode&VM_DBABORT) 94 abort(); 95 } 96 97 /* issue a warning of some type */ 98 #if __STD_C 99 static void dbwarn(Vmalloc_t* vm, Void_t* data, int where, 100 const char* file, int line, const Void_t* func, int type) 101 #else 102 static void dbwarn(vm, data, where, file, line, func, type) 103 Vmalloc_t* vm; /* region holding the block */ 104 Void_t* data; /* data block */ 105 int where; /* byte that was corrupted */ 106 const char* file; /* file where call originates */ 107 int line; /* line number of call */ 108 const Void_t* func; /* function called from */ 109 int type; /* operation being done */ 110 #endif 111 { 112 char buf[1024], *bufp, *endbuf, *s; 113 #define SLOP 64 /* enough for a message and an int */ 114 115 DBINIT(); 116 117 bufp = buf; 118 endbuf = buf + sizeof(buf); 119 120 if(type == DB_ALLOC) 121 bufp = (*_Vmstrcpy)(bufp, "alloc error", ':'); 122 else if(type == DB_FREE) 123 bufp = (*_Vmstrcpy)(bufp, "free error", ':'); 124 else if(type == DB_RESIZE) 125 bufp = (*_Vmstrcpy)(bufp, "resize error", ':'); 126 else if(type == DB_CHECK) 127 bufp = (*_Vmstrcpy)(bufp, "corrupted data", ':'); 128 else if(type == DB_WATCH) 129 bufp = (*_Vmstrcpy)(bufp, "alert", ':'); 130 131 /* region info */ 132 bufp = (*_Vmstrcpy)(bufp, "region", '='); 133 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(vm), 0), ':'); 134 135 if(data) 136 { bufp = (*_Vmstrcpy)(bufp,"block",'='); 137 bufp = (*_Vmstrcpy)(bufp,(*_Vmitoa)(VLONG(data),0),':'); 138 } 139 140 if(!data) 141 { if(where == DB_ALLOC) 142 bufp = (*_Vmstrcpy)(bufp, "can't get memory", ':'); 143 else bufp = (*_Vmstrcpy)(bufp, "region is locked", ':'); 144 } 145 else if(type == DB_FREE || type == DB_RESIZE) 146 { if(where == 0) 147 bufp = (*_Vmstrcpy)(bufp, "unallocated block", ':'); 148 else bufp = (*_Vmstrcpy)(bufp, "already freed", ':'); 149 } 150 else if(type == DB_WATCH) 151 { bufp = (*_Vmstrcpy)(bufp, "size", '='); 152 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(DBSIZE(data),-1), ':'); 153 if(where == DB_ALLOC) 154 bufp = (*_Vmstrcpy)(bufp,"just allocated", ':'); 155 else if(where == DB_FREE) 156 bufp = (*_Vmstrcpy)(bufp,"being freed", ':'); 157 else if(where == DB_RESIZE) 158 bufp = (*_Vmstrcpy)(bufp,"being resized", ':'); 159 else if(where == DB_RESIZED) 160 bufp = (*_Vmstrcpy)(bufp,"just resized", ':'); 161 } 162 else if(type == DB_CHECK) 163 { bufp = (*_Vmstrcpy)(bufp, "bad byte at", '='); 164 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(LONGV(where),-1), ':'); 165 if((s = DBFILE(data)) && (bufp + strlen(s) + SLOP) < endbuf) 166 { bufp = (*_Vmstrcpy)(bufp,"allocated at", '='); 167 bufp = (*_Vmstrcpy)(bufp, s, ','); 168 bufp = (*_Vmstrcpy)(bufp,(*_Vmitoa)(LONGV(DBLINE(data)),-1),':'); 169 } 170 } 171 172 /* location where offending call originates from */ 173 if(file && file[0] && line > 0 && (bufp + strlen(file) + SLOP) < endbuf) 174 { bufp = (*_Vmstrcpy)(bufp, "detected at", '='); 175 bufp = (*_Vmstrcpy)(bufp, file, ','); 176 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(LONGV(line),-1), ','); 177 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(func),-1), ':'); 178 } 179 180 *(bufp - 1) = '\n'; 181 *bufp = '\0'; 182 183 vmdbwarn(vm,buf,(bufp-buf)); 184 } 185 186 /* check for watched address and issue warnings */ 187 #if __STD_C 188 static void dbwatch(Vmalloc_t* vm, Void_t* data, 189 const char* file, int line, const Void_t* func, int type) 190 #else 191 static void dbwatch(vm, data, file, line, func, type) 192 Vmalloc_t* vm; 193 Void_t* data; 194 const char* file; 195 int line; 196 const Void_t* func; 197 int type; 198 #endif 199 { 200 reg int n; 201 202 for(n = Dbnwatch; n >= 0; --n) 203 { if(Dbwatch[n] == data) 204 { dbwarn(vm,data,type,file,line,func,DB_WATCH); 205 return; 206 } 207 } 208 } 209 210 /* record information about the block */ 211 #if __STD_C 212 static void dbsetinfo(Vmuchar_t* data, size_t size, const char* file, int line) 213 #else 214 static void dbsetinfo(data, size, file, line) 215 Vmuchar_t* data; /* real address not the one from Vmbest */ 216 size_t size; /* the actual requested size */ 217 const char* file; /* file where the request came from */ 218 int line; /* and line number */ 219 #endif 220 { 221 reg Vmuchar_t *begp, *endp; 222 reg Dbfile_t *last, *db; 223 224 DBINIT(); 225 226 /* find the file structure */ 227 if(!file || !file[0]) 228 db = NIL(Dbfile_t*); 229 else 230 { for(last = NIL(Dbfile_t*), db = Dbfile; db; last = db, db = db->next) 231 if(strcmp(db->file,file) == 0) 232 break; 233 if(!db) 234 { db = (Dbfile_t*)vmalloc(Vmheap,sizeof(Dbfile_t)+strlen(file)); 235 if(db) 236 { (*_Vmstrcpy)(db->file,file,0); 237 db->next = Dbfile; 238 Dbfile = db->next; 239 } 240 } 241 else if(last) /* move-to-front heuristic */ 242 { last->next = db->next; 243 db->next = Dbfile; 244 Dbfile = db->next; 245 } 246 } 247 248 DBSETFL(data,(db ? db->file : NIL(char*)),line); 249 DBSIZE(data) = size; 250 DBSEG(data) = SEG(DBBLOCK(data)); 251 252 DBHEAD(data,begp,endp); 253 while(begp < endp) 254 *begp++ = DB_MAGIC; 255 DBTAIL(data,begp,endp); 256 while(begp < endp) 257 *begp++ = DB_MAGIC; 258 } 259 260 /* Check to see if an address is in some data block of a region. 261 ** This returns -(offset+1) if block is already freed, +(offset+1) 262 ** if block is live, 0 if no match. 263 */ 264 #if __STD_C 265 static long dbaddr(Vmalloc_t* vm, Void_t* addr) 266 #else 267 static long dbaddr(vm, addr) 268 Vmalloc_t* vm; 269 Void_t* addr; 270 #endif 271 { 272 reg Block_t *b, *endb; 273 reg Seg_t* seg; 274 reg Vmuchar_t* data; 275 reg long offset = -1L; 276 reg Vmdata_t* vd = vm->data; 277 reg int local, inuse; 278 279 SETINUSE(vd, inuse); 280 GETLOCAL(vd,local); 281 if(ISLOCK(vd,local) || !addr) 282 { CLRINUSE(vd, inuse); 283 return -1L; 284 } 285 SETLOCK(vd,local); 286 287 b = endb = NIL(Block_t*); 288 for(seg = vd->seg; seg; seg = seg->next) 289 { b = SEGBLOCK(seg); 290 endb = (Block_t*)(seg->baddr - sizeof(Head_t)); 291 if((Vmuchar_t*)addr > (Vmuchar_t*)b && 292 (Vmuchar_t*)addr < (Vmuchar_t*)endb) 293 break; 294 } 295 if(!seg) 296 goto done; 297 298 if(local) /* must be vmfree or vmresize checking address */ 299 { if(DBSEG(addr) == seg) 300 { b = DBBLOCK(addr); 301 if(ISBUSY(SIZE(b)) && !ISJUNK(SIZE(b)) ) 302 offset = 0; 303 else offset = -2L; 304 } 305 goto done; 306 } 307 308 while(b < endb) 309 { data = (Vmuchar_t*)DATA(b); 310 if((Vmuchar_t*)addr >= data && (Vmuchar_t*)addr < data+SIZE(b)) 311 { if(ISBUSY(SIZE(b)) && !ISJUNK(SIZE(b)) ) 312 { data = DB2DEBUG(data); 313 if((Vmuchar_t*)addr >= data && 314 (Vmuchar_t*)addr < data+DBSIZE(data)) 315 offset = (Vmuchar_t*)addr - data; 316 } 317 goto done; 318 } 319 320 b = (Block_t*)((Vmuchar_t*)DATA(b) + (SIZE(b)&~BITS) ); 321 } 322 323 done: 324 CLRLOCK(vd,local); 325 CLRINUSE(vd, inuse); 326 return offset; 327 } 328 329 330 #if __STD_C 331 static long dbsize(Vmalloc_t* vm, Void_t* addr) 332 #else 333 static long dbsize(vm, addr) 334 Vmalloc_t* vm; 335 Void_t* addr; 336 #endif 337 { 338 reg Block_t *b, *endb; 339 reg Seg_t* seg; 340 reg long size; 341 reg Vmdata_t* vd = vm->data; 342 reg int inuse; 343 344 SETINUSE(vd, inuse); 345 if(ISLOCK(vd,0)) 346 { CLRINUSE(vd, inuse); 347 return -1L; 348 } 349 SETLOCK(vd,0); 350 351 size = -1L; 352 for(seg = vd->seg; seg; seg = seg->next) 353 { b = SEGBLOCK(seg); 354 endb = (Block_t*)(seg->baddr - sizeof(Head_t)); 355 if((Vmuchar_t*)addr <= (Vmuchar_t*)b || 356 (Vmuchar_t*)addr >= (Vmuchar_t*)endb) 357 continue; 358 while(b < endb) 359 { if(addr == (Void_t*)DB2DEBUG(DATA(b))) 360 { if(ISBUSY(SIZE(b)) && !ISJUNK(SIZE(b)) ) 361 size = (long)DBSIZE(addr); 362 goto done; 363 } 364 365 b = (Block_t*)((Vmuchar_t*)DATA(b) + (SIZE(b)&~BITS) ); 366 } 367 } 368 done: 369 CLRLOCK(vd,0); 370 CLRINUSE(vd, inuse); 371 return size; 372 } 373 374 #if __STD_C 375 static Void_t* dballoc(Vmalloc_t* vm, size_t size) 376 #else 377 static Void_t* dballoc(vm, size) 378 Vmalloc_t* vm; 379 size_t size; 380 #endif 381 { 382 reg size_t s; 383 reg Vmuchar_t* data; 384 reg char* file; 385 reg int line; 386 reg Void_t* func; 387 reg Vmdata_t* vd = vm->data; 388 reg int inuse; 389 390 SETINUSE(vd, inuse); 391 VMFLF(vm,file,line,func); 392 393 if(ISLOCK(vd,0) ) 394 { dbwarn(vm,NIL(Vmuchar_t*),0,file,line,func,DB_ALLOC); 395 CLRINUSE(vd, inuse); 396 return NIL(Void_t*); 397 } 398 SETLOCK(vd,0); 399 400 if(vd->mode&VM_DBCHECK) 401 vmdbcheck(vm); 402 403 s = ROUND(size,ALIGN) + DB_EXTRA; 404 if(s < sizeof(Body_t)) /* no tiny blocks during Vmdebug */ 405 s = sizeof(Body_t); 406 407 if(!(data = (Vmuchar_t*)KPVALLOC(vm,s,(*(Vmbest->allocf))) ) ) 408 { dbwarn(vm,NIL(Vmuchar_t*),DB_ALLOC,file,line,func,DB_ALLOC); 409 goto done; 410 } 411 412 data = DB2DEBUG(data); 413 dbsetinfo(data,size,file,line); 414 415 if((vd->mode&VM_TRACE) && _Vmtrace) 416 { vm->file = file; vm->line = line; vm->func = func; 417 (*_Vmtrace)(vm,NIL(Vmuchar_t*),data,size,0); 418 } 419 420 if(Dbnwatch > 0 ) 421 dbwatch(vm,data,file,line,func,DB_ALLOC); 422 423 done: 424 CLRLOCK(vd,0); 425 ANNOUNCE(0, vm, VM_ALLOC, (Void_t*)data, vm->disc); 426 CLRINUSE(vd, inuse); 427 return (Void_t*)data; 428 } 429 430 431 #if __STD_C 432 static int dbfree(Vmalloc_t* vm, Void_t* data ) 433 #else 434 static int dbfree(vm, data ) 435 Vmalloc_t* vm; 436 Void_t* data; 437 #endif 438 { 439 char* file; 440 int line; 441 Void_t* func; 442 reg long offset; 443 reg int rv, *ip, *endip; 444 reg Vmdata_t* vd = vm->data; 445 reg int inuse; 446 447 SETINUSE(vd, inuse); 448 VMFLF(vm,file,line,func); 449 450 if(!data) 451 { CLRINUSE(vd, inuse); 452 return 0; 453 } 454 455 if(ISLOCK(vd,0) ) 456 { dbwarn(vm,NIL(Vmuchar_t*),0,file,line,func,DB_FREE); 457 CLRINUSE(vd, inuse); 458 return -1; 459 } 460 SETLOCK(vd,0); 461 462 if(vd->mode&VM_DBCHECK) 463 vmdbcheck(vm); 464 465 if((offset = KPVADDR(vm,data,dbaddr)) != 0) 466 { dbwarn(vm,(Vmuchar_t*)data,offset == -1L ? 0 : 1,file,line,func,DB_FREE); 467 if(vm->disc->exceptf) 468 (void)(*vm->disc->exceptf)(vm,VM_BADADDR,data,vm->disc); 469 CLRLOCK(vd,0); 470 CLRINUSE(vd, inuse); 471 return -1; 472 } 473 474 if(Dbnwatch > 0) 475 dbwatch(vm,data,file,line,func,DB_FREE); 476 477 if((vd->mode&VM_TRACE) && _Vmtrace) 478 { vm->file = file; vm->line = line; vm->func = func; 479 (*_Vmtrace)(vm,(Vmuchar_t*)data,NIL(Vmuchar_t*),DBSIZE(data),0); 480 } 481 482 /* clear free space */ 483 ip = (int*)data; 484 endip = ip + (DBSIZE(data)+sizeof(int)-1)/sizeof(int); 485 while(ip < endip) 486 *ip++ = 0; 487 488 rv = KPVFREE((vm), (Void_t*)DB2BEST(data), (*Vmbest->freef)); 489 CLRLOCK(vd,0); 490 ANNOUNCE(0, vm, VM_FREE, data, vm->disc); 491 CLRINUSE(vd, inuse); 492 return rv; 493 } 494 495 /* Resizing an existing block */ 496 #if __STD_C 497 static Void_t* dbresize(Vmalloc_t* vm, Void_t* addr, reg size_t size, int type) 498 #else 499 static Void_t* dbresize(vm,addr,size,type) 500 Vmalloc_t* vm; /* region allocating from */ 501 Void_t* addr; /* old block of data */ 502 reg size_t size; /* new size */ 503 int type; /* !=0 for movable, >0 for copy */ 504 #endif 505 { 506 reg Vmuchar_t* data; 507 reg size_t s, oldsize; 508 reg long offset; 509 char *file, *oldfile; 510 int line, oldline; 511 Void_t* func; 512 reg Vmdata_t* vd = vm->data; 513 reg int inuse; 514 515 SETINUSE(vd, inuse); 516 if(!addr) 517 { oldsize = 0; 518 data = (Vmuchar_t*)dballoc(vm,size); 519 goto done; 520 } 521 if(size == 0) 522 { (void)dbfree(vm,addr); 523 CLRINUSE(vd, inuse); 524 return NIL(Void_t*); 525 } 526 527 VMFLF(vm,file,line,func); 528 529 if(ISLOCK(vd,0) ) 530 { dbwarn(vm,NIL(Vmuchar_t*),0,file,line,func,DB_RESIZE); 531 CLRINUSE(vd, inuse); 532 return NIL(Void_t*); 533 } 534 SETLOCK(vd,0); 535 536 if(vd->mode&VM_DBCHECK) 537 vmdbcheck(vm); 538 539 if((offset = KPVADDR(vm,addr,dbaddr)) != 0) 540 { dbwarn(vm,(Vmuchar_t*)addr,offset == -1L ? 0 : 1,file,line,func,DB_RESIZE); 541 if(vm->disc->exceptf) 542 (void)(*vm->disc->exceptf)(vm,VM_BADADDR,addr,vm->disc); 543 CLRLOCK(vd,0); 544 CLRINUSE(vd, inuse); 545 return NIL(Void_t*); 546 } 547 548 if(Dbnwatch > 0) 549 dbwatch(vm,addr,file,line,func,DB_RESIZE); 550 551 /* Vmbest data block */ 552 data = DB2BEST(addr); 553 oldsize = DBSIZE(addr); 554 oldfile = DBFILE(addr); 555 oldline = DBLINE(addr); 556 557 /* do the resize */ 558 s = ROUND(size,ALIGN) + DB_EXTRA; 559 if(s < sizeof(Body_t)) 560 s = sizeof(Body_t); 561 data = (Vmuchar_t*)KPVRESIZE(vm,(Void_t*)data,s, 562 (type&~VM_RSZERO),(*(Vmbest->resizef)) ); 563 if(!data) /* failed, reset data for old block */ 564 { dbwarn(vm,NIL(Vmuchar_t*),DB_ALLOC,file,line,func,DB_RESIZE); 565 dbsetinfo((Vmuchar_t*)addr,oldsize,oldfile,oldline); 566 } 567 else 568 { data = DB2DEBUG(data); 569 dbsetinfo(data,size,file,line); 570 571 if((vd->mode&VM_TRACE) && _Vmtrace) 572 { vm->file = file; vm->line = line; 573 (*_Vmtrace)(vm,(Vmuchar_t*)addr,data,size,0); 574 } 575 if(Dbnwatch > 0) 576 dbwatch(vm,data,file,line,func,DB_RESIZED); 577 } 578 579 CLRLOCK(vd,0); 580 ANNOUNCE(0, vm, VM_RESIZE, (Void_t*)data, vm->disc); 581 582 done: if(data && (type&VM_RSZERO) && size > oldsize) 583 { reg Vmuchar_t *d = data+oldsize, *ed = data+size; 584 do { *d++ = 0; } while(d < ed); 585 } 586 CLRINUSE(vd, inuse); 587 return (Void_t*)data; 588 } 589 590 /* compact any residual free space */ 591 #if __STD_C 592 static int dbcompact(Vmalloc_t* vm) 593 #else 594 static int dbcompact(vm) 595 Vmalloc_t* vm; 596 #endif 597 { 598 return (*(Vmbest->compactf))(vm); 599 } 600 601 /* check for memory overwrites over all live blocks */ 602 #if __STD_C 603 int vmdbcheck(Vmalloc_t* vm) 604 #else 605 int vmdbcheck(vm) 606 Vmalloc_t* vm; 607 #endif 608 { 609 reg Block_t *b, *endb; 610 reg Seg_t* seg; 611 int rv; 612 reg Vmdata_t* vd = vm->data; 613 614 /* check the meta-data of this region */ 615 if(vd->mode & (VM_MTDEBUG|VM_MTBEST|VM_MTPROFILE)) 616 { if(_vmbestcheck(vd, NIL(Block_t*)) < 0) 617 return -1; 618 if(!(vd->mode&VM_MTDEBUG)) 619 return 0; 620 } 621 else return -1; 622 623 rv = 0; 624 for(seg = vd->seg; seg; seg = seg->next) 625 { b = SEGBLOCK(seg); 626 endb = (Block_t*)(seg->baddr - sizeof(Head_t)); 627 while(b < endb) 628 { reg Vmuchar_t *data, *begp, *endp; 629 630 if(ISJUNK(SIZE(b)) || !ISBUSY(SIZE(b))) 631 goto next; 632 633 data = DB2DEBUG(DATA(b)); 634 if(DBISBAD(data)) /* seen this before */ 635 { rv += 1; 636 goto next; 637 } 638 639 DBHEAD(data,begp,endp); 640 for(; begp < endp; ++begp) 641 if(*begp != DB_MAGIC) 642 goto set_bad; 643 644 DBTAIL(data,begp,endp); 645 for(; begp < endp; ++begp) 646 { if(*begp == DB_MAGIC) 647 continue; 648 set_bad: 649 dbwarn(vm,data,begp-data,NIL(char*),0,0,DB_CHECK); 650 DBSETBAD(data); 651 rv += 1; 652 goto next; 653 } 654 655 next: b = (Block_t*)((Vmuchar_t*)DATA(b) + (SIZE(b)&~BITS)); 656 } 657 } 658 659 return rv; 660 } 661 662 /* set/delete an address to watch */ 663 #if __STD_C 664 Void_t* vmdbwatch(Void_t* addr) 665 #else 666 Void_t* vmdbwatch(addr) 667 Void_t* addr; /* address to insert */ 668 #endif 669 { 670 reg int n; 671 reg Void_t* out; 672 673 out = NIL(Void_t*); 674 if(!addr) 675 Dbnwatch = 0; 676 else 677 { for(n = Dbnwatch - 1; n >= 0; --n) 678 if(Dbwatch[n] == addr) 679 break; 680 if(n < 0) /* insert */ 681 { if(Dbnwatch == S_WATCH) 682 { /* delete left-most */ 683 out = Dbwatch[0]; 684 Dbnwatch -= 1; 685 for(n = 0; n < Dbnwatch; ++n) 686 Dbwatch[n] = Dbwatch[n+1]; 687 } 688 Dbwatch[Dbnwatch] = addr; 689 Dbnwatch += 1; 690 } 691 } 692 return out; 693 } 694 695 #if __STD_C 696 static Void_t* dbalign(Vmalloc_t* vm, size_t size, size_t align) 697 #else 698 static Void_t* dbalign(vm, size, align) 699 Vmalloc_t* vm; 700 size_t size; 701 size_t align; 702 #endif 703 { 704 reg Vmuchar_t* data; 705 reg size_t s; 706 reg char* file; 707 reg int line; 708 reg Void_t* func; 709 reg Vmdata_t* vd = vm->data; 710 reg int inuse; 711 712 SETINUSE(vd, inuse); 713 VMFLF(vm,file,line,func); 714 715 if(size <= 0 || align <= 0) 716 { CLRINUSE(vd, inuse); 717 return NIL(Void_t*); 718 } 719 720 if(ISLOCK(vd,0) ) 721 { CLRINUSE(vd, inuse); 722 return NIL(Void_t*); 723 } 724 SETLOCK(vd,0); 725 726 if((s = ROUND(size,ALIGN) + DB_EXTRA) < sizeof(Body_t)) 727 s = sizeof(Body_t); 728 729 if(!(data = (Vmuchar_t*)KPVALIGN(vm,s,align,(*(Vmbest->alignf)))) ) 730 goto done; 731 732 data += DB_HEAD; 733 dbsetinfo(data,size,file,line); 734 735 if((vd->mode&VM_TRACE) && _Vmtrace) 736 { vm->file = file; vm->line = line; vm->func = func; 737 (*_Vmtrace)(vm,NIL(Vmuchar_t*),data,size,align); 738 } 739 740 done: 741 CLRLOCK(vd,0); 742 ANNOUNCE(0, vm, VM_ALLOC, (Void_t*)data, vm->disc); 743 CLRINUSE(vd, inuse); 744 return (Void_t*)data; 745 } 746 747 /* print statistics of region vm. If vm is NULL, use Vmregion */ 748 #if __STD_C 749 ssize_t vmdbstat(Vmalloc_t* vm) 750 #else 751 ssize_t vmdbstat(vm) 752 Vmalloc_t* vm; 753 #endif 754 { Vmstat_t st; 755 char buf[1024], *bufp; 756 757 vmstat(vm ? vm : Vmregion, &st); 758 bufp = buf; 759 bufp = (*_Vmstrcpy)(bufp, "n_busy", '='); 760 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)((Vmulong_t)st.n_busy,-1), ','); 761 bufp = (*_Vmstrcpy)(bufp, " s_busy", '='); 762 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.s_busy),-1), '\n'); 763 bufp = (*_Vmstrcpy)(bufp, "n_free", '='); 764 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)((Vmulong_t)st.n_free,-1), ','); 765 bufp = (*_Vmstrcpy)(bufp, " s_free", '='); 766 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.s_free),-1), '\n'); 767 bufp = (*_Vmstrcpy)(bufp, "m_busy", '='); 768 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.m_busy),-1), ','); 769 bufp = (*_Vmstrcpy)(bufp, " m_free", '='); 770 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.m_free),-1), '\n'); 771 bufp = (*_Vmstrcpy)(bufp, "n_segment", '='); 772 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)((Vmulong_t)st.n_seg,-1), ','); 773 bufp = (*_Vmstrcpy)(bufp, " extent", '='); 774 bufp = (*_Vmstrcpy)(bufp, (*_Vmitoa)(VLONG(st.extent),-1), '\n'); 775 *bufp = 0; 776 write(Dbfd, buf, strlen(buf)); 777 return strlen(buf); 778 } 779 780 static Vmethod_t _Vmdebug = 781 { 782 dballoc, 783 dbresize, 784 dbfree, 785 dbaddr, 786 dbsize, 787 dbcompact, 788 dbalign, 789 VM_MTDEBUG 790 }; 791 792 __DEFINE__(Vmethod_t*,Vmdebug,&_Vmdebug); 793 794 #ifdef NoF 795 NoF(vmdebug) 796 #endif 797 798 #endif 799