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