log_dump.c

jfs 源码

			fprintf(outfp, "??????????????????????????????????????????????????????\n");
		}
	}
	/* end output file is open */
	return (rc < 0) ? (rc) : (0);
}

/*----------------------------------------------------------------
 *
 * NAME:        ldmp_readSuper(fd, sb)
 *
 * FUNCTION:    read the superblock for the file system described
 *              by the file descriptor of the opened aggregate/lv.
 *              if a read of primary superblock fails,
 *              try to read the secondary superblock. report error only
 *              when both reads failed.
 */
int ldmp_readSuper(int32_t fd,	/* file descriptor */
		   struct superblock * sb)
{				/* superblock of the opened aggregate/lv */
	int rc;

	union {
		struct superblock super;
		char block[PSIZE];
	} super;

	/*
	 * seek to the postion of the primary superblock.
	 * since at this time we don't know the aggregate/lv
	 * logical block size yet, we have to use the fixed
	 * byte offset address SUPER1_OFF to seek for.
	 */

	/*
	 * read super block
	 */
	rc = ujfs_rw_diskblocks(fd, SUPER1_OFF, (unsigned) SIZE_OF_SUPER, super.block, GET);
	if (rc != 0) {
		printf
		    ("ldmp_readSuper: read primary agg superblock failed. errno=%d  Continuing.\n",
		     errno);
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		fprintf(outfp,
			"ldmp_readSuper: read primary agg superblock failed. errno=%d Continuing\n",
			errno);
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		/* read failed for the primary superblock:
		 * try to read the secondary superblock
		 */
		rc = ujfs_rw_diskblocks(fd, SUPER2_OFF, (unsigned) SIZE_OF_SUPER, super.block, GET);
		if (rc != 0) {
			printf
			    ("ldmp_readSuper: read 2ndary agg superblock failed. errno=%d  Cannot continue.\n",
			     errno);
			fprintf(outfp, "??????????????????????????????????????????????????????\n");
			fprintf(outfp,
				"ldmp_readSuper: read 2ndary agg superblock failed. errno=%d  Cannot continue.\n",
				errno);
			fprintf(outfp, "??????????????????????????????????????????????????????\n");
			return (MAJOR_ERROR);
		}
	}

	*sb = super.super;

	ujfs_swap_superblock(sb);

	return (0);
}

extern void exit(int);

/*----------------------------------------------------------------
 *
 *      ldmp_logError(type)
 *
 * error handling for log read errors.
 */
int ldmp_logError(int type, int logaddr)
{
	retcode = -1;
	logsup.state = LOGREADERR;

	switch (type) {
	case LOGEND:
		printf("ldmp_logError:find end of log failed \n");
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		fprintf(outfp, "ldmp_logError:find end of log failed \n");
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		break;
	case READERR:
		printf("log read failed 0x%x\n", logaddr);
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		fprintf(outfp, "log read failed 0x%x\n", logaddr);
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		break;
	case UNKNOWNR:
		printf("unknown log record type \nlog read failed 0x%x\n", logaddr);
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		fprintf(outfp, "unknown log record type \nlog read failed 0x%x\n", logaddr);
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		break;
	case IOERROR:
		printf("i/o error log reading page 0x%x\n", logaddr);
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		fprintf(outfp, "i/o error log reading page 0x%x\n", logaddr);
		fprintf(outfp, "??????????????????????????????????????????????????????\n");
		break;
	case LOGWRAP:
		printf("log wrapped...\n");
		fprintf(outfp, "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
		fprintf(outfp, "log wrapped...\n");
		fprintf(outfp, "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n");
	}

	return (0);
}

/*----------------------------------------------------------------
 *
 *      ldmp_xdump()
 *
 * hex dump
 */
void ldmp_xdump(char *saddr, int count)
{
#define LINESZ     60
#define ASCIISTRT  40
#define HEXEND     36

	int i, j, k, hexdigit;
	int c;
	char *hexchar;
	char linebuf[LINESZ + 1];
	char prevbuf[LINESZ + 1];
	char *linestart;
	int asciistart;
	char asterisk = ' ';
	void ldmp_x_scpy();
	int ldmp_x_scmp();

	hexchar = "0123456789ABCDEF";
	prevbuf[0] = '\0';
	i = (int) saddr % 4;
	if (i != 0)
		saddr = saddr - i;

	for (i = 0; i < count;) {
		for (j = 0; j < LINESZ; j++)
			linebuf[j] = ' ';

		linestart = saddr;
		asciistart = ASCIISTRT;
		for (j = 0; j < HEXEND;) {
			for (k = 0; k < 4; k++) {
				c = *(saddr++) & 0xFF;
				if ((c >= 0x20) && (c <= 0x7e))
					linebuf[asciistart++] = (char) c;
				else
					linebuf[asciistart++] = '.';
				hexdigit = c >> 4;
				linebuf[j++] = hexchar[hexdigit];
				hexdigit = c & 0x0f;
				linebuf[j++] = hexchar[hexdigit];
				i++;
			}
			if (i >= count)
				break;
			linebuf[j++] = ' ';
		}
		linebuf[LINESZ] = '\0';
		if (((j = ldmp_x_scmp(linebuf, prevbuf)) == 0) && (i < count)) {
			if (asterisk == ' ') {
				asterisk = '*';
				fprintf(outfp, "    *\n");
			}
		} else {
			fprintf(outfp, "    %p  %s\n", linestart, linebuf);
			asterisk = ' ';
			ldmp_x_scpy(prevbuf, linebuf);
		}
	}

	return;
}

/*----------------------------------------------------------------
 *
 *      ldmp_x_scmp()
 *
 */
int ldmp_x_scmp(char *s1, char *s2)
{
	while ((*s1) && (*s1 == *s2)) {
		s1++;
		s2++;
	}
	if (*s1 || *s2)
		return (-1);
	else
		return (0);
}

/*----------------------------------------------------------------
 *
 *      ldmp_x_scpy()
 *
 */
void ldmp_x_scpy(char *s1, char *s2)
{
	while ((*s1 = *s2) != '\0') {
		s1++;
		s2++;
	}
}

/***************************************************************************
 *
 * NAME: disp_noredopage
 *
 * FUNCTION:
 *
 * PARAMETERS:  none
 *
 * NOTES:
 *
 * RETURNS:
 *      success: LOGDMP_OK
 *      failure: something else
 */
int disp_noredopage(struct lrd *lrd_ptr)
{
	fprintf(outfp, "fileset = d %d    inode = d %d (x %x)\n",
		lrd_ptr->log.noredopage.fileset,
		lrd_ptr->log.noredopage.inode, lrd_ptr->log.noredopage.inode);

	switch (lrd_ptr->log.noredopage.type) {
	case LOG_INODE:
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:INODE\n", lrd_ptr->log.noredopage.type);
		break;
	case LOG_XTREE:
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:XTREE\n  ", lrd_ptr->log.noredopage.type);
		break;
	case (LOG_XTREE | LOG_NEW):
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:XTREE_NEW\n  ",
			lrd_ptr->log.noredopage.type);
		break;
	case (LOG_BTROOT | LOG_XTREE):
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:BTROOT_XTREE\n  ",
			lrd_ptr->log.noredopage.type);
		break;
	case LOG_DTREE:
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:DTREE\n  ", lrd_ptr->log.noredopage.type);
		break;
	case (LOG_DTREE | LOG_NEW):
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:DTREE_NEW \n ",
			lrd_ptr->log.noredopage.type);
		break;
	case (LOG_DTREE | LOG_EXTEND):
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:DTREE_EXTEND\n  ",
			lrd_ptr->log.noredopage.type);
		break;
	case (LOG_BTROOT | LOG_DTREE):
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:BTROOT_DTREE\n  ",
			lrd_ptr->log.noredopage.type);
		break;
	case (LOG_BTROOT | LOG_DTREE | LOG_NEW):
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:BTROOT_DTREE.NEW\n  ",
			lrd_ptr->log.noredopage.type);
		break;
	case LOG_EA:
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:EA\n", lrd_ptr->log.noredopage.type);
		break;
	case LOG_ACL:
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:ACL\n", lrd_ptr->log.noredopage.type);
		break;
	case LOG_DATA:
		fprintf(outfp, "\ttype = d %d NOREDOPAGE:DATA\n", lrd_ptr->log.noredopage.type);
		break;
/*
    case LOG_NOREDOFILE:
       fprintf( outfp, "\ttype = d %d NOREDOPAGE:NOREDOFILE\n",
                lrd_ptr->log.noredopage.type );
       break;
*/
	default:
		fprintf(outfp, "\ttype = d %d ***UNRECOGNIZED***\n", lrd_ptr->log.noredopage.type);
		break;
	}

	fprintf(outfp, "\tpxd length = d %d   phys offset = x %llx  (d %lld)\n",
		lengthPXD(&(lrd_ptr->log.noredopage.pxd)),
		(long long) addressPXD(&(lrd_ptr->log.noredopage.pxd)),
		(long long) addressPXD(&(lrd_ptr->log.noredopage.pxd)));

	return (LOGDMP_OK);
}				/* end of disp_noredopage() */

/***************************************************************************
 *
 * NAME: disp_noredoinoext
 *
 * FUNCTION:
 *
 * PARAMETERS:  none
 *
 * NOTES:
 *
 * RETURNS:
 *      success: LOGDMP_OK
 *      failure: something else
 */
int disp_noredoinoext(struct lrd * lrd_ptr)
{
	fprintf(outfp, "fileset = d %d  \n", lrd_ptr->log.noredoinoext.fileset);

	fprintf(outfp, "\tiag number = d %d   extent index = d %d\n",
		lrd_ptr->log.noredoinoext.iagnum, lrd_ptr->log.noredoinoext.inoext_idx);

	fprintf(outfp, "\tpxd length = d %d   phys offset = x %llx  (d %lld)\n",
		lengthPXD(&(lrd_ptr->log.noredoinoext.pxd)),
		(long long) addressPXD(&(lrd_ptr->log.noredoinoext.pxd)),
		(long long) addressPXD(&(lrd_ptr->log.noredoinoext.pxd)));

	return (LOGDMP_OK);
}				/* end of disp_noredopage() */

/***************************************************************************
 *
 * NAME: disp_redopage
 *
 * FUNCTION:
 *
 * PARAMETERS:  none
 *
 * NOTES:
 *
 * RETURNS:
 *      success: LOGDMP_OK
 *      failure: something else
 */
int disp_redopage(struct lrd * lrd_ptr)
{
	fprintf(outfp, "fileset = d %d    inode = d %d (x %x)\n",
		lrd_ptr->log.redopage.fileset, lrd_ptr->log.redopage.inode,
		lrd_ptr->log.redopage.inode);

	switch (lrd_ptr->log.redopage.type) {
	case LOG_INODE:
		fprintf(outfp, "\ttype = d %d REDOPAGE:INODE\n", lrd_ptr->log.redopage.type);
		break;
	case LOG_XTREE:
		fprintf(outfp, "\ttype = d %d REDOPAGE:XTREE\n  ", lrd_ptr->log.redopage.type);
		break;
	case (LOG_XTREE | LOG_NEW):
		fprintf(outfp, "\ttype = d %d REDOPAGE:XTREE_NEW\n  ", lrd_ptr->log.redopage.type);
		break;
	case (LOG_BTROOT | LOG_XTREE):
		fprintf(outfp, "\ttype = d %d REDOPAGE:BTROOT_XTREE\n  ",
			lrd_ptr->log.redopage.type);
		break;
	case LOG_DTREE:
		fprintf(outfp, "\ttype = d %d REDOPAGE:DTREE\n  ", lrd_ptr->log.redopage.type);
		break;
	case (LOG_DTREE | LOG_NEW):
		fprintf(outfp, "\ttype = d %d REDOPAGE:DTREE_NEW \n ", lrd_ptr->log.redopage.type);
		break;
	case (LOG_DTREE | LOG_EXTEND):
		fprintf(outfp, "\ttype = d %d REDOPAGE:DTREE_EXTEND\n  ",
			lrd_ptr->log.redopage.type);
		break;
	case (LOG_BTROOT | LOG_DTREE):
		fprintf(outfp, "\ttype = d %d REDOPAGE:BTROOT_DTREE\n  ",
			lrd_ptr->log.redopage.type);
		break;
	case (LOG_BTROOT | LOG_DTREE | LOG_NEW):
		fprintf(outfp, "\ttype = d %d REDOPAGE:BTROOT_DTREE.NEW\n  ",
			lrd_ptr->log.redopage.type);
		break;
	case LOG_EA:
		fprintf(outfp, "\ttype = d %d REDOPAGE:EA\n", lrd_ptr->log.redopage.type);
		break;
	case LOG_ACL:
		fprintf(outfp, "\ttype = d %d REDOPAGE:ACL\n", lrd_ptr->log.redopage.type);
		break;
	case LOG_DATA:
		fprintf(outfp, "\ttype = d %d REDOPAGE:DATA\n", lrd_ptr->log.redopage.type);
		break;
/*
    case LOG_NOREDOFILE:
       fprintf( outfp, "\ttype = d %d REDOPAGE:NOREDOFILE\n",
                lrd_ptr->log.redopage.type );
       break;
*/
	default:
		fprintf(outfp, "\ttype = d %d ***UNRECOGNIZED***\n", lrd_ptr->log.redopage.type);
		break;
	}
	fprintf(outfp, "\tl2linesize = d %d    ", lrd_ptr->log.redopage.l2linesize);
	fprintf(outfp, "pxd length = d %d   phys offset = x %llx  (d %lld)\n",
		lengthPXD(&(lrd_ptr->log.redopage.pxd)),
		(long long) addressPXD(&(lrd_ptr->log.redopage.pxd)),
		(long long) addressPXD(&(lrd_ptr->log.redopage.pxd)));

	return (LOGDMP_OK);
}				/* end of disp_redopage() */

/***************************************************************************
 *
 * NAME: disp_updatemap
 *
 * FUNCTION:
 *
 * PARAMETERS:  none
 *
 * NOTES:
 *
 * RETURNS:
 *      success: LOGDMP_OK
 *      failure: something else
 */
int disp_updatemap(struct lrd * lrd_ptr)
{
	int flag_unrecognized = -1;
	fprintf(outfp, "fileset = d %d    inode = d %d (x %x)\n",
		lrd_ptr->log.updatemap.fileset, lrd_ptr->log.updatemap.inode,
		lrd_ptr->log.updatemap.inode);

	fprintf(outfp, "\ttype = x %x UPDATEMAP: ", lrd_ptr->log.updatemap.type);

	if ((lrd_ptr->log.updatemap.type & LOG_ALLOCXADLIST) == LOG_ALLOCXADLIST) {
		flag_unrecognized = 0;
		fprintf(outfp, " ALLOCXADLIST");
	}
	if ((lrd_ptr->log.updatemap.type & LOG_ALLOCPXDLIST) == LOG_ALLOCPXDLIST) {
		flag_unrecognized = 0;
		fprintf(outfp, " ALLOCPXDLIST");
	}
	if ((lrd_ptr->log.updatemap.type & LOG_ALLOCXAD) == LOG_ALLOCXAD) {
		flag_unrecognized = 0;
		fprintf(outfp, " ALLOCXAD");
	}
	if ((lrd_ptr->log.updatemap.type & LOG_ALLOCPXD) == LOG_ALLOCPXD) {
		flag_unrecognized = 0;
		fprintf(outfp, " ALLOCPXD");
	}
	if ((lrd_ptr->log.updatemap.type & LOG_FREEXADLIST) == LOG_FREEXADLIST) {
		flag_unrecognized = 0;
		fprintf(outfp, " FREEXADLIST");
	}
	if ((lrd_ptr->log.updatemap.type & LOG_FREEPXDLIST) == LOG_FREEPXDLIST) {
		flag_unrecognized = 0;
		fprintf(outfp, " FREEPXDLIST");
	}
	if ((lrd_ptr->log.updatemap.type & LOG_FREEXAD) == LOG_FREEXAD) {
		flag_unrecognized = 0;
		fprintf(outfp, " FREEXAD");
	}
	if ((lrd_ptr->log.updatemap.type & LOG_FREEPXD) == LOG_FREEPXD) {
		flag_unrecognized = 0;
		fprintf(outfp, " FREEPXD");
	}
	if (flag_unrecognized) {
		fprintf(outfp, " *** UNRECOGNIZED ***");
	}

	fprintf(outfp, "\n");

	fprintf(outfp, "\tnxd = d %d  (number of extents)\n", lrd_ptr->log.updatemap.nxd);
	fprintf(outfp, "\tpxd length = d %d   phys offset = x %llx  (d %lld)\n",
		lengthPXD(&(lrd_ptr->log.updatemap.pxd)),
		(long long) addressPXD(&(lrd_ptr->log.updatemap.pxd)),
		(long long) addressPXD(&(lrd_ptr->log.updatemap.pxd)));

	return (LOGDMP_OK);
}				/* end of disp_updatemap() */

/*****************************************************************************
 * NAME: open_outfile
 *
 * FUNCTION:  Open the output file.
 *
 * PARAMETERS:
 *      Device  - input - the device specification
 *
 * NOTES:
 *
 * RETURNS:
 *      success: XCHKLOG_OK
 *      failure: something else
 */
int open_outfile()
{
	int openof_rc = 0;

	outfp = fopen(output_filename, "w");

	if (outfp == NULL) {	/* output file open failed */
		printf("LOG_DUMP: unable to open output file: ./jfslog.dmp\n");
		openof_rc = -1;
	} else {
		logdmp_outfile_is_open = -1;
	}

	return (openof_rc);
}				/* end of open_outfile ( ) */