xref: /freebsd/sbin/fsck_ffs/fsck.h (revision 7aa383846770374466b1dcb2cefd71bde9acf463)
1 /*
2  * Copyright (c) 2002 Networks Associates Technology, Inc.
3  * All rights reserved.
4  *
5  * This software was developed for the FreeBSD Project by Marshall
6  * Kirk McKusick and Network Associates Laboratories, the Security
7  * Research Division of Network Associates, Inc. under DARPA/SPAWAR
8  * contract N66001-01-C-8035 ("CBOSS"), as part of the DARPA CHATS
9  * research program.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * Copyright (c) 1980, 1986, 1993
33  *	The Regents of the University of California.  All rights reserved.
34  *
35  * Redistribution and use in source and binary forms, with or without
36  * modification, are permitted provided that the following conditions
37  * are met:
38  * 1. Redistributions of source code must retain the above copyright
39  *    notice, this list of conditions and the following disclaimer.
40  * 2. Redistributions in binary form must reproduce the above copyright
41  *    notice, this list of conditions and the following disclaimer in the
42  *    documentation and/or other materials provided with the distribution.
43  * 4. Neither the name of the University nor the names of its contributors
44  *    may be used to endorse or promote products derived from this software
45  *    without specific prior written permission.
46  *
47  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
48  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
50  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
51  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
52  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
53  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
54  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
55  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
56  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
57  * SUCH DAMAGE.
58  *
59  *	@(#)fsck.h	8.4 (Berkeley) 5/9/95
60  * $FreeBSD$
61  */
62 
63 #ifndef _FSCK_H_
64 #define	_FSCK_H_
65 
66 #include <unistd.h>
67 #include <stdlib.h>
68 #include <stdio.h>
69 
70 #define	MAXDUP		10	/* limit on dup blks (per inode) */
71 #define	MAXBAD		10	/* limit on bad blks (per inode) */
72 #define	MAXBUFSPACE	40*1024	/* maximum space to allocate to buffers */
73 #define	INOBUFSIZE	56*1024	/* size of buffer to read inodes in pass1 */
74 
75 union dinode {
76 	struct ufs1_dinode dp1;
77 	struct ufs2_dinode dp2;
78 };
79 #define	DIP(dp, field) \
80 	((sblock.fs_magic == FS_UFS1_MAGIC) ? \
81 	(dp)->dp1.field : (dp)->dp2.field)
82 
83 #define DIP_SET(dp, field, val) do { \
84 	if (sblock.fs_magic == FS_UFS1_MAGIC) \
85 		(dp)->dp1.field = (val); \
86 	else \
87 		(dp)->dp2.field = (val); \
88 	} while (0)
89 
90 /*
91  * Each inode on the file system is described by the following structure.
92  * The linkcnt is initially set to the value in the inode. Each time it
93  * is found during the descent in passes 2, 3, and 4 the count is
94  * decremented. Any inodes whose count is non-zero after pass 4 needs to
95  * have its link count adjusted by the value remaining in ino_linkcnt.
96  */
97 struct inostat {
98 	char	ino_state;	/* state of inode, see below */
99 	char	ino_type;	/* type of inode */
100 	short	ino_linkcnt;	/* number of links not found */
101 };
102 /*
103  * Inode states.
104  */
105 #define	USTATE	0x1		/* inode not allocated */
106 #define	FSTATE	0x2		/* inode is file */
107 #define	FZLINK	0x3		/* inode is file with a link count of zero */
108 #define	DSTATE	0x4		/* inode is directory */
109 #define	DZLINK	0x5		/* inode is directory with a zero link count  */
110 #define	DFOUND	0x6		/* directory found during descent */
111 /*     		0x7		   UNUSED - see S_IS_DVALID() definition */
112 #define	DCLEAR	0x8		/* directory is to be cleared */
113 #define	FCLEAR	0x9		/* file is to be cleared */
114 /*     	DUNFOUND === (state == DSTATE || state == DZLINK) */
115 #define	S_IS_DUNFOUND(state)	(((state) & ~0x1) == DSTATE)
116 /*     	DVALID   === (state == DSTATE || state == DZLINK || state == DFOUND) */
117 #define	S_IS_DVALID(state)	(((state) & ~0x3) == DSTATE)
118 #define	INO_IS_DUNFOUND(ino)	S_IS_DUNFOUND(inoinfo(ino)->ino_state)
119 #define	INO_IS_DVALID(ino)	S_IS_DVALID(inoinfo(ino)->ino_state)
120 /*
121  * Inode state information is contained on per cylinder group lists
122  * which are described by the following structure.
123  */
124 struct inostatlist {
125 	long	il_numalloced;	/* number of inodes allocated in this cg */
126 	struct inostat *il_stat;/* inostat info for this cylinder group */
127 } *inostathead;
128 
129 /*
130  * buffer cache structure.
131  */
132 struct bufarea {
133 	struct bufarea *b_next;		/* free list queue */
134 	struct bufarea *b_prev;		/* free list queue */
135 	ufs2_daddr_t b_bno;
136 	int b_size;
137 	int b_errs;
138 	int b_flags;
139 	union {
140 		char *b_buf;			/* buffer space */
141 		ufs1_daddr_t *b_indir1;		/* UFS1 indirect block */
142 		ufs2_daddr_t *b_indir2;		/* UFS2 indirect block */
143 		struct fs *b_fs;		/* super block */
144 		struct cg *b_cg;		/* cylinder group */
145 		struct ufs1_dinode *b_dinode1;	/* UFS1 inode block */
146 		struct ufs2_dinode *b_dinode2;	/* UFS2 inode block */
147 	} b_un;
148 	char b_dirty;
149 };
150 
151 #define	IBLK(bp, i) \
152 	((sblock.fs_magic == FS_UFS1_MAGIC) ? \
153 	(bp)->b_un.b_indir1[i] : (bp)->b_un.b_indir2[i])
154 
155 #define IBLK_SET(bp, i, val) do { \
156 	if (sblock.fs_magic == FS_UFS1_MAGIC) \
157 		(bp)->b_un.b_indir1[i] = (val); \
158 	else \
159 		(bp)->b_un.b_indir2[i] = (val); \
160 	} while (0)
161 
162 #define	B_INUSE 1
163 
164 #define	MINBUFS		5	/* minimum number of buffers required */
165 struct bufarea bufhead;		/* head of list of other blks in filesys */
166 struct bufarea sblk;		/* file system superblock */
167 struct bufarea cgblk;		/* cylinder group blocks */
168 struct bufarea *pdirbp;		/* current directory contents */
169 struct bufarea *pbp;		/* current inode block */
170 
171 #define	dirty(bp) do { \
172 	if (fswritefd < 0) \
173 		pfatal("SETTING DIRTY FLAG IN READ_ONLY MODE\n"); \
174 	else \
175 		(bp)->b_dirty = 1; \
176 } while (0)
177 #define	initbarea(bp) do { \
178 	(bp)->b_dirty = 0; \
179 	(bp)->b_bno = (ufs2_daddr_t)-1; \
180 	(bp)->b_flags = 0; \
181 } while (0)
182 
183 #define	sbdirty()	dirty(&sblk)
184 #define	cgdirty()	dirty(&cgblk)
185 #define	sblock		(*sblk.b_un.b_fs)
186 #define	cgrp		(*cgblk.b_un.b_cg)
187 
188 enum fixstate {DONTKNOW, NOFIX, FIX, IGNORE};
189 ino_t cursnapshot;
190 
191 struct inodesc {
192 	enum fixstate id_fix;	/* policy on fixing errors */
193 	int (*id_func)(struct inodesc *);
194 				/* function to be applied to blocks of inode */
195 	ino_t id_number;	/* inode number described */
196 	ino_t id_parent;	/* for DATA nodes, their parent */
197 	ufs_lbn_t id_lbn;	/* logical block number of current block */
198 	ufs2_daddr_t id_blkno;	/* current block number being examined */
199 	int id_numfrags;	/* number of frags contained in block */
200 	off_t id_filesize;	/* for DATA nodes, the size of the directory */
201 	ufs2_daddr_t id_entryno;/* for DATA nodes, current entry number */
202 	int id_loc;		/* for DATA nodes, current location in dir */
203 	struct direct *id_dirp;	/* for DATA nodes, ptr to current entry */
204 	char *id_name;		/* for DATA nodes, name to find or enter */
205 	char id_type;		/* type of descriptor, DATA or ADDR */
206 };
207 /* file types */
208 #define	DATA	1	/* a directory */
209 #define	SNAP	2	/* a snapshot */
210 #define	ADDR	3	/* anything but a directory or a snapshot */
211 
212 /*
213  * Linked list of duplicate blocks.
214  *
215  * The list is composed of two parts. The first part of the
216  * list (from duplist through the node pointed to by muldup)
217  * contains a single copy of each duplicate block that has been
218  * found. The second part of the list (from muldup to the end)
219  * contains duplicate blocks that have been found more than once.
220  * To check if a block has been found as a duplicate it is only
221  * necessary to search from duplist through muldup. To find the
222  * total number of times that a block has been found as a duplicate
223  * the entire list must be searched for occurences of the block
224  * in question. The following diagram shows a sample list where
225  * w (found twice), x (found once), y (found three times), and z
226  * (found once) are duplicate block numbers:
227  *
228  *    w -> y -> x -> z -> y -> w -> y
229  *    ^		     ^
230  *    |		     |
231  * duplist	  muldup
232  */
233 struct dups {
234 	struct dups *next;
235 	ufs2_daddr_t dup;
236 };
237 struct dups *duplist;		/* head of dup list */
238 struct dups *muldup;		/* end of unique duplicate dup block numbers */
239 
240 /*
241  * Inode cache data structures.
242  */
243 struct inoinfo {
244 	struct	inoinfo *i_nexthash;	/* next entry in hash chain */
245 	ino_t	i_number;		/* inode number of this entry */
246 	ino_t	i_parent;		/* inode number of parent */
247 	ino_t	i_dotdot;		/* inode number of `..' */
248 	size_t	i_isize;		/* size of inode */
249 	u_int	i_numblks;		/* size of block array in bytes */
250 	ufs2_daddr_t i_blks[1];		/* actually longer */
251 } **inphead, **inpsort;
252 long numdirs, dirhash, listmax, inplast;
253 long countdirs;			/* number of directories we actually found */
254 
255 #define MIBSIZE	3		/* size of fsck sysctl MIBs */
256 int	adjrefcnt[MIBSIZE];	/* MIB command to adjust inode reference cnt */
257 int	adjblkcnt[MIBSIZE];	/* MIB command to adjust inode block count */
258 int	adjndir[MIBSIZE];	/* MIB command to adjust number of directories */
259 int	adjnbfree[MIBSIZE];	/* MIB command to adjust number of free blocks */
260 int	adjnifree[MIBSIZE];	/* MIB command to adjust number of free inodes */
261 int	adjnffree[MIBSIZE];	/* MIB command to adjust number of free frags */
262 int	adjnumclusters[MIBSIZE];	/* MIB command to adjust number of free clusters */
263 int	freefiles[MIBSIZE];	/* MIB command to free a set of files */
264 int	freedirs[MIBSIZE];	/* MIB command to free a set of directories */
265 int	freeblks[MIBSIZE];	/* MIB command to free a set of data blocks */
266 struct	fsck_cmd cmd;		/* sysctl file system update commands */
267 char	snapname[BUFSIZ];	/* when doing snapshots, the name of the file */
268 char	*cdevname;		/* name of device being checked */
269 long	dev_bsize;		/* computed value of DEV_BSIZE */
270 long	secsize;		/* actual disk sector size */
271 char	nflag;			/* assume a no response */
272 char	yflag;			/* assume a yes response */
273 int	bkgrdflag;		/* use a snapshot to run on an active system */
274 int	bflag;			/* location of alternate super block */
275 int	debug;			/* output debugging info */
276 int	inoopt;			/* trim out unused inodes */
277 char	ckclean;		/* only do work if not cleanly unmounted */
278 int	cvtlevel;		/* convert to newer file system format */
279 int	bkgrdcheck;		/* determine if background check is possible */
280 int	bkgrdsumadj;		/* whether the kernel have ability to adjust superblock summary */
281 char	usedsoftdep;		/* just fix soft dependency inconsistencies */
282 char	preen;			/* just fix normal inconsistencies */
283 char	rerun;			/* rerun fsck. Only used in non-preen mode */
284 int	returntosingle;		/* 1 => return to single user mode on exit */
285 char	resolved;		/* cleared if unresolved changes => not clean */
286 char	havesb;			/* superblock has been read */
287 char	skipclean;		/* skip clean file systems if preening */
288 int	fsmodified;		/* 1 => write done to file system */
289 int	fsreadfd;		/* file descriptor for reading file system */
290 int	fswritefd;		/* file descriptor for writing file system */
291 
292 ufs2_daddr_t maxfsblock;	/* number of blocks in the file system */
293 char	*blockmap;		/* ptr to primary blk allocation map */
294 ino_t	maxino;			/* number of inodes in file system */
295 
296 ino_t	lfdir;			/* lost & found directory inode number */
297 const char *lfname;		/* lost & found directory name */
298 int	lfmode;			/* lost & found directory creation mode */
299 
300 ufs2_daddr_t n_blks;		/* number of blocks in use */
301 ino_t n_files;			/* number of files in use */
302 
303 volatile sig_atomic_t	got_siginfo;	/* received a SIGINFO */
304 volatile sig_atomic_t	got_sigalarm;	/* received a SIGALRM */
305 
306 #define	clearinode(dp) \
307 	if (sblock.fs_magic == FS_UFS1_MAGIC) { \
308 		(dp)->dp1 = ufs1_zino; \
309 	} else { \
310 		(dp)->dp2 = ufs2_zino; \
311 	}
312 struct	ufs1_dinode ufs1_zino;
313 struct	ufs2_dinode ufs2_zino;
314 
315 #define	setbmap(blkno)	setbit(blockmap, blkno)
316 #define	testbmap(blkno)	isset(blockmap, blkno)
317 #define	clrbmap(blkno)	clrbit(blockmap, blkno)
318 
319 #define	STOP	0x01
320 #define	SKIP	0x02
321 #define	KEEPON	0x04
322 #define	ALTERED	0x08
323 #define	FOUND	0x10
324 
325 #define	EEXIT	8		/* Standard error exit. */
326 
327 struct fstab;
328 
329 
330 void		adjust(struct inodesc *, int lcnt);
331 ufs2_daddr_t	allocblk(long frags);
332 ino_t		allocdir(ino_t parent, ino_t request, int mode);
333 ino_t		allocino(ino_t request, int type);
334 void		blkerror(ino_t ino, const char *type, ufs2_daddr_t blk);
335 char	       *blockcheck(char *name);
336 int		blread(int fd, char *buf, ufs2_daddr_t blk, long size);
337 void		bufinit(void);
338 void		blwrite(int fd, char *buf, ufs2_daddr_t blk, long size);
339 void		cacheino(union dinode *dp, ino_t inumber);
340 void		catch(int);
341 void		catchquit(int);
342 int		changeino(ino_t dir, const char *name, ino_t newnum);
343 int		check_cgmagic(int cg, struct cg *cgp);
344 int		chkrange(ufs2_daddr_t blk, int cnt);
345 void		ckfini(int markclean);
346 int		ckinode(union dinode *dp, struct inodesc *);
347 void		clri(struct inodesc *, const char *type, int flag);
348 int		clearentry(struct inodesc *);
349 void		direrror(ino_t ino, const char *errmesg);
350 int		dirscan(struct inodesc *);
351 int		dofix(struct inodesc *, const char *msg);
352 int		eascan(struct inodesc *, struct ufs2_dinode *dp);
353 void		fileerror(ino_t cwd, ino_t ino, const char *errmesg);
354 int		findino(struct inodesc *);
355 int		findname(struct inodesc *);
356 void		flush(int fd, struct bufarea *bp);
357 void		freeblk(ufs2_daddr_t blkno, long frags);
358 void		freeino(ino_t ino);
359 void		freeinodebuf(void);
360 int		ftypeok(union dinode *dp);
361 void		getblk(struct bufarea *bp, ufs2_daddr_t blk, long size);
362 struct bufarea *getdatablk(ufs2_daddr_t blkno, long size);
363 struct inoinfo *getinoinfo(ino_t inumber);
364 union dinode   *getnextinode(ino_t inumber, int rebuildcg);
365 void		getpathname(char *namebuf, ino_t curdir, ino_t ino);
366 union dinode   *ginode(ino_t inumber);
367 void		infohandler(int sig);
368 void		alarmhandler(int sig);
369 void		inocleanup(void);
370 void		inodirty(void);
371 struct inostat *inoinfo(ino_t inum);
372 int		linkup(ino_t orphan, ino_t parentdir, char *name);
373 int		makeentry(ino_t parent, ino_t ino, const char *name);
374 void		panic(const char *fmt, ...) __printflike(1, 2);
375 void		pass1(void);
376 void		pass1b(void);
377 int		pass1check(struct inodesc *);
378 void		pass2(void);
379 void		pass3(void);
380 void		pass4(void);
381 int		pass4check(struct inodesc *);
382 void		pass5(void);
383 void		pfatal(const char *fmt, ...) __printflike(1, 2);
384 void		pinode(ino_t ino);
385 void		propagate(void);
386 void		pwarn(const char *fmt, ...) __printflike(1, 2);
387 int		readsb(int listerr);
388 int		reply(const char *question);
389 void		rwerror(const char *mesg, ufs2_daddr_t blk);
390 void		sblock_init(void);
391 void		setinodebuf(ino_t);
392 int		setup(char *dev);
393 void		gjournal_check(const char *filesys);
394 int		suj_check(const char *filesys);
395 
396 #endif	/* !_FSCK_H_ */
397