1 /* vi: set sw=4 ts=4: */
3 * fsck.c - a file system consistency checker for Linux.
5 * (C) 1991, 1992 Linus Torvalds. This file may be redistributed
6 * as per the GNU copyleft.
10 * 09.11.91 - made the first rudimentary functions
12 * 10.11.91 - updated, does checking, no repairs yet.
13 * Sent out to the mailing-list for testing.
15 * 14.11.91 - Testing seems to have gone well. Added some
16 * correction-code, and changed some functions.
18 * 15.11.91 - More correction code. Hopefully it notices most
19 * cases now, and tries to do something about them.
21 * 16.11.91 - More corrections (thanks to Mika Jalava). Most
22 * things seem to work now. Yeah, sure.
25 * 19.04.92 - Had to start over again from this old version, as a
26 * kernel bug ate my enhanced fsck in february.
28 * 28.02.93 - added support for different directory entry sizes..
30 * Sat Mar 6 18:59:42 1993, faith@cs.unc.edu: Output namelen with
31 * super-block information
33 * Sat Oct 9 11:17:11 1993, faith@cs.unc.edu: make exit status conform
34 * to that required by fsutil
36 * Mon Jan 3 11:06:52 1994 - Dr. Wettstein (greg%wind.uucp@plains.nodak.edu)
37 * Added support for file system valid flag. Also
38 * added program_version variable and output of
39 * program name and version number when program
42 * 30.10.94 - added support for v2 filesystem
43 * (Andreas Schwab, schwab@issan.informatik.uni-dortmund.de)
45 * 10.12.94 - added test to prevent checking of mounted fs adapted
46 * from Theodore Ts'o's (tytso@athena.mit.edu) e2fsck
47 * program. (Daniel Quinlan, quinlan@yggdrasil.com)
49 * 01.07.96 - Fixed the v2 fs stuff to use the right #defines and such
50 * for modern libcs (janl@math.uio.no, Nicolai Langfeldt)
52 * 02.07.96 - Added C bit fiddling routines from rmk@ecs.soton.ac.uk
53 * (Russell King). He made them for ARM. It would seem
54 * that the ARM is powerful enough to do this in C whereas
55 * i386 and m64k must use assembly to get it fast >:-)
56 * This should make minix fsck system-independent.
57 * (janl@math.uio.no, Nicolai Langfeldt)
59 * 04.11.96 - Added minor fixes from Andreas Schwab to avoid compiler
60 * warnings. Added mc68k bitops from
61 * Joerg Dorchain <dorchain@mpi-sb.mpg.de>.
63 * 06.11.96 - Added v2 code submitted by Joerg Dorchain, but written by
66 * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@misiek.eu.org>
67 * - added Native Language Support
70 * I've had no time to add comments - hopefully the function names
71 * are comments enough. As with all file system checkers, this assumes
72 * the file system is quiescent - don't use it on a mounted device
73 * unless you can be sure nobody is writing to it (and remember that the
74 * kernel can write to it when it searches for files).
76 * Usage: fsck [-larvsm] device
77 * -l for a listing of all the filenames
78 * -a for automatic repairs (not implemented)
79 * -r for repairs (interactive) (not implemented)
80 * -v for verbose (tells how many files)
81 * -s for super-block info
82 * -m for minix-like "mode not cleared" warnings
83 * -f force filesystem check even if filesystem marked as valid
85 * The device may be a block device or a image of one, but this isn't
86 * enforced (but it's not much fun on a character device :-).
98 #include <sys/param.h>
101 #define BLOCK_SIZE_BITS 10
102 #define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
105 * This is the original minix inode layout on disk.
106 * Note the 8-bit gid and atime and ctime.
119 * The new minix inode has all the time entries, as well as
120 * long block numbers and a third indirect block (7+1+1+1
121 * instead of 7+1+1). Also, some previously 8-bit values are
122 * now 16-bit. The inode is now 64 bytes instead of 32.
124 struct minix2_inode {
138 MINIX_LINK_MAX = 250,
139 MINIX2_LINK_MAX = 65530,
141 MINIX_I_MAP_SLOTS = 8,
142 MINIX_Z_MAP_SLOTS = 64,
143 MINIX_SUPER_MAGIC = 0x137F, /* original minix fs */
144 MINIX_SUPER_MAGIC2 = 0x138F, /* minix fs, 30 char names */
145 MINIX2_SUPER_MAGIC = 0x2468, /* minix V2 fs */
146 MINIX2_SUPER_MAGIC2 = 0x2478, /* minix V2 fs, 30 char names */
147 MINIX_VALID_FS = 0x0001, /* Clean fs. */
148 MINIX_ERROR_FS = 0x0002, /* fs has errors. */
150 MINIX_INODES_PER_BLOCK = ((BLOCK_SIZE)/(sizeof (struct minix_inode))),
151 MINIX2_INODES_PER_BLOCK = ((BLOCK_SIZE)/(sizeof (struct minix2_inode))),
153 MINIX_V1 = 0x0001, /* original minix fs */
154 MINIX_V2 = 0x0002 /* minix V2 fs */
157 #define INODE_VERSION(inode) inode->i_sb->u.minix_sb.s_version
160 * minix super-block data on disk
162 struct minix_super_block {
165 uint16_t s_imap_blocks;
166 uint16_t s_zmap_blocks;
167 uint16_t s_firstdatazone;
168 uint16_t s_log_zone_size;
175 struct minix_dir_entry {
181 #define NAME_MAX 255 /* # chars in a file name */
183 #define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
186 #define BLKGETSIZE _IO(0x12,96) /* return device size */
193 enum { ROOT_INO = 1 };
195 #define UPPER(size,n) ((size+((n)-1))/(n))
196 #define INODE_SIZE (sizeof(struct minix_inode))
197 #ifdef CONFIG_FEATURE_MINIX2
198 #define INODE_SIZE2 (sizeof(struct minix2_inode))
199 #define INODE_BLOCKS UPPER(INODES, (version2 ? MINIX2_INODES_PER_BLOCK \
200 : MINIX_INODES_PER_BLOCK))
202 #define INODE_BLOCKS UPPER(INODES, (MINIX_INODES_PER_BLOCK))
204 #define INODE_BUFFER_SIZE (INODE_BLOCKS * BLOCK_SIZE)
206 #define BITS_PER_BLOCK (BLOCK_SIZE<<3)
208 static char *program_version = "1.2 - 11/11/96";
209 static char *device_name;
211 static int repair, automatic, verbose, list, show, warn_mode, force;
212 static int directory, regular, blockdev, chardev, links, symlinks, total;
214 static int changed; /* flags if the filesystem has been changed */
215 static int errors_uncorrected; /* flag if some error was not corrected */
216 static int dirsize = 16;
217 static int namelen = 14;
218 static struct termios termios;
219 static int termios_set;
221 static char *inode_buffer;
222 #define Inode (((struct minix_inode *) inode_buffer)-1)
223 #define Inode2 (((struct minix2_inode *) inode_buffer)-1)
224 static char super_block_buffer[BLOCK_SIZE];
226 #define Super (*(struct minix_super_block *)super_block_buffer)
227 #define INODES ((unsigned long)Super.s_ninodes)
228 #ifdef CONFIG_FEATURE_MINIX2
230 #define ZONES ((unsigned long)(version2 ? Super.s_zones : Super.s_nzones))
232 #define ZONES ((unsigned long)(Super.s_nzones))
234 #define IMAPS ((unsigned long)Super.s_imap_blocks)
235 #define ZMAPS ((unsigned long)Super.s_zmap_blocks)
236 #define FIRSTZONE ((unsigned long)Super.s_firstdatazone)
237 #define ZONESIZE ((unsigned long)Super.s_log_zone_size)
238 #define MAXSIZE ((unsigned long)Super.s_max_size)
239 #define MAGIC (Super.s_magic)
240 #define NORM_FIRSTZONE (2+IMAPS+ZMAPS+INODE_BLOCKS)
242 static char *inode_map;
243 static char *zone_map;
245 static unsigned char *inode_count;
246 static unsigned char *zone_count;
248 static void recursive_check(unsigned int ino);
249 #ifdef CONFIG_FEATURE_MINIX2
250 static void recursive_check2(unsigned int ino);
253 static inline int bit(char * a,unsigned int i)
255 return (a[i >> 3] & (1<<(i & 7))) != 0;
257 #define inode_in_use(x) (bit(inode_map,(x)))
258 #define zone_in_use(x) (bit(zone_map,(x)-FIRSTZONE+1))
260 #define mark_inode(x) (setbit(inode_map,(x)),changed=1)
261 #define unmark_inode(x) (clrbit(inode_map,(x)),changed=1)
263 #define mark_zone(x) (setbit(zone_map,(x)-FIRSTZONE+1),changed=1)
264 #define unmark_zone(x) (clrbit(zone_map,(x)-FIRSTZONE+1),changed=1)
266 static void leave(int) ATTRIBUTE_NORETURN;
267 static void leave(int status)
270 tcsetattr(0, TCSANOW, &termios);
274 static void die(const char *str)
276 bb_error_msg("%s", str);
281 enum { MAX_DEPTH = 32 };
282 static int name_depth;
283 static char *current_name;
284 static char *name_component[MAX_DEPTH+1];
286 /* Wed Feb 9 15:17:06 MST 2000 */
287 /* dynamically allocate name_list (instead of making it static) */
288 static inline void alloc_current_name(void)
290 current_name = xmalloc(MAX_DEPTH * (BUFSIZ + 1));
291 current_name[0] = '/';
292 current_name[1] = '\0';
293 name_component[0] = ¤t_name[0];
296 #ifdef CONFIG_FEATURE_CLEAN_UP
297 /* execute this atexit() to deallocate name_list[] */
298 /* piptigger was here */
299 static inline void free_current_name(void)
305 static void push_filename(const char *name)
309 // [0] [1] [2] <-name_component[i]
310 if (name_depth < MAX_DEPTH) {
312 char *p = name_component[name_depth];
314 len = sprintf(p, "%.*s", namelen, name);
315 name_component[name_depth + 1] = p + len;
320 static void pop_filename(void) {
322 if (name_depth < MAX_DEPTH) {
323 *name_component[name_depth] = '\0';
325 current_name[0] = '/';
326 current_name[1] = '\0';
331 static int ask(const char *string, int def)
337 errors_uncorrected = 1;
343 errors_uncorrected = 1;
346 printf(def ? "%s (y/n)? " : "%s (n/y)? ", string);
349 if ((c = getchar()) == EOF) {
351 errors_uncorrected = 1;
358 } else if (c == 'N') {
361 } else if (c == ' ' || c == '\n')
368 errors_uncorrected = 1;
374 * Make certain that we aren't checking a filesystem that is on a
375 * mounted partition. Code adapted from e2fsck, Copyright (C) 1993,
376 * 1994 Theodore Ts'o. Also licensed under GPL.
378 static void check_mount(void)
385 if ((f = setmntent(MOUNTED, "r")) == NULL)
387 while ((mnt = getmntent(f)) != NULL)
388 if (strcmp(device_name, mnt->mnt_fsname) == 0)
395 * If the root is mounted read-only, then /etc/mtab is
396 * probably not correct; so we won't issue a warning based on
399 fd = open(MOUNTED, O_RDWR);
400 if (fd < 0 && errno == EROFS)
405 printf("%s is mounted. ", device_name);
407 if (isatty(0) && isatty(1))
408 cont = ask("Do you really want to continue", 0);
410 printf("Check aborted\n");
417 * check_zone_nr checks to see that *nr is a valid zone nr. If it
418 * isn't, it will possibly be repaired. Check_zone_nr sets *corrected
419 * if an error was corrected, and returns the zone (0 for no zone
420 * or a bad zone-number).
422 static int check_zone_nr2(uint32_t *nr, int *corrected)
429 else if (*nr >= ZONES)
433 printf("Zone nr %s in file '%s'.", msg, current_name);
434 if (ask("Remove block", 1)) {
441 static int check_zone_nr(uint16_t *nr, int *corrected)
444 int r = check_zone_nr2(&nr32, corrected);
445 *nr = (uint16_t)nr32;
450 * read-block reads block nr into the buffer at addr.
452 static void read_block(unsigned int nr, char *addr)
455 memset(addr, 0, BLOCK_SIZE);
458 if (BLOCK_SIZE * nr != lseek(IN, BLOCK_SIZE * nr, SEEK_SET)) {
459 printf("%s: unable to seek to block in file '%s'\n",
460 bb_msg_read_error, current_name);
461 errors_uncorrected = 1;
462 memset(addr, 0, BLOCK_SIZE);
463 } else if (BLOCK_SIZE != read(IN, addr, BLOCK_SIZE)) {
464 printf("%s: bad block in file '%s'\n",
465 bb_msg_read_error, current_name);
466 errors_uncorrected = 1;
467 memset(addr, 0, BLOCK_SIZE);
472 * write_block writes block nr to disk.
474 static void write_block(unsigned int nr, char *addr)
478 if (nr < FIRSTZONE || nr >= ZONES) {
479 printf("Internal error: trying to write bad block\n"
480 "Write request ignored\n");
481 errors_uncorrected = 1;
484 if (BLOCK_SIZE * nr != lseek(IN, BLOCK_SIZE * nr, SEEK_SET))
485 die("seek failed in write_block");
486 if (BLOCK_SIZE != write(IN, addr, BLOCK_SIZE)) {
487 printf("%s: bad block in file '%s'\n",
488 bb_msg_write_error, current_name);
489 errors_uncorrected = 1;
494 * map_block calculates the absolute block nr of a block in a file.
495 * It sets 'changed' if the inode has needed changing, and re-writes
496 * any indirect blocks with errors.
498 static int map_block(struct minix_inode *inode, unsigned int blknr)
500 uint16_t ind[BLOCK_SIZE >> 1];
501 uint16_t dind[BLOCK_SIZE >> 1];
502 int blk_chg, block, result;
505 return check_zone_nr(inode->i_zone + blknr, &changed);
508 block = check_zone_nr(inode->i_zone + 7, &changed);
509 read_block(block, (char *) ind);
511 result = check_zone_nr(blknr + ind, &blk_chg);
513 write_block(block, (char *) ind);
517 block = check_zone_nr(inode->i_zone + 8, &changed);
518 read_block(block, (char *) dind);
520 result = check_zone_nr(dind + (blknr / 512), &blk_chg);
522 write_block(block, (char *) dind);
524 read_block(block, (char *) ind);
526 result = check_zone_nr(ind + (blknr % 512), &blk_chg);
528 write_block(block, (char *) ind);
532 #ifdef CONFIG_FEATURE_MINIX2
533 static int map_block2(struct minix2_inode *inode, unsigned int blknr)
535 uint32_t ind[BLOCK_SIZE >> 2];
536 uint32_t dind[BLOCK_SIZE >> 2];
537 uint32_t tind[BLOCK_SIZE >> 2];
538 int blk_chg, block, result;
541 return check_zone_nr2(inode->i_zone + blknr, &changed);
544 block = check_zone_nr2(inode->i_zone + 7, &changed);
545 read_block(block, (char *) ind);
547 result = check_zone_nr2(blknr + ind, &blk_chg);
549 write_block(block, (char *) ind);
553 if (blknr >= 256 * 256) {
554 block = check_zone_nr2(inode->i_zone + 8, &changed);
555 read_block(block, (char *) dind);
557 result = check_zone_nr2(dind + blknr / 256, &blk_chg);
559 write_block(block, (char *) dind);
561 read_block(block, (char *) ind);
563 result = check_zone_nr2(ind + blknr % 256, &blk_chg);
565 write_block(block, (char *) ind);
569 block = check_zone_nr2(inode->i_zone + 9, &changed);
570 read_block(block, (char *) tind);
572 result = check_zone_nr2(tind + blknr / (256 * 256), &blk_chg);
574 write_block(block, (char *) tind);
576 read_block(block, (char *) dind);
578 result = check_zone_nr2(dind + (blknr / 256) % 256, &blk_chg);
580 write_block(block, (char *) dind);
582 read_block(block, (char *) ind);
584 result = check_zone_nr2(ind + blknr % 256, &blk_chg);
586 write_block(block, (char *) ind);
591 static void write_super_block(void)
594 * Set the state of the filesystem based on whether or not there
595 * are uncorrected errors. The filesystem valid flag is
596 * unconditionally set if we get this far.
598 Super.s_state |= MINIX_VALID_FS;
599 if (errors_uncorrected)
600 Super.s_state |= MINIX_ERROR_FS;
602 Super.s_state &= ~MINIX_ERROR_FS;
604 if (BLOCK_SIZE != lseek(IN, BLOCK_SIZE, SEEK_SET))
605 die("seek failed in write_super_block");
606 if (BLOCK_SIZE != write(IN, super_block_buffer, BLOCK_SIZE))
607 die("unable to write super-block");
610 static void write_tables(void)
614 if (IMAPS * BLOCK_SIZE != write(IN, inode_map, IMAPS * BLOCK_SIZE))
615 die("Unable to write inode map");
616 if (ZMAPS * BLOCK_SIZE != write(IN, zone_map, ZMAPS * BLOCK_SIZE))
617 die("Unable to write zone map");
618 if (INODE_BUFFER_SIZE != write(IN, inode_buffer, INODE_BUFFER_SIZE))
619 die("Unable to write inodes");
622 static void get_dirsize(void)
625 char blk[BLOCK_SIZE];
628 #ifdef CONFIG_FEATURE_MINIX2
630 block = Inode2[ROOT_INO].i_zone[0];
633 block = Inode[ROOT_INO].i_zone[0];
634 read_block(block, blk);
635 for (size = 16; size < BLOCK_SIZE; size <<= 1) {
636 if (strcmp(blk + size + 2, "..") == 0) {
645 static void read_superblock(void)
647 if (BLOCK_SIZE != lseek(IN, BLOCK_SIZE, SEEK_SET))
649 if (BLOCK_SIZE != read(IN, super_block_buffer, BLOCK_SIZE))
650 die("unable to read super block");
651 /* already initialized to:
656 if (MAGIC == MINIX_SUPER_MAGIC) {
657 } else if (MAGIC == MINIX_SUPER_MAGIC2) {
660 #ifdef CONFIG_FEATURE_MINIX2
661 } else if (MAGIC == MINIX2_SUPER_MAGIC) {
663 } else if (MAGIC == MINIX2_SUPER_MAGIC2) {
669 die("bad magic number in super-block");
670 if (ZONESIZE != 0 || BLOCK_SIZE != 1024)
671 die("Only 1k blocks/zones supported");
672 if (IMAPS * BLOCK_SIZE * 8 < INODES + 1)
673 die("bad s_imap_blocks field in super-block");
674 if (ZMAPS * BLOCK_SIZE * 8 < ZONES - FIRSTZONE + 1)
675 die("bad s_zmap_blocks field in super-block");
678 static void read_tables(void)
680 inode_map = xzalloc(IMAPS * BLOCK_SIZE);
681 zone_map = xzalloc(ZMAPS * BLOCK_SIZE);
682 inode_buffer = xmalloc(INODE_BUFFER_SIZE);
683 inode_count = xmalloc(INODES + 1);
684 zone_count = xmalloc(ZONES);
685 if (IMAPS * BLOCK_SIZE != read(IN, inode_map, IMAPS * BLOCK_SIZE))
686 die("Unable to read inode map");
687 if (ZMAPS * BLOCK_SIZE != read(IN, zone_map, ZMAPS * BLOCK_SIZE))
688 die("Unable to read zone map");
689 if (INODE_BUFFER_SIZE != read(IN, inode_buffer, INODE_BUFFER_SIZE))
690 die("Unable to read inodes");
691 if (NORM_FIRSTZONE != FIRSTZONE) {
692 printf("Warning: Firstzone != Norm_firstzone\n");
693 errors_uncorrected = 1;
697 printf("%ld inodes\n"
699 "Firstdatazone=%ld (%ld)\n"
702 "Filesystem state=%d\n"
706 FIRSTZONE, NORM_FIRSTZONE,
707 BLOCK_SIZE << ZONESIZE,
714 static struct minix_inode *get_inode(unsigned int nr)
716 struct minix_inode *inode;
718 if (!nr || nr > INODES)
722 if (!inode_count[nr]) {
723 if (!inode_in_use(nr)) {
724 printf("Inode %d marked not used, but used for file "
725 "'%s'\n", nr, current_name);
727 if (ask("Mark in use", 1))
730 errors_uncorrected = 1;
733 if (S_ISDIR(inode->i_mode))
735 else if (S_ISREG(inode->i_mode))
737 else if (S_ISCHR(inode->i_mode))
739 else if (S_ISBLK(inode->i_mode))
741 else if (S_ISLNK(inode->i_mode))
743 else if (S_ISSOCK(inode->i_mode));
744 else if (S_ISFIFO(inode->i_mode));
746 printf("%s has mode %05o\n", current_name, inode->i_mode);
751 if (!++inode_count[nr]) {
752 printf("Warning: inode count too big\n");
754 errors_uncorrected = 1;
759 #ifdef CONFIG_FEATURE_MINIX2
760 static struct minix2_inode *get_inode2(unsigned int nr)
762 struct minix2_inode *inode;
764 if (!nr || nr > INODES)
768 if (!inode_count[nr]) {
769 if (!inode_in_use(nr)) {
770 printf("Inode %d marked not used, but used for file "
771 "'%s'\n", nr, current_name);
773 if (ask("Mark in use", 1))
776 errors_uncorrected = 1;
779 if (S_ISDIR(inode->i_mode))
781 else if (S_ISREG(inode->i_mode))
783 else if (S_ISCHR(inode->i_mode))
785 else if (S_ISBLK(inode->i_mode))
787 else if (S_ISLNK(inode->i_mode))
789 else if (S_ISSOCK(inode->i_mode));
790 else if (S_ISFIFO(inode->i_mode));
792 printf("%s has mode %05o\n", current_name, inode->i_mode);
796 if (!++inode_count[nr]) {
797 printf("Warning: inode count too big\n");
799 errors_uncorrected = 1;
805 static void check_root(void)
807 struct minix_inode *inode = Inode + ROOT_INO;
809 if (!inode || !S_ISDIR(inode->i_mode))
810 die("root inode isn't a directory");
813 #ifdef CONFIG_FEATURE_MINIX2
814 static void check_root2(void)
816 struct minix2_inode *inode = Inode2 + ROOT_INO;
818 if (!inode || !S_ISDIR(inode->i_mode))
819 die("root inode isn't a directory");
823 static int add_zone(uint16_t *znr, int *corrected)
829 block = check_zone_nr(znr, corrected);
832 if (zone_count[block]) {
833 printf("Block has been used before. Now in file '%s'.",
835 if (ask("Clear", 1)) {
842 if (!zone_in_use(block)) {
843 printf("Block %d in file '%s' is marked not in use.",
844 block, current_name);
845 if (ask("Correct", 1))
848 if (!++zone_count[block])
853 #ifdef CONFIG_FEATURE_MINIX2
854 static int add_zone2(uint32_t *znr, int *corrected)
860 block = check_zone_nr2(znr, corrected);
863 if (zone_count[block]) {
864 printf("Block has been used before. Now in file '%s'.",
866 if (ask("Clear", 1)) {
873 if (!zone_in_use(block)) {
874 printf("Block %d in file '%s' is marked not in use.",
875 block, current_name);
876 if (ask("Correct", 1))
879 if (!++zone_count[block])
885 static void add_zone_ind(uint16_t *znr, int *corrected)
887 static char blk[BLOCK_SIZE];
891 block = add_zone(znr, corrected);
894 read_block(block, blk);
895 for (i = 0; i < (BLOCK_SIZE >> 1); i++)
896 add_zone(i + (uint16_t *) blk, &chg_blk);
898 write_block(block, blk);
901 #ifdef CONFIG_FEATURE_MINIX2
902 static void add_zone_ind2(uint32_t *znr, int *corrected)
904 static char blk[BLOCK_SIZE];
908 block = add_zone2(znr, corrected);
911 read_block(block, blk);
912 for (i = 0; i < BLOCK_SIZE >> 2; i++)
913 add_zone2(i + (uint32_t *) blk, &chg_blk);
915 write_block(block, blk);
919 static void add_zone_dind(uint16_t *znr, int *corrected)
921 static char blk[BLOCK_SIZE];
925 block = add_zone(znr, corrected);
928 read_block(block, blk);
929 for (i = 0; i < (BLOCK_SIZE >> 1); i++)
930 add_zone_ind(i + (uint16_t *) blk, &blk_chg);
932 write_block(block, blk);
935 #ifdef CONFIG_FEATURE_MINIX2
936 static void add_zone_dind2(uint32_t *znr, int *corrected)
938 static char blk[BLOCK_SIZE];
942 block = add_zone2(znr, corrected);
945 read_block(block, blk);
946 for (i = 0; i < BLOCK_SIZE >> 2; i++)
947 add_zone_ind2(i + (uint32_t *) blk, &blk_chg);
949 write_block(block, blk);
952 static void add_zone_tind2(uint32_t *znr, int *corrected)
954 static char blk[BLOCK_SIZE];
958 block = add_zone2(znr, corrected);
961 read_block(block, blk);
962 for (i = 0; i < BLOCK_SIZE >> 2; i++)
963 add_zone_dind2(i + (uint32_t *) blk, &blk_chg);
965 write_block(block, blk);
969 static void check_zones(unsigned int i)
971 struct minix_inode *inode;
973 if (!i || i > INODES)
975 if (inode_count[i] > 1) /* have we counted this file already? */
978 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
979 !S_ISLNK(inode->i_mode)) return;
980 for (i = 0; i < 7; i++)
981 add_zone(i + inode->i_zone, &changed);
982 add_zone_ind(7 + inode->i_zone, &changed);
983 add_zone_dind(8 + inode->i_zone, &changed);
986 #ifdef CONFIG_FEATURE_MINIX2
987 static void check_zones2(unsigned int i)
989 struct minix2_inode *inode;
991 if (!i || i > INODES)
993 if (inode_count[i] > 1) /* have we counted this file already? */
996 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode)
997 && !S_ISLNK(inode->i_mode))
999 for (i = 0; i < 7; i++)
1000 add_zone2(i + inode->i_zone, &changed);
1001 add_zone_ind2(7 + inode->i_zone, &changed);
1002 add_zone_dind2(8 + inode->i_zone, &changed);
1003 add_zone_tind2(9 + inode->i_zone, &changed);
1007 static void check_file(struct minix_inode *dir, unsigned int offset)
1009 static char blk[BLOCK_SIZE];
1010 struct minix_inode *inode;
1015 block = map_block(dir, offset / BLOCK_SIZE);
1016 read_block(block, blk);
1017 name = blk + (offset % BLOCK_SIZE) + 2;
1018 ino = *(uint16_t *) (name - 2);
1020 printf("%s contains a bad inode number for file '%.*s'.",
1021 current_name, namelen, name);
1022 if (ask(" Remove", 1)) {
1023 *(uint16_t *) (name - 2) = 0;
1024 write_block(block, blk);
1028 push_filename(name);
1029 inode = get_inode(ino);
1032 if (!inode || strcmp(".", name)) {
1033 printf("%s: bad directory: '.' isn't first\n", current_name);
1034 errors_uncorrected = 1;
1038 if (offset == dirsize) {
1039 if (!inode || strcmp("..", name)) {
1040 printf("%s: bad directory: '..' isn't second\n", current_name);
1041 errors_uncorrected = 1;
1047 push_filename(name);
1050 printf("%6d %07o %3d ", ino, inode->i_mode, inode->i_nlinks);
1051 printf("%s%s\n", current_name, S_ISDIR(inode->i_mode) ? ":" : "");
1054 if (inode && S_ISDIR(inode->i_mode))
1055 recursive_check(ino);
1060 #ifdef CONFIG_FEATURE_MINIX2
1061 static void check_file2(struct minix2_inode *dir, unsigned int offset)
1063 static char blk[BLOCK_SIZE];
1064 struct minix2_inode *inode;
1069 block = map_block2(dir, offset / BLOCK_SIZE);
1070 read_block(block, blk);
1071 name = blk + (offset % BLOCK_SIZE) + 2;
1072 ino = *(uint16_t *) (name - 2);
1074 printf("%s contains a bad inode number for file '%.*s'.",
1075 current_name, namelen, name);
1076 if (ask(" Remove", 1)) {
1077 *(uint16_t *) (name - 2) = 0;
1078 write_block(block, blk);
1082 push_filename(name);
1083 inode = get_inode2(ino);
1086 if (!inode || strcmp(".", name)) {
1087 printf("%s: bad directory: '.' isn't first\n", current_name);
1088 errors_uncorrected = 1;
1092 if (offset == dirsize) {
1093 if (!inode || strcmp("..", name)) {
1094 printf("%s: bad directory: '..' isn't second\n", current_name);
1095 errors_uncorrected = 1;
1101 push_filename(name);
1104 printf("%6d %07o %3d ", ino, inode->i_mode, inode->i_nlinks);
1105 printf("%s%s\n", current_name, S_ISDIR(inode->i_mode) ? ":" : "");
1108 if (inode && S_ISDIR(inode->i_mode))
1109 recursive_check2(ino);
1115 static void recursive_check(unsigned int ino)
1117 struct minix_inode *dir;
1118 unsigned int offset;
1121 if (!S_ISDIR(dir->i_mode))
1122 die("internal error");
1123 if (dir->i_size < 2 * dirsize) {
1124 printf("%s: bad directory: size<32", current_name);
1125 errors_uncorrected = 1;
1127 for (offset = 0; offset < dir->i_size; offset += dirsize)
1128 check_file(dir, offset);
1131 #ifdef CONFIG_FEATURE_MINIX2
1132 static void recursive_check2(unsigned int ino)
1134 struct minix2_inode *dir;
1135 unsigned int offset;
1138 if (!S_ISDIR(dir->i_mode))
1139 die("internal error");
1140 if (dir->i_size < 2 * dirsize) {
1141 printf("%s: bad directory: size<32", current_name);
1142 errors_uncorrected = 1;
1144 for (offset = 0; offset < dir->i_size; offset += dirsize)
1145 check_file2(dir, offset);
1149 static int bad_zone(int i)
1153 if (BLOCK_SIZE * i != lseek(IN, BLOCK_SIZE * i, SEEK_SET))
1154 die("seek failed in bad_zone");
1155 return (BLOCK_SIZE != read(IN, buffer, BLOCK_SIZE));
1158 static void check_counts(void)
1162 for (i = 1; i <= INODES; i++) {
1163 if (warn_mode && Inode[i].i_mode && !inode_in_use(i)) {
1164 printf("Inode %d mode not cleared.", i);
1165 if (ask("Clear", 1)) {
1166 Inode[i].i_mode = 0;
1170 if (!inode_count[i]) {
1171 if (!inode_in_use(i))
1173 printf("Inode %d not used, marked used in the bitmap.", i);
1174 if (ask("Clear", 1))
1178 if (!inode_in_use(i)) {
1179 printf("Inode %d used, marked unused in the bitmap.", i);
1183 if (Inode[i].i_nlinks != inode_count[i]) {
1184 printf("Inode %d (mode = %07o), i_nlinks=%d, counted=%d.",
1185 i, Inode[i].i_mode, Inode[i].i_nlinks, inode_count[i]);
1186 if (ask("Set i_nlinks to count", 1)) {
1187 Inode[i].i_nlinks = inode_count[i];
1192 for (i = FIRSTZONE; i < ZONES; i++) {
1193 if (zone_in_use(i) == zone_count[i])
1195 if (!zone_count[i]) {
1198 printf("Zone %d: marked in use, no file uses it.", i);
1199 if (ask("Unmark", 1))
1203 printf("Zone %d: %sin use, counted=%d\n",
1204 i, zone_in_use(i) ? "" : "not ", zone_count[i]);
1208 #ifdef CONFIG_FEATURE_MINIX2
1209 static void check_counts2(void)
1213 for (i = 1; i <= INODES; i++) {
1214 if (warn_mode && Inode2[i].i_mode && !inode_in_use(i)) {
1215 printf("Inode %d mode not cleared.", i);
1216 if (ask("Clear", 1)) {
1217 Inode2[i].i_mode = 0;
1221 if (!inode_count[i]) {
1222 if (!inode_in_use(i))
1224 printf("Inode %d not used, marked used in the bitmap.", i);
1225 if (ask("Clear", 1))
1229 if (!inode_in_use(i)) {
1230 printf("Inode %d used, marked unused in the bitmap.", i);
1234 if (Inode2[i].i_nlinks != inode_count[i]) {
1235 printf("Inode %d (mode = %07o), i_nlinks=%d, counted=%d.",
1236 i, Inode2[i].i_mode, Inode2[i].i_nlinks,
1238 if (ask("Set i_nlinks to count", 1)) {
1239 Inode2[i].i_nlinks = inode_count[i];
1244 for (i = FIRSTZONE; i < ZONES; i++) {
1245 if (zone_in_use(i) == zone_count[i])
1247 if (!zone_count[i]) {
1250 printf("Zone %d: marked in use, no file uses it.", i);
1251 if (ask("Unmark", 1))
1255 printf("Zone %d: %sin use, counted=%d\n",
1256 i, zone_in_use(i) ? "" : "not ", zone_count[i]);
1261 static void check(void)
1263 memset(inode_count, 0, (INODES + 1) * sizeof(*inode_count));
1264 memset(zone_count, 0, ZONES * sizeof(*zone_count));
1265 check_zones(ROOT_INO);
1266 recursive_check(ROOT_INO);
1270 #ifdef CONFIG_FEATURE_MINIX2
1271 static void check2(void)
1273 memset(inode_count, 0, (INODES + 1) * sizeof(*inode_count));
1274 memset(zone_count, 0, ZONES * sizeof(*zone_count));
1275 check_zones2(ROOT_INO);
1276 recursive_check2(ROOT_INO);
1281 int fsck_minix_main(int argc, char **argv)
1286 alloc_current_name();
1287 #ifdef CONFIG_FEATURE_CLEAN_UP
1288 /* Don't bother to free memory. Exit does
1289 * that automagically, so we can save a few bytes */
1290 atexit(free_current_name);
1293 if (INODE_SIZE * MINIX_INODES_PER_BLOCK != BLOCK_SIZE)
1294 die("bad inode size");
1295 #ifdef CONFIG_FEATURE_MINIX2
1296 if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE)
1297 die("bad v2 inode size");
1299 while (argc-- > 1) {
1301 if (argv[0][0] != '-') {
1305 device_name = argv[0];
1308 switch (argv[0][0]) {
1338 check_mount(); /* trying to check a mounted filesystem? */
1339 if (repair && !automatic) {
1340 if (!isatty(0) || !isatty(1))
1341 die("need terminal for interactive repairs");
1343 IN = open(device_name, repair ? O_RDWR : O_RDONLY);
1345 fprintf(stderr,"unable to open device '%s'\n",device_name);
1348 sync(); /* paranoia? */
1352 * Determine whether or not we should continue with the checking.
1353 * This is based on the status of the filesystem valid and error
1354 * flags and whether or not the -f switch was specified on the
1357 printf("%s, %s\n", bb_applet_name, program_version);
1358 if (!(Super.s_state & MINIX_ERROR_FS) &&
1359 (Super.s_state & MINIX_VALID_FS) && !force) {
1361 printf("%s is clean, no check\n", device_name);
1364 printf("Forcing filesystem check on %s\n", device_name);
1366 printf("Filesystem on %s is dirty, needs checking\n",
1371 if (repair && !automatic) {
1372 tcgetattr(0, &termios);
1374 tmp.c_lflag &= ~(ICANON | ECHO);
1375 tcsetattr(0, TCSANOW, &tmp);
1378 #ifdef CONFIG_FEATURE_MINIX2
1391 for (i = 1, free_cnt = 0; i <= INODES; i++)
1392 if (!inode_in_use(i))
1394 printf("\n%6ld inodes used (%ld%%)\n", (INODES - free_cnt),
1395 100 * (INODES - free_cnt) / INODES);
1396 for (i = FIRSTZONE, free_cnt = 0; i < ZONES; i++)
1397 if (!zone_in_use(i))
1399 printf("%6ld zones used (%ld%%)\n", (ZONES - free_cnt),
1400 100 * (ZONES - free_cnt) / ZONES);
1401 printf("\n%6d regular files\n"
1403 "%6d character device files\n"
1404 "%6d block device files\n"
1406 "%6d symbolic links\n"
1409 regular, directory, chardev, blockdev,
1410 links - 2 * directory + 1, symlinks,
1411 total - 2 * directory + 1);
1415 printf("----------------------------\n"
1416 "FILE SYSTEM HAS BEEN CHANGED\n"
1417 "----------------------------\n");
1420 write_super_block();
1422 if (repair && !automatic)
1423 tcsetattr(0, TCSANOW, &termios);
1427 if (errors_uncorrected)