?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
import less(1)
[unleashed/tickless.git] / usr / src / lib / libast / common / vmalloc / vmdebug.c
blob3cb1e3963e828aba54549fa5597c15c4117ed176
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
unleashed repo fork