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);
}
