Logo Search packages:      
Sourcecode: jfsutils version File versions  Download package

log_dump.c

/*
 *   Copyright (c) International Business Machines Corp., 2000-2002
 *
 *   This program is free software;  you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program;  if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
#include <config.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include "jfs_types.h"
#include "jfs_endian.h"
#include "jfs_filsys.h"
#include "jfs_superblock.h"
#include "jfs_dinode.h"
#include "jfs_dtree.h"
#include "jfs_xtree.h"
#include "jfs_logmgr.h"
#include "jfs_dmap.h"
#include "jfs_imap.h"
#include "logredo.h"
#include "devices.h"
#include "debug.h"

extern int LogOpenMode;

#define LOGDMP_OK       0
#define LOGDMP_FAILED   -1

#define MAKEDEV(__x,__y)        (dev_t)(((__x)<<16) | (__y))

#define LOGPNTOB(x)  ((x)<<L2LOGPSIZE)

#define LOG2NUM(NUM, L2NUM)\
{\
        if ((NUM) <= 0)\
                L2NUM = -1;\
        else\
        if ((NUM) == 1)\
                L2NUM = 0;\
        else\
        {\
                L2NUM = 0;\
                while ( (NUM) > 1 )\
                {\
                        L2NUM++;\
                        (NUM) >>= 1;\
                }\
        }\
}

/* + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 *
 *       things for the log.
 */
int32_t logend;               /* address of the end of last log record */
struct logsuper logsup;       /* log super block */
int32_t numdoblk;       /* number of do blocks used     */
int32_t numnodofile;          /* number of nodo file blocks used  */

/* + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 *
 * The output file.
 *
 */

FILE *outfp;

#define  output_filename  "./jfslog.dmp"

int logdmp_outfile_is_open = 0;

/* + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 *
 *      open file system aggregate/lv array
 *
 * logredo() processes a single log.
 * at the first release, logredo will process a single log
 * related to one aggregate. But the future release, logredo needs to
 * to process one single log related to multiple agreegates.
 * In both cases, the aggregate(logical volume) where the log stays
 * will be different from  the file system aggregate/lv.
 *
 * There will be one imap for the aggregate inode allocation map
 * and a list of imap pointers to multiple fileset inode allocation maps.
 *
 * There is one block allocation map per aggregate and shared by all the
 * filesets within the aggregate.
 *
 * the log and related aggregates (logical volumes) are all in
 * the same volume group, i.e., each logical volume is uniquely specified
 * by their minor number with the same major number,
 * the maximum number of lvs in a volume group is NUMMINOR (256).
 */

/*
 * We only deal with the log here.  No need for vopen array
 */
struct vopen volume;

/* + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 *
 *      file system page buffer cache
 *
 * for k > 0, bufhdr[k] describes contents of buffer[k-1].
 * bufhdr[0] is reserved as anchor for free/lru list:
 * bufhdr[0].next points to the MRU buffer (head),
 * bufhdr[0].prev points to the LRU buffer (tail);
 */

/* buffer header table */
struct bufhdr {
      int16_t next;           /* 2: next on free/lru list */
      int16_t prev;           /* 2: previous on free/lru list */
      int16_t hnext;          /* 2: next on hash chain */
      int16_t hprev;          /* 2: previous on hash chain */
      char modify;            /* 1: buffer was modified */
      char inuse;       /* 1: buffer on hash chain */
      int16_t reserve;  /* 2 */
      int32_t vol;            /* 4: minor of agrregate/lv number */
      pxd_t pxd;        /* 8: on-disk page pxd */
} bufhdr[NBUFPOOL];           /* (24) */

/* buffer table */
struct bufpool {
      char bytes[PSIZE];
} buffer[NBUFPOOL - 1];

/*
 *      log page buffer cache
 *
 * log has its own 4 page buffer pool.
 */
uint8_t afterdata[LOGPSIZE * 2];    /* buffer to read in redopage data */

/*
 * Miscellaneous
 */
caddr_t prog;                 /* Program name */
int32_t mntcnt, bufsize;
char *mntinfo;
int32_t retcode;        /* return code from logredo    */

/*
 * external references
 */
extern char *optarg;
extern int optind;
extern int initMaps(int32_t);
extern int updateMaps(int);
extern int findEndOfLog(void);
extern int logRead(int32_t, struct lrd *, char *);
extern int logredoInit(void);
extern int alloc_wrksp(uint32_t, int, int, void **);  /* defined in fsckwsp.c */

/*
 * forward references
 */
int open_outfile(void);
int ldmp_readSuper(FILE *, struct superblock *);
int ldmp_isLogging(caddr_t, int32_t, char *, int32_t);
int ldmp_logError(int, int);
int usage(void);

int disp_updatemap(struct lrd *);
int disp_redopage(struct lrd *);
int disp_noredopage(struct lrd *);
int disp_noredoinoext(struct lrd *);

void ldmp_xdump(char *, int);
int ldmp_x_scmp(char *, char *);
void ldmp_x_scpy(char *, char *);
int prtdesc(struct lrd *);

/* --------------------------------------------------------------------
 *
 * NAME:        jfs_logdump()
 *
 * FUNCTION:
 *
 */

int jfs_logdump(caddr_t pathname, FILE *fp, int32_t dump_all)
{
      int rc;
      int32_t logaddr, nextaddr, lastaddr, nlogrecords;
      struct lrd ld;
      int32_t lowest_lr_byte = 2 * LOGPSIZE + LOGPHDRSIZE;
      int32_t highest_lr_byte = 0;
      int log_has_wrapped = 0;
      int in_use;

      rc = open_outfile();

      if (rc == 0) {          /* output file is open */
            /*
             * loop until we get enough memory to read vmount struct
             */
            mntinfo = (char *) &bufsize;
            bufsize = sizeof (int);

            /*
             * Find and open the log
             */
            LogOpenMode = O_RDONLY;
            rc = findLog(fp, &in_use);

            if (rc < 0) {
                  printf("JFS_LOGDUMP:Error occurred when open/read device\n");
                  fprintf(outfp, "??????????????????????????????????????????????????????\n");
                  fprintf(outfp, "JFS_LOGDUMP:Error occurred when open/read device\n");
                  fprintf(outfp, "??????????????????????????????????????????????????????\n");
                  return (rc);
            }

            /*
             * validate log superblock
             *
             * aggregate block size is for log file as well.
             */

            rc = ujfs_rw_diskblocks(Log.fp,
                              (uint64_t) (Log.xaddr + LOGPNTOB(LOGSUPER_B)),
                              (unsigned) sizeof (struct logsuper), (char *) &logsup, GET);
            if (rc != 0) {
                  printf("JFS_LOGDUMP:couldn't read log superblock:failure in %s\n", prog);
                  fprintf(outfp, "??????????????????????????????????????????????????????\n");
                  fprintf(outfp, "JFS_LOGDUMP:couldn't read log superblock:failure in %s\n",
                        prog);
                  fprintf(outfp, "??????????????????????????????????????????????????????\n");
                  return (LOGSUPER_READ_ERROR);
            }
            ujfs_swap_logsuper(&logsup);

            fprintf(outfp, "JOURNAL SUPERBLOCK: \n");
            fprintf(outfp, "------------------------------------------------------\n");
            fprintf(outfp, "   magic number: x %x \n", logsup.magic);
            fprintf(outfp, "   version     : x %x \n", logsup.version);
            fprintf(outfp, "   serial      : x %x \n", logsup.serial);
            fprintf(outfp, "   size        : t %d pages (4096 bytes/page)\n", logsup.size);
            fprintf(outfp, "   bsize       : t %d bytes/block\n", logsup.bsize);
            fprintf(outfp, "   l2bsize     : t %d \n", logsup.l2bsize);
            fprintf(outfp, "   flag        : x %x \n", logsup.flag);
            fprintf(outfp, "   state       : x %x \n", logsup.state);
            fprintf(outfp, "   end         : x %x \n", logsup.end);
            fprintf(outfp, "\n");
            fprintf(outfp, "======================================================\n");
            fprintf(outfp, "\n");

            if (logsup.magic != LOGMAGIC) {
                  fprintf(outfp, "\n");
                  fprintf(outfp, "**WARNING** %s: %s is not a log file\n", prog, pathname);
                  fprintf(outfp, "\n");
                  fprintf(outfp, "======================================================\n");
                  fprintf(outfp, "\n");
            }

            if (logsup.version != LOGVERSION) {
                  fprintf(outfp, "\n");
                  fprintf(outfp, "**WARNING** %s and log file %s version mismatch\n", prog,
                        pathname);
                  fprintf(outfp, "\n");
                  fprintf(outfp, "======================================================\n");
                  fprintf(outfp, "\n");
            }

            if (logsup.state == LOGREDONE) {
                  fprintf(outfp, "\n");
                  fprintf(outfp, "**WARNING** %s and log file %s state is LOGREDONE\n", prog,
                        pathname);
                  fprintf(outfp, "\n");
                  fprintf(outfp, "======================================================\n");
                  fprintf(outfp, "\n");
            }

            Log.size = logsup.size;
            Log.serial = logsup.serial;

            /*
             * find the end of log
             */
            logend = findEndOfLog();
            if (logend < 0) {
                  printf("logend < 0\n");
                  ldmp_logError(LOGEND, 0);
                  ujfs_swap_logsuper(&logsup);
                  rc = ujfs_rw_diskblocks(Log.fp,
                                    (uint64_t) (Log.xaddr + LOGPNTOB(LOGSUPER_B)),
                                    (unsigned long) LOGPSIZE, (char *) &logsup, PUT);
                  rc = logend;
                  goto loopexit;
            }

            highest_lr_byte = logsup.size * LOGPSIZE - LOGRDSIZE;

            if ((logend < lowest_lr_byte) || (logend > highest_lr_byte)) {
                  fprintf(outfp, "\n");
                  fprintf(outfp,
                        "**ERROR** logend address is not valid for a logrec. logend: 0x0%x\n",
                        logend);
                  fprintf(outfp, "\n");
                  fprintf(outfp, "======================================================\n");
                  fprintf(outfp, "\n");
                  return (INVALID_LOGEND);
            }

            /*
             *      replay log
             *
             * read log backwards and process records as we go.
             * reading stops at place specified by first SYNCPT we
             * encounter.
             */
            nlogrecords = lastaddr = 0;
            nextaddr = logend;
            do {
                  logaddr = nextaddr;
                  nextaddr = logRead(logaddr, &ld, afterdata);
                  fprintf(outfp,
                        "logrec d %d   Logaddr= x %x   Nextaddr= x %x   Backchain = x %x\n",
                        nlogrecords, logaddr, nextaddr, ld.backchain);
                  fprintf(outfp, "\n");
                  nlogrecords += 1;
                  /*
                   *
                   * Validate the nextaddr as much as possible
                   *
                   */
                  if (nextaddr < 0) {
                        ldmp_logError(READERR, logaddr);
                        if (nextaddr == REFORMAT_ERROR) {
                              rc = nextaddr;
                              goto loopexit;
                        }
                        break;
                  }
                  /*
                   * Certain errors we'll assume signal the end of the log
                   * since we're just dumping everything from the latest
                   * commit record to the earliest valid record.
                   */
                  if ((nextaddr < lowest_lr_byte) || (nextaddr > highest_lr_byte)) {
                        lastaddr = logaddr;
                  }

                  if (nextaddr == logaddr) {
                        lastaddr = logaddr;
                  }

                  if (nextaddr > logaddr) {
                        if (log_has_wrapped) {
                              fprintf(outfp, "\n");
                              fprintf(outfp,
                                    "**ERROR** log wrapped twice. logaddr:0x0%x nextaddr:0x0%x\n",
                                    logaddr, nextaddr);
                              fprintf(outfp, "\n");
                              fprintf(outfp,
                                    "======================================================\n");
                              fprintf(outfp, "\n");
                              lastaddr = logaddr;
                        } else {
                              log_has_wrapped = -1;
                        }
                  }
                  /*
                   *
                   * The addresses seem ok.  Process the current record.
                   *
                   */
                  if (lastaddr != logaddr) {
                        switch (ld.type) {
                        case LOG_COMMIT:
                              fprintf(outfp,
                                    "LOG_COMMIT   (type = d %d)   logtid = d %d   aggregate = d %d\n",
                                    ld.type, ld.logtid, ld.aggregate);
                              fprintf(outfp, "\n");
                              fprintf(outfp, "\tdata length = d %d\n", ld.length);

                              break;

                        case LOG_MOUNT:
                              fprintf(outfp,
                                    "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
                              fprintf(outfp,
                                    "LOG_MOUNT   (type = d %d)   logtid = d %d   aggregate = d %d\n",
                                    ld.type, ld.logtid, ld.aggregate);
                              fprintf(outfp, "\n");
                              fprintf(outfp, "\tdata length = d %d\n", ld.length);
                              fprintf(outfp,
                                    "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
                              break;

                        case LOG_SYNCPT:
                              fprintf(outfp,
                                    "****************************************************************\n");
                              fprintf(outfp,
                                    "LOG_SYNCPT   (type = d %d)   logtid = d %d    aggregate = d %d\n",
                                    ld.type, ld.logtid, ld.aggregate);
                              fprintf(outfp, "\n");
                              fprintf(outfp, "\tdata length = d %d\n", ld.length);
                              fprintf(outfp, "\tsync = x %x\n", ld.log.syncpt.sync);
                              fprintf(outfp,
                                    "****************************************************************\n");

                              rc = 0;
                              if (!dump_all) {  /* user just wants from last synch point forward */
                                    if (lastaddr == 0) {
                                          lastaddr = (ld.log.syncpt.sync == 0)
                                              ? logaddr : ld.log.syncpt.sync;
                                    }
                              }     /* end user just wants from last synch point forward */
                              break;

                        case LOG_REDOPAGE:
                              fprintf(outfp,
                                    "LOG_REDOPAGE   (type = d %d)   logtid = d %d    aggregate = d %d\n",
                                    ld.type, ld.logtid, ld.aggregate);
                              fprintf(outfp, "\n");
                              fprintf(outfp, "\tdata length = d %d    ", ld.length);
                              disp_redopage(&ld);
                              break;

                        case LOG_NOREDOPAGE:
                              fprintf(outfp,
                                    "LOG_NOREDOPAGE   (type = d %d)   logtid = d %d   aggregate = d %d\n",
                                    ld.type, ld.logtid, ld.aggregate);
                              fprintf(outfp, "\n");
                              fprintf(outfp, "\tdata length = d %d    ", ld.length);
                              disp_noredopage(&ld);
                              break;

                        case LOG_NOREDOINOEXT:
                              fprintf(outfp,
                                    "LOG_NOREDOINOEXT (type = d %d)   logtid = d %d   aggregate = d %d\n",
                                    ld.type, ld.logtid, ld.aggregate);
                              fprintf(outfp, "\n");
                              fprintf(outfp, "\tdata length = d %d    ", ld.length);
                              disp_noredoinoext(&ld);
                              break;

                        case LOG_UPDATEMAP:
                              fprintf(outfp,
                                    "LOG_UPDATEMAP   (type = d %d)   logtid = d %d   aggregate = d %d\n",
                                    ld.type, ld.logtid, ld.aggregate);
                              fprintf(outfp, "\n");
                              fprintf(outfp, "\tdata length = d %d    ", ld.length);
                              disp_updatemap(&ld);
                              break;

                        default:
                              fprintf(outfp,
                                    "*UNRECOGNIZED*   (type = d %d)   logtid = d %d   aggregate = d %d\n",
                                    ld.type, ld.logtid, ld.aggregate);
                              fprintf(outfp, "\n");
                              fprintf(outfp, "\tdata length = d %d\n", ld.length);
                              fprintf(outfp, "\n");
                              fprintf(outfp, "**ERROR** unrecognized log record type\n");
                              fprintf(outfp, "\n");
                              fprintf(outfp,
                                    "======================================================\n");
                              fprintf(outfp, "\n");
                              return (UNRECOG_LOGRECTYP);
                        }

                        if (rc == 0) {
                              fprintf(outfp, "\n");
                              if (ld.length > 0) {
                                    ldmp_xdump((char *) afterdata, ld.length);
                              }
                        }

                        fprintf(outfp, "\n");
                        fprintf(outfp,
                              "----------------------------------------------------------------------\n");
                  }
                  /* end if( lastaddr != logaddr )  */
            } while (logaddr != lastaddr);

            loopexit:

            /*
             * Close the output file
             */
            if (logdmp_outfile_is_open) {
                  fclose(outfp);
            }

            if (rc == 0) {    /* log has been dumped successfully */
                  printf
                      ("JFS_LOGDUMP: The current JFS log has been dumped into ./jfslog.dmp\n");
            } else {
                  printf("JFS_LOGDUMP:Failed in %s\n", prog);
                  fprintf(outfp, "??????????????????????????????????????????????????????\n");
                  fprintf(outfp, "JFS_LOGDUMP:Failed in %s\n", prog);
                  fprintf(outfp, "??????????????????????????????????????????????????????\n");
            }
      }
      /* end output file is open */
      return (rc < 0) ? (rc) : (0);
}

/*----------------------------------------------------------------
 *
 * NAME:        ldmp_readSuper(fp, 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(FILE *fp,  /* 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(fp, 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(fp, 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 = ' ';

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

Generated by  Doxygen 1.6.0   Back to index