void dumpdatalist(Datalist* list, char* tag) { Bytebuffer* buf = bbNew(); bufdump(list,buf); fprintf(stderr,"%s: %s\n",tag,bbContents(buf)); bbFree(buf); }
/* bpoold * Dump a buffer pool. The buffer headers are always listed. * If DUMPALLOC is nonzero, the contents of allocated buffers * are dumped. If DUMPFREE is nonzero, free blocks are * dumped as well. If FreeWipe checking is enabled, free * blocks which have been clobbered will always be dumped. */ void bpoold( _In_ BytePool_t *pool, _In_ void *buf, _In_ int dumpalloc, _In_ int dumpfree) { struct bfhead *b = BFH(buf); while (b->bh.bsize != ESent) { long bs = b->bh.bsize; if (bs < 0) { bs = -bs; V printf("Allocated buffer: size %6ld bytes.\n", (long) bs); if (dumpalloc) { bufdump(pool, (void *) (((char *) b) + sizeof(struct bhead))); } } else { char *lerr = ""; assert(bs > 0); if ((b->ql.blink->ql.flink != b) || (b->ql.flink->ql.blink != b)) { lerr = " (Bad free list links)"; } V printf("Free block: size %6ld bytes.%s\n", (long) bs, lerr); #ifdef FreeWipe lerr = ((char *) b) + sizeof(struct bfhead); if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) || (memcmp(lerr, lerr + 1, (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) { V printf( "(Contents of above free block have been overstored.)\n"); bufdump(pool, (void *) (((char *) b) + sizeof(struct bhead))); } else #endif if (dumpfree) { bufdump(pool, (void *) (((char *) b) + sizeof(struct bhead))); } } b = BFH(((char *) b) + bs); } }
void report(char* lead, Datalist* list) { extern void bufdump(Datalist*,Bytebuffer*); Bytebuffer* buf = bbNew(); bufdump(list,buf); fprintf(stderr,"\n%s::%s\n",lead,bbContents(buf)); fflush(stderr); bbFree(buf); }
void bufdump(Datalist* list, Bytebuffer* buf) { int i; NCConstant** dpl; unsigned int count; if(list == NULL) { bbCat(buf,"NULL"); return; } count = list->length; for(dpl=list->data,i=0;i<count;i++,dpl++) { NCConstant* dp = *dpl; switch (dp->nctype) { case NC_COMPOUND: bbCat(buf,"{"); bufdump(dp->value.compoundv,buf); bbCat(buf,"}"); break; case NC_ARRAY: bbCat(buf,"["); bufdump(dp->value.compoundv,buf); bbCat(buf,"]"); break; case NC_VLEN: bbCat(buf,"{*"); bufdump(dp->value.compoundv,buf); bbCat(buf,"}"); break; default: if(isprimplus(dp->nctype) || dp->nctype == NC_FILLVALUE) { bbCat(buf," "); dumpdataprim(dp,buf); } else { char tmp[64]; sprintf(tmp,"?%d? ",dp->nctype); bbCat(buf,tmp); } break; } } }
void dumpconstant(NCConstant* con, char* tag) { Bytebuffer* buf = bbNew(); Datalist* dl = builddatalist(1); dlappend(dl,con); bufdump(dl,buf); fprintf(stderr,"%s: %s\n",tag,bbContents(buf)); bbFree(buf); }
/* bpoolv * Validate a buffer pool. If NDEBUG isn't defined, * any error generates an assertion failure. */ OsStatus_t bpoolv( _In_ BytePool_t *pool, _In_ void *buf) { struct bfhead *b = BFH(buf); while (b->bh.bsize != ESent) { long bs = b->bh.bsize; if (bs < 0) { bs = -bs; } else { char *lerr = ""; assert(bs > 0); if (bs <= 0) { return OsError; } if ((b->ql.blink->ql.flink != b) || (b->ql.flink->ql.blink != b)) { V printf("Free block: size %6ld bytes. (Bad free list links)\n", (long) bs); assert(0); return OsError; } #ifdef FreeWipe lerr = ((char *) b) + sizeof(struct bfhead); if ((bs > sizeof(struct bfhead)) && ((*lerr != 0x55) || (memcmp(lerr, lerr + 1, (MemSize) (bs - (sizeof(struct bfhead) + 1))) != 0))) { V printf( "(Contents of above free block have been overstored.)\n"); bufdump(pool, (void *) (((char *) b) + sizeof(struct bhead))); assert(0); return OsError; } #endif } b = BFH(((char *) b) + bs); } return OsSuccess; }
void idump(void) { inoptr ip; ptptr pp; extern struct cinode i_tab[]; kprintf("Err %d root %d\n", udata.u_error, root - i_tab); kputs("\tMAGIC\tDEV\tNUM\tMODE\tNLINK\t(DEV)\tREFS\tDIRTY\n"); for (ip = i_tab; ip < i_tab + ITABSIZE; ++ip) { kprintf("%d\t%d\t%d\t%u\t0%o\t", ip - i_tab, ip->c_magic, ip->c_dev, ip->c_num, ip->c_node.i_mode); kprintf("%d\t%d\t%d\t%d\n", /* line split for compiler */ ip->c_node.i_nlink, ip->c_node.i_addr[0], ip->c_refs, ip->c_dirty); if (!ip->c_magic) break; } kputs ("\n\tSTAT\tWAIT\tPID\tPPTR\tALARM\tPENDING\tIGNORED\tCHILD\n"); for (pp = ptab; pp < ptab + PTABSIZE /*maxproc */ ; ++pp) { if (pp->p_status == P_EMPTY) continue; kprintf("%d\t%d\t0x%x\t%d\t", pp - ptab, pp->p_status, pp->p_wait, pp->p_pid); kprintf("%d\t%d\t0x%lx\t0x%lx\n", pp->p_pptr - ptab, pp->p_alarm, pp->p_pending, pp->p_ignored); } bufdump(); kprintf("insys %d ptab %d call %d cwd %d sp 0x%x\n", udata.u_insys, udata.u_ptab - ptab, udata.u_callno, udata.u_cwd - i_tab, udata.u_sp); }
void dumpconstant1(NCConstant* con) { switch (con->nctype) { case NC_COMPOUND: { Datalist* dl = con->value.compoundv; Bytebuffer* buf = bbNew(); bufdump(dl,buf); /* fprintf(stderr,"(0x%lx){",(unsigned long)dl);*/ fprintf(stderr,"{%s}",bbDup(buf)); bbFree(buf); } break; case NC_STRING: if(con->value.stringv.len > 0 && con->value.stringv.stringv != NULL) fprintf(stderr,"\"%s\"",con->value.stringv.stringv); else fprintf(stderr,"\"\""); break; case NC_OPAQUE: if(con->value.opaquev.len > 0 && con->value.opaquev.stringv != NULL) fprintf(stderr,"0x%s",con->value.opaquev.stringv); else fprintf(stderr,"0x--"); break; case NC_ECONST: fprintf(stderr,"%s",(con->value.enumv==NULL?"?":con->value.enumv->name)); break; case NC_FILLVALUE: fprintf(stderr,"_"); break; case NC_CHAR: fprintf(stderr,"'%c'",con->value.charv); break; case NC_BYTE: fprintf(stderr,"%hhd",con->value.int8v); break; case NC_UBYTE: fprintf(stderr,"%hhu",con->value.uint8v); break; case NC_SHORT: fprintf(stderr,"%hd",con->value.int16v); break; case NC_USHORT: fprintf(stderr,"%hu",con->value.uint16v); break; case NC_INT: fprintf(stderr,"%d",con->value.int32v); break; case NC_UINT: fprintf(stderr,"%u",con->value.uint32v); break; case NC_INT64: fprintf(stderr,"%lld",con->value.int64v); break; case NC_UINT64: fprintf(stderr,"%llu",con->value.uint64v); break; case NC_FLOAT: fprintf(stderr,"%g",con->value.floatv); break; case NC_DOUBLE: fprintf(stderr,"%g",con->value.doublev); break; default: fprintf(stderr,"<unknown>"); break; } fflush(stderr); }