Return to fsck.m CVS log

Up to [Research Unix] / researchv10dc / vol2 / fsck

Annotation of researchv10dc/vol2/fsck/fsck.m, revision 1.1

1.1     ! root        1: |make(rp)
        !             2: 
        !             3: |insert(../monk/monk.mac)
        !             4: 
        !             5: |comment(VOL2HEADER)|set_counter(page 581-1)|set_string(page_headers "'''")|set_string(even_headers "'Fsck \(em The UNIX File System Check Program''\f(NIfsck\fP'")|set_string(odd_headers "'\f(NIfsck\fP''Fsck \(em The UNIX File System Check Program'")|set_string(even_footers "_\\nP__UNIX Papers_")|set_string(odd_footers "'Research Tenth Edition''\\nP'")
        !             6: 
        !             7: |environment(S;
        !             8:        inline off, size -1;)
        !             9: 
        !            10: |environment(text_list;
        !            11:        list.type fixed, list.pre "\&", list.format 1, list.post "\ \ ",
        !            12:        list.indent "nnnnnn", list on;
        !            13: 
        !            14:        list off)
        !            15: 
        !            16: |author(name "T. J. Kowalski", initials TJK, location MH, department 11229,
        !            17:        extension x2771, room 2C-552)
        !            18: 
        !            19: |date(July 1, 1979)
        !            20: 
        !            21: |title(Fsck |sp(minus) The |s(UNIX) File System Check Program)
        !            22: 
        !            23: |keywords(File System Repair)
        !            24: 
        !            25: |begin(abstract)
        !            26: The |s(UNIX)|sp(registered) File System Check program |i(fsck)
        !            27: is an interactive file system check and repair program.
        !            28: |i(Fsck) uses the redundant structural information
        !            29: in the |s(UNIX) file system
        !            30: to do several consistency checks.
        !            31: If an inconsistency is detected,
        !            32: it is reported to the operator,
        !            33: who may elect to fix or ignore each inconsistency.
        !            34: These inconsistencies
        !            35: result from the permanent interruption of the file system updates,
        !            36: which are performed every time a file is modified.
        !            37: |i(Fsck) is frequently able to repair corrupted file systems
        !            38: using procedures based on the order in which |s(UNIX) honors
        !            39: these file system update requests.
        !            40: |p
        !            41: The purpose of this document
        !            42: is to describe the normal updating of the file system,
        !            43: to discuss the possible causes of file system corruption,
        !            44: and to present the corrective actions carried out by |i(fsck).
        !            45: Both the program
        !            46: and the interaction between the program and the operator are described.
        !            47: |end(abstract)
        !            48: 
        !            49: |titlebox
        !            50: 
        !            51: |style(two_column)
        !            52: 
        !            53: |section(Introduction)
        !            54: 
        !            55: When a |s(UNIX) system|reference(ritchie thompson unix cacm)
        !            56: is brought up,
        !            57: a consistency check of the file systems should always be performed.
        !            58: This precautionary measure
        !            59: helps to insure a reliable environment for file storage on disk.
        !            60: If an inconsistency is discovered,
        !            61: corrective action must be taken.
        !            62: No changes are made to any file system
        !            63: by |i(fsck) without prior operator approval.
        !            64: |p
        !            65: The purpose of this memo is to dispel the mystique
        !            66: surrounding file system inconsistencies.
        !            67: It first describes the updating of the file system
        !            68: (the calm before the storm)
        !            69: and then describes file system corruption (the storm).
        !            70: Finally,
        !            71: the set of heuristically sound corrective actions
        !            72: used by |i(fsck)|reference(system iii manual)
        !            73: (the Coast Guard to the rescue)
        !            74: is presented.
        !            75: 
        !            76: |section(Update Of The File System)
        !            77: 
        !            78: Every working day hundreds of files are created, modified, and removed.
        !            79: Every time a file is modified, the |s(UNIX) operating system
        !            80: performs a series of file system updates.
        !            81: These updates, when written on disk, yield a consistent file system.
        !            82: To understand what happens
        !            83: if a permanent interruption occurs in this sequence,
        !            84: it is important to know the probable order of update requests.|reference(thompson unix bstj)
        !            85: Knowing what pieces of information were probably written
        !            86: to the file system first,
        !            87: heuristic procedures can be developed to repair a corrupted file system.
        !            88: |p
        !            89: There are five types of file system updates.
        !            90: These involve the super-block,
        !            91: inodes, indirect blocks,
        !            92: data blocks (directories and files), and free list blocks.
        !            93: 
        !            94: |subsection(Super-Block)
        !            95: 
        !            96: The super-block contains
        !            97: part of the free block list,
        !            98: part of the free i-list,
        !            99: and information about
        !           100: the size of the file system,
        !           101: the size of the i-list,
        !           102: the count of free blocks,
        !           103: and the count of free inodes.
        !           104: |p
        !           105: The super-block of a mounted file system
        !           106: (the root file system is always mounted)
        !           107: is written whenever the file system is unmounted
        !           108: or a |i(sync) command is issued.
        !           109: 
        !           110: |subsection(Inodes)
        !           111: 
        !           112: An inode contains information about
        !           113: the type of inode (directory, data, or special),
        !           114: the number of directory entries linked to the inode,
        !           115: the list of blocks claimed by the inode,
        !           116: and the size of the inode.
        !           117: |p
        !           118: An inode is written to the file system
        !           119: when the file associated with the inode is closed.|footnote(All
        !           120: in-core blocks are also written to the file system on issue of
        !           121: a |i(sync) system call.)
        !           122: 
        !           123: |subsection(Indirect Blocks)
        !           124: 
        !           125: There are three types of indirect blocks:
        !           126: single-indirect, double-indirect and triple-indirect.
        !           127: A single-indirect block contains
        !           128: a list of some of the block numbers claimed by an inode.
        !           129: Each of the 128 indirect block entries is a data-block number.
        !           130: A double-indirect block contains a list of single-indirect block numbers.
        !           131: A triple-indirect block contains a list of double-indirect block numbers.
        !           132: |p
        !           133: Indirect blocks are written to the file system
        !           134: whenever they have been modified and released|footnote(More precisely,
        !           135: they are queued for eventual writing.
        !           136: Physical I/O is deferred until the buffer is needed by UNIX
        !           137: or a |i(sync) command is issued.)
        !           138: by the operating system.
        !           139: 
        !           140: |subsection(Data Blocks)
        !           141: 
        !           142: A data block may contain file information
        !           143: or directory entries.
        !           144: Each directory entry consists of a file name
        !           145: and an inode number.
        !           146: |p
        !           147: Data blocks are written to the file system
        !           148: whenever they have been modified and released by the operating system.
        !           149: 
        !           150: |subsection(First Free List Block)
        !           151: 
        !           152: The super-block contains the first free list block.
        !           153: The free list blocks
        !           154: are a list of all blocks that are not allocated to the super-block,
        !           155: inodes, indirect blocks, or data blocks.
        !           156: Each free list block contains
        !           157: a count of the number of entries in this free list block,
        !           158: a pointer to the next free list block,
        !           159: and a partial list of free blocks in the file system.
        !           160: |p
        !           161: Free list blocks are written to the file system
        !           162: whenever they have been modified and released by the operating system.
        !           163: 
        !           164: |section(Corruption Of The File System)
        !           165: 
        !           166: A file system can become corrupted in a variety of ways.
        !           167: The most common problems
        !           168: are improper shutdown procedures and hardware failures.
        !           169: 
        !           170: |subsection(Improper System Shutdown and Startup)
        !           171: 
        !           172: File systems may become corrupted when proper shutdown procedures
        !           173: are not observed, e.g.,
        !           174: forgetting to |i(sync) the system before halting the |s(CPU),
        !           175: physically write-protecting a mounted file system,
        !           176: or taking a mounted file system off-line.
        !           177: |p
        !           178: File systems may become further corrupted if proper startup procedures
        !           179: are not observed, e.g.,
        !           180: not checking a file system for inconsistencies,
        !           181: and not repairing inconsistencies.
        !           182: Allowing a corrupted file system to be used (and, thus, to be modified further)
        !           183: can be disastrous.
        !           184: 
        !           185: |subsection(Hardware Failure)
        !           186: 
        !           187: Any piece of hardware can fail at any time.
        !           188: Failures can be as subtle as a bad block on a disk pack,
        !           189: or as obvious as a non-functional disk-controller.
        !           190: 
        !           191: |section(Detection And Correction Of Corruption)
        !           192: 
        !           193: A quiescent|footnote(I.e., unmounted and not being written on.)
        !           194: file system may be checked for structural integrity
        !           195: by performing consistency checks on the redundant data
        !           196: intrinsic to a file system.
        !           197: The redundant data is either read from the file system
        !           198: or computed from other known values.
        !           199: A quiescent state is important during the checking of a file system
        !           200: because of the multi-pass nature of the |i(fsck) program.
        !           201: |p
        !           202: When an inconsistency is discovered
        !           203: |i(fsck) reports the inconsistency
        !           204: and requests the operator to choose a corrective action.
        !           205: |p
        !           206: Discussed in this section are how to discover inconsistencies
        !           207: and possible corrective actions
        !           208: for the super-block, the inodes, the indirect blocks,
        !           209: the data blocks containing directory entries, and the free list blocks.
        !           210: These corrective actions
        !           211: can be performed interactively by the |i(fsck) command
        !           212: under control of the operator.
        !           213: 
        !           214: |subsection(Super-Block)
        !           215: 
        !           216: The most common corrupted item is the super-block.
        !           217: The super-block is prone to corruption
        !           218: because every change to the file system's blocks or inodes
        !           219: modifies the super-block.
        !           220: |p
        !           221: The super-block and its associated parts
        !           222: are most often corrupted when the computer is halted
        !           223: and the last command involving output to the file system
        !           224: was not a |i(sync) command.
        !           225: |p
        !           226: The super-block can be checked for inconsistencies involving file system size,
        !           227: i-list size,
        !           228: free block list,
        !           229: free block count,
        !           230: and the free inode count.
        !           231: 
        !           232: |subsubsection(File system size and i-list size.)
        !           233: |save(File system size and i-list size.)
        !           234: 
        !           235: The file system size must be larger than the number of blocks
        !           236: used by the super-block
        !           237: and the number of blocks used by the list of inodes.
        !           238: The number of inodes must be less than 65,535.
        !           239: The file system size and i-list size
        !           240: are critical pieces of information to the |i(fsck) program.
        !           241: While there is no way to check these sizes,
        !           242: |i(fsck) can check that they are within reasonable bounds.
        !           243: All other checks of the file system
        !           244: depend on the correctness of these sizes.
        !           245: 
        !           246: |subsubsection(Free block list.)
        !           247: |save(Free block list.)
        !           248: 
        !           249: The free block list starts in the super-block
        !           250: and continues through the free list blocks of the file system.
        !           251: Each free list block can be checked
        !           252: for list count out of range,
        !           253: for block numbers out of range,
        !           254: and for blocks already allocated within the file system.
        !           255: A check is made to see that all the blocks in the file system were found.
        !           256: |p
        !           257: The first free block list is in the super-block.
        !           258: |i(Fsck) checks the list count
        !           259: for a value of less than zero or greater than fifty.
        !           260: It also checks each block number
        !           261: for a value of less than the first data block in the file system
        !           262: or greater than the last block in the file system.
        !           263: Then it compares each block number to a list of already allocated blocks.
        !           264: If the free list block pointer is non-zero,
        !           265: the next free list block is read in and the process is repeated.
        !           266: |p
        !           267: When all the blocks have been accounted for,
        !           268: a check is made to see if the number of blocks used by the free block list
        !           269: plus the number of blocks claimed by the inodes
        !           270: equals the total number of blocks in the file system.
        !           271: |p
        !           272: If anything is wrong with the free block list,
        !           273: then |i(fsck) may rebuild it,
        !           274: excluding all blocks in the list of allocated blocks.
        !           275: 
        !           276: |subsubsection(Free block count.)
        !           277: |save(Free block count.)
        !           278: 
        !           279: The super-block contains a count of the total number of free blocks
        !           280: within the file system.
        !           281: |i(Fsck) compares this count to the number of free blocks it found
        !           282: within the file system.
        !           283: If they don't agree,
        !           284: then |i(fsck) may replace the count in the super-block
        !           285: by the real free block count.
        !           286: 
        !           287: |subsubsection(Free inode count.)
        !           288: |save(Free inode count.)
        !           289: 
        !           290: The super-block contains a count of the total number of free inodes
        !           291: within the file system.
        !           292: |i(Fsck) compares this count to the number of free inodes it found
        !           293: within the file system.
        !           294: If they don't agree,
        !           295: then |i(fsck)
        !           296: may replace the count in the super-block by the real free inode count.
        !           297: 
        !           298: |subsection(Inodes)
        !           299: 
        !           300: An individual inode is not as likely to be corrupted as the super-block.
        !           301: However,
        !           302: because of the great number of active inodes,
        !           303: corruption in the i-list is almost as likely as corruption
        !           304: in the super-block.
        !           305: |p
        !           306: The list of inodes is checked sequentially starting with inode 1
        !           307: (there is no inode 0)
        !           308: and going to the last inode in the file system.
        !           309: Each inode can be checked for
        !           310: inconsistencies involving format and type,
        !           311: link count,
        !           312: duplicate blocks,
        !           313: bad blocks,
        !           314: and inode size.
        !           315: 
        !           316: |subsubsection(Format and type.)
        !           317: |save(Format and type.)
        !           318: 
        !           319: Each inode contains a mode word.
        !           320: This mode word describes the type and state of the inode.
        !           321: Inodes may be one of four types:
        !           322: regular inode, directory inode, special block inode,
        !           323: and special character inode.
        !           324: If an inode is not one of these types, then the inode has an illegal type.
        !           325: Inodes may be found in one of three states:
        !           326: unallocated, allocated, and neither unallocated nor allocated.
        !           327: This last state suggests an incorrectly formatted inode.
        !           328: Incorrect format may result
        !           329: if bad data is written into the i-list through,
        !           330: for example,
        !           331: a hardware failure.
        !           332: The only possible corrective action for |i(fsck) is clearing the inode.
        !           333: 
        !           334: |subsubsection(Link count.)
        !           335: |save(Link count.)
        !           336: 
        !           337: Contained in each inode is a count of the total number of directory entries
        !           338: linked to the inode.
        !           339: |p
        !           340: |i(Fsck) verifies the link count of each inode
        !           341: by traversing down the total directory structure,
        !           342: starting from the root directory,
        !           343: and calculating a real link count for each inode.
        !           344: |p
        !           345: If the stored link count is non-zero and the real link count is zero,
        !           346: it means that no directory entry appears for the inode.
        !           347: If the stored and real link counts are non-zero and unequal,
        !           348: a directory entry may have been added or removed
        !           349: without the inode being updated.
        !           350: |p
        !           351: If the stored link count is non-zero and the real link count is zero,
        !           352: |i(fsck) may link the disconnected file to the |cw(lost+found) directory.
        !           353: If the stored and real link counts are non-zero and unequal,
        !           354: |i(fsck) may replace the stored link count by the real link count.
        !           355: 
        !           356: |subsubsection(Duplicate blocks)
        !           357: |save(Duplicate blocks)
        !           358: 
        !           359: Contained in each inode is a list or pointers to lists (indirect blocks)
        !           360: of all the blocks claimed by the inode.
        !           361: |p
        !           362: |i(Fsck) compares each block number claimed by an inode
        !           363: to a list of already allocated blocks.
        !           364: If a block number is already claimed by another inode,
        !           365: the block number is added to a list of duplicate blocks.
        !           366: Otherwise,
        !           367: the list of allocated blocks is updated to include the block number.
        !           368: If there are any duplicate blocks,
        !           369: |i(fsck) will pass over part of the i-list a second time
        !           370: to find the inode of the duplicated block,
        !           371: because without examining the files
        !           372: associated with these inodes for correct content,
        !           373: there is not enough information available to decide what inode is corrupted
        !           374: and should be cleared.
        !           375: Usually the inode with the earliest modify time is incorrect
        !           376: and should be cleared.
        !           377: |p
        !           378: This condition can occur
        !           379: when a file system contains blocks claimed by both the free block list
        !           380: and by other parts of the file system.
        !           381: |p
        !           382: If there is a large number of duplicate blocks in an inode,
        !           383: this may be because an indirect block is not being written to the file system.
        !           384: |p
        !           385: |i(Fsck) will prompt the operator to clear both inodes.
        !           386: 
        !           387: |subsubsection(Bad blocks)
        !           388: |save(Bad blocks)
        !           389: 
        !           390: Contained in each inode
        !           391: is a list or pointer to lists of all the blocks claimed by the inode.
        !           392: |p
        !           393: |i(Fsck) checks each block number claimed by an inode
        !           394: for a value lower than that of the first data block,
        !           395: or greater than the last block in the file system.
        !           396: If the block number is outside this range,
        !           397: the block number is a bad block number.
        !           398: |p
        !           399: If there is a large number of bad blocks in an inode,
        !           400: this may be because an indirect block is not being written to the file system.
        !           401: |p
        !           402: |i(Fsck) will prompt the operator to clear both inodes.
        !           403: 
        !           404: |subsubsection(Size checks.)
        !           405: |save(Size checks.)
        !           406: 
        !           407: Each inode contains a thirty-two bit (four-byte) size field.
        !           408: This size shows the number of characters in the file
        !           409: associated with the inode.
        !           410: This size can be checked for inconsistencies,
        !           411: e.g.,
        !           412: directory sizes that are not a multiple of sixteen characters,
        !           413: or a mismatch between the number of blocks shown by the inode size
        !           414: and the number really in use.
        !           415: |p
        !           416: A directory inode within the |s(UNIX) file system
        !           417: has the directory bit set in the inode mode word.
        !           418: The directory size must be a multiple of sixteen
        !           419: because a directory entry contains sixteen bytes
        !           420: (two bytes for the inode number
        !           421: and fourteen bytes for the file or directory name).
        !           422: |p
        !           423: |i(Fsck) will warn of directory misalignment.
        !           424: This is only a warning
        !           425: because not enough information can be gathered to correct the misalignment.
        !           426: |p
        !           427: A rough check of the consistency of the size field of an inode
        !           428: can be performed by using it to compute
        !           429: the number of blocks that should be associated with the inode
        !           430: and comparing it to the real number of blocks claimed by the inode.
        !           431: |p
        !           432: |i(Fsck) calculates the number of blocks that should be in an inode
        !           433: by dividing the number of characters in an inode
        !           434: by the number of characters per block (512)
        !           435: and rounding up.
        !           436: |i(Fsck) adds one block for each indirect block associated with the inode.
        !           437: If the real number of blocks does not match the computed number of blocks,
        !           438: |i(fsck) will warn of a possible file-size error.
        !           439: This is only a warning
        !           440: because |s(UNIX) does not fill in blocks in files created in random order.
        !           441: 
        !           442: |subsection(Indirect Blocks)
        !           443: 
        !           444: Indirect blocks are owned by an inode.
        !           445: Therefore,
        !           446: inconsistencies in indirect blocks directly affect the inode that owns them.
        !           447: |p
        !           448: Inconsistencies that can be checked
        !           449: are blocks already claimed by another inode
        !           450: and block numbers outside the range of the file system.
        !           451: |p
        !           452: For a discussion of detection and correction
        !           453: of the inconsistencies associated with indirect blocks,
        !           454: apply iteratively Sections |remember(Duplicate blocks)
        !           455: and |remember(Bad blocks) to each level of indirect blocks.
        !           456: 
        !           457: |subsection(Data Blocks)
        !           458: |save(Data Blocks)
        !           459: 
        !           460: The two types of data blocks are
        !           461: plain data blocks and directory data blocks.
        !           462: Plain data blocks contain the information stored in a file.
        !           463: Directory data blocks contain directory entries.
        !           464: |i(Fsck) does not attempt to check
        !           465: the validity of the contents of a plain data block.
        !           466: |p
        !           467: Each directory data block can be checked for inconsistencies involving
        !           468: directory inode numbers pointing to unallocated inodes,
        !           469: directory inode numbers greater than the number of inodes in the file system,
        !           470: incorrect directory inode numbers for ``|b(.)'' and ``|b(..)'',
        !           471: and directories that are disconnected from the file system.
        !           472: |p
        !           473: If a directory entry inode number points to an unallocated inode,
        !           474: then |i(fsck) may remove that directory entry.
        !           475: This condition occurs when
        !           476: the data blocks containing the directory entries
        !           477: were modified and written to the file system
        !           478: but the corresponding inode was not.
        !           479: |p
        !           480: If a directory entry inode number is pointing beyond the end of the i-list,
        !           481: |i(fsck) may remove that directory entry.
        !           482: This condition occurs if bad data is written into a directory data block.
        !           483: |p
        !           484: The directory inode number entry for ``|b(.)''
        !           485: should be the first entry in the directory data block.
        !           486: Its value should be equal to the inode number for the directory data block.
        !           487: |p
        !           488: The directory inode number entry for ``|b(..)''
        !           489: should be the second entry in the directory data block.
        !           490: Its value should be equal to
        !           491: the inode number for the parent of the directory entry
        !           492: (or the inode number of the directory data block
        !           493: if the directory is the root directory).
        !           494: |p
        !           495: If the directory inode numbers are incorrect,
        !           496: |i(fsck) may replace them by the correct values.
        !           497: |p
        !           498: |i(Fsck) checks the general connectivity of the file system.
        !           499: If directories are found not to be linked into the file system,
        !           500: |i(fsck) will link the directory back into the file system
        !           501: in the |cw(lost+found) directory.
        !           502: This condition occurs when inodes are written to the file system
        !           503: but the corresponding directory data blocks are not.
        !           504: 
        !           505: |subsection(Free List Blocks)
        !           506: 
        !           507: Free list blocks are owned by the super-block.
        !           508: Therefore,
        !           509: inconsistencies in free list blocks directly affect the super-block.
        !           510: |p
        !           511: Inconsistencies that can be checked are
        !           512: list count out of range,
        !           513: block numbers out of range,
        !           514: and blocks already associated with the file system.
        !           515: |p
        !           516: For a discussion of detection and correction of the inconsistencies
        !           517: associated with free list blocks, see Section |remember(Free block list.).
        !           518: 
        !           519: |section(Acknowledgements)
        !           520: 
        !           521: I would like to thank Larry A. Wehr
        !           522: for advice that led to the first version of |i(fsck),
        !           523: and Rick B. Brandt for adapting |i(fsck) to |s(UNIX).
        !           524: 
        !           525: |reference_placement
        !           526: 
        !           527: |style(one_column)
        !           528: .ne 1i
        !           529: |appendix(FSCK ERROR CONDITIONS)
        !           530: 
        !           531: |style(two_column)
        !           532: 
        !           533: |section(Conventions)
        !           534: ...........
        !           535: 
        !           536: |i(Fsck) is a multi-pass file system check program.
        !           537: Each file system pass invokes a different |i(Phase) of the |i(fsck) program.
        !           538: After the initial setup,
        !           539: |i(fsck) performs successive |i(Phases) over each file system,
        !           540: checking blocks and sizes,
        !           541: path-names,
        !           542: connectivity,
        !           543: reference counts,
        !           544: and the free block list
        !           545: (possibly rebuilding it),
        !           546: and performs some cleanup.
        !           547: |p
        !           548: When an inconsistency is detected,
        !           549: |i(fsck) reports the error condition to the operator.
        !           550: If a response is required,
        !           551: |i(fsck) prints a prompt message and waits for a response.
        !           552: This appendix explains the meaning of each error condition,
        !           553: the possible responses,
        !           554: and the related error conditions.
        !           555: |p
        !           556: The error conditions are organized by the |i(Phase) of the |i(fsck) program
        !           557: in which they can occur.
        !           558: The error conditions that may occur in more than one Phase
        !           559: will be discussed under initialization.
        !           560: 
        !           561: |section(Initialization)
        !           562: 
        !           563: Before a file system check can be performed,
        !           564: certain tables have to be set up and certain files opened.
        !           565: This section concerns itself with the opening of files
        !           566: and the initialization of tables.
        !           567: It lists error conditions resulting from
        !           568: command line options,
        !           569: memory requests,
        !           570: opening of files,
        !           571: status of files,
        !           572: file system size checks,
        !           573: and creation of the scratch file.
        !           574: 
        !           575: |unnumbered_subsection{|cw[C option?]}
        !           576: 
        !           577: |cw(C) is not a legal option to |i(fsck);
        !           578: legal options are
        !           579: |cw(-y),
        !           580: |cw(-n),
        !           581: |cw(-s),
        !           582: |cw(-S),
        !           583: and
        !           584: |cw(-t).
        !           585: |i(Fsck) stops on this error condition.
        !           586: See the |i(fsck)(8) for further detail.
        !           587: 
        !           588: |unnumbered_subsection{|cw[Bad -t option]}
        !           589: 
        !           590: The |cw(-t) option is not followed by a file name.
        !           591: |i(Fsck) stops on this error condition.
        !           592: See the |i(fsck)(8) for further detail.
        !           593: 
        !           594: |unnumbered_subsection{|cw[Invalid -s argument, defaults assumed]}
        !           595: 
        !           596: The |cw(-s) option is not suffixed by 3, 4,
        !           597: or blocks-per-cylinder:blocks-to-skip.
        !           598: |i(Fsck) assumes a default value of 400 blocks-per-cylinder
        !           599: and 9 blocks-to-skip.
        !           600: See the |i(fsck)(8) for more details.
        !           601: 
        !           602: |unnumbered_subsection{|cw[Incompatible options: -n and -s]}
        !           603: 
        !           604: It is not possible to salvage the free block list
        !           605: without modifying the file system.
        !           606: |i(Fsck) stops on this error condition.
        !           607: See the |i(fsck)(8) for further detail.
        !           608: 
        !           609: |unnumbered_subsection{|cw[Can't get memory]}
        !           610: 
        !           611: |i(Fsck)'s request for memory for its virtual memory tables failed.
        !           612: This should never happen.
        !           613: |i(Fsck) stops on this error condition.
        !           614: See a guru.
        !           615: 
        !           616: |unnumbered_subsection{|cw[Can't open checklist file: F]}
        !           617: 
        !           618: The default file system checklist file |b(F) (usually |cw(/etc/checklist))
        !           619: cannot be opened for reading.
        !           620: |i(Fsck) stops on this error condition.
        !           621: Check access modes of |b(F).
        !           622: 
        !           623: |unnumbered_subsection{|cw[Can't stat root]}
        !           624: 
        !           625: |i(Fsck)'s request for statistics about the root directory ``/'' failed.
        !           626: This should never happen.
        !           627: |i(Fsck) stops on this error condition.
        !           628: See a guru.
        !           629: 
        !           630: |unnumbered_subsection{|cw[Can't stat F]}
        !           631: 
        !           632: |i(Fsck)'s request for statistics about the file system |b(F) failed.
        !           633: It ignores this file system and continues checking the next file system given.
        !           634: Check access modes of |b(F).
        !           635: 
        !           636: |unnumbered_subsection{|cw[F is not a block or character device]}
        !           637: 
        !           638: You have given |i(fsck) a regular file name by mistake.
        !           639: It ignores this file system and continues checking the next file system given.
        !           640: Check file type of |b(F).
        !           641: 
        !           642: |unnumbered_subsection{|cw[Can't open F]}
        !           643: 
        !           644: The file system |b(F) cannot be opened for reading.
        !           645: It ignores this file system and continues checking the next file system given.
        !           646: Check access modes of |b(F).
        !           647: 
        !           648: |unnumbered_subsection{|cw[Size check: fsize X isize Y]}
        !           649: 
        !           650: More blocks are used for the i-list |b(Y)
        !           651: than there are blocks in the file system |b(X),
        !           652: or there are more than 65,535 inodes in the file system.
        !           653: It ignores this file system and continues checking the next file system given.
        !           654: See Section |remember(File system size and i-list size.).
        !           655: 
        !           656: |unnumbered_subsection{|cw[Can't create F]}
        !           657: 
        !           658: |i(Fsck)'s request to create a scratch file |b(F) failed.
        !           659: It ignores this file system and continues checking the next file system given.
        !           660: Check access modes of |b(F).
        !           661: 
        !           662: |unnumbered_subsection{|cw[CAN NOT SEEK: BLK B (CONTINUE)]}
        !           663: 
        !           664: |i(Fsck)'s request for moving to a specified block number |b(B)
        !           665: in the file system failed.
        !           666: This should never happen.
        !           667: See a guru.
        !           668: |p
        !           669: Possible responses to the |s(CONTINUE) prompt are:
        !           670: 
        !           671: |blank_space(1)
        !           672: |begin(text_list)
        !           673: 
        !           674: |S(|item(YES)) attempt to continue the file system check.
        !           675: Often,
        !           676: however the problem will persist.
        !           677: This error condition will not allow a complete check of the file system.
        !           678: A second run of |i(fsck) should be made to re-check this file system.
        !           679: If the block was part of the virtual memory buffer cache,
        !           680: |i(fsck) will stop with the message ``Fatal I/O error''.
        !           681: 
        !           682: |S(|item(NO)) stop the program.
        !           683: 
        !           684: |end(text_list)
        !           685: 
        !           686: |unnumbered_subsection{|cw[CAN NOT READ: BLK B (CONTINUE)]}
        !           687: 
        !           688: |i(Fsck)'s request for reading a specified block number |b(B)
        !           689: in the file system failed.
        !           690: This should never happen.
        !           691: See a guru.
        !           692: |p
        !           693: Possible responses to the |s(CONTINUE) prompt are:
        !           694: 
        !           695: |blank_space(1)
        !           696: |begin(text_list)
        !           697: 
        !           698: |S(|item(YES)) attempt to continue the file system check.
        !           699: Often,
        !           700: however,
        !           701: the problem will persist.
        !           702: This error condition will not allow a complete check of the file system.
        !           703: A second run of |i(fsck) should be made to re-check this file system.
        !           704: If the block was part of the virtual memory buffer cache,
        !           705: |i(fsck) will stop with the message ``Fatal I/O error''.
        !           706: 
        !           707: |S(|item(NO)) stop the program.
        !           708: 
        !           709: |end(text_list)
        !           710: 
        !           711: |unnumbered_subsection{|cw[CAN NOT WRITE: BLK B (CONTINUE)]}
        !           712: |i(Fsck)'s request for writing a specified block number |b(B)
        !           713: in the file system failed.
        !           714: The disk is write-protected.
        !           715: See a guru.
        !           716: |p
        !           717: Possible responses to the |s(CONTINUE) prompt are:
        !           718: 
        !           719: |blank_space(1)
        !           720: |begin(text_list)
        !           721: 
        !           722: |S(|item(YES)) attempt to continue the file system check.
        !           723: Often,
        !           724: however,
        !           725: the problem will persist.
        !           726: This error condition will not allow a complete check of the file system.
        !           727: A second run of |i(fsck) should be made to re-check this file system.
        !           728: If the block was part of the virtual memory buffer cache,
        !           729: |i(fsck) will stop with the message ``Fatal I/O error''.
        !           730: 
        !           731: |S(|item(NO)) stop the program.
        !           732: 
        !           733: |end(text_list)
        !           734: 
        !           735: |section(Phase 1: Check blocks and sizes)
        !           736: 
        !           737: This phase concerns itself with the i-list.
        !           738: This section lists error conditions resulting from
        !           739: checking inode types,
        !           740: setting up the zero-link-count table,
        !           741: examining inode block numbers for bad or duplicate blocks,
        !           742: checking inode size,
        !           743: and checking inode format.
        !           744: 
        !           745: |unnumbered_subsection{|cw[UNKNOWN FILE TYPE I=I (CLEAR)]}
        !           746: 
        !           747: The mode word of the inode |b(I) shows that the inode is not a
        !           748: special character inode,
        !           749: regular inode,
        !           750: or directory inode.
        !           751: See Section |remember(Format and type.).
        !           752: |p
        !           753: Possible responses to the |s(CLEAR) prompt are:
        !           754: 
        !           755: |blank_space(1)
        !           756: |begin(text_list)
        !           757: 
        !           758: |S(|item(YES)) de-allocate inode |b(I) by zeroing its contents.
        !           759: This will always invoke the |s(UNALLOCATED) error condition in Phase 2
        !           760: for each directory entry pointing to this inode.
        !           761: 
        !           762: |S(|item(NO)) ignore this error condition.
        !           763: 
        !           764: |end(text_list)
        !           765: 
        !           766: |unnumbered_subsection{|cw[LINK COUNT TABLE OVERFLOW (CONTINUE)]}
        !           767: 
        !           768: An internal table for |i(fsck)
        !           769: containing allocated inodes with a link count of zero has no more room.
        !           770: Recompile |i(fsck) with a larger value of |s(MAXLNCNT).
        !           771: |p
        !           772: Possible responses
        !           773: to the |s(CONTINUE) prompt are:
        !           774: 
        !           775: |blank_space(1)
        !           776: |begin(text_list)
        !           777: 
        !           778: |S(|item(YES)) continue with the program.
        !           779: This error condition will not allow a complete check of the file system.
        !           780: A second run of |i(fsck) should be made to re-check this file system.
        !           781: If another allocated inode with a zero link count is found,
        !           782: this error condition is repeated.
        !           783: 
        !           784: |S(|item(NO)) stop the program.
        !           785: 
        !           786: |end(text_list)
        !           787: 
        !           788: |unnumbered_subsection{|cw[B BAD I=I]}
        !           789: 
        !           790: Inode |b(I) contains block number |b(B) with a number lower than
        !           791: the number of the first data block in the file system
        !           792: or greater than the number of the last block in the file system.
        !           793: This error condition
        !           794: may invoke the |s(EXCESSIVE) |s(BAD) |s(BLKS) error condition in Phase 1
        !           795: if inode |b(I) has too many block numbers outside the file system range.
        !           796: This error condition will always invoke the |s(BAD)/|s(DUP) error condition
        !           797: in Phase 2 and Phase 4.
        !           798: See Section |remember(Bad blocks).
        !           799: 
        !           800: |unnumbered_subsection{|cw[EXCESSIVE BAD BLKS I=I (CONTINUE)]}
        !           801: 
        !           802: There is more than a tolerable number (usually 10) of blocks
        !           803: with a number lower than the number of the first data block in the file system
        !           804: or greater than the number of last block in the file system
        !           805: associated with inode |b(I).
        !           806: See Section |remember(Bad blocks).
        !           807: |p
        !           808: Possible responses to the |s(CONTINUE) prompt are:
        !           809: 
        !           810: |blank_space(1)
        !           811: |begin(text_list)
        !           812: 
        !           813: |S(|item(YES)) ignore the rest of the blocks in this inode
        !           814: and continue checking with the next inode in the file system.
        !           815: This error condition will not allow a complete check of the file system.
        !           816: A second run of |i(fsck) should be made to re-check this file system.
        !           817: 
        !           818: |S(|item(NO)) stop the program.
        !           819: 
        !           820: |end(text_list)
        !           821: 
        !           822: |unnumbered_subsection{|cw[B DUP I=I]}
        !           823: 
        !           824: Inode |b(I) contains block number |b(B),
        !           825: which is already claimed by another inode.
        !           826: This error condition
        !           827: may invoke the |s(EXCESSIVE) |s(DUP) |s(BLKS) error condition in Phase 1
        !           828: if inode |b(I) has too many block numbers claimed by other inodes.
        !           829: This error condition will always invoke Phase 1b
        !           830: and the |s(BAD)/|s(DUP) error condition in Phase 2 and Phase 4.
        !           831: See Section |remember(Duplicate blocks).
        !           832: 
        !           833: |unnumbered_subsection{|cw[EXCESSIVE DUP BLKS I=I (CONTINUE)]}
        !           834: 
        !           835: There is more than a tolerable number (usually 10) of blocks
        !           836: claimed by other inodes.
        !           837: See Section |remember(Duplicate blocks).
        !           838: |p
        !           839: Possible responses to the |s(CONTINUE) prompt are:
        !           840: 
        !           841: |blank_space(1)
        !           842: |begin(text_list)
        !           843: 
        !           844: |S(|item(YES)) ignore the rest of the blocks in this inode
        !           845: and continue checking with the next inode in the file system.
        !           846: This error condition will not allow a complete check of the file system.
        !           847: A second run of |i(fsck) should be made to re-check this file system.
        !           848: 
        !           849: |S(|item(NO)) stop the program.
        !           850: 
        !           851: |end(text_list)
        !           852: 
        !           853: |unnumbered_subsection{|cw[DUP TABLE OVERFLOW (CONTINUE)]}
        !           854: 
        !           855: An internal table in |i(fsck)
        !           856: containing duplicate block numbers has no more room.
        !           857: Recompile |i(fsck) with a larger value of |s(DUPTBLSIZE).
        !           858: |p
        !           859: Possible responses to the |s(CONTINUE) prompt are:
        !           860: 
        !           861: |blank_space(1)
        !           862: |begin(text_list)
        !           863: 
        !           864: |S(|item(YES)) continue with the program.
        !           865: This error condition will not allow a complete check of the file system.
        !           866: A second run of |i(fsck) should be made to re-check this file system.
        !           867: If another duplicate block is found, this error condition will repeat.
        !           868: 
        !           869: |S(|item(NO)) stop the program.
        !           870: 
        !           871: |end(text_list)
        !           872: 
        !           873: |unnumbered_subsection{|cw[POSSIBLE FILE SIZE ERROR I=I]}
        !           874: 
        !           875: The inode |b(I) size
        !           876: does not match the real number of blocks used by the inode.
        !           877: This is only a warning.
        !           878: See Section |remember(Size checks.).
        !           879: 
        !           880: |unnumbered_subsection{|cw[DIRECTORY MISALIGNED I=I]}
        !           881: 
        !           882: The size of a directory inode
        !           883: is not a multiple of the size of a directory entry (usually 16).
        !           884: This is only a warning.
        !           885: See Section |remember(Size checks.).
        !           886: 
        !           887: |unnumbered_subsection{|cw[PARTIALLY ALLOCATED INODE I=I (CLEAR)]}
        !           888: 
        !           889: Inode |b(I) is neither allocated nor unallocated.
        !           890: See Section |remember(Format and type.).
        !           891: |p
        !           892: Possible responses to the |s(CLEAR) prompt are:
        !           893: 
        !           894: |blank_space(1)
        !           895: |begin(text_list)
        !           896: 
        !           897: |S(|item(YES)) de-allocate inode |b(I) by zeroing its contents.
        !           898: 
        !           899: |S(|item(NO)) ignore this error condition.
        !           900: 
        !           901: |end(text_list)
        !           902: 
        !           903: |section(Phase 1b: Rescan for more dups)
        !           904: 
        !           905: When a duplicate block is found in Phase 1,
        !           906: the file system is rescanned to find the inode
        !           907: that previously claimed that block.
        !           908: This section describes when the duplicate block is found.
        !           909: 
        !           910: |unnumbered_subsection{|cw[B DUP I=I]}
        !           911: 
        !           912: Inode |b(I) contains block number |b(B),
        !           913: which is already claimed by another inode.
        !           914: This error will always invoke the |s(BAD)/|s(DUP) error condition
        !           915: in Phase 2.
        !           916: You can determine what inodes have overlapping blocks
        !           917: by examining this error condition
        !           918: and the |s(DUP) error condition in Phase 1.
        !           919: See Section |remember(Duplicate blocks).
        !           920: 
        !           921: .......
        !           922: |section(Phase 2: Check path-names)
        !           923: 
        !           924: This phase concerns itself with removing directory entries pointing to
        !           925: flawed inodes detected in Phase 1 and Phase 1b.
        !           926: This section lists error conditions resulting from
        !           927: root inode mode and status,
        !           928: directory inode pointers in range,
        !           929: and directory entries pointing to bad inodes.
        !           930: 
        !           931: |unnumbered_subsection{|cw[ROOT INODE UNALLOCATED. TERMINATING.]}
        !           932: 
        !           933: The root inode (usually inode number 2) has no allocate mode bits.
        !           934: This should never happen.
        !           935: The program will stop.
        !           936: See Section |remember(Format and type.).
        !           937: 
        !           938: |unnumbered_subsection{|cw[ROOT INODE NOT DIRECTORY (FIX)]}
        !           939: 
        !           940: The root inode (usually inode number 2) is not directory inode type.
        !           941: See Section |remember(Format and type.).
        !           942: |p
        !           943: Possible responses to the |s(FIX) prompt are:
        !           944: 
        !           945: |blank_space(1)
        !           946: |begin(text_list)
        !           947: 
        !           948: |S(|item(YES)) make the root inode's type be a directory.
        !           949: If the root inode's data blocks are not directory blocks,
        !           950: a large number of error conditions will be produced.
        !           951: 
        !           952: |S(|item(NO)) stop the program.
        !           953: 
        !           954: |end(text_list)
        !           955: 
        !           956: |unnumbered_subsection{|cw[DUPS/BAD IN ROOT INODE (CONTINUE)]}
        !           957: 
        !           958: Phase 1 or Phase 1b has found duplicate blocks
        !           959: or bad blocks in the root inode (usually inode number 2) for the file system.
        !           960: See Sections |remember(Duplicate blocks) and |remember(Bad blocks).
        !           961: |p
        !           962: Possible responses to the |s(CONTINUE) prompt are:
        !           963: 
        !           964: |blank_space(1)
        !           965: |begin(text_list)
        !           966: 
        !           967: |S(|item(YES)) ignore the |s(DUPS)/|s(BAD) error condition in the root inode and
        !           968: attempt to continue the file system check.
        !           969: If the root inode is not correct,
        !           970: then this action may result in a large number of other error conditions.
        !           971: 
        !           972: |S(|item(NO)) stop the program.
        !           973: 
        !           974: |end(text_list)
        !           975: 
        !           976: |unnumbered_subsection{|cw[I OUT OF RANGE I=I NAME=F (REMOVE)]}
        !           977: 
        !           978: A directory entry |b(F) has an inode number |b(I)
        !           979: that is greater than the end of the i-list.
        !           980: See Section |remember(Data Blocks).
        !           981: |p
        !           982: Possible responses to the |s(REMOVE) prompt are:
        !           983: 
        !           984: |blank_space(1)
        !           985: |begin(text_list)
        !           986: 
        !           987: |S(|item(YES)) the directory entry |b(F) will be removed.
        !           988: 
        !           989: |S(|item(NO)) ignore this error condition.
        !           990: 
        !           991: |end(text_list)
        !           992: 
        !           993: |unnumbered_subsection{|cw[UNALLOCATED I=I OWNER=O MODE=M SIZE=S MTIME=T NAME=F (REMOVE)]}
        !           994: 
        !           995: A directory entry |b(F) has an inode |b(I) without allocate mode bits.
        !           996: The owner |b(O), mode |b(M), size |b(S), modify time |b(T),
        !           997: and file name |b(F) are printed.
        !           998: See Section |remember(Data Blocks).
        !           999: |p
        !          1000: Possible responses to the |s(REMOVE) prompt are:
        !          1001: 
        !          1002: |blank_space(1)
        !          1003: |begin(text_list)
        !          1004: 
        !          1005: |S(|item(YES)) the directory entry |b(F) will be removed.
        !          1006: 
        !          1007: |S(|item(NO)) ignore this error condition.
        !          1008: 
        !          1009: |end(text_list)
        !          1010: 
        !          1011: |unnumbered_subsection{|cw[DUP/BAD I=I OWNER=O MODE=M SIZE=S MTIME=T DIR=F (REMOVE)]}
        !          1012: 
        !          1013: Phase 1 or Phase 1b has found duplicate blocks or bad blocks
        !          1014: associated with directory entry/inode |b(F)/|b(I).
        !          1015: The owner |b(O), mode |b(M), size |b(S), modify time |b(T),
        !          1016: and directory name |b(F) are printed.
        !          1017: See Sections |remember(Duplicate blocks) and |remember(Bad blocks).
        !          1018: |p
        !          1019: Possible responses to the |s(REMOVE) prompt are:
        !          1020: 
        !          1021: |blank_space(1)
        !          1022: |begin(text_list)
        !          1023: 
        !          1024: |S(|item(YES)) the directory entry |b(F) will be removed.
        !          1025: 
        !          1026: |S(|item(NO)) ignore this error condition.
        !          1027: 
        !          1028: |end(text_list)
        !          1029: 
        !          1030: |unnumbered_subsection{|cw[DUP/BAD I=I OWNER=O MODE=M SIZE=S MTIME=T FILE=F (REMOVE)]}
        !          1031: 
        !          1032: Phase 1 or Phase 1b has found duplicate blocks or bad blocks
        !          1033: associated with directory entry/inode |b(F)/|b(I).
        !          1034: The owner |b(O), mode |b(M), size |b(S), modify time |b(T),
        !          1035: and file name |b(F) are printed.
        !          1036: See Sections |remember(Duplicate blocks) and |remember(Bad blocks).
        !          1037: |p
        !          1038: Possible responses to the |s(REMOVE) prompt are:
        !          1039: 
        !          1040: |blank_space(1)
        !          1041: |begin(text_list)
        !          1042: 
        !          1043: |S(|item(YES)) the directory entry |b(F) will be removed.
        !          1044: 
        !          1045: |S(|item(NO)) ignore this error condition.
        !          1046: 
        !          1047: |end(text_list)
        !          1048: 
        !          1049: |section(Phase 3: Check connectivity)
        !          1050: 
        !          1051: This phase concerns itself with the directory connectivity seen in Phase 2.
        !          1052: This section lists error conditions resulting from
        !          1053: unreferenced directories
        !          1054: and missing or full |cw(lost+found) directories.
        !          1055: 
        !          1056: |unnumbered_subsection{|cw[UNREF DIR I=I OWNER=O MODE=M SIZE=S MTIME=T (RECONNECT)]}
        !          1057: 
        !          1058: The directory inode |b(I)
        !          1059: was not connected to a directory entry when the file system was traversed.
        !          1060: The owner |b(O), mode |b(M), size |b(S),
        !          1061: and modify time |b(T) of directory inode |b(I) are printed.
        !          1062: See Sections |remember(Data Blocks) and |remember(Link count.).
        !          1063: |p
        !          1064: Possible responses to the |s(RECONNECT) prompt are:
        !          1065: 
        !          1066: |blank_space(1)
        !          1067: |begin(text_list)
        !          1068: 
        !          1069: |S(|item(YES)) reconnect directory inode |b(I) to the file system
        !          1070: in the directory for lost files (usually |cw(lost+found)).
        !          1071: This action may invoke the |cw(lost+found) error condition in Phase 3
        !          1072: if there are problems connecting directory inode |b(I) to |cw(lost+found).
        !          1073: If the link is successful,
        !          1074: this action may also invoke the |s(CONNECTED) error condition in Phase 3.
        !          1075: 
        !          1076: |S(|item(NO)) ignore this error condition.
        !          1077: The |s(UNREF) error condition in Phase 4 will always occur as a result.
        !          1078: 
        !          1079: |end(text_list)
        !          1080: 
        !          1081: |unnumbered_subsection{|cw[SORRY. NO lost+found DIRECTORY]}
        !          1082: 
        !          1083: There is no |cw(lost+found) directory in the root directory of the file system;
        !          1084: |i(fsck) ignores the request to link a directory in |cw(lost+found).
        !          1085: The |s(UNREF) error condition in Phase 4 will always occur as a result.
        !          1086: Check access modes of |cw(lost+found).
        !          1087: See |i(fsck)(1M) manual entry for further detail.
        !          1088: 
        !          1089: |unnumbered_subsection{|cw[SORRY. NO SPACE IN lost+found DIRECTORY]}
        !          1090: 
        !          1091: There is no space to add another entry to the |cw(lost+found) directory
        !          1092: in the root directory of the file system;
        !          1093: |i(fsck) ignores the request to link a directory in |cw(lost+found).
        !          1094: The |s(UNREF) error condition in Phase 4 will always occur as a result.
        !          1095: Clean out unnecessary entries in |cw(lost+found)
        !          1096: or make |cw(lost+found) larger.
        !          1097: See |i(fsck)(1M) manual entry for further detail.
        !          1098: 
        !          1099: |unnumbered_subsection{|cw[DIR I=I1 CONNECTED. PARENT WAS I=I2]}
        !          1100: 
        !          1101: This is an advisory message showing that a directory inode |b(I1)
        !          1102: was successfully connected to the |cw(lost+found) directory.
        !          1103: The parent inode |b(I2) of the directory inode |b(I1)
        !          1104: is replaced by the inode number of the |cw(lost+found) directory.
        !          1105: See Sections |remember(Data Blocks) and |remember(Link count.).
        !          1106: 
        !          1107: |section(Phase 4: Check reference counts)
        !          1108: 
        !          1109: This phase concerns itself with the link count information
        !          1110: seen in Phase 2 and Phase 3.
        !          1111: This section lists error conditions resulting from
        !          1112: unreferenced files,
        !          1113: missing or full |cw(lost+found) directory,
        !          1114: incorrect link counts for files, directories, or special files,
        !          1115: unreferenced files and directories,
        !          1116: bad and duplicate blocks in files and directories,
        !          1117: and incorrect total free inode counts.
        !          1118: 
        !          1119: |unnumbered_subsection{|cw[UNREF FILE I=I OWNER=O MODE=M SIZE=S MTIME=T (RECONNECT)]}
        !          1120: 
        !          1121: Inode |b(I)
        !          1122: was not connected to a directory entry when the file system was traversed.
        !          1123: The owner |b(O), mode |b(M), size |b(S),
        !          1124: and modify time |b(T) of inode |b(I) are printed.
        !          1125: See Section |remember(Link count.).
        !          1126: |p
        !          1127: Possible responses to the |s(RECONNECT) prompt are:
        !          1128: 
        !          1129: |blank_space(1)
        !          1130: |begin(text_list)
        !          1131: 
        !          1132: |S(|item(YES)) reconnect inode |b(I) to the file system
        !          1133: in the directory for lost files (usually |cw(lost+found)).
        !          1134: This action may invoke the |cw(lost+found) error condition in Phase 4
        !          1135: if there are problems connecting inode |b(I) to |cw(lost+found).
        !          1136: 
        !          1137: |S(|item(NO)) ignore this error condition.
        !          1138: This will always invoke the |s(CLEAR) error condition in Phase 4.
        !          1139: 
        !          1140: |end(text_list)
        !          1141: 
        !          1142: |unnumbered_subsection{|cw[SORRY. NO lost+found DIRECTORY]}
        !          1143: 
        !          1144: There is no |cw(lost+found) directory in the root directory of the file system;
        !          1145: |i(fsck) ignores the request to link a file in |cw(lost+found).
        !          1146: This will always invoke the |s(CLEAR) error condition in Phase 4.
        !          1147: Check access modes of |cw(lost+found).
        !          1148: 
        !          1149: |unnumbered_subsection{|cw[SORRY. NO SPACE IN lost+found DIRECTORY]}
        !          1150: 
        !          1151: There is no space to add another entry to the |cw(lost+found) directory
        !          1152: in the root directory of the file system;
        !          1153: |i(fsck) ignores the request to link a file in |cw(lost+found).
        !          1154: This will always invoke the |s(CLEAR) error condition in Phase 4.
        !          1155: Check size and contents of |cw(lost+found).
        !          1156: 
        !          1157: |unnumbered_subsection{|cw[(CLEAR)]}
        !          1158: 
        !          1159: The inode mentioned in the immediately previous error condition
        !          1160: cannot be reconnected.
        !          1161: See Section |remember(Link count.).
        !          1162: |p
        !          1163: Possible responses to the |s(CLEAR) prompt are:
        !          1164: 
        !          1165: |blank_space(1)
        !          1166: |begin(text_list)
        !          1167: 
        !          1168: |S(|item(YES)) de-allocate the inode
        !          1169: mentioned in the preceding error condition by zeroing its contents.
        !          1170: 
        !          1171: |S(|item(NO)) ignore this error condition.
        !          1172: 
        !          1173: |end(text_list)
        !          1174: 
        !          1175: |unnumbered_subsection{|cw[LINK COUNT FILE I=I OWNER=O MODE=M SIZE=S MTIME=T COUNT=X SHOULD BE Y (ADJUST)]}
        !          1176: 
        !          1177: The link count for inode |b(I), which is a file, is |b(X) but should be |b(Y).
        !          1178: The owner |b(O), mode |b(M), size |b(S), and modify time |b(T) are printed.
        !          1179: See Section |remember(Link count.).
        !          1180: |p
        !          1181: Possible responses to the |s(ADJUST) prompt are:
        !          1182: 
        !          1183: |blank_space(1)
        !          1184: |begin(text_list)
        !          1185: 
        !          1186: |S(|item(YES)) replace the link count of file inode |b(I) with |b(Y).
        !          1187: 
        !          1188: |S(|item(NO)) ignore this error condition.
        !          1189: 
        !          1190: |end(text_list)
        !          1191: 
        !          1192: |unnumbered_subsection{|cw[LINK COUNT DIR I=I OWNER=O MODE=M SIZE=S MTIME=T COUNT=X SHOULD BE Y (ADJUST)]}
        !          1193: 
        !          1194: The link count for inode |b(I),
        !          1195: which is a directory, is |b(X) but should be |b(Y).
        !          1196: The owner |b(O), mode |b(M), size |b(S),
        !          1197: and modify time |b(T) of directory inode |b(I) are printed.
        !          1198: See Section |remember(Link count.).
        !          1199: |p
        !          1200: Possible responses to the |s(ADJUST) prompt are:
        !          1201: 
        !          1202: |blank_space(1)
        !          1203: |begin(text_list)
        !          1204: 
        !          1205: |S(|item(YES)) replace the link count of directory inode |b(I) with |b(Y).
        !          1206: 
        !          1207: |S(|item(NO)) ignore this error condition.
        !          1208: 
        !          1209: |end(text_list)
        !          1210: 
        !          1211: |unnumbered_subsection{|cw[LINK COUNT F I=I OWNER=O MODE=M SIZE=S MTIME=T COUNT=X SHOULD BE Y (ADJUST)]}
        !          1212: 
        !          1213: The link count for inode |b(I) is |b(X) but should be |b(Y).
        !          1214: The name |b(F), owner |b(O), mode |b(M), size |b(S),
        !          1215: and modify time |b(T) are printed.
        !          1216: See Section |remember(Link count.).
        !          1217: |p
        !          1218: Possible responses to the |s(ADJUST) prompt are:
        !          1219: 
        !          1220: |blank_space(1)
        !          1221: |begin(text_list)
        !          1222: 
        !          1223: |S(|item(YES)) replace the link count of inode |b(I) with |b(Y).
        !          1224: 
        !          1225: |S(|item(NO)) ignore this error condition.
        !          1226: 
        !          1227: |end(text_list)
        !          1228: 
        !          1229: |unnumbered_subsection{|cw[UNREF FILE I=I OWNER=O MODE=M SIZE=S MTIME=T (CLEAR)]}
        !          1230: 
        !          1231: Inode |b(I), which is a file,
        !          1232: was not connected to a directory entry when the file system was traversed.
        !          1233: The owner |b(O), mode |b(M), size |b(S),
        !          1234: and modify time |b(T) of inode |b(I) are printed.
        !          1235: See Sections |remember(Link count.) and |remember(Data Blocks).
        !          1236: |p
        !          1237: Possible responses to the |s(CLEAR) prompt are:
        !          1238: 
        !          1239: |blank_space(1)
        !          1240: |begin(text_list)
        !          1241: 
        !          1242: |S(|item(YES)) de-allocate inode |b(I) by zeroing its contents.
        !          1243: 
        !          1244: |S(|item(NO)) ignore this error condition.
        !          1245: 
        !          1246: |end(text_list)
        !          1247: 
        !          1248: |unnumbered_subsection{|cw[UNREF DIR I=I OWNER=O MODE=M SIZE=S MTIME=T (CLEAR)]}
        !          1249: 
        !          1250: Inode |b(I), which is a directory,
        !          1251: was not connected to a directory entry when the file system was traversed.
        !          1252: The owner |b(O), mode |b(M), size |b(S),
        !          1253: and modify time |b(T) of inode |b(I) are printed.
        !          1254: See Sections |remember(Link count.) and |remember(Data Blocks).
        !          1255: |p
        !          1256: Possible responses to the |s(CLEAR) prompt are:
        !          1257: 
        !          1258: |blank_space(1)
        !          1259: |begin(text_list)
        !          1260: 
        !          1261: |S(|item(YES)) de-allocate inode |b(I) by zeroing its contents.
        !          1262: 
        !          1263: |S(|item(NO)) ignore this error condition.
        !          1264: 
        !          1265: |end(text_list)
        !          1266: 
        !          1267: |unnumbered_subsection{|cw[BAD/DUP FILE I=I OWNER=O MODE=M SIZE=S MTIME=T (CLEAR)]}
        !          1268: 
        !          1269: Phase 1 or Phase 1b has found duplicate blocks or bad blocks
        !          1270: associated with file inode |b(I).
        !          1271: The owner |b(O), mode |b(M), size |b(S),
        !          1272: and modify time |b(T) of inode |b(I) are printed.
        !          1273: See Sections |remember(Duplicate blocks) and |remember(Bad blocks).
        !          1274: |p
        !          1275: Possible responses to the |s(CLEAR) prompt are:
        !          1276: 
        !          1277: |blank_space(1)
        !          1278: |begin(text_list)
        !          1279: 
        !          1280: |S(|item(YES)) de-allocate inode |b(I) by zeroing its contents.
        !          1281: 
        !          1282: |S(|item(NO)) ignore this error condition.
        !          1283: 
        !          1284: |end(text_list)
        !          1285: 
        !          1286: |unnumbered_subsection{|cw[BAD/DUP DIR I=I OWNER=O MODE=M SIZE=S MTIME=T (CLEAR)]}
        !          1287: 
        !          1288: Phase 1 or Phase 1b has found duplicate blocks or bad blocks
        !          1289: associated with directory inode |b(I).
        !          1290: The owner |b(O), mode |b(M), size |b(S),
        !          1291: and modify time |b(T) of inode |b(I) are printed.
        !          1292: See Sections |remember(Duplicate blocks) and |remember(Bad blocks).
        !          1293: |p
        !          1294: Possible responses to the |s(CLEAR) prompt are:
        !          1295: 
        !          1296: |blank_space(1)
        !          1297: |begin(text_list)
        !          1298: 
        !          1299: |S(|item(YES)) de-allocate inode |b(I) by zeroing its contents.
        !          1300: 
        !          1301: |S(|item(NO)) ignore this error condition.
        !          1302: 
        !          1303: |end(text_list)
        !          1304: 
        !          1305: |unnumbered_subsection{|cw[FREE INODE COUNT WRONG IN SUPERBLK (FIX)]}
        !          1306: 
        !          1307: The real count of the free inodes
        !          1308: does not match the count in the super-block of the file system.
        !          1309: See Section |remember(Free inode count.).
        !          1310: |p
        !          1311: Possible responses to the |s(FIX) prompt are:
        !          1312: 
        !          1313: |blank_space(1)
        !          1314: |begin(text_list)
        !          1315: 
        !          1316: |S(|item(YES)) replace the count in the super-block by the real count.
        !          1317: 
        !          1318: |S(|item(NO)) ignore this error condition.
        !          1319: 
        !          1320: |end(text_list)
        !          1321: 
        !          1322: |section(Phase 5: Check free list)
        !          1323: 
        !          1324: This phase concerns itself with the free block list.
        !          1325: This section lists error conditions resulting from
        !          1326: bad blocks in the free block list,
        !          1327: bad free blocks count,
        !          1328: duplicate blocks in the free block list,
        !          1329: unused blocks from the file system not in the free block list,
        !          1330: and an incorrect total free block count.
        !          1331: 
        !          1332: |unnumbered_subsection{|cw[EXCESSIVE BAD BLKS IN FREE LIST (CONTINUE)]}
        !          1333: 
        !          1334: The free block list contains more than a tolerable number (usually 10)
        !          1335: of blocks with a value less than the first data block in the file system
        !          1336: or greater than the last block in the file system.
        !          1337: See Sections |remember(Free block list.) and |remember(Bad blocks).
        !          1338: |p
        !          1339: Possible responses to the |s(CONTINUE) prompt are:
        !          1340: 
        !          1341: |blank_space(1)
        !          1342: |begin(text_list)
        !          1343: 
        !          1344: |S(|item(YES)) ignore the rest of the free block list
        !          1345: and continue the execution of |i(fsck).
        !          1346: This error condition will always invoke
        !          1347: the |s(BAD) |s(BLKS) |s(IN) |s(FREE) |s(LIST) error condition in Phase 5.
        !          1348: 
        !          1349: |S(|item(NO)) stop the program.
        !          1350: 
        !          1351: |end(text_list)
        !          1352: 
        !          1353: |unnumbered_subsection{|cw[EXCESSIVE DUP BLKS IN FREE LIST (CONTINUE)]}
        !          1354: 
        !          1355: The free block list contains more than a tolerable number (usually 10)
        !          1356: of blocks claimed by inodes or earlier parts of the free block list.
        !          1357: See Sections |remember(Free block list.) and |remember(Duplicate blocks).
        !          1358: |p
        !          1359: Possible responses to the |s(CONTINUE) prompt are:
        !          1360: 
        !          1361: |blank_space(1)
        !          1362: |begin(text_list)
        !          1363: 
        !          1364: |S(|item(YES)) ignore the rest of the free block list
        !          1365: and continue the execution of |i(fsck).
        !          1366: This error condition will always invoke
        !          1367: the |s(DUP) |s(BLKS) |s(IN) |s(FREE) |s(LIST) error condition in Phase 5.
        !          1368: 
        !          1369: |S(|item(NO)) stop the program.
        !          1370: 
        !          1371: |end(text_list)
        !          1372: 
        !          1373: |unnumbered_subsection{|cw[BAD FREEBLK COUNT]}
        !          1374: 
        !          1375: The count of free blocks in a free list block is greater than 50
        !          1376: or less than zero.
        !          1377: This error condition will always invoke
        !          1378: the |s(BAD) |s(FREE) |s(LIST) condition in Phase 5.
        !          1379: See Section |remember(Free block list.).
        !          1380: 
        !          1381: |unnumbered_subsection{|cw[X BAD BLKS IN FREE LIST]}
        !          1382: 
        !          1383: |b(X) blocks in the free block list
        !          1384: have a block number lower than the first data block in the file system
        !          1385: or greater than the last block in the file system.
        !          1386: This error condition will always invoke
        !          1387: the |s(BAD) |s(FREE) |s(LIST) condition in Phase 5.
        !          1388: See Sections |remember(Free block list.) and |remember(Bad blocks).
        !          1389: 
        !          1390: |unnumbered_subsection{|cw[X DUP BLKS IN FREE LIST]}
        !          1391: 
        !          1392: |b(X) blocks claimed by inodes or earlier parts of the free list block
        !          1393: were found in the free block list.
        !          1394: This error condition will always invoke
        !          1395: the |s(BAD) |s(FREE) |s(LIST) condition in Phase 5.
        !          1396: See Sections |remember(Free block list.) and |remember(Duplicate blocks).
        !          1397: 
        !          1398: |unnumbered_subsection{|cw[X BLK(S) MISSING]}
        !          1399: 
        !          1400: |b(X) blocks unused by the file system were not found in the free block list.
        !          1401: This error condition will always invoke
        !          1402: the |s(BAD) |s(FREE) |s(LIST) condition in Phase 5.
        !          1403: See Section |remember(Free block list.).
        !          1404: 
        !          1405: |unnumbered_subsection{|cw[FREE BLK COUNT WRONG IN SUPERBLOCK (FIX)]}
        !          1406: 
        !          1407: The real count of free blocks
        !          1408: does not match the count in the super-block of the file system.
        !          1409: See Section |remember(Free block count.).
        !          1410: |p
        !          1411: Possible responses to the |s(FIX) prompt are:
        !          1412: 
        !          1413: |blank_space(1)
        !          1414: |begin(text_list)
        !          1415: 
        !          1416: |S(|item(YES)) replace the count in the super-block by the real count.
        !          1417: 
        !          1418: |S(|item(NO)) ignore this error condition.
        !          1419: 
        !          1420: |end(text_list)
        !          1421: 
        !          1422: |unnumbered_subsection{|cw[BAD FREE LIST (SALVAGE)]}
        !          1423: 
        !          1424: Phase 5 has found
        !          1425: bad blocks in the free block list,
        !          1426: duplicate blocks in the free block list,
        !          1427: or blocks missing from the file system.
        !          1428: See Sections |remember(Free block list.), |remember(Duplicate blocks),
        !          1429: and |remember(Bad blocks).
        !          1430: |p
        !          1431: Possible responses to the |s(SALVAGE) prompt are:
        !          1432: 
        !          1433: |blank_space(1)
        !          1434: |begin(text_list)
        !          1435: 
        !          1436: |S(|item(YES)) replace the current free block list with a new free block list.
        !          1437: The new free block list will be ordered to reduce time
        !          1438: spent by the disk waiting to rotate into position.
        !          1439: 
        !          1440: |S(|item(NO)) ignore this error condition.
        !          1441: 
        !          1442: |end(text_list)
        !          1443: 
        !          1444: |section(Phase 6: Salvage free list)
        !          1445: 
        !          1446: This phase concerns itself with the free block list reconstruction.
        !          1447: This section lists error conditions resulting from
        !          1448: the blocks-to-skip and blocks-per-cylinder values.
        !          1449: 
        !          1450: |unnumbered_subsection{|cw[Default free block list spacing assumed]}
        !          1451: 
        !          1452: This is an advisory message
        !          1453: showing that the blocks-to-skip is greater than the blocks-per-cylinder,
        !          1454: the blocks-to-skip is less than one,
        !          1455: the blocks-per-cylinder is less than one,
        !          1456: or the blocks-per-cylinder is greater than 500.
        !          1457: The default values of 9 blocks-to-skip and 400 blocks-per-cylinder are used.
        !          1458: See the |i(fsck)(1M) manual entry for further detail.
        !          1459: 
        !          1460: |section(Cleanup)
        !          1461: 
        !          1462: Once a file system has been checked, a few cleanup functions are performed.
        !          1463: This section lists advisory messages about
        !          1464: the file system
        !          1465: and its modified status.
        !          1466: 
        !          1467: |unnumbered_subsection{|cw[X files Y blocks Z free]}
        !          1468: 
        !          1469: This is an advisory message showing that the file system checked
        !          1470: contained |b(X) files
        !          1471: using |b(Y) blocks
        !          1472: leaving |b(Z) blocks free in the file system.
        !          1473: 
        !          1474: |unnumbered_subsection{|cw[***** BOOT UNIX (NO SYNC!) *****]}
        !          1475: 
        !          1476: This is an advisory message showing that a mounted file system
        !          1477: or the root file system has been modified by |i(fsck).
        !          1478: If |s(UNIX) is not rebooted immediately,
        !          1479: the work done by |i(fsck)
        !          1480: may be undone by the in-core copies of tables kept by |s(UNIX).
        !          1481: 
        !          1482: |unnumbered_subsection{|cw[***** FILE SYSTEM WAS MODIFIED *****]}
        !          1483: 
        !          1484: This is an advisory message showing that the current file system
        !          1485: was modified by |i(fsck).
        !          1486: If this file system is mounted or is the current root file system,
        !          1487: |i(fsck) should be halted and |s(UNIX) rebooted.
        !          1488: If |s(UNIX) is not rebooted immediately,
        !          1489: the work done by |i(fsck)
        !          1490: may be undone by the in-core copies of tables kept by |s(UNIX).

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.