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