sbin/fsck/fsck.h

   1 /*
   2  * Copyright (c) 1980, 1986, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      @(#)fsck.h      8.4 (Berkeley) 5/9/95
  30  * $FreeBSD: src/sbin/fsck/fsck.h,v 1.12.2.1 2001/01/23 23:11:07 iedowse Exp $
  31  * $DragonFly: src/sbin/fsck/fsck.h,v 1.9 2007/04/20 22:20:10 dillon Exp $
  32  */
  33
  34 #include <unistd.h>
  35 #include <stdlib.h>
  36 #include <stdio.h>
  37
  38 #define MAXDUP          10      /* limit on dup blks (per inode) */
  39 #define MAXBAD          10      /* limit on bad blks (per inode) */
  40 #define MAXBUFSPACE     40*1024 /* maximum space to allocate to buffers */
  41 #define INOBUFSIZE      56*1024 /* size of buffer to read inodes in pass1 */
  42
  43 /*
  44  * Each inode on the filesystem is described by the following structure.
  45  * The linkcnt is initially set to the value in the inode. Each time it
  46  * is found during the descent in passes 2, 3, and 4 the count is
  47  * decremented. Any inodes whose count is non-zero after pass 4 needs to
  48  * have its link count adjusted by the value remaining in ino_linkcnt.
  49  */
  50 struct inostat {
  51         char    ino_state;      /* state of inode, see below */
  52         char    ino_type;       /* type of inode */
  53         short   ino_linkcnt;    /* number of links not found */
  54 };
  55 /*
  56  * Inode states.
  57  */
  58 #define USTATE  01              /* inode not allocated */
  59 #define FSTATE  02              /* inode is file */
  60 #define DSTATE  03              /* inode is directory */
  61 #define DFOUND  04              /* directory found during descent */
  62 #define DCLEAR  05              /* directory is to be cleared */
  63 #define FCLEAR  06              /* file is to be cleared */
  64 /*
  65  * Inode state information is contained on per cylinder group lists
  66  * which are described by the following structure.
  67  */
  68 struct inostatlist {
  69         long    il_numalloced;  /* number of inodes allocated in this cg */
  70         struct inostat *il_stat;/* inostat info for this cylinder group */
  71 } *inostathead;
  72
  73 /*
  74  * buffer cache structure.
  75  */
  76 struct bufarea {
  77         struct bufarea *b_next;         /* free list queue */
  78         struct bufarea *b_prev;         /* free list queue */
  79         ufs_daddr_t b_bno;
  80         int b_size;
  81         int b_errs;
  82         int b_flags;
  83         union {
  84                 char *b_buf;                    /* buffer space */
  85                 ufs_daddr_t *b_indir;           /* indirect block */
  86                 struct fs *b_fs;                /* super block */
  87                 struct cg *b_cg;                /* cylinder group */
  88                 struct ufs1_dinode *b_dinode;   /* inode block */
  89         } b_un;
  90         char b_dirty;
  91 };
  92
  93 #define B_INUSE 1
  94
  95 #define MINBUFS         5       /* minimum number of buffers required */
  96 struct bufarea bufhead;         /* head of list of other blks in filesys */
  97 struct bufarea sblk;            /* file system superblock */
  98 struct bufarea cgblk;           /* cylinder group blocks */
  99 struct bufarea *pdirbp;         /* current directory contents */
 100 struct bufarea *pbp;            /* current inode block */
 101
 102 #define dirty(bp)       (bp)->b_dirty = 1
 103 #define initbarea(bp) \
 104         (bp)->b_dirty = 0; \
 105         (bp)->b_bno = (ufs_daddr_t)-1; \
 106         (bp)->b_flags = 0;
 107
 108 #define sbdirty()       sblk.b_dirty = 1
 109 #define cgdirty()       cgblk.b_dirty = 1
 110 #define sblock          (*sblk.b_un.b_fs)
 111 #define cgrp            (*cgblk.b_un.b_cg)
 112
 113 enum fixstate {DONTKNOW, NOFIX, FIX, IGNORE};
 114
 115 struct inodesc {
 116         enum fixstate id_fix;   /* policy on fixing errors */
 117         int (*id_func)(struct inodesc *);       /* function to be applied to blocks of inode */
 118         ufs1_ino_t id_number;   /* inode number described */
 119         ufs1_ino_t id_parent;   /* for DATA nodes, their parent */
 120         ufs_daddr_t id_blkno;   /* current block number being examined */
 121         int id_numfrags;        /* number of frags contained in block */
 122         quad_t id_filesize;     /* for DATA nodes, the size of the directory */
 123         int id_loc;             /* for DATA nodes, current location in dir */
 124         int id_entryno;         /* for DATA nodes, current entry number */
 125         struct direct *id_dirp; /* for DATA nodes, ptr to current entry */
 126         char *id_name;          /* for DATA nodes, name to find or enter */
 127         char id_type;           /* type of descriptor, DATA or ADDR */
 128 };
 129 /* file types */
 130 #define DATA    1
 131 #define ADDR    2
 132
 133 /*
 134  * Linked list of duplicate blocks.
 135  *
 136  * The list is composed of two parts. The first part of the
 137  * list (from duplist through the node pointed to by muldup)
 138  * contains a single copy of each duplicate block that has been
 139  * found. The second part of the list (from muldup to the end)
 140  * contains duplicate blocks that have been found more than once.
 141  * To check if a block has been found as a duplicate it is only
 142  * necessary to search from duplist through muldup. To find the
 143  * total number of times that a block has been found as a duplicate
 144  * the entire list must be searched for occurences of the block
 145  * in question. The following diagram shows a sample list where
 146  * w (found twice), x (found once), y (found three times), and z
 147  * (found once) are duplicate block numbers:
 148  *
 149  *    w -> y -> x -> z -> y -> w -> y
 150  *    ^              ^
 151  *    |              |
 152  * duplist        muldup
 153  */
 154 struct dups {
 155         struct dups *next;
 156         ufs_daddr_t dup;
 157 };
 158 struct dups *duplist;           /* head of dup list */
 159 struct dups *muldup;            /* end of unique duplicate dup block numbers */
 160
 161 /*
 162  * Linked list of inodes with zero link counts.
 163  */
 164 struct zlncnt {
 165         struct zlncnt *next;
 166         ufs1_ino_t zlncnt;
 167 };
 168 struct zlncnt *zlnhead;         /* head of zero link count list */
 169
 170 /*
 171  * Inode cache data structures.
 172  */
 173 struct inoinfo {
 174         struct  inoinfo *i_nexthash;    /* next entry in hash chain */
 175         ufs1_ino_t      i_number;               /* inode number of this entry */
 176         ufs1_ino_t      i_parent;               /* inode number of parent */
 177         ufs1_ino_t      i_dotdot;               /* inode number of `..' */
 178         size_t  i_isize;                /* size of inode */
 179         u_int   i_numblks;              /* size of block array in bytes */
 180         ufs_daddr_t i_blks[1];          /* actually longer */
 181 } **inphead, **inpsort;
 182 long numdirs, dirhash, listmax, inplast, dirhashmask;
 183 long countdirs;                 /* number of directories we actually found */
 184
 185 /*
 186  * Be careful about cache locality of reference, large filesystems may
 187  * have tens of millions of directories in them and if fsck has to swap
 188  * we want it to swap efficiently.  For this reason we try to group
 189  * adjacent inodes together by a reasonable factor.
 190  */
 191 #define DIRHASH(ino)    ((ino >> 3) & dirhashmask)
 192
 193 char    *cdevname;              /* name of device being checked */
 194 long    dev_bsize;              /* computed value of DEV_BSIZE */
 195 long    secsize;                /* actual disk sector size */
 196 char    fflag;                  /* force check, ignore clean flag */
 197 char    nflag;                  /* assume a no response */
 198 char    yflag;                  /* assume a yes response */
 199 int     bflag;                  /* location of alternate super block */
 200 int     debug;                  /* output debugging info */
 201 int     cvtlevel;               /* convert to newer file system format */
 202 int     doinglevel1;            /* converting to new cylinder group format */
 203 int     doinglevel2;            /* converting to new inode format */
 204 int     newinofmt;              /* filesystem has new inode format */
 205 char    usedsoftdep;            /* just fix soft dependency inconsistencies */
 206 char    preen;                  /* just fix normal inconsistencies */
 207 char    rerun;                  /* rerun fsck. Only used in non-preen mode */
 208 int     returntosingle;         /* 1 => return to single user mode on exit */
 209 char    resolved;               /* cleared if unresolved changes => not clean */
 210 char    havesb;                 /* superblock has been read */
 211 int     fsmodified;             /* 1 => write done to file system */
 212 int     fsreadfd;               /* file descriptor for reading file system */
 213 int     fswritefd;              /* file descriptor for writing file system */
 214 int     lastmntonly;            /* Output the last mounted on only */
 215
 216 ufs_daddr_t maxfsblock;         /* number of blocks in the file system */
 217 char    *blockmap;              /* ptr to primary blk allocation map */
 218 ufs1_ino_t      maxino;                 /* number of inodes in file system */
 219
 220 ufs1_ino_t      lfdir;                  /* lost & found directory inode number */
 221 char    *lfname;                /* lost & found directory name */
 222 int     lfmode;                 /* lost & found directory creation mode */
 223
 224 ufs_daddr_t n_blks;             /* number of blocks in use */
 225 ufs_daddr_t n_files;            /* number of files in use */
 226
 227 int     got_siginfo;            /* received a SIGINFO */
 228
 229 #define clearinode(dp)  (*(dp) = zino)
 230 struct  ufs1_dinode zino;
 231
 232 #define setbmap(blkno)  setbit(blockmap, blkno)
 233 #define testbmap(blkno) isset(blockmap, blkno)
 234 #define clrbmap(blkno)  clrbit(blockmap, blkno)
 235
 236 #define STOP    0x01
 237 #define SKIP    0x02
 238 #define KEEPON  0x04
 239 #define ALTERED 0x08
 240 #define FOUND   0x10
 241
 242 #define EEXIT   8               /* Standard error exit. */
 243
 244 struct fstab;
 245
 246
 247 void            adjust(struct inodesc *, int);
 248 ufs_daddr_t     allocblk(long);
 249 ufs1_ino_t              allocdir(ufs1_ino_t, ufs1_ino_t, int);
 250 ufs1_ino_t              allocino(ufs1_ino_t, int);
 251 void            blkerror(ufs1_ino_t, char *, ufs_daddr_t);
 252 char           *blockcheck(char *);
 253 int             bread(int, char *, ufs_daddr_t, long);
 254 void            bufinit(void);
 255 void            bwrite(int, char *, ufs_daddr_t, long);
 256 void            cacheino(struct ufs1_dinode *, ufs1_ino_t);
 257 void            catch(int);
 258 void            catchquit(int);
 259 int             changeino(ufs1_ino_t, char *, ufs1_ino_t);
 260 int             checkfstab(int, int,
 261                         int (*)(struct fstab *),
 262                         int (*)(char *, char *, long, int));
 263 int             chkrange(ufs_daddr_t, int);
 264 void            ckfini(int);
 265 int             ckinode(struct ufs1_dinode *, struct inodesc *);
 266 void            clri(struct inodesc *, char *, int);
 267 int             clearentry(struct inodesc *);
 268 void            direrror(ufs1_ino_t, char *);
 269 int             dirscan(struct inodesc *);
 270 int             dofix(struct inodesc *, char *);
 271 void            ffs_clrblock(struct fs *, u_char *, ufs_daddr_t);
 272 void            ffs_fragacct(struct fs *, int, int32_t [], int);
 273 int             ffs_isblock(struct fs *, u_char *, ufs_daddr_t);
 274 void            ffs_setblock(struct fs *, u_char *, ufs_daddr_t);
 275 void            fileerror(ufs1_ino_t, ufs1_ino_t, char *);
 276 int             findino(struct inodesc *);
 277 int             findname(struct inodesc *);
 278 void            flush(int, struct bufarea *);
 279 void            freeblk(ufs_daddr_t, long);
 280 void            freeino(ufs1_ino_t);
 281 void            freeinodebuf(void);
 282 int             ftypeok(struct ufs1_dinode *);
 283 void            getblk(struct bufarea *, ufs_daddr_t, long);
 284 struct bufarea *getdatablk(ufs_daddr_t, long);
 285 struct inoinfo *getinoinfo(ufs1_ino_t);
 286 struct ufs1_dinode  *getnextinode(ufs1_ino_t);
 287 void            getpathname(char *, ufs1_ino_t, ufs1_ino_t);
 288 struct ufs1_dinode  *ginode(ufs1_ino_t);
 289 void            infohandler(int);
 290 void            inocleanup(void);
 291 void            inodirty(void);
 292 struct inostat *inoinfo(ufs1_ino_t);
 293 int             linkup(ufs1_ino_t, ufs1_ino_t, char *);
 294 int             makeentry(ufs1_ino_t, ufs1_ino_t, char *);
 295 void            panic(const char *, ...) __printflike(1, 2);
 296 void            pass1(void);
 297 void            pass1b(void);
 298 int             pass1check(struct inodesc *);
 299 void            pass2(void);
 300 void            pass3(void);
 301 void            pass4(void);
 302 int             pass4check(struct inodesc *);
 303 void            pass5(void);
 304 void            pfatal(const char *, ...) __printflike(1, 2);
 305 void            pinode(ufs1_ino_t);
 306 void            propagate(void);
 307 void            pwarn(const char *, ...) __printflike(1, 2);
 308 int             reply(char *);
 309 void            setinodebuf(ufs1_ino_t);
 310 int             setup(char *);
 311 void            voidquit(int);