sberr.c

操作系统源代码

/* 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);