xref: /illumos-gate/usr/src/cmd/fs.d/ufs/fsck/fsck.h (revision bfbf29e2d493eb4d7f76ee725d3229899602a088)
1 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
2 /*	  All Rights Reserved	*/
3 
4 /*
5  * Copyright (c) 1980, 1986, 1990 The Regents of the University of California.
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms are permitted
9  * provided that: (1) source distributions retain this entire copyright
10  * notice and comment, and (2) distributions including binaries display
11  * the following acknowledgement:  ``This product includes software
12  * developed by the University of California, Berkeley and its contributors''
13  * in the documentation or other materials provided with the distribution
14  * and in all advertising materials mentioning features or use of this
15  * software. Neither the name of the University nor the names of its
16  * contributors may be used to endorse or promote products derived
17  * from this software without specific prior written permission.
18  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21  */
22 
23 /*
24  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  */
27 
28 #ifndef	_FSCK_FSCK_H
29 #define	_FSCK_FSCK_H
30 
31 #ifdef	__cplusplus
32 extern "C" {
33 #endif
34 
35 #include <stdio.h>
36 #include <stdarg.h>
37 #include <search.h>
38 #include <sys/param.h>
39 #include <sys/types.h>
40 #include <sys/mnttab.h>
41 #include <sys/vfstab.h>
42 #include <sys/fs/ufs_fs.h>
43 #include <sys/fs/ufs_inode.h>
44 
45 #define	MAXDUP		10	/* limit on dup blks (per inode) */
46 #define	MAXBAD		10	/* limit on bad blks (per inode) */
47 #define	MAXBUFSPACE	40*1024 /* initial space to allocate to buffers */
48 #define	INOBUFSIZE	56*1024	/* size of buffer to read inodes in pass1 */
49 
50 #ifndef BUFSIZ
51 #define	BUFSIZ MAXPATHLEN
52 #endif
53 
54 /*
55  * Inode states in statemap[].
56  */
57 #define	USTATE	0x01		/* inode not allocated */
58 #define	FSTATE	0x02		/* inode is file */
59 #define	DSTATE	0x04		/* inode is directory */
60 #define	SSTATE	0x08		/* inode is a shadow/acl */
61 #define	STMASK	0x0f		/* pick off the basic state/type */
62 
63 /* flags OR'd into the above */
64 #define	INZLINK  0x0010		/* inode has zero links */
65 #define	INFOUND  0x0020		/* inode was found during descent */
66 #define	INCLEAR  0x0040		/* inode is to be cleared */
67 #define	INORPHAN 0x0080		/* inode is a known orphan (pass3 only) */
68 #define	INDELAYD 0x0200		/* link count update delayed */
69 #define	INMASK   0xfff0		/* pick off the modifiers */
70 
71 #define	FZLINK	(FSTATE | INZLINK)
72 #define	DZLINK	(DSTATE | INZLINK)
73 #define	SZLINK	(SSTATE | INZLINK)
74 
75 #define	DFOUND	(DSTATE | INFOUND)
76 
77 #define	DCLEAR	(DSTATE | INCLEAR)
78 #define	FCLEAR	(FSTATE | INCLEAR)
79 #define	SCLEAR	(SSTATE | INCLEAR)
80 
81 /*
82  * These tests depend on the state/type defines above not overlapping bits.
83  *
84  *	DUNFOUND === (state == DSTATE || state == DZLINK)
85  *          INCLEAR is irrelevant to the determination of
86  *          connectedness, so it's not included in this test.
87  *
88  *	DVALID   === (state == DSTATE || state == DZLINK || state == DFOUND)
89  */
90 #define	S_IS_DUNFOUND(state)	(((state) & (DSTATE | INZLINK)) \
91 				== (state))
92 #define	S_IS_DVALID(state)	(((state) & (DSTATE | INZLINK | INFOUND | \
93 				INORPHAN)) == (state))
94 #define	S_IS_ZLINK(state)	(((state) & INZLINK) != 0)
95 #define	INO_IS_DUNFOUND(ino)	S_IS_DUNFOUND(statemap[ino])
96 #define	INO_IS_DVALID(ino)	S_IS_DVALID(statemap[ino])
97 
98 /*
99  * buffer cache structure.
100  */
101 struct bufarea {
102 	struct bufarea	*b_next;		/* free list queue */
103 	struct bufarea	*b_prev;		/* free list queue */
104 	diskaddr_t	b_bno;			/* physical sector number */
105 	int	b_size;
106 	int	b_errs;
107 	int	b_flags;
108 	int	b_cnt;				/* reference cnt */
109 	union {
110 		char	*b_buf;			/* buffer space */
111 		daddr32_t	*b_indir;	/* indirect block */
112 		struct	fs *b_fs;		/* super block */
113 		struct	cg *b_cg;		/* cylinder group */
114 		struct	dinode *b_dinode;	/* inode block */
115 	} b_un;
116 	char	b_dirty;
117 };
118 
119 #define	B_INUSE 1
120 
121 #define	MINBUFS		5	/* minimum number of buffers required */
122 extern struct bufarea sblk;	/* file system superblock */
123 extern struct bufarea cgblk;	/* cylinder group blocks */
124 extern struct bufarea *pbp;	/* pointer to inode data in buffer pool */
125 extern struct bufarea *pdirbp;	/* pointer to directory data in buffer pool */
126 
127 #define	sbdirty()	dirty(&sblk)
128 #define	cgdirty()	dirty(&cgblk)
129 #define	sblock		(*sblk.b_un.b_fs)
130 #define	cgrp		(*cgblk.b_un.b_cg)
131 
132 /*
133  * inodesc.id_fix values.  See inode.c for a description of their usage.
134  */
135 enum fixstate {
136 	DONTKNOW, NOFIX, FIX, IGNORE
137 };
138 
139 /*
140  * Tells truncino() whether or not to attempt to update the parent
141  * directory's link count.  Also, TI_NODUP flags when we're discarding
142  * fragments that are beyond the original end of the file, and so
143  * should not be considered duplicate-claim candidates.
144  */
145 #define	TI_NOPARENT	0x0001	/* leave parent's di_nlink alone */
146 #define	TI_PARENT	0x0002	/* update parent's di_nlink */
147 #define	TI_NODUP	0x0004	/* not a dup candidate */
148 
149 /*
150  * Modes for ckinode() and ckinode_common().
151  *
152  * CKI_TRAVERSE is the common case, and requests a traditional
153  * traversal of blocks or directory entries.
154  *
155  * CKI_TRUNCATE indicates that we're truncating the file, and that any
156  * block indices beyond the end of the target length should be cleared
157  * after the callback has returned (i.e., this is a superset of
158  * CKI_TRAVERSE).  idesc->id_truncto is the first logical block number
159  * to clear.  If it is less than zero, then the traversal will be
160  * equivalent to a simple CKI_TRAVERSE.
161  */
162 enum cki_action { CKI_TRAVERSE, CKI_TRUNCATE };
163 
164 /*
165  * The general definition of an ino_t is an unsigned quantity.
166  * However, the on-disk version is an int32_t, which is signed.
167  * Since we really want to be able to detect wrapped-around
168  * inode numbers and such, we'll use something that's compatible
169  * with what's on disk since that's the only context that really
170  * matters.  If an int32_t is found not to be sufficiently large,
171  * this will make it much easier to change later.
172  *
173  * Note that there is one unsigned inode field in the on-disk
174  * inode, ic_oeftflag.  Since all other inode fields are signed,
175  * no legitimate inode number can be put into ic_oeftflag that
176  * would overflow into the high bit.  Essentially, it should
177  * actually be declared as int32_t just like all the others, and
178  * we're going to pretend that it was.
179  *
180  * None of the routines that we use in ufs_subr.c do anything with
181  * inode numbers.  If that changes, then great care will be needed
182  * to deal with the differences in definition of ino_t and fsck_ino_t.
183  * Lint is your friend.
184  */
185 typedef int32_t		fsck_ino_t;
186 
187 /*
188  * See the full discussion of the interactions between struct inodesc
189  * and ckinode() in inode.c
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 	fsck_ino_t id_number;	/* inode number described */
196 	fsck_ino_t id_parent;	/* for DATA nodes, their parent */
197 				/* also used for extra (*id_func) parameter */
198 				/* and return values */
199 	daddr32_t id_lbn;	/* logical fragment number of current block */
200 	daddr32_t id_blkno;	/* physical fragment number being examined */
201 	int id_numfrags;	/* number of frags contained in block */
202 	daddr32_t id_truncto;	/* # blocks to truncate to, -1 for no trunc. */
203 	offset_t id_filesize;	/* for DATA nodes, the size of the directory */
204 	uint_t id_loc;		/* for DATA nodes, current location in dir */
205 	daddr32_t id_entryno;	/* for DATA nodes, current dir entry number */
206 	daddr32_t id_firsthole;	/* for DATA inode, logical block that is */
207 				/* zero but shouldn't be, -1 for no holes */
208 	struct direct *id_dirp;	/* for DATA nodes, ptr to current entry */
209 	caddr_t id_name;	/* for DATA nodes, name to find or enter */
210 	char id_type;		/* type of descriptor, DATA or ADDR */
211 };
212 
213 /* file types (0 is reserved for catching bugs) */
214 #define	DATA	1	/* a directory */
215 #define	ACL	2	/* an acl/shadow */
216 #define	ADDR	3	/* anything but a directory or an acl/shadow */
217 
218 /*
219  * OR'd flags for find_dup_ref()'s mode argument
220  */
221 #define	DB_CREATE	0x01	/* if dup record found, make one */
222 #define	DB_INCR		0x02	/* increment block's reference count */
223 #define	DB_DECR		0x04	/* decrement block's reference count */
224 
225 /*
226  * Cache data structures
227  */
228 struct inoinfo {
229 	struct inoinfo	*i_nextlist;	/* next inode/acl cache entry */
230 	fsck_ino_t	i_number;	/* inode number of this entry */
231 	fsck_ino_t	i_parent;	/* inode number of parent */
232 	fsck_ino_t	i_dotdot;	/* inode number of .. */
233 	fsck_ino_t	i_extattr;	/* inode of hidden attr dir */
234 	offset_t	i_isize;	/* size of inode */
235 	size_t		i_blkssize;	/* size of block array in bytes */
236 	daddr32_t	i_blks[1];	/* actually longer */
237 };
238 
239 /*
240  * Inode cache
241  */
242 extern struct inoinfo **inphead, **inpsort;
243 extern int64_t numdirs, listmax, inplast;
244 
245 /*
246  * ACL cache
247  */
248 extern struct inoinfo **aclphead, **aclpsort;
249 extern int64_t numacls, aclmax, aclplast;
250 
251 /*
252  * Tree of directories we haven't reconnected or cleared.  Any
253  * dir inode that linkup() fails on gets added, any that clri()
254  * succeeds on gets removed.  If there are any left at the end of
255  * pass four, then we have a user-forced corrupt filesystem, and
256  * need to set iscorrupt.
257  *
258  * Elements are fsck_ino_t instances (not pointers).
259  */
260 extern void *limbo_dirs;
261 
262 /*
263  * Number of directories we actually found in the filesystem,
264  * as opposed to how many the superblock claims there are.
265  */
266 extern fsck_ino_t countdirs;
267 
268 /*
269  * shadowclients and shadowclientinfo are structures for keeping track of
270  * shadow inodes that exist, and which regular inodes use them (i.e. are
271  * their clients).
272  */
273 
274 struct shadowclients {
275 	fsck_ino_t *client;	/* an array of inode numbers */
276 	int nclients; /* how many inodes in the array are in use (valid) */
277 	struct shadowclients *next; /* link to more client inode numbers */
278 };
279 struct shadowclientinfo {
280 	fsck_ino_t shadow;	/* the shadow inode that this info is for */
281 	int totalClients;	/* how many inodes total refer to this */
282 	struct shadowclients *clients; /* a linked list of wads of clients */
283 	struct shadowclientinfo *next; /* link to the next shadow inode */
284 };
285 /* global pointer to this shadow/client information */
286 extern struct shadowclientinfo *shadowclientinfo;
287 extern struct shadowclientinfo *attrclientinfo;
288 
289 /*
290  * In ufs_inode.h ifdef _KERNEL, this is defined as `/@/'.  However,
291  * to avoid all sorts of potential confusion (you can't actually use
292  * `foo/@/bar' to get to an attribute), we use something that doesn't
293  * look quite so much like a simple pathname.
294  */
295 #define	XATTR_DIR_NAME	" <xattr> "
296 
297 /*
298  * granularity -- how many client inodes do we make space for at a time
299  * initialized in setup.c;
300  */
301 extern int maxshadowclients;
302 
303 /*
304  * Initialized global variables.
305  */
306 extern caddr_t lfname;
307 
308 /*
309  * Unitialized globals.
310  */
311 extern char	*devname;	/* name of device being checked */
312 extern size_t	dev_bsize;	/* computed value of DEV_BSIZE */
313 extern int	secsize;	/* actual disk sector size */
314 extern char	nflag;		/* assume a no response */
315 extern char	yflag;		/* assume a yes response */
316 extern daddr32_t	bflag;	/* location of alternate super block */
317 extern int	debug;		/* output debugging info */
318 extern int	rflag;		/* check raw file systems */
319 extern int	fflag;		/* check regardless of clean flag (force) */
320 extern int	mflag;		/* sanity check only */
321 extern int	verbose;	/* be chatty */
322 extern char	preen;		/* just fix normal inconsistencies */
323 extern char	mountedfs;	/* checking mounted device */
324 extern int	exitstat;	/* exit status (see EX* defines below) */
325 extern char	hotroot;	/* checking root device */
326 extern char	rerun;		/* rerun fsck. Only used in non-preen mode */
327 extern int	interrupted;	/* 1 => exit EXSIGNAL on exit */
328 extern char	havesb;		/* superblock has been read */
329 extern int	fsmodified;	/* 1 => write done to file system */
330 extern int	fsreadfd;	/* file descriptor for reading file system */
331 extern int	fswritefd;	/* file descriptor for writing file system */
332 extern int	iscorrupt;	/* known to be corrupt/inconsistent */
333 				/* -1 means mark clean so user can mount+fix */
334 extern int	isdirty;	/* 1 => write pending to file system */
335 
336 extern int	islog;		/* logging file system */
337 extern int	islogok;	/* log is okay */
338 
339 extern int	errorlocked;	/* set => mounted fs has been error-locked */
340 				/* implies fflag "force check flag" */
341 extern char	*elock_combuf;	/* error lock comment buffer */
342 extern char	*elock_mountp;	/* mount point; used to unlock error-lock */
343 extern int	pid;		/* fsck's process id (put in lockfs comment) */
344 extern int	mountfd;	/* fd of mount point */
345 
346 extern daddr32_t maxfsblock;	/* number of blocks in the file system */
347 extern uint_t	largefile_count; /* global largefile counter */
348 extern char	*mount_point;	/* if mounted, this is where */
349 extern char	*blockmap;	/* ptr to primary blk allocation map */
350 extern fsck_ino_t	maxino;	/* number of inodes in file system */
351 extern fsck_ino_t	lastino; /* last inode in use */
352 extern ushort_t *statemap;	/* ptr to inode state table */
353 extern short	*lncntp;	/* ptr to link count table */
354 
355 extern fsck_ino_t	lfdir;	/* lost & found directory inode number */
356 extern int	overflowed_lf;	/* tried to wrap lost & found's link count */
357 extern int	reattached_dir;	/* reconnected at least one directory */
358 extern int	broke_dir_link;	/* broke at least one directory hardlink */
359 
360 extern daddr32_t	n_blks;		/* number of blocks in use */
361 extern fsck_ino_t	n_files;	/* number of files in use */
362 
363 #define	clearinode(dp)	{ \
364 	*(dp) = zino; \
365 }
366 extern struct	dinode zino;
367 
368 #define	testbmap(blkno)	isset(blockmap, blkno)
369 #define	setbmap(blkno)	setbit(blockmap, blkno)
370 #define	clrbmap(blkno)	clrbit(blockmap, blkno)
371 
372 #define	STOP	0x01
373 #define	SKIP	0x02
374 #define	KEEPON	0x04
375 #define	ALTERED	0x08
376 #define	FOUND	0x10
377 
378 /*
379  * Support relatively easy debugging of lncntp[] updates.  This can't
380  * be a function, because of the (_op) step.  Normally, we just do that.
381  */
382 #define	TRACK_LNCNTP(_ino, _op) (_op)
383 
384 /*
385  * See if the net link count for an inode has gone outside
386  * what can be represented on disk.  Returning text as NULL
387  * indicates no.
388  *
389  * Remember that link counts are effectively inverted, so
390  * underflow and overflow are reversed as well.
391  *
392  * This check should be done before modifying the actual link
393  * count.
394  */
395 #define	LINK_RANGE(text, current, offset) { \
396 	int net = ((int)(current)) + ((int)(offset)); \
397 	text = NULL; \
398 	if (net > (MAXLINK)) \
399 		text = "UNDERFLOW"; \
400 	else if (net < -(MAXLINK)) \
401 		text = "OVERFLOW"; \
402 }
403 
404 /*
405  * If LINK_RANGE() indicated a problem, this is the boiler-plate
406  * for dealing with it.  Usage is:
407  *
408  *     LINK_RANGE(text, current, offset);
409  *     if (text != NULL) {
410  *         LINK_CLEAR(text, ino, mode, idp);
411  *         if (statemap[ino] == USTATE)
412  *             ...inode was cleared...
413  *     }
414  *
415  * Note that clri() will set iscorrupt if the user elects not to
416  * clear the problem inode, so the filesystem won't get reported
417  * as clean when it shouldn't be.
418  */
419 #define	LINK_CLEAR(text, ino, mode, idp) { \
420 	pwarn("%s LINK COUNT %s", file_id((ino), (mode)), (text)); \
421 	pinode((ino)); \
422 	pfatal(""); \
423 	init_inodesc((idp)); \
424 	(idp)->id_type = ADDR; \
425 	(idp)->id_func = pass4check; \
426 	(idp)->id_number = ino; \
427 	(idp)->id_fix = DONTKNOW; \
428 	clri((idp), (text), CLRI_QUIET, CLRI_NOP_CORRUPT); \
429 }
430 
431 /*
432  * Used for checking link count under/overflow specifically on
433  * the lost+found directory.  If the user decides not to do the
434  * clri(), then flag that we've hit this problem and refuse to do
435  * the reconnect.
436  */
437 #define	LFDIR_LINK_RANGE_RVAL(text, current, offset, idp, rval) { \
438 	LINK_RANGE(text, current, offset); \
439 	if (text != NULL) { \
440 		LINK_CLEAR(text, lfdir, IFDIR, idp); \
441 		if (statemap[lfdir] == USTATE) { \
442 			lfdir = 0; \
443 			return (rval); \
444 		} else { \
445 			overflowed_lf++; \
446 		} \
447 	} \
448 }
449 
450 #define	LFDIR_LINK_RANGE_NORVAL(text, current, offset, idp) { \
451 	LINK_RANGE(text, current, offset); \
452 	if (text != NULL) { \
453 		LINK_CLEAR(text, lfdir, IFDIR, idp); \
454 		if (statemap[lfdir] == USTATE) { \
455 			lfdir = 0; \
456 			return; \
457 		} else { \
458 			overflowed_lf++; \
459 		} \
460 	} \
461 }
462 
463 /*
464  * Values for mounted() and mountedfs.
465  */
466 #define	M_NOMNT		0	/* filesystem is not mounted */
467 #define	M_RO		1	/* filesystem is mounted read-only */
468 #define	M_RW		2	/* filesystem is mounted read-write */
469 
470 #define	EXOKAY		0	/* file system is unmounted and ok */
471 #define	EXBADPARM	1	/* bad parameter(s) given */
472 #define	EXUMNTCHK	32	/* fsck -m: unmounted, needs checking */
473 #define	EXMOUNTED	33	/* file system already mounted, not magic, */
474 				/* or it is magic and mounted read/write */
475 #define	EXNOSTAT	34	/* cannot stat device */
476 #define	EXREBOOTNOW	35	/* modified root or something equally scary */
477 #define	EXFNDERRS	36	/* uncorrectable errors, terminate normally */
478 #define	EXSIGNAL	37	/* a signal was caught during processing */
479 #define	EXERRFATAL	39	/* uncorrectable errors, exit immediately */
480 #define	EXROOTOKAY	40	/* for root, same as 0 */
481 
482 /*
483  * Values for clri()'s `verbose' and `corrupting' arguments (third
484  * and fourth, respectively).
485  */
486 #define	CLRI_QUIET		1
487 #define	CLRI_VERBOSE		2
488 
489 #define	CLRI_NOP_OK		1
490 #define	CLRI_NOP_CORRUPT	2
491 
492 /*
493  * Filesystems that are `magical' - if they exist in vfstab,
494  * then they have to be mounted for the system to have gotten
495  * far enough to be able to run fsck.  Thus, don't get all
496  * bent out of shape if we're asked to check it and it is mounted.
497  * Actual initialization of the array is in main.c
498  */
499 enum magic {
500 	MAGIC_NONE = 0,
501 	MAGIC_ROOT = 1,
502 	MAGIC_USR = 2,
503 	MAGIC_LIMIT = 3
504 };
505 extern char *magic_fs[];
506 
507 /*
508  * Paths needed by calcsb().
509  */
510 #define	MKFS_PATH	"/usr/lib/fs/ufs/mkfs"
511 #define	NEWFS_PATH	"/usr/lib/fs/ufs/newfs"
512 
513 int		acltypeok(struct dinode *);
514 void		add_orphan_dir(fsck_ino_t);
515 void		adjust(struct inodesc *, int);
516 daddr32_t	allocblk(int);
517 fsck_ino_t	allocdir(fsck_ino_t, fsck_ino_t, int, int);
518 fsck_ino_t	allocino(fsck_ino_t, int);
519 void		blkerror(fsck_ino_t, caddr_t, daddr32_t, daddr32_t);
520 void		brelse(struct bufarea *);
521 void		bufinit(void);
522 void		bwrite(int, caddr_t, diskaddr_t, int64_t);
523 void		cacheacl(struct dinode *, fsck_ino_t);
524 void		cacheino(struct dinode *, fsck_ino_t);
525 void		catch(int);
526 void		catchquit(int);
527 caddr_t		cg_sanity(struct cg *, int);
528 void		cgflush(void);
529 int		cgisdirty(void);
530 int		changeino(fsck_ino_t, caddr_t, fsck_ino_t);
531 int		check_mnttab(caddr_t, caddr_t, size_t);
532 int		check_vfstab(caddr_t, caddr_t, size_t);
533 int		chkrange(daddr32_t, int);
534 void		ckfini(void);
535 int		ckinode(struct dinode *, struct inodesc *, enum cki_action);
536 void		clearattrref(fsck_ino_t);
537 int		cleardirentry(fsck_ino_t, fsck_ino_t);
538 void		clearshadow(fsck_ino_t, struct shadowclientinfo **);
539 void		clri(struct inodesc *, caddr_t, int, int);
540 void		deshadow(struct shadowclientinfo *, void (*)(fsck_ino_t));
541 void		direrror(fsck_ino_t, caddr_t, ...);
542 int		dirscan(struct inodesc *);
543 void		dirty(struct bufarea *);
544 int		do_errorlock(int);
545 int		dofix(struct inodesc *, caddr_t, ...);
546 void		examinelog(void (*)(daddr32_t));
547 void		errexit(caddr_t, ...);
548 void		fileerror(fsck_ino_t, fsck_ino_t, caddr_t, ...);
549 caddr_t		file_id(fsck_ino_t, mode_t);
550 int		find_dup_ref(daddr32_t, fsck_ino_t, daddr32_t, int);
551 int		findino(struct inodesc *);
552 int		findname(struct inodesc *);
553 void		fix_cg(struct cg *, int);
554 void		flush(int, struct bufarea *);
555 void		free_dup_state(void);
556 void		freeblk(fsck_ino_t, daddr32_t, int);
557 void		freeino(fsck_ino_t, int);
558 void		freeinodebuf(void);
559 int		fsck_asprintf(caddr_t *, caddr_t, ...);
560 int		fsck_bread(int, caddr_t, diskaddr_t, size_t);
561 int		ftypeok(struct dinode *);
562 struct bufarea	*getblk(struct bufarea *, daddr32_t, size_t);
563 struct bufarea	*getdatablk(daddr32_t, size_t size);
564 diskaddr_t	getdisksize(caddr_t, int);
565 struct inoinfo	*getinoinfo(fsck_ino_t);
566 struct dinode	*getnextinode(fsck_ino_t);
567 struct dinode	*getnextrefresh(void);
568 void		getpathname(caddr_t, fsck_ino_t, fsck_ino_t);
569 struct dinode	*ginode(fsck_ino_t);
570 caddr_t		hasvfsopt(struct vfstab *, caddr_t);
571 int		have_dups(void);
572 void		init_inodesc(struct inodesc *);
573 void		init_inoinfo(struct inoinfo *, struct dinode *, fsck_ino_t);
574 void		initbarea(struct bufarea *);
575 int		ino_t_cmp(const void *, const void *);
576 int		inocached(fsck_ino_t);
577 void		inocleanup(void);
578 void		inodirty(void);
579 int		is_errorlocked(caddr_t);
580 int		linkup(fsck_ino_t, fsck_ino_t, caddr_t);
581 int		lookup_named_ino(fsck_ino_t, caddr_t);
582 int		makeentry(fsck_ino_t, fsck_ino_t, caddr_t);
583 void		maybe_convert_attrdir_to_dir(fsck_ino_t);
584 int		mounted(caddr_t, caddr_t, size_t);
585 void		pass1(void);
586 void		pass1b(void);
587 int		pass1check(struct inodesc *);
588 void		pass2(void);
589 void		pass3a(void);
590 void		pass3b(void);
591 int		pass3bcheck(struct inodesc *);
592 void		pass4(void);
593 int		pass4check(struct inodesc *);
594 void		pass5(void);
595 void		pfatal(caddr_t, ...);
596 void		pinode(fsck_ino_t);
597 void		printclean(void);
598 void		propagate(void);
599 void		pwarn(caddr_t, ...);
600 caddr_t		rawname(caddr_t);
601 void		registershadowclient(fsck_ino_t, fsck_ino_t,
602 		    struct shadowclientinfo **);
603 void		remove_orphan_dir(fsck_ino_t);
604 int		reply(caddr_t, ...);
605 int		report_dups(int);
606 void		resetinodebuf(void);
607 char		*setup(caddr_t);
608 void		truncino(fsck_ino_t, offset_t, int);
609 void		unbufinit(void);
610 caddr_t		unrawname(caddr_t);
611 void		unregistershadow(fsck_ino_t, struct shadowclientinfo **);
612 int		updateclean(void);
613 int		writable(caddr_t);
614 void		write_altsb(int);
615 
616 /*
617  * Functions from the kernel sources (ufs_subr.c, etc).
618  */
619 extern void	fragacct(struct fs *, int, int32_t *, int);
620 
621 #ifdef	__cplusplus
622 }
623 #endif
624 
625 #endif	/* _FSCK_FSCK_H */
626