680 lines
18 KiB
C
Executable file
680 lines
18 KiB
C
Executable file
/* SB - Copyright 1982 by Ken Harrenstien, SRI International
|
||
* This software is quasi-public; it may be used freely with
|
||
* like software, but may NOT be sold or made part of licensed
|
||
* products without permission of the author. In all cases
|
||
* the source code and any modifications thereto must remain
|
||
* available to any user.
|
||
*
|
||
* This is part of the SB library package.
|
||
* Any software using the SB library must likewise be made
|
||
* quasi-public, with freely available sources.
|
||
*/
|
||
|
||
#define PRINT /* Include printout stuff */
|
||
|
||
#include "sb.h"
|
||
#include <stdio.h>
|
||
|
||
extern struct smblk *sbm_nfl;
|
||
extern struct smblk *sbm_list;
|
||
extern struct sdblk *sbx_nfl;
|
||
|
||
#ifdef PRINT
|
||
#define PRF(stmt) {if(p) stmt;}
|
||
#define PRFBUG(str,stmt) {if(p) stmt;else return(str);}
|
||
#define PRFBAD(str,stmt) {if(p) stmt; return(str);}
|
||
#else
|
||
#define PRF(stmt) ;
|
||
#define PRFBUG(str,stmt) return(str);
|
||
#define PRFBAD(str,stmt) return(str);
|
||
#endif
|
||
|
||
#ifndef NPTRS
|
||
#define NPTRS (1000) /* Catch loops of period less than this. */
|
||
#endif
|
||
|
||
int sbe_dec = 0; /* Set nonzero to use decimal printout */
|
||
|
||
struct ptab {
|
||
int pt_pflag; /* Printflag value */
|
||
char *pt_err; /* Error string return */
|
||
int pt_xerr; /* Error index return */
|
||
int pt_hidx; /* Highest freelist entry */
|
||
int pt_nsto; /* # entries stored in table */
|
||
int pt_cnt; /* # of entry store attempts */
|
||
struct smblk *pt_tab[NPTRS];
|
||
};
|
||
|
||
_PROTOTYPE( char *sbe_sdtab, (struct ptab *pt, int p, int phys) );
|
||
_PROTOTYPE( char *sbe_schk, (struct sdblk *sd, struct ptab *pt) );
|
||
_PROTOTYPE( int sbe_tbent, (struct ptab *pt, struct smblk *sm) );
|
||
|
||
#define PTF_PRF 01 /* Do printout stuff */
|
||
#define PTF_OVFERR 02 /* Complain if table overflows */
|
||
#define PTF_SDPHYS 04 /* Follow SD phys links (else logical links) */
|
||
|
||
struct flgt {
|
||
int flg_bit;
|
||
int flg_chr;
|
||
};
|
||
|
||
_PROTOTYPE( char *sbe_fstr, (int flags, struct flgt *fp) );
|
||
|
||
char *sbe_mvfy(), *sbe_mfl(), *sbe_mlst(); /* SBM */
|
||
char *sbe_sbvfy(), *sbe_sbs(); /* SBBUF */
|
||
char *sbe_svfy(), *sbe_sdlist(), *sbe_sdtab(), *sbe_schk(); /* SD */
|
||
char *sbe_fstr(); /* Misc utility */
|
||
|
||
|
||
/* SBE_MEM() - Print out memory usage list
|
||
*/
|
||
sbe_mem()
|
||
{
|
||
printf("\nMemory Usage:\n");
|
||
printf("\tsbm_nfl : %6o\n",sbm_nfl);
|
||
printf("\tsbm_list: %6o\n",sbm_list);
|
||
printf("\tsmblk nodes are %o bytes long.\n",sizeof (struct smblk));
|
||
|
||
sbe_mlst(1); /* Scan mem list, printing stuff. */
|
||
}
|
||
|
||
/* SBE_MVFY() - Verify memory allocation structures
|
||
* Returns error message (0 if no errors found).
|
||
*/
|
||
char *
|
||
sbe_mvfy()
|
||
{ register char *res;
|
||
|
||
if((res = sbe_mfl(0))
|
||
|| (res = sbe_mlst(0)))
|
||
return(res);
|
||
return(0);
|
||
}
|
||
|
||
/* SBM Debugging Routines */
|
||
|
||
struct flgt smflgtab[] = {
|
||
SM_USE, 'U',
|
||
SM_NXM, 'N',
|
||
SM_EXT, 'E',
|
||
SM_MNODS,'M',
|
||
SM_DNODS,'D',
|
||
0,0
|
||
};
|
||
|
||
static char smfhelp[] = "U-Used, N-NXM, E-External, M-SMnodes, D-SDnodes";
|
||
static char smhdline[] = "\
|
||
SM: back smaddr smlen smuse smflags";
|
||
|
||
/* SBE_MFL(printflag) - Verify/Print memory freelist
|
||
* Returns error message (0 if no errors found).
|
||
*/
|
||
char *
|
||
sbe_mfl(p)
|
||
int p;
|
||
{ register struct smblk *sm;
|
||
register int i;
|
||
struct ptab smtab; /* For loop detection */
|
||
|
||
PRF(printf("Tracing SM node freelist --\n"))
|
||
PRF(printf(" Maximum loop detection size is %d.", NPTRS))
|
||
if((sm = sbm_nfl) == 0)
|
||
{ PRF(printf("\n\tNo list.\n"))
|
||
return(0); /* Null freelist is ok */
|
||
}
|
||
smtab.pt_pflag = p ? PTF_PRF : 0;
|
||
smtab.pt_nsto = smtab.pt_cnt = 0;
|
||
i = 0; /* Print 8 addrs/line */
|
||
for(; sm; sm = sm->smforw)
|
||
{
|
||
PRF(printf("%s%7o->", (i==0 ? "\n " : ""), sm))
|
||
if(++i >= 8) i = 0;
|
||
if(sbe_tbent(&smtab, sm) < 0) /* If hit loop, stop */
|
||
PRFBAD("SM freelist loop",
|
||
printf("\nLOOP - %o seen as node %d!!\n",
|
||
sm, smtab.pt_xerr))
|
||
if(sm->smflags)
|
||
{ PRF((i = 0, printf("\nFreelist node has flags:\n")))
|
||
PRFBUG("Free SM flagged", sbe_smp(sm, 0))
|
||
}
|
||
}
|
||
PRF(printf("\nEnd - %d nodes on SM freelist.\n", smtab.pt_cnt))
|
||
return(0);
|
||
}
|
||
|
||
/* SBE_MLST(printflag) - Verify/Print allocated memory list.
|
||
* Returns error message (0 if no errors found).
|
||
*/
|
||
char *
|
||
sbe_mlst(p)
|
||
int p;
|
||
{ register struct smblk *sm, *smf, *smb;
|
||
char *nextaddr;
|
||
int i;
|
||
struct ptab smtab; /* For loop detection */
|
||
|
||
PRF(printf("Tracing mem list -- \n"))
|
||
if((sm = sbm_list) == 0)
|
||
{ PRF(printf("\tNo list?!\n"))
|
||
if(sbm_nfl) /* Ensure rest are 0 too */
|
||
return("No mem list?!!");
|
||
return(0);
|
||
}
|
||
|
||
smtab.pt_pflag = p;
|
||
smtab.pt_cnt = smtab.pt_nsto = 0;
|
||
smb = 0;
|
||
PRF(printf(" Flags: %s\n%s\n", smfhelp, smhdline))
|
||
for(; sm; sm = smf)
|
||
{ PRF(printf(" %6o: ",sm))
|
||
if(sbe_tbent(&smtab, sm) < 0)
|
||
PRFBAD("Loop in mem list!!",
|
||
printf("LOOP - seen as node %d!!\n", smtab.pt_xerr))
|
||
|
||
if(sm->smback == smb)
|
||
PRF(printf("^ ")) /* Back ptr OK */
|
||
|
||
else PRFBUG("Bad back ptr!",
|
||
printf("%6o BAD Backptr!!\n\t ",sm->smback))
|
||
|
||
if((sm->smflags&0377)!= SM_NID)
|
||
PRFBUG("SM: bad node ID",
|
||
printf("BAD - no node ID!\n\t "))
|
||
PRF(printf((sm->smflags&SM_USE) ? " " : "FREE "))
|
||
if(sm->smlen == 0)
|
||
PRFBUG("SM: len 0",
|
||
printf("Zero-length area!"))
|
||
if((sm->smflags&SM_USE)==0
|
||
&& rndrem(sm->smaddr - sbm_lowaddr))
|
||
PRFBUG("Bad free-mem block",
|
||
printf("Bad free-mem block"))
|
||
PRF(sbe_smp(sm, 1)) /* Print out rest of info */
|
||
|
||
if(nextaddr != sm->smaddr
|
||
&& smtab.pt_cnt != 1) /* 1st time needs init */
|
||
{ PRFBUG("Alignment error!",
|
||
printf("\t BAD!! %6o expected; ",nextaddr))
|
||
#if !(MINIX)
|
||
PRF((i = sm->smaddr - nextaddr) > 0
|
||
? printf("%d skipped.\n",i)
|
||
: printf("%d overlapped.\n",-i))
|
||
#endif
|
||
}
|
||
nextaddr = sm->smaddr + sm->smlen;
|
||
smf = sm->smforw;
|
||
smb = sm; /* Save ptr to back */
|
||
}
|
||
PRF(printf("End = %6o\n",nextaddr))
|
||
return(0);
|
||
}
|
||
|
||
#ifdef PRINT
|
||
sbe_smp(sm,type)
|
||
register struct smblk *sm;
|
||
int type;
|
||
{
|
||
if(type==0)
|
||
printf(" %6o: %s ", sm,
|
||
((sm->smflags&SM_USE) ? " " : "FREE"));
|
||
printf("%6o: ", sm->smaddr);
|
||
printf((sbe_dec ? "%5d. %5d." : "%6o %6o"), sm->smlen, sm->smuse);
|
||
printf(" %7o = %s\n", sm->smflags, sbe_fstr(sm->smflags, smflgtab));
|
||
}
|
||
#endif /*PRINT*/
|
||
|
||
/* SD (SBSTR) debugging routines */
|
||
|
||
struct flgt sdflgtab[] = {
|
||
SD_LOCK, 'L',
|
||
SD_LCK2, 'T',
|
||
SD_MOD, '*',
|
||
0,0
|
||
};
|
||
|
||
static char sdfhelp[] = "\
|
||
<f> flags: *-MOD (disk outofdate), L-LOCK, T-LCK2 (temp)";
|
||
static char sdhdline[] = "\
|
||
<f> SD: slforw slback sdflgs sdforw sdback sdmem sdfile sdaddr sdlen";
|
||
|
||
|
||
/* SBE_SFL(printflag) - Verify/Print SD freelist
|
||
* Returns error message (0 if no errors found).
|
||
*/
|
||
char *
|
||
sbe_sfl(p)
|
||
int p;
|
||
{ register struct sdblk *sd;
|
||
register int i;
|
||
struct ptab sdtab; /* For loop detection */
|
||
|
||
PRF(printf("Tracing SDBLK node freelist --\n"))
|
||
PRF(printf(" Maximum loop detection size is %d.", NPTRS))
|
||
if((sd = sbx_nfl) == 0)
|
||
{ PRF(printf("\n\tNo list.\n"))
|
||
return(0); /* Null freelist is ok */
|
||
}
|
||
sdtab.pt_pflag = p ? PTF_PRF : 0;
|
||
sdtab.pt_nsto = sdtab.pt_cnt = 0;
|
||
i = 0; /* Print 8 addrs/line */
|
||
for(; sd; sd = sd->slforw)
|
||
{
|
||
PRF(printf("%s%7o->", (i==0 ? "\n " : ""), sd))
|
||
if(++i >= 8) i = 0;
|
||
if(sbe_tbent(&sdtab, sd) < 0) /* If hit loop, stop */
|
||
PRFBAD("SD freelist loop",
|
||
printf("\nLOOP - %o seen as node %d!!",
|
||
sd, sdtab.pt_xerr))
|
||
if(sd->sdflags)
|
||
{ PRF((i = 0, printf("\nFreelist node has flags:\n")))
|
||
PRFBUG("Free SD flagged", sbe_psd(sd))
|
||
}
|
||
}
|
||
PRF(printf("\nEnd - %d nodes on SD freelist.\n", sdtab.pt_cnt))
|
||
return(0);
|
||
}
|
||
|
||
|
||
|
||
/* SBE_SDS() - Print out all sdblk data stuff
|
||
*/
|
||
sbe_sds()
|
||
{ int sbe_psd();
|
||
|
||
printf("Printout of all in-use SDBLKs:\n");
|
||
printf(" %s\n", sdfhelp);
|
||
printf("%s\n", sdhdline);
|
||
sbm_nfor(SM_DNODS,sizeof(struct sdblk),sbe_psd,0);
|
||
printf("\n");
|
||
}
|
||
|
||
/* SBE_PSD - Auxiliary for invocation by SBE_SDS above. */
|
||
sbe_psd(sd)
|
||
register struct sdblk *sd;
|
||
{ register int flags;
|
||
|
||
flags = sd->sdflags;
|
||
printf("%c%c%c",
|
||
((flags&SD_MOD) ? '*' : ' '),
|
||
((flags&SD_LOCK) ? 'L' : ' '),
|
||
((flags&SD_LCK2) ? 'T' : ' '));
|
||
|
||
printf(" %7o: %6o %6o %6o %6o %6o %6o %6o %7lo %5ld.\n", sd,
|
||
sd->slforw, sd->slback, sd->sdflags,
|
||
sd->sdforw, sd->sdback, sd->sdmem,
|
||
sd->sdfile, sd->sdaddr, sd->sdlen);
|
||
return(0);
|
||
}
|
||
|
||
/* SBE_SVFY() - Verify all SD blocks
|
||
* Returns error message (0 if no errors found).
|
||
*/
|
||
char *
|
||
sbe_svfy()
|
||
{ register char *res;
|
||
return((res = sbe_sdlist(0,0)) ? res : sbe_sdlist(0,1));
|
||
}
|
||
|
||
/* SBE_SDLIST(printflag, physflag) - Verify/Print all SD blocks.
|
||
* Show logical lists if physflag 0
|
||
* Show physical lists otherwise
|
||
* Returns error message (0 if no errors found).
|
||
*/
|
||
char *
|
||
sbe_sdlist(p,phys)
|
||
int p, phys;
|
||
{ register char *res;
|
||
struct ptab sdtab; /* The SDLIST table to use */
|
||
|
||
/* First put freelist in table, then scan for all
|
||
* SD nodes. Each active node (not in table) gets
|
||
* its entire list traced forward/backward and added to table.
|
||
*/
|
||
if(res = sbe_sdtab(&sdtab, p, phys)) /* Set up freelist table */
|
||
return(res);
|
||
|
||
/* Freelist entered in table, now scan all SD's */
|
||
res = (char *)sbm_nfor(SM_DNODS,sizeof(struct sdblk),
|
||
sbe_schk, &sdtab);
|
||
|
||
PRF(printf("\n"))
|
||
return(res);
|
||
}
|
||
|
||
/* SBE_SDTAB(tableptr, printflag, physflag) - Auxiliary for SBE_SDLIST.
|
||
* Stuffs all freelist SDBLK addresses in table for dup detection.
|
||
* Returns error message (0 if no errors found).
|
||
*/
|
||
char *
|
||
sbe_sdtab(pt, p, phys)
|
||
register struct ptab *pt;
|
||
int p, phys;
|
||
{ register struct sdblk *sd;
|
||
register int res;
|
||
|
||
pt->pt_pflag = (p ? PTF_PRF : 0) | (phys ? PTF_SDPHYS : 0)
|
||
| PTF_OVFERR;
|
||
pt->pt_cnt = pt->pt_nsto = 0; /* Initialize */
|
||
|
||
/* Stick freelist in table */
|
||
for(sd = sbx_nfl; sd; sd = sd->slforw)
|
||
{ if(sbe_tbent(pt, sd) < 0)
|
||
{ if(pt->pt_xerr < 0)
|
||
PRFBAD("SD freelist too long",
|
||
printf("SD freelist too long (%d)\n",
|
||
NPTRS))
|
||
PRFBAD("SD freelist loop",
|
||
printf("SD freelist loop at %o\n", pt->pt_xerr))
|
||
}
|
||
|
||
if(sd->sdflags)
|
||
{
|
||
PRF(printf("Bad free SD, non-zero flag:\n"))
|
||
PRFBUG("Free SD flagged", sbe_psd(sd))
|
||
}
|
||
}
|
||
pt->pt_hidx = pt->pt_nsto; /* Set idx of 1st non-FL entry */
|
||
return(0);
|
||
}
|
||
|
||
/* SBE_SCHK(SDptr, tableptr) - Auxiliary for SBE_SDLIST.
|
||
* If SD not already in table, verifies or prints
|
||
* the complete physical or logical list it's on, and enters all
|
||
* of its SDs into table (to prevent doing it again).
|
||
* Returns 0 if no errors, else error string.
|
||
** There is a problem when the table overflows. The tbent routine
|
||
** wants to add it (wrapping around at bottom) in that case, because
|
||
** that still helps detect loops. But this routine wants to reset
|
||
** the table back (after scanning to head of list) and once it starts
|
||
** scanning forward again it will fail, because some of the SDs are
|
||
** still in the table due to the wraparound! Thus PTF_OVFERR is always
|
||
** set, in order to at least give the right error message.
|
||
*/
|
||
char *
|
||
sbe_schk(sd, pt)
|
||
register struct sdblk *sd;
|
||
struct ptab *pt;
|
||
{ register struct sdblk *sdx;
|
||
register struct smblk *sm;
|
||
struct sbfile *savfile;
|
||
chroff lastaddr;
|
||
int p, res, savidx, phys;
|
||
|
||
phys = pt->pt_pflag&PTF_SDPHYS; /* Set up physflag */
|
||
if(phys && (sd->sdfile == 0)) /* Ignore non-phys stuff if phys */
|
||
return(0);
|
||
p = pt->pt_pflag&PTF_PRF; /* Set up printflag */
|
||
savidx = pt->pt_nsto; /* Remember initial extent of table */
|
||
|
||
if(sbe_tbent(pt, sd) < 0)
|
||
{ if(pt->pt_xerr >= 0) /* OK if already in table */
|
||
return(0);
|
||
PRFBAD("Too many SDs",
|
||
printf("Too many SDs for table (%d)\n", NPTRS))
|
||
}
|
||
|
||
/* Now search backward for start of list */
|
||
while(sdx = (phys ? sd->sdback : sd->slback))
|
||
if(sbe_tbent(pt,sdx) >= 0)
|
||
sd = sdx;
|
||
else break;
|
||
if(sdx)
|
||
{ if(pt->pt_xerr < 0) /* Table error? */
|
||
PRFBAD("Too many SDs",
|
||
printf("Too many SDs for table (%d)\n",NPTRS))
|
||
PRF(printf("Backlist loop!! Dup'd node:%s\n",
|
||
(pt->pt_xerr < pt->pt_hidx) ?
|
||
"(on freelist!)" : "" ))
|
||
PRFBUG((phys ? "Phys SD loop" : "SD loop"), sbe_psd(sdx))
|
||
}
|
||
/* Reset table to flush nodes backed over */
|
||
pt->pt_cnt = pt->pt_nsto = savidx;
|
||
|
||
/* SD now points to start of list. Begin stepping thru list... */
|
||
PRF(printf("---- %sList started: ", (phys ? "Phys " : "")))
|
||
if(phys)
|
||
{ savfile = sd->sdfile;
|
||
PRF(printf(" SF: %o, fd= %d, ln= %ld\n",
|
||
savfile,savfile->sffd,savfile->sflen))
|
||
if(savfile->sfptr1 != sd)
|
||
PRFBUG("SFPTR1 bad",
|
||
printf(" BAD!! Sfptr1 %o doesn't match SD %o!!\n",
|
||
savfile->sfptr1, sd))
|
||
lastaddr = 0;
|
||
}
|
||
else PRF(printf("\n"))
|
||
|
||
PRF(printf("%s\n", sdhdline))
|
||
for(sdx = 0; sd; (sdx = sd, sd = (phys ? sd->sdforw : sd->slforw)))
|
||
{
|
||
PRF(sbe_psd(sd)) /* Print it out */
|
||
if(sdx != (phys ? sd->sdback : sd->slback))
|
||
{ if(phys)
|
||
PRFBUG("PSD bad sdback",printf("\tBad phys backptr\n"))
|
||
else
|
||
PRFBUG("SD bad slback",printf("\tBad backptr\n"))
|
||
}
|
||
|
||
if((sd->sdflags&0377) != SD_NID)
|
||
PRFBUG("Bad SD node ID", printf("\tBad node ID!\n"))
|
||
|
||
|
||
if(sd->sdfile && (sd->sdlen < 0 || sd->sdaddr < 0))
|
||
PRFBUG("SD: neg len/addr",
|
||
printf("\tNeg disk len/addr\n"))
|
||
if(phys) goto dophys;
|
||
|
||
/* Do special stuff for logical list */
|
||
if(sm = sd->sdmem)
|
||
{ if((sm->smflags&0377) != SM_NID)
|
||
PRFBUG("SD: bad SM",
|
||
printf("\nBad SMBLK ptr\n"))
|
||
if((sd->sdflags&SD_MOD)==0
|
||
&& sd->sdlen != sm->smuse)
|
||
PRFBUG("SD != SM",
|
||
printf("\tBad SMBLK? Len conflict\n"))
|
||
if(sm->smlen < sm->smuse)
|
||
PRFBUG("SD: SM len < use",
|
||
printf("\tBad SMBLK, len < use\n"))
|
||
}
|
||
goto doboth; /* Skip phys stuff */
|
||
|
||
/* Do special stuff for phys list */
|
||
dophys: if(sd->sdfile != savfile)
|
||
PRFBUG("SD: bad sdfile",
|
||
printf("\tBad sdfile ptr! Shd be %o\n",
|
||
savfile))
|
||
if(sd->sdaddr < lastaddr)
|
||
PRFBUG("SD addr out of order",
|
||
printf("\tBad disk addr, not in order!\n"))
|
||
lastaddr = sd->sdaddr;
|
||
/* Done with special phys stuff */
|
||
|
||
doboth: if(sbe_tbent(pt, sd) < 0)
|
||
{ if(pt->pt_xerr < 0)
|
||
PRFBAD("Too many SDs",
|
||
printf("Too many SDs for table (%d)\n",NPTRS))
|
||
|
||
PRFBUG("SD loop",
|
||
printf("\tLOOP!! This SD already seen%s.\n",
|
||
(pt->pt_xerr < pt->pt_hidx) ?
|
||
" (on freelist!)" : "" ))
|
||
break;
|
||
}
|
||
}
|
||
PRF(printf("-----------\n"))
|
||
return(0);
|
||
}
|
||
|
||
/* SBE_DSK(SFptr) - Print out disk usage list for specific file
|
||
*/
|
||
|
||
sbe_dsk(sfp)
|
||
SBFILE *sfp;
|
||
{
|
||
printf("SBFILE printout not coded: %o\n",sfp);
|
||
}
|
||
|
||
/* SBBUF structure debugging routines */
|
||
|
||
struct flgt sbflgtab[] = {
|
||
SB_OVW, 'O',
|
||
SB_WRIT,'W',
|
||
0,0
|
||
};
|
||
static char sbfhelp[] = "O-Overwrite, W-Write";
|
||
|
||
/* SBE_SBVFY(SBptr) - Verify a SB-string.
|
||
* Returns error message (0 if no errors found).
|
||
*/
|
||
char *
|
||
sbe_sbvfy(sbp)
|
||
SBBUF *sbp;
|
||
{ return(sbe_sbs(sbp,0));
|
||
}
|
||
|
||
/* SBE_SBS(SBptr, printflag) - Verify/Print SBSTR data stuff
|
||
* Returns error message (0 if no errors found).
|
||
*/
|
||
char *
|
||
sbe_sbs(sbp,p)
|
||
SBBUF *sbp;
|
||
int p;
|
||
{ register SBBUF *sb;
|
||
register struct smblk *sm;
|
||
register struct sdblk *sd;
|
||
|
||
sb = sbp;
|
||
PRF(printf("SBSTR %o: ",sb))
|
||
if(sb == 0)
|
||
PRFBUG(0,printf("Zero pointer???\n"))
|
||
|
||
/* First print out cryptic summary in case pointers bomb
|
||
* out farther on. */
|
||
PRF(printf(" (io,cur,r,w,f,.,+ = %o,%o,%d,%d,%o,%lo,%lo)\n",
|
||
sb->sbiop, sb->sbcur, sb->sbrleft, sb->sbwleft,
|
||
sb->sbflags, sb->sbdot, sb->sboff))
|
||
|
||
PRF(printf(" sbflags %5o = %s (%s)\n",
|
||
sb->sbflags, sbe_fstr(sb->sbflags,sbflgtab),
|
||
sbfhelp))
|
||
|
||
if(sd = sb->sbcur) /* Okay, now try getting pointers */
|
||
sm = sd->sdmem;
|
||
else sm = 0;
|
||
|
||
PRF(printf(" sbcur %6o",sd))
|
||
if(sd)
|
||
{
|
||
PRF(printf("\n %s\n ", sdhdline))
|
||
PRF(sbe_psd(sd))
|
||
|
||
if((sd->sdflags&0377) != SD_NID)
|
||
PRFBUG("SBCUR not SD?",printf(" BAD SDBLK ID!! \n"))
|
||
if(sm)
|
||
{
|
||
PRF(printf(" %s\n ", smhdline))
|
||
PRF(sbe_smp(sm,0))
|
||
if((sm->smflags&0377) != SM_NID)
|
||
PRFBUG("SBCUR has bad SM",
|
||
printf(" BAD SMBLK ID!!\n"))
|
||
}
|
||
}
|
||
|
||
|
||
PRF(printf(" sbiop %6o",sb->sbiop))
|
||
if(sb->sbiop)
|
||
{ if(!sm || sb->sbiop < sm->smaddr
|
||
|| sb->sbiop > (sm->smaddr + sm->smlen))
|
||
PRFBUG("Bad SBIOP", printf(" BAD"))
|
||
}
|
||
else if(sb->sbrleft > 0 || sb->sbwleft > 0)
|
||
PRFBUG("Bad SBIOP/cnts", printf(" BAD"))
|
||
PRF(printf("\n"))
|
||
|
||
PRF(printf(" sbrleft %5o = %5d.",sb->sbrleft, sb->sbrleft))
|
||
if(sb->sbrleft
|
||
&& ( !sm
|
||
|| sb->sbwleft
|
||
|| (sb->sbflags&SB_WRIT)
|
||
|| (sb->sbrleft != (sm->smuse - (sb->sbiop - sm->smaddr)))
|
||
))
|
||
PRFBUG("Bad sbrleft", printf(" BAD"))
|
||
PRF(printf("\n"))
|
||
|
||
PRF(printf(" sbwleft %5o = %5d.", sb->sbwleft, sb->sbwleft))
|
||
if(sb->sbwleft
|
||
&& ( !sm
|
||
|| (sb->sbflags&SB_WRIT) == 0
|
||
|| (sb->sbwleft > (sm->smlen - (sb->sbiop - sm->smaddr)))
|
||
))
|
||
PRFBUG("Bad sbwleft", printf(" BAD"))
|
||
PRF(printf("\n"))
|
||
|
||
PRF(printf(" sbdot %7lo = %7ld.", sb->sbdot, sb->sbdot))
|
||
if(sb->sbdot < 0)
|
||
PRFBUG("Bad sbdot", printf(" BAD"))
|
||
|
||
PRF(printf("\n sboff %7lo = %7ld.\n", sb->sboff, sb->sboff))
|
||
PRF(printf(" I/O ptr loc: %ld.\n\n", sb_tell(sb)))
|
||
|
||
return(0);
|
||
}
|
||
|
||
/* SBE_TBENT() - Auxiliary to add and check entries to a pointer table.
|
||
* Note we assume here that smblk ptrs are used, although sdblks
|
||
* can also be hacked. This wins as long as the two kinds of ptrs
|
||
* are basically identical (saves horrible casting problems).
|
||
* Returns index # if successful (between 0 and NPTRS-1 inclusive).
|
||
* Otherwise an error (-1), with relevant info in pt_xerr:
|
||
* -1 if out of room and flag set making it an error
|
||
* 0-n if entry already existed.
|
||
*/
|
||
sbe_tbent(pt, sm)
|
||
register struct ptab *pt;
|
||
struct smblk *sm;
|
||
{ register struct smblk **smt;
|
||
register int i;
|
||
int p;
|
||
|
||
p = pt->pt_pflag&PTF_PRF; /* Set up print flag */
|
||
smt = &(pt->pt_tab[0]);
|
||
if(i = pt->pt_nsto)
|
||
{ do {
|
||
if(sm == *smt++)
|
||
{ pt->pt_xerr = pt->pt_nsto - i;
|
||
return(-1);
|
||
}
|
||
} while(--i);
|
||
--smt;
|
||
}
|
||
|
||
i = pt->pt_cnt++;
|
||
if(++(pt->pt_nsto) > NPTRS)
|
||
{ if(pt->pt_pflag&PTF_OVFERR)
|
||
{ pt->pt_err = "Ptrtab overflow";
|
||
pt->pt_xerr = -1;
|
||
return(-1);
|
||
}
|
||
pt->pt_nsto = NPTRS;
|
||
i %= NPTRS;
|
||
}
|
||
pt->pt_tab[i] = sm;
|
||
return(i);
|
||
}
|
||
|
||
/* SBE_FSTR(flags, flagtab) - Auxiliary to convert flag word to a string
|
||
* and return pointer to it. Handy for printfs.
|
||
*/
|
||
char *
|
||
sbe_fstr(flags, fp)
|
||
register int flags;
|
||
register struct flgt *fp;
|
||
{ static char retstr[17]; /* Max of 16 flags */
|
||
register char *cp;
|
||
cp = retstr;
|
||
for(; fp->flg_bit; ++fp)
|
||
*cp++ = (fp->flg_bit&flags) ? fp->flg_chr : ' ';
|
||
*cp = 0;
|
||
return(retstr);
|
||
}
|