![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fsck.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / vol2 / fsck|
Return to fsck.m CVS log | Up to [Research Unix] / researchv10dc / vol2 / fsck |
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.