dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / cmd / fs.d / ufs / fsck / fsck.h

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */

/*
 * Copyright (c) 1980, 1986, 1990 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are permitted
 * provided that: (1) source distributions retain this entire copyright
 * notice and comment, and (2) distributions including binaries display
 * the following acknowledgement:  ``This product includes software
 * developed by the University of California, Berkeley and its contributors''
 * in the documentation or other materials provided with the distribution
 * and in all advertising materials mentioning features or use of this
 * software. Neither the name of the University nor the names of its
 * contributors may be used to endorse or promote products derived
 * from this software without specific prior written permission.
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 */

/*
 * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _FSCK_FSCK_H
#define _FSCK_FSCK_H

#pragma ident   "%Z%%M% %I%     %E% SMI"        /* SVr4.0 1.3   */

#ifdef  __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <stdarg.h>
#include <search.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/mnttab.h>
#include <sys/vfstab.h>
#include <sys/fs/ufs_fs.h>
#include <sys/fs/ufs_inode.h>

#define MAXDUP          10      /* limit on dup blks (per inode) */
#define MAXBAD          10      /* limit on bad blks (per inode) */
#define MAXBUFSPACE     40*1024 /* initial space to allocate to buffers */
#define INOBUFSIZE      56*1024 /* size of buffer to read inodes in pass1 */

#ifndef BUFSIZ
#define BUFSIZ MAXPATHLEN
#endif

/*
 * Inode states in statemap[].
 */
#define USTATE  0x01            /* inode not allocated */
#define FSTATE  0x02            /* inode is file */
#define DSTATE  0x04            /* inode is directory */
#define SSTATE  0x08            /* inode is a shadow/acl */
#define STMASK  0x0f            /* pick off the basic state/type */

/* flags OR'd into the above */
#define INZLINK  0x0010         /* inode has zero links */
#define INFOUND  0x0020         /* inode was found during descent */
#define INCLEAR  0x0040         /* inode is to be cleared */
#define INORPHAN 0x0080         /* inode is a known orphan (pass3 only) */
#define INDELAYD 0x0200         /* link count update delayed */
#define INMASK   0xfff0         /* pick off the modifiers */

#define FZLINK  (FSTATE | INZLINK)
#define DZLINK  (DSTATE | INZLINK)
#define SZLINK  (SSTATE | INZLINK)

#define DFOUND  (DSTATE | INFOUND)

#define DCLEAR  (DSTATE | INCLEAR)
#define FCLEAR  (FSTATE | INCLEAR)
#define SCLEAR  (SSTATE | INCLEAR)

/*
 * These tests depend on the state/type defines above not overlapping bits.
 *
 *      DUNFOUND === (state == DSTATE || state == DZLINK)
 *          INCLEAR is irrelevant to the determination of
 *          connectedness, so it's not included in this test.
 *
 *      DVALID   === (state == DSTATE || state == DZLINK || state == DFOUND)
 */
#define S_IS_DUNFOUND(state)    (((state) & (DSTATE | INZLINK)) \
                                == (state))
#define S_IS_DVALID(state)      (((state) & (DSTATE | INZLINK | INFOUND | \
                                INORPHAN)) == (state))
#define S_IS_ZLINK(state)       (((state) & INZLINK) != 0)
#define INO_IS_DUNFOUND(ino)    S_IS_DUNFOUND(statemap[ino])
#define INO_IS_DVALID(ino)      S_IS_DVALID(statemap[ino])

/*
 * buffer cache structure.
 */
struct bufarea {
        struct bufarea  *b_next;                /* free list queue */
        struct bufarea  *b_prev;                /* free list queue */
        diskaddr_t      b_bno;                  /* physical sector number */
        int     b_size;
        int     b_errs;
        int     b_flags;
        int     b_cnt;                          /* reference cnt */
        union {
                char    *b_buf;                 /* buffer space */
                daddr32_t       *b_indir;       /* indirect block */
                struct  fs *b_fs;               /* super block */
                struct  cg *b_cg;               /* cylinder group */
                struct  dinode *b_dinode;       /* inode block */
        } b_un;
        char    b_dirty;
};

#define B_INUSE 1

#define MINBUFS         5       /* minimum number of buffers required */
struct bufarea bufhead;         /* head of list of other blks in filesys */
struct bufarea sblk;            /* file system superblock */
struct bufarea asblk;           /* alternate superblock */
struct bufarea cgblk;           /* cylinder group blocks */
struct bufarea *pbp;            /* pointer to inode data in buffer pool */
struct bufarea *pdirbp;         /* pointer to directory data in buffer pool */

#define sbdirty()       dirty(&sblk)
#define cgdirty()       dirty(&cgblk)
#define sblock          (*sblk.b_un.b_fs)
#define cgrp            (*cgblk.b_un.b_cg)

/*
 * inodesc.id_fix values.  See inode.c for a description of their usage.
 */
enum fixstate {
        DONTKNOW, NOFIX, FIX, IGNORE
};

/*
 * Tells truncino() whether or not to attempt to update the parent
 * directory's link count.  Also, TI_NODUP flags when we're discarding
 * fragments that are beyond the original end of the file, and so
 * should not be considered duplicate-claim candidates.
 */
#define TI_NOPARENT     0x0001  /* leave parent's di_nlink alone */
#define TI_PARENT       0x0002  /* update parent's di_nlink */
#define TI_NODUP        0x0004  /* not a dup candidate */

/*
 * Modes for ckinode() and ckinode_common().
 *
 * CKI_TRAVERSE is the common case, and requests a traditional
 * traversal of blocks or directory entries.
 *
 * CKI_TRUNCATE indicates that we're truncating the file, and that any
 * block indices beyond the end of the target length should be cleared
 * after the callback has returned (i.e., this is a superset of
 * CKI_TRAVERSE).  idesc->id_truncto is the first logical block number
 * to clear.  If it is less than zero, then the traversal will be
 * equivalent to a simple CKI_TRAVERSE.
 */
enum cki_action { CKI_TRAVERSE, CKI_TRUNCATE };

/*
 * The general definition of an ino_t is an unsigned quantity.
 * However, the on-disk version is an int32_t, which is signed.
 * Since we really want to be able to detect wrapped-around
 * inode numbers and such, we'll use something that's compatible
 * with what's on disk since that's the only context that really
 * matters.  If an int32_t is found not to be sufficiently large,
 * this will make it much easier to change later.
 *
 * Note that there is one unsigned inode field in the on-disk
 * inode, ic_oeftflag.  Since all other inode fields are signed,
 * no legitimate inode number can be put into ic_oeftflag that
 * would overflow into the high bit.  Essentially, it should
 * actually be declared as int32_t just like all the others, and
 * we're going to pretend that it was.
 *
 * None of the routines that we use in ufs_subr.c do anything with
 * inode numbers.  If that changes, then great care will be needed
 * to deal with the differences in definition of ino_t and fsck_ino_t.
 * Lint is your friend.
 */
typedef int32_t         fsck_ino_t;

/*
 * See the full discussion of the interactions between struct inodesc
 * and ckinode() in inode.c
 */
struct inodesc {
        enum fixstate id_fix;   /* policy on fixing errors */
        int (*id_func)(struct inodesc *);
                                /* function to be applied to blocks of inode */
        fsck_ino_t id_number;   /* inode number described */
        fsck_ino_t id_parent;   /* for DATA nodes, their parent */
                                /* also used for extra (*id_func) parameter */
                                /* and return values */
        daddr32_t id_lbn;       /* logical fragment number of current block */
        daddr32_t id_blkno;     /* physical fragment number being examined */
        int id_numfrags;        /* number of frags contained in block */
        daddr32_t id_truncto;   /* # blocks to truncate to, -1 for no trunc. */
        offset_t id_filesize;   /* for DATA nodes, the size of the directory */
        uint_t id_loc;          /* for DATA nodes, current location in dir */
        daddr32_t id_entryno;   /* for DATA nodes, current dir entry number */
        daddr32_t id_firsthole; /* for DATA inode, logical block that is */
                                /* zero but shouldn't be, -1 for no holes */
        struct direct *id_dirp; /* for DATA nodes, ptr to current entry */
        caddr_t id_name;        /* for DATA nodes, name to find or enter */
        char id_type;           /* type of descriptor, DATA or ADDR */
};

/* file types (0 is reserved for catching bugs) */
#define DATA    1       /* a directory */
#define ACL     2       /* an acl/shadow */
#define ADDR    3       /* anything but a directory or an acl/shadow */

/*
 * OR'd flags for find_dup_ref()'s mode argument
 */
#define DB_CREATE       0x01    /* if dup record found, make one */
#define DB_INCR         0x02    /* increment block's reference count */
#define DB_DECR         0x04    /* decrement block's reference count */

/*
 * Cache data structures
 */
struct inoinfo {
        struct inoinfo  *i_nextlist;    /* next inode/acl cache entry */
        fsck_ino_t      i_number;       /* inode number of this entry */
        fsck_ino_t      i_parent;       /* inode number of parent */
        fsck_ino_t      i_dotdot;       /* inode number of .. */
        fsck_ino_t      i_extattr;      /* inode of hidden attr dir */
        offset_t        i_isize;        /* size of inode */
        size_t          i_blkssize;     /* size of block array in bytes */
        daddr32_t       i_blks[1];      /* actually longer */
};

/*
 * Inode cache
 */
struct inoinfo **inphead, **inpsort;
int64_t numdirs, listmax, inplast;

/*
 * ACL cache
 */
struct inoinfo **aclphead, **aclpsort;
int64_t numacls, aclmax, aclplast;

/*
 * Tree of directories we haven't reconnected or cleared.  Any
 * dir inode that linkup() fails on gets added, any that clri()
 * succeeds on gets removed.  If there are any left at the end of
 * pass four, then we have a user-forced corrupt filesystem, and
 * need to set iscorrupt.
 *
 * Elements are fsck_ino_t instances (not pointers).
 */
void *limbo_dirs;

/*
 * Number of directories we actually found in the filesystem,
 * as opposed to how many the superblock claims there are.
 */
fsck_ino_t countdirs;

/*
 * shadowclients and shadowclientinfo are structures for keeping track of
 * shadow inodes that exist, and which regular inodes use them (i.e. are
 * their clients).
 */

struct shadowclients {
        fsck_ino_t *client;     /* an array of inode numbers */
        int nclients; /* how many inodes in the array are in use (valid) */
        struct shadowclients *next; /* link to more client inode numbers */
};
struct shadowclientinfo {
        fsck_ino_t shadow;      /* the shadow inode that this info is for */
        int totalClients;       /* how many inodes total refer to this */
        struct shadowclients *clients; /* a linked list of wads of clients */
        struct shadowclientinfo *next; /* link to the next shadow inode */
};
/* global pointer to this shadow/client information */
struct shadowclientinfo *shadowclientinfo;
struct shadowclientinfo *attrclientinfo;

/*
 * In ufs_inode.h ifdef _KERNEL, this is defined as `/@/'.  However,
 * to avoid all sorts of potential confusion (you can't actually use
 * `foo/@/bar' to get to an attribute), we use something that doesn't
 * look quite so much like a simple pathname.
 */
#define XATTR_DIR_NAME  " <xattr> "

/*
 * granularity -- how many client inodes do we make space for at a time
 * initialized in setup.c;
 */
extern int maxshadowclients;

/*
 * Initialized global variables.
 */
extern caddr_t lfname;

/*
 * Unitialized globals.
 */
char    *devname;               /* name of device being checked */
size_t  dev_bsize;              /* computed value of DEV_BSIZE */
int     secsize;                /* actual disk sector size */
char    nflag;                  /* assume a no response */
char    yflag;                  /* assume a yes response */
daddr32_t       bflag;          /* location of alternate super block */
int     debug;                  /* output debugging info */
int     rflag;                  /* check raw file systems */
int     roflag;                 /* do normal checks but don't update disk */
int     fflag;                  /* check regardless of clean flag (force) */
int     mflag;                  /* sanity check only */
int     verbose;                /* be chatty */
char    preen;                  /* just fix normal inconsistencies */
char    mountedfs;              /* checking mounted device */
int     exitstat;               /* exit status (see EX* defines below) */
char    hotroot;                /* checking root device */
char    rerun;                  /* rerun fsck. Only used in non-preen mode */
int     interrupted;            /* 1 => exit EXSIGNAL on exit */
char    havesb;                 /* superblock has been read */
int     fsmodified;             /* 1 => write done to file system */
int     fsreadfd;               /* file descriptor for reading file system */
int     fswritefd;              /* file descriptor for writing file system */
int     iscorrupt;              /* known to be corrupt/inconsistent */
                                /* -1 means mark clean so user can mount+fix */
int     isdirty;                /* 1 => write pending to file system */

int     islog;                  /* logging file system */
int     islogok;                /* log is okay */

int     errorlocked;            /* set => mounted fs has been error-locked */
                                /* implies fflag "force check flag" */
char    *elock_combuf;          /* error lock comment buffer */
char    *elock_mountp;          /* mount point; used to unlock error-lock */
int     pid;                    /* fsck's process id (put in lockfs comment) */
int     mountfd;                /* fd of mount point */
struct lockfs   *lfp;           /* current lockfs status */

daddr32_t       maxfsblock;     /* number of blocks in the file system */
uint_t  largefile_count;        /* global largefile counter */
char    *mount_point;           /* if mounted, this is where */
char    *blockmap;              /* ptr to primary blk allocation map */
fsck_ino_t      maxino;         /* number of inodes in file system */
fsck_ino_t      lastino;        /* last inode in use */
ushort_t *statemap;             /* ptr to inode state table */
short   *lncntp;                /* ptr to link count table */

fsck_ino_t      lfdir;          /* lost & found directory inode number */
int             overflowed_lf;  /* tried to wrap lost & found's link count */
int             reattached_dir; /* reconnected at least one directory */
int             broke_dir_link; /* broke at least one directory hardlink */

daddr32_t       n_blks;         /* number of blocks in use */
fsck_ino_t      n_files;        /* number of files in use */

#define clearinode(dp)  { \
        *(dp) = zino; \
}
struct  dinode zino;

#define testbmap(blkno) isset(blockmap, blkno)
#define setbmap(blkno)  setbit(blockmap, blkno)
#define clrbmap(blkno)  clrbit(blockmap, blkno)

#define STOP    0x01
#define SKIP    0x02
#define KEEPON  0x04
#define ALTERED 0x08
#define FOUND   0x10

/*
 * Support relatively easy debugging of lncntp[] updates.  This can't
 * be a function, because of the (_op) step.  Normally, we just do that.
 */
#define TRACK_LNCNTP(_ino, _op) (_op)

/*
 * See if the net link count for an inode has gone outside
 * what can be represented on disk.  Returning text as NULL
 * indicates no.
 *
 * Remember that link counts are effectively inverted, so
 * underflow and overflow are reversed as well.
 *
 * This check should be done before modifying the actual link
 * count.
 */
#define LINK_RANGE(text, current, offset) { \
        int net = ((int)(current)) + ((int)(offset)); \
        text = NULL; \
        if (net > (MAXLINK)) \
                text = "UNDERFLOW"; \
        else if (net < -(MAXLINK)) \
                text = "OVERFLOW"; \
}

/*
 * If LINK_RANGE() indicated a problem, this is the boiler-plate
 * for dealing with it.  Usage is:
 *
 *     LINK_RANGE(text, current, offset);
 *     if (text != NULL) {
 *         LINK_CLEAR(text, ino, mode, idp);
 *         if (statemap[ino] == USTATE)
 *             ...inode was cleared...
 *     }
 *
 * Note that clri() will set iscorrupt if the user elects not to
 * clear the problem inode, so the filesystem won't get reported
 * as clean when it shouldn't be.
 */
#define LINK_CLEAR(text, ino, mode, idp) { \
        pwarn("%s LINK COUNT %s", file_id((ino), (mode)), (text)); \
        pinode((ino)); \
        pfatal(""); \
        init_inodesc((idp)); \
        (idp)->id_type = ADDR; \
        (idp)->id_func = pass4check; \
        (idp)->id_number = ino; \
        (idp)->id_fix = DONTKNOW; \
        clri((idp), (text), CLRI_QUIET, CLRI_NOP_CORRUPT); \
}

/*
 * Used for checking link count under/overflow specifically on
 * the lost+found directory.  If the user decides not to do the
 * clri(), then flag that we've hit this problem and refuse to do
 * the reconnect.
 */
#define LFDIR_LINK_RANGE_RVAL(text, current, offset, idp, rval) { \
        LINK_RANGE(text, current, offset); \
        if (text != NULL) { \
                LINK_CLEAR(text, lfdir, IFDIR, idp); \
                if (statemap[lfdir] == USTATE) { \
                        lfdir = 0; \
                        return (rval); \
                } else { \
                        overflowed_lf++; \
                } \
        } \
}

#define LFDIR_LINK_RANGE_NORVAL(text, current, offset, idp) { \
        LINK_RANGE(text, current, offset); \
        if (text != NULL) { \
                LINK_CLEAR(text, lfdir, IFDIR, idp); \
                if (statemap[lfdir] == USTATE) { \
                        lfdir = 0; \
                        return; \
                } else { \
                        overflowed_lf++; \
                } \
        } \
}

/*
 * Values for mounted() and mountedfs.
 */
#define M_NOMNT         0       /* filesystem is not mounted */
#define M_RO            1       /* filesystem is mounted read-only */
#define M_RW            2       /* filesystem is mounted read-write */

#define EXOKAY          0       /* file system is unmounted and ok */
#define EXBADPARM       1       /* bad parameter(s) given */
#define EXUMNTCHK       32      /* fsck -m: unmounted, needs checking */
#define EXMOUNTED       33      /* file system already mounted, not magic, */
                                /* or it is magic and mounted read/write */
#define EXNOSTAT        34      /* cannot stat device */
#define EXREBOOTNOW     35      /* modified root or something equally scary */
#define EXFNDERRS       36      /* uncorrectable errors, terminate normally */
#define EXSIGNAL        37      /* a signal was caught during processing */
#define EXERRFATAL      39      /* uncorrectable errors, exit immediately */
#define EXROOTOKAY      40      /* for root, same as 0 */

/*
 * Values for clri()'s `verbose' and `corrupting' arguments (third
 * and fourth, respectively).
 */
#define CLRI_QUIET              1
#define CLRI_VERBOSE            2

#define CLRI_NOP_OK             1
#define CLRI_NOP_CORRUPT        2

/*
 * Filesystems that are `magical' - if they exist in vfstab,
 * then they have to be mounted for the system to have gotten
 * far enough to be able to run fsck.  Thus, don't get all
 * bent out of shape if we're asked to check it and it is mounted.
 * Actual initialization of the array is in main.c
 */
enum magic {
        MAGIC_NONE = 0,
        MAGIC_ROOT = 1,
        MAGIC_USR = 2,
        MAGIC_LIMIT = 3
};
extern char *magic_fs[];

/*
 * Paths needed by calcsb().
 */
#define MKFS_PATH       "/usr/lib/fs/ufs/mkfs"
#define NEWFS_PATH      "/usr/lib/fs/ufs/newfs"

int             acltypeok(struct dinode *);
void            add_orphan_dir(fsck_ino_t);
void            adjust(struct inodesc *, int);
daddr32_t       allocblk(int);
fsck_ino_t      allocdir(fsck_ino_t, fsck_ino_t, int, int);
fsck_ino_t      allocino(fsck_ino_t, int);
void            blkerror(fsck_ino_t, caddr_t, daddr32_t, daddr32_t);
void            brelse(struct bufarea *);
void            bufinit(void);
void            bwrite(int, caddr_t, diskaddr_t, int64_t);
void            cacheacl(struct dinode *, fsck_ino_t);
void            cacheino(struct dinode *, fsck_ino_t);
void            catch(int);
void            catchquit(int);
caddr_t         cg_sanity(struct cg *, int);
void            cgflush(void);
int             cgisdirty(void);
int             changeino(fsck_ino_t, caddr_t, fsck_ino_t);
int             check_mnttab(caddr_t, caddr_t, size_t);
int             check_vfstab(caddr_t, caddr_t, size_t);
int             chkrange(daddr32_t, int);
void            ckfini(void);
int             ckinode(struct dinode *, struct inodesc *, enum cki_action);
void            clearattrref(fsck_ino_t);
int             cleardirentry(fsck_ino_t, fsck_ino_t);
void            clearshadow(fsck_ino_t, struct shadowclientinfo **);
void            clri(struct inodesc *, caddr_t, int, int);
void            deshadow(struct shadowclientinfo *, void (*)(fsck_ino_t));
void            direrror(fsck_ino_t, caddr_t, ...);
int             dirscan(struct inodesc *);
void            dirty(struct bufarea *);
int             do_errorlock(int);
int             dofix(struct inodesc *, caddr_t, ...);
void            examinelog(void (*)(daddr32_t));
void            errexit(caddr_t, ...);
void            fileerror(fsck_ino_t, fsck_ino_t, caddr_t, ...);
caddr_t         file_id(fsck_ino_t, mode_t);
int             find_dup_ref(daddr32_t, fsck_ino_t, daddr32_t, int);
int             findino(struct inodesc *);
int             findname(struct inodesc *);
void            fix_cg(struct cg *, int);
void            flush(int, struct bufarea *);
void            free_dup_state(void);
void            freeblk(fsck_ino_t, daddr32_t, int);
void            freeino(fsck_ino_t, int);
void            freeinodebuf(void);
int             fsck_asprintf(caddr_t *, caddr_t, ...);
int             fsck_bread(int, caddr_t, diskaddr_t, size_t);
int             ftypeok(struct dinode *);
struct bufarea  *getblk(struct bufarea *, daddr32_t, size_t);
struct bufarea  *getdatablk(daddr32_t, size_t size);
diskaddr_t      getdisksize(caddr_t, int);
struct inoinfo  *getinoinfo(fsck_ino_t);
struct dinode   *getnextinode(fsck_ino_t);
struct dinode   *getnextrefresh(void);
void            getpathname(caddr_t, fsck_ino_t, fsck_ino_t);
struct dinode   *ginode(fsck_ino_t);
caddr_t         hasvfsopt(struct vfstab *, caddr_t);
int             have_dups(void);
void            init_inodesc(struct inodesc *);
void            init_inoinfo(struct inoinfo *, struct dinode *, fsck_ino_t);
void            initbarea(struct bufarea *);
int             ino_t_cmp(const void *, const void *);
int             inocached(fsck_ino_t);
void            inocleanup(void);
void            inodirty(void);
int             is_errorlocked(caddr_t);
int             linkup(fsck_ino_t, fsck_ino_t, caddr_t);
int             lookup_named_ino(fsck_ino_t, caddr_t);
int             makeentry(fsck_ino_t, fsck_ino_t, caddr_t);
void            maybe_convert_attrdir_to_dir(fsck_ino_t);
int             mounted(caddr_t, caddr_t, size_t);
void            pass1(void);
void            pass1b(void);
int             pass1check(struct inodesc *);
void            pass2(void);
void            pass3a(void);
void            pass3b(void);
int             pass3bcheck(struct inodesc *);
void            pass4(void);
int             pass4check(struct inodesc *);
void            pass5(void);
void            pfatal(caddr_t, ...);
void            pinode(fsck_ino_t);
void            printclean(void);
void            propagate(void);
void            pwarn(caddr_t, ...);
caddr_t         rawname(caddr_t);
void            registershadowclient(fsck_ino_t, fsck_ino_t,
                    struct shadowclientinfo **);
void            remove_orphan_dir(fsck_ino_t);
int             reply(caddr_t, ...);
int             report_dups(int);
void            resetinodebuf(void);
char            *setup(caddr_t);
void            truncino(fsck_ino_t, offset_t, int);
void            unbufinit(void);
caddr_t         unrawname(caddr_t);
void            unregistershadow(fsck_ino_t, struct shadowclientinfo **);
int             updateclean(void);
int             writable(caddr_t);
void            write_altsb(int);

/*
 * Functions from the kernel sources (ufs_subr.c, etc).
 */
extern void     fragacct(struct fs *, int, int32_t *, int);

#ifdef  __cplusplus
}
#endif

#endif  /* _FSCK_FSCK_H */