aboutsummaryrefslogtreecommitdiff
path: root/fsck_minix.c
diff options
context:
space:
mode:
authorEric Andersen <andersen@codepoet.org>2001-10-24 05:00:29 +0000
committerEric Andersen <andersen@codepoet.org>2001-10-24 05:00:29 +0000
commitbdfd0d78bc44e73d693510e70087857785b3b521 (patch)
tree153a573095afac8d8d0ea857759ecabd77fb28b7 /fsck_minix.c
parent9260fc5552a3ee52eb95823aa6689d52a1ffd33c (diff)
downloadbusybox-w32-bdfd0d78bc44e73d693510e70087857785b3b521.tar.gz
busybox-w32-bdfd0d78bc44e73d693510e70087857785b3b521.tar.bz2
busybox-w32-bdfd0d78bc44e73d693510e70087857785b3b521.zip
Major rework of the directory structure and the entire build system.
-Erik
Diffstat (limited to 'fsck_minix.c')
-rw-r--r--fsck_minix.c1478
1 files changed, 0 insertions, 1478 deletions
diff --git a/fsck_minix.c b/fsck_minix.c
deleted file mode 100644
index 952968d85..000000000
--- a/fsck_minix.c
+++ /dev/null
@@ -1,1478 +0,0 @@
1/* vi: set sw=4 ts=4: */
2/*
3 * fsck.c - a file system consistency checker for Linux.
4 *
5 * (C) 1991, 1992 Linus Torvalds. This file may be redistributed
6 * as per the GNU copyleft.
7 */
8
9/*
10 * 09.11.91 - made the first rudimetary functions
11 *
12 * 10.11.91 - updated, does checking, no repairs yet.
13 * Sent out to the mailing-list for testing.
14 *
15 * 14.11.91 - Testing seems to have gone well. Added some
16 * correction-code, and changed some functions.
17 *
18 * 15.11.91 - More correction code. Hopefully it notices most
19 * cases now, and tries to do something about them.
20 *
21 * 16.11.91 - More corrections (thanks to Mika Jalava). Most
22 * things seem to work now. Yeah, sure.
23 *
24 *
25 * 19.04.92 - Had to start over again from this old version, as a
26 * kernel bug ate my enhanced fsck in february.
27 *
28 * 28.02.93 - added support for different directory entry sizes..
29 *
30 * Sat Mar 6 18:59:42 1993, faith@cs.unc.edu: Output namelen with
31 * super-block information
32 *
33 * Sat Oct 9 11:17:11 1993, faith@cs.unc.edu: make exit status conform
34 * to that required by fsutil
35 *
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
40 * is executed.
41 *
42 * 30.10.94 - added support for v2 filesystem
43 * (Andreas Schwab, schwab@issan.informatik.uni-dortmund.de)
44 *
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)
48 *
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)
51 *
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 systemindependent.
57 * (janl@math.uio.no, Nicolai Langfeldt)
58 *
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>.
62 *
63 * 06.11.96 - Added v2 code submitted by Joerg Dorchain, but written by
64 * Andreas Schwab.
65 *
66 * 1999-02-22 Arkadiusz Mi¶kiewicz <misiek@misiek.eu.org>
67 * - added Native Language Support
68 *
69 *
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).
75 *
76 * Usuage: 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
84 *
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 :-).
87 */
88
89#include <stdio.h>
90#include <errno.h>
91#include <unistd.h>
92#include <string.h>
93#include <fcntl.h>
94#include <ctype.h>
95#include <stdlib.h>
96#include <termios.h>
97#include <mntent.h>
98#include <sys/param.h>
99#include "busybox.h"
100
101static const int MINIX_ROOT_INO = 1;
102static const int MINIX_LINK_MAX = 250;
103static const int MINIX2_LINK_MAX = 65530;
104
105static const int MINIX_I_MAP_SLOTS = 8;
106static const int MINIX_Z_MAP_SLOTS = 64;
107static const int MINIX_SUPER_MAGIC = 0x137F; /* original minix fs */
108static const int MINIX_SUPER_MAGIC2 = 0x138F; /* minix fs, 30 char names */
109static const int MINIX2_SUPER_MAGIC = 0x2468; /* minix V2 fs */
110static const int MINIX2_SUPER_MAGIC2 = 0x2478; /* minix V2 fs, 30 char names */
111static const int MINIX_VALID_FS = 0x0001; /* Clean fs. */
112static const int MINIX_ERROR_FS = 0x0002; /* fs has errors. */
113
114#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
115#define MINIX2_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix2_inode)))
116
117static const int MINIX_V1 = 0x0001; /* original minix fs */
118static const int MINIX_V2 = 0x0002; /* minix V2 fs */
119
120#define INODE_VERSION(inode) inode->i_sb->u.minix_sb.s_version
121
122/*
123 * This is the original minix inode layout on disk.
124 * Note the 8-bit gid and atime and ctime.
125 */
126struct minix_inode {
127 u_int16_t i_mode;
128 u_int16_t i_uid;
129 u_int32_t i_size;
130 u_int32_t i_time;
131 u_int8_t i_gid;
132 u_int8_t i_nlinks;
133 u_int16_t i_zone[9];
134};
135
136/*
137 * The new minix inode has all the time entries, as well as
138 * long block numbers and a third indirect block (7+1+1+1
139 * instead of 7+1+1). Also, some previously 8-bit values are
140 * now 16-bit. The inode is now 64 bytes instead of 32.
141 */
142struct minix2_inode {
143 u_int16_t i_mode;
144 u_int16_t i_nlinks;
145 u_int16_t i_uid;
146 u_int16_t i_gid;
147 u_int32_t i_size;
148 u_int32_t i_atime;
149 u_int32_t i_mtime;
150 u_int32_t i_ctime;
151 u_int32_t i_zone[10];
152};
153
154/*
155 * minix super-block data on disk
156 */
157struct minix_super_block {
158 u_int16_t s_ninodes;
159 u_int16_t s_nzones;
160 u_int16_t s_imap_blocks;
161 u_int16_t s_zmap_blocks;
162 u_int16_t s_firstdatazone;
163 u_int16_t s_log_zone_size;
164 u_int32_t s_max_size;
165 u_int16_t s_magic;
166 u_int16_t s_state;
167 u_int32_t s_zones;
168};
169
170struct minix_dir_entry {
171 u_int16_t inode;
172 char name[0];
173};
174
175#define BLOCK_SIZE_BITS 10
176#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
177
178#define NAME_MAX 255 /* # chars in a file name */
179
180#define MINIX_INODES_PER_BLOCK ((BLOCK_SIZE)/(sizeof (struct minix_inode)))
181
182#ifndef BLKGETSIZE
183#define BLKGETSIZE _IO(0x12,96) /* return device size */
184#endif
185
186#ifndef __linux__
187#define volatile
188#endif
189
190static const int ROOT_INO = 1;
191
192#define UPPER(size,n) ((size+((n)-1))/(n))
193#define INODE_SIZE (sizeof(struct minix_inode))
194#ifdef BB_FEATURE_MINIX2
195#define INODE_SIZE2 (sizeof(struct minix2_inode))
196#define INODE_BLOCKS UPPER(INODES, (version2 ? MINIX2_INODES_PER_BLOCK \
197 : MINIX_INODES_PER_BLOCK))
198#else
199#define INODE_BLOCKS UPPER(INODES, (MINIX_INODES_PER_BLOCK))
200#endif
201#define INODE_BUFFER_SIZE (INODE_BLOCKS * BLOCK_SIZE)
202
203#define BITS_PER_BLOCK (BLOCK_SIZE<<3)
204
205static char *program_version = "1.2 - 11/11/96";
206static char *device_name = NULL;
207static int IN;
208static int repair = 0, automatic = 0, verbose = 0, list = 0, show =
209 0, warn_mode = 0, force = 0;
210static int directory = 0, regular = 0, blockdev = 0, chardev = 0, links =
211 0, symlinks = 0, total = 0;
212
213static int changed = 0; /* flags if the filesystem has been changed */
214static int errors_uncorrected = 0; /* flag if some error was not corrected */
215static int dirsize = 16;
216static int namelen = 14;
217static int version2 = 0;
218static struct termios termios;
219static int termios_set = 0;
220
221/* File-name data */
222static const int MAX_DEPTH = 32;
223static int name_depth = 0;
224// static char name_list[MAX_DEPTH][BUFSIZ + 1];
225static char **name_list = NULL;
226
227static char *inode_buffer = NULL;
228
229#define Inode (((struct minix_inode *) inode_buffer)-1)
230#define Inode2 (((struct minix2_inode *) inode_buffer)-1)
231static char super_block_buffer[BLOCK_SIZE];
232
233#define Super (*(struct minix_super_block *)super_block_buffer)
234#define INODES ((unsigned long)Super.s_ninodes)
235#ifdef BB_FEATURE_MINIX2
236#define ZONES ((unsigned long)(version2 ? Super.s_zones : Super.s_nzones))
237#else
238#define ZONES ((unsigned long)(Super.s_nzones))
239#endif
240#define IMAPS ((unsigned long)Super.s_imap_blocks)
241#define ZMAPS ((unsigned long)Super.s_zmap_blocks)
242#define FIRSTZONE ((unsigned long)Super.s_firstdatazone)
243#define ZONESIZE ((unsigned long)Super.s_log_zone_size)
244#define MAXSIZE ((unsigned long)Super.s_max_size)
245#define MAGIC (Super.s_magic)
246#define NORM_FIRSTZONE (2+IMAPS+ZMAPS+INODE_BLOCKS)
247
248static char *inode_map;
249static char *zone_map;
250
251static unsigned char *inode_count = NULL;
252static unsigned char *zone_count = NULL;
253
254static void recursive_check(unsigned int ino);
255#ifdef BB_FEATURE_MINIX2
256static void recursive_check2(unsigned int ino);
257#endif
258
259static inline int bit(char * a,unsigned int i)
260{
261 return (a[i >> 3] & (1<<(i & 7))) != 0;
262}
263#define inode_in_use(x) (bit(inode_map,(x)))
264#define zone_in_use(x) (bit(zone_map,(x)-FIRSTZONE+1))
265
266#define mark_inode(x) (setbit(inode_map,(x)),changed=1)
267#define unmark_inode(x) (clrbit(inode_map,(x)),changed=1)
268
269#define mark_zone(x) (setbit(zone_map,(x)-FIRSTZONE+1),changed=1)
270#define unmark_zone(x) (clrbit(zone_map,(x)-FIRSTZONE+1),changed=1)
271
272static void leave(int) __attribute__ ((noreturn));
273static void leave(int status)
274{
275 if (termios_set)
276 tcsetattr(0, TCSANOW, &termios);
277 exit(status);
278}
279
280static void die(const char *str)
281{
282 error_msg("%s", str);
283 leave(8);
284}
285
286/*
287 * This simply goes through the file-name data and prints out the
288 * current file.
289 */
290static void print_current_name(void)
291{
292 int i = 0;
293
294 while (i < name_depth)
295 printf("/%.*s", namelen, name_list[i++]);
296 if (i == 0)
297 printf("/");
298}
299
300static int ask(const char *string, int def)
301{
302 int c;
303
304 if (!repair) {
305 printf("\n");
306 errors_uncorrected = 1;
307 return 0;
308 }
309 if (automatic) {
310 printf("\n");
311 if (!def)
312 errors_uncorrected = 1;
313 return def;
314 }
315 printf(def ? "%s (y/n)? " : "%s (n/y)? ", string);
316 for (;;) {
317 fflush(stdout);
318 if ((c = getchar()) == EOF) {
319 if (!def)
320 errors_uncorrected = 1;
321 return def;
322 }
323 c = toupper(c);
324 if (c == 'Y') {
325 def = 1;
326 break;
327 } else if (c == 'N') {
328 def = 0;
329 break;
330 } else if (c == ' ' || c == '\n')
331 break;
332 }
333 if (def)
334 printf("y\n");
335 else {
336 printf("n\n");
337 errors_uncorrected = 1;
338 }
339 return def;
340}
341
342/*
343 * Make certain that we aren't checking a filesystem that is on a
344 * mounted partition. Code adapted from e2fsck, Copyright (C) 1993,
345 * 1994 Theodore Ts'o. Also licensed under GPL.
346 */
347static void check_mount(void)
348{
349 FILE *f;
350 struct mntent *mnt;
351 int cont;
352 int fd;
353
354 if ((f = setmntent(MOUNTED, "r")) == NULL)
355 return;
356 while ((mnt = getmntent(f)) != NULL)
357 if (strcmp(device_name, mnt->mnt_fsname) == 0)
358 break;
359 endmntent(f);
360 if (!mnt)
361 return;
362
363 /*
364 * If the root is mounted read-only, then /etc/mtab is
365 * probably not correct; so we won't issue a warning based on
366 * it.
367 */
368 fd = open(MOUNTED, O_RDWR);
369 if (fd < 0 && errno == EROFS)
370 return;
371 else
372 close(fd);
373
374 printf("%s is mounted. ", device_name);
375 if (isatty(0) && isatty(1))
376 cont = ask("Do you really want to continue", 0);
377 else
378 cont = 0;
379 if (!cont) {
380 printf("check aborted.\n");
381 exit(0);
382 }
383 return;
384}
385
386/*
387 * check_zone_nr checks to see that *nr is a valid zone nr. If it
388 * isn't, it will possibly be repaired. Check_zone_nr sets *corrected
389 * if an error was corrected, and returns the zone (0 for no zone
390 * or a bad zone-number).
391 */
392static int check_zone_nr(unsigned short *nr, int *corrected)
393{
394 if (!*nr)
395 return 0;
396 if (*nr < FIRSTZONE)
397 printf("Zone nr < FIRSTZONE in file `");
398 else if (*nr >= ZONES)
399 printf("Zone nr >= ZONES in file `");
400 else
401 return *nr;
402 print_current_name();
403 printf("'.");
404 if (ask("Remove block", 1)) {
405 *nr = 0;
406 *corrected = 1;
407 }
408 return 0;
409}
410
411#ifdef BB_FEATURE_MINIX2
412static int check_zone_nr2(unsigned int *nr, int *corrected)
413{
414 if (!*nr)
415 return 0;
416 if (*nr < FIRSTZONE)
417 printf("Zone nr < FIRSTZONE in file `");
418 else if (*nr >= ZONES)
419 printf("Zone nr >= ZONES in file `");
420 else
421 return *nr;
422 print_current_name();
423 printf("'.");
424 if (ask("Remove block", 1)) {
425 *nr = 0;
426 *corrected = 1;
427 }
428 return 0;
429}
430#endif
431
432/*
433 * read-block reads block nr into the buffer at addr.
434 */
435static void read_block(unsigned int nr, char *addr)
436{
437 if (!nr) {
438 memset(addr, 0, BLOCK_SIZE);
439 return;
440 }
441 if (BLOCK_SIZE * nr != lseek(IN, BLOCK_SIZE * nr, SEEK_SET)) {
442 printf("Read error: unable to seek to block in file '");
443 print_current_name();
444 printf("'\n");
445 memset(addr, 0, BLOCK_SIZE);
446 errors_uncorrected = 1;
447 } else if (BLOCK_SIZE != read(IN, addr, BLOCK_SIZE)) {
448 printf("Read error: bad block in file '");
449 print_current_name();
450 printf("'\n");
451 memset(addr, 0, BLOCK_SIZE);
452 errors_uncorrected = 1;
453 }
454}
455
456/*
457 * write_block writes block nr to disk.
458 */
459static void write_block(unsigned int nr, char *addr)
460{
461 if (!nr)
462 return;
463 if (nr < FIRSTZONE || nr >= ZONES) {
464 printf("Internal error: trying to write bad block\n"
465 "Write request ignored\n");
466 errors_uncorrected = 1;
467 return;
468 }
469 if (BLOCK_SIZE * nr != lseek(IN, BLOCK_SIZE * nr, SEEK_SET))
470 die("seek failed in write_block");
471 if (BLOCK_SIZE != write(IN, addr, BLOCK_SIZE)) {
472 printf("Write error: bad block in file '");
473 print_current_name();
474 printf("'\n");
475 errors_uncorrected = 1;
476 }
477}
478
479/*
480 * map-block calculates the absolute block nr of a block in a file.
481 * It sets 'changed' if the inode has needed changing, and re-writes
482 * any indirect blocks with errors.
483 */
484static int map_block(struct minix_inode *inode, unsigned int blknr)
485{
486 unsigned short ind[BLOCK_SIZE >> 1];
487 unsigned short dind[BLOCK_SIZE >> 1];
488 int blk_chg, block, result;
489
490 if (blknr < 7)
491 return check_zone_nr(inode->i_zone + blknr, &changed);
492 blknr -= 7;
493 if (blknr < 512) {
494 block = check_zone_nr(inode->i_zone + 7, &changed);
495 read_block(block, (char *) ind);
496 blk_chg = 0;
497 result = check_zone_nr(blknr + ind, &blk_chg);
498 if (blk_chg)
499 write_block(block, (char *) ind);
500 return result;
501 }
502 blknr -= 512;
503 block = check_zone_nr(inode->i_zone + 8, &changed);
504 read_block(block, (char *) dind);
505 blk_chg = 0;
506 result = check_zone_nr(dind + (blknr / 512), &blk_chg);
507 if (blk_chg)
508 write_block(block, (char *) dind);
509 block = result;
510 read_block(block, (char *) ind);
511 blk_chg = 0;
512 result = check_zone_nr(ind + (blknr % 512), &blk_chg);
513 if (blk_chg)
514 write_block(block, (char *) ind);
515 return result;
516}
517
518#ifdef BB_FEATURE_MINIX2
519static int map_block2(struct minix2_inode *inode, unsigned int blknr)
520{
521 unsigned int ind[BLOCK_SIZE >> 2];
522 unsigned int dind[BLOCK_SIZE >> 2];
523 unsigned int tind[BLOCK_SIZE >> 2];
524 int blk_chg, block, result;
525
526 if (blknr < 7)
527 return check_zone_nr2(inode->i_zone + blknr, &changed);
528 blknr -= 7;
529 if (blknr < 256) {
530 block = check_zone_nr2(inode->i_zone + 7, &changed);
531 read_block(block, (char *) ind);
532 blk_chg = 0;
533 result = check_zone_nr2(blknr + ind, &blk_chg);
534 if (blk_chg)
535 write_block(block, (char *) ind);
536 return result;
537 }
538 blknr -= 256;
539 if (blknr >= 256 * 256) {
540 block = check_zone_nr2(inode->i_zone + 8, &changed);
541 read_block(block, (char *) dind);
542 blk_chg = 0;
543 result = check_zone_nr2(dind + blknr / 256, &blk_chg);
544 if (blk_chg)
545 write_block(block, (char *) dind);
546 block = result;
547 read_block(block, (char *) ind);
548 blk_chg = 0;
549 result = check_zone_nr2(ind + blknr % 256, &blk_chg);
550 if (blk_chg)
551 write_block(block, (char *) ind);
552 return result;
553 }
554 blknr -= 256 * 256;
555 block = check_zone_nr2(inode->i_zone + 9, &changed);
556 read_block(block, (char *) tind);
557 blk_chg = 0;
558 result = check_zone_nr2(tind + blknr / (256 * 256), &blk_chg);
559 if (blk_chg)
560 write_block(block, (char *) tind);
561 block = result;
562 read_block(block, (char *) dind);
563 blk_chg = 0;
564 result = check_zone_nr2(dind + (blknr / 256) % 256, &blk_chg);
565 if (blk_chg)
566 write_block(block, (char *) dind);
567 block = result;
568 read_block(block, (char *) ind);
569 blk_chg = 0;
570 result = check_zone_nr2(ind + blknr % 256, &blk_chg);
571 if (blk_chg)
572 write_block(block, (char *) ind);
573 return result;
574}
575#endif
576
577static void write_super_block(void)
578{
579 /*
580 * Set the state of the filesystem based on whether or not there
581 * are uncorrected errors. The filesystem valid flag is
582 * unconditionally set if we get this far.
583 */
584 Super.s_state |= MINIX_VALID_FS;
585 if (errors_uncorrected)
586 Super.s_state |= MINIX_ERROR_FS;
587 else
588 Super.s_state &= ~MINIX_ERROR_FS;
589
590 if (BLOCK_SIZE != lseek(IN, BLOCK_SIZE, SEEK_SET))
591 die("seek failed in write_super_block");
592 if (BLOCK_SIZE != write(IN, super_block_buffer, BLOCK_SIZE))
593 die("unable to write super-block");
594
595 return;
596}
597
598static void write_tables(void)
599{
600 write_super_block();
601
602 if (IMAPS * BLOCK_SIZE != write(IN, inode_map, IMAPS * BLOCK_SIZE))
603 die("Unable to write inode map");
604 if (ZMAPS * BLOCK_SIZE != write(IN, zone_map, ZMAPS * BLOCK_SIZE))
605 die("Unable to write zone map");
606 if (INODE_BUFFER_SIZE != write(IN, inode_buffer, INODE_BUFFER_SIZE))
607 die("Unable to write inodes");
608}
609
610static void get_dirsize(void)
611{
612 int block;
613 char blk[BLOCK_SIZE];
614 int size;
615
616#ifdef BB_FEATURE_MINIX2
617 if (version2)
618 block = Inode2[ROOT_INO].i_zone[0];
619 else
620#endif
621 block = Inode[ROOT_INO].i_zone[0];
622 read_block(block, blk);
623 for (size = 16; size < BLOCK_SIZE; size <<= 1) {
624 if (strcmp(blk + size + 2, "..") == 0) {
625 dirsize = size;
626 namelen = size - 2;
627 return;
628 }
629 }
630 /* use defaults */
631}
632
633static void read_superblock(void)
634{
635 if (BLOCK_SIZE != lseek(IN, BLOCK_SIZE, SEEK_SET))
636 die("seek failed");
637 if (BLOCK_SIZE != read(IN, super_block_buffer, BLOCK_SIZE))
638 die("unable to read super block");
639 if (MAGIC == MINIX_SUPER_MAGIC) {
640 namelen = 14;
641 dirsize = 16;
642 version2 = 0;
643 } else if (MAGIC == MINIX_SUPER_MAGIC2) {
644 namelen = 30;
645 dirsize = 32;
646 version2 = 0;
647#ifdef BB_FEATURE_MINIX2
648 } else if (MAGIC == MINIX2_SUPER_MAGIC) {
649 namelen = 14;
650 dirsize = 16;
651 version2 = 1;
652 } else if (MAGIC == MINIX2_SUPER_MAGIC2) {
653 namelen = 30;
654 dirsize = 32;
655 version2 = 1;
656#endif
657 } else
658 die("bad magic number in super-block");
659 if (ZONESIZE != 0 || BLOCK_SIZE != 1024)
660 die("Only 1k blocks/zones supported");
661 if (IMAPS * BLOCK_SIZE * 8 < INODES + 1)
662 die("bad s_imap_blocks field in super-block");
663 if (ZMAPS * BLOCK_SIZE * 8 < ZONES - FIRSTZONE + 1)
664 die("bad s_zmap_blocks field in super-block");
665}
666
667static void read_tables(void)
668{
669 inode_map = xmalloc(IMAPS * BLOCK_SIZE);
670 zone_map = xmalloc(ZMAPS * BLOCK_SIZE);
671 memset(inode_map, 0, sizeof(inode_map));
672 memset(zone_map, 0, sizeof(zone_map));
673 inode_buffer = xmalloc(INODE_BUFFER_SIZE);
674 inode_count = xmalloc(INODES + 1);
675 zone_count = xmalloc(ZONES);
676 if (IMAPS * BLOCK_SIZE != read(IN, inode_map, IMAPS * BLOCK_SIZE))
677 die("Unable to read inode map");
678 if (ZMAPS * BLOCK_SIZE != read(IN, zone_map, ZMAPS * BLOCK_SIZE))
679 die("Unable to read zone map");
680 if (INODE_BUFFER_SIZE != read(IN, inode_buffer, INODE_BUFFER_SIZE))
681 die("Unable to read inodes");
682 if (NORM_FIRSTZONE != FIRSTZONE) {
683 printf("Warning: Firstzone != Norm_firstzone\n");
684 errors_uncorrected = 1;
685 }
686 get_dirsize();
687 if (show) {
688 printf("%ld inodes\n", INODES);
689 printf("%ld blocks\n", ZONES);
690 printf("Firstdatazone=%ld (%ld)\n", FIRSTZONE, NORM_FIRSTZONE);
691 printf("Zonesize=%d\n", BLOCK_SIZE << ZONESIZE);
692 printf("Maxsize=%ld\n", MAXSIZE);
693 printf("Filesystem state=%d\n", Super.s_state);
694 printf("namelen=%d\n\n", namelen);
695 }
696}
697
698static struct minix_inode *get_inode(unsigned int nr)
699{
700 struct minix_inode *inode;
701
702 if (!nr || nr > INODES)
703 return NULL;
704 total++;
705 inode = Inode + nr;
706 if (!inode_count[nr]) {
707 if (!inode_in_use(nr)) {
708 printf("Inode %d marked not used, but used for file '", nr);
709 print_current_name();
710 printf("'\n");
711 if (repair) {
712 if (ask("Mark in use", 1))
713 mark_inode(nr);
714 } else {
715 errors_uncorrected = 1;
716 }
717 }
718 if (S_ISDIR(inode->i_mode))
719 directory++;
720 else if (S_ISREG(inode->i_mode))
721 regular++;
722 else if (S_ISCHR(inode->i_mode))
723 chardev++;
724 else if (S_ISBLK(inode->i_mode))
725 blockdev++;
726 else if (S_ISLNK(inode->i_mode))
727 symlinks++;
728 else if (S_ISSOCK(inode->i_mode));
729 else if (S_ISFIFO(inode->i_mode));
730 else {
731 print_current_name();
732 printf(" has mode %05o\n", inode->i_mode);
733 }
734
735 } else
736 links++;
737 if (!++inode_count[nr]) {
738 printf("Warning: inode count too big.\n");
739 inode_count[nr]--;
740 errors_uncorrected = 1;
741 }
742 return inode;
743}
744
745#ifdef BB_FEATURE_MINIX2
746static struct minix2_inode *get_inode2(unsigned int nr)
747{
748 struct minix2_inode *inode;
749
750 if (!nr || nr > INODES)
751 return NULL;
752 total++;
753 inode = Inode2 + nr;
754 if (!inode_count[nr]) {
755 if (!inode_in_use(nr)) {
756 printf("Inode %d marked not used, but used for file '", nr);
757 print_current_name();
758 printf("'\n");
759 if (repair) {
760 if (ask("Mark in use", 1))
761 mark_inode(nr);
762 else
763 errors_uncorrected = 1;
764 }
765 }
766 if (S_ISDIR(inode->i_mode))
767 directory++;
768 else if (S_ISREG(inode->i_mode))
769 regular++;
770 else if (S_ISCHR(inode->i_mode))
771 chardev++;
772 else if (S_ISBLK(inode->i_mode))
773 blockdev++;
774 else if (S_ISLNK(inode->i_mode))
775 symlinks++;
776 else if (S_ISSOCK(inode->i_mode));
777 else if (S_ISFIFO(inode->i_mode));
778 else {
779 print_current_name();
780 printf(" has mode %05o\n", inode->i_mode);
781 }
782 } else
783 links++;
784 if (!++inode_count[nr]) {
785 printf("Warning: inode count too big.\n");
786 inode_count[nr]--;
787 errors_uncorrected = 1;
788 }
789 return inode;
790}
791#endif
792
793static void check_root(void)
794{
795 struct minix_inode *inode = Inode + ROOT_INO;
796
797 if (!inode || !S_ISDIR(inode->i_mode))
798 die("root inode isn't a directory");
799}
800
801#ifdef BB_FEATURE_MINIX2
802static void check_root2(void)
803{
804 struct minix2_inode *inode = Inode2 + ROOT_INO;
805
806 if (!inode || !S_ISDIR(inode->i_mode))
807 die("root inode isn't a directory");
808}
809#endif
810
811static int add_zone(unsigned short *znr, int *corrected)
812{
813 int result;
814 int block;
815
816 result = 0;
817 block = check_zone_nr(znr, corrected);
818 if (!block)
819 return 0;
820 if (zone_count[block]) {
821 printf("Block has been used before. Now in file `");
822 print_current_name();
823 printf("'.");
824 if (ask("Clear", 1)) {
825 *znr = 0;
826 block = 0;
827 *corrected = 1;
828 }
829 }
830 if (!block)
831 return 0;
832 if (!zone_in_use(block)) {
833 printf("Block %d in file `", block);
834 print_current_name();
835 printf("' is marked not in use.");
836 if (ask("Correct", 1))
837 mark_zone(block);
838 }
839 if (!++zone_count[block])
840 zone_count[block]--;
841 return block;
842}
843
844#ifdef BB_FEATURE_MINIX2
845static int add_zone2(unsigned int *znr, int *corrected)
846{
847 int result;
848 int block;
849
850 result = 0;
851 block = check_zone_nr2(znr, corrected);
852 if (!block)
853 return 0;
854 if (zone_count[block]) {
855 printf("Block has been used before. Now in file `");
856 print_current_name();
857 printf("'.");
858 if (ask("Clear", 1)) {
859 *znr = 0;
860 block = 0;
861 *corrected = 1;
862 }
863 }
864 if (!block)
865 return 0;
866 if (!zone_in_use(block)) {
867 printf("Block %d in file `", block);
868 print_current_name();
869 printf("' is marked not in use.");
870 if (ask("Correct", 1))
871 mark_zone(block);
872 }
873 if (!++zone_count[block])
874 zone_count[block]--;
875 return block;
876}
877#endif
878
879static void add_zone_ind(unsigned short *znr, int *corrected)
880{
881 static char blk[BLOCK_SIZE];
882 int i, chg_blk = 0;
883 int block;
884
885 block = add_zone(znr, corrected);
886 if (!block)
887 return;
888 read_block(block, blk);
889 for (i = 0; i < (BLOCK_SIZE >> 1); i++)
890 add_zone(i + (unsigned short *) blk, &chg_blk);
891 if (chg_blk)
892 write_block(block, blk);
893}
894
895#ifdef BB_FEATURE_MINIX2
896static void add_zone_ind2(unsigned int *znr, int *corrected)
897{
898 static char blk[BLOCK_SIZE];
899 int i, chg_blk = 0;
900 int block;
901
902 block = add_zone2(znr, corrected);
903 if (!block)
904 return;
905 read_block(block, blk);
906 for (i = 0; i < BLOCK_SIZE >> 2; i++)
907 add_zone2(i + (unsigned int *) blk, &chg_blk);
908 if (chg_blk)
909 write_block(block, blk);
910}
911#endif
912
913static void add_zone_dind(unsigned short *znr, int *corrected)
914{
915 static char blk[BLOCK_SIZE];
916 int i, blk_chg = 0;
917 int block;
918
919 block = add_zone(znr, corrected);
920 if (!block)
921 return;
922 read_block(block, blk);
923 for (i = 0; i < (BLOCK_SIZE >> 1); i++)
924 add_zone_ind(i + (unsigned short *) blk, &blk_chg);
925 if (blk_chg)
926 write_block(block, blk);
927}
928
929#ifdef BB_FEATURE_MINIX2
930static void add_zone_dind2(unsigned int *znr, int *corrected)
931{
932 static char blk[BLOCK_SIZE];
933 int i, blk_chg = 0;
934 int block;
935
936 block = add_zone2(znr, corrected);
937 if (!block)
938 return;
939 read_block(block, blk);
940 for (i = 0; i < BLOCK_SIZE >> 2; i++)
941 add_zone_ind2(i + (unsigned int *) blk, &blk_chg);
942 if (blk_chg)
943 write_block(block, blk);
944}
945
946static void add_zone_tind2(unsigned int *znr, int *corrected)
947{
948 static char blk[BLOCK_SIZE];
949 int i, blk_chg = 0;
950 int block;
951
952 block = add_zone2(znr, corrected);
953 if (!block)
954 return;
955 read_block(block, blk);
956 for (i = 0; i < BLOCK_SIZE >> 2; i++)
957 add_zone_dind2(i + (unsigned int *) blk, &blk_chg);
958 if (blk_chg)
959 write_block(block, blk);
960}
961#endif
962
963static void check_zones(unsigned int i)
964{
965 struct minix_inode *inode;
966
967 if (!i || i > INODES)
968 return;
969 if (inode_count[i] > 1) /* have we counted this file already? */
970 return;
971 inode = Inode + i;
972 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
973 !S_ISLNK(inode->i_mode)) return;
974 for (i = 0; i < 7; i++)
975 add_zone(i + inode->i_zone, &changed);
976 add_zone_ind(7 + inode->i_zone, &changed);
977 add_zone_dind(8 + inode->i_zone, &changed);
978}
979
980#ifdef BB_FEATURE_MINIX2
981static void check_zones2(unsigned int i)
982{
983 struct minix2_inode *inode;
984
985 if (!i || i > INODES)
986 return;
987 if (inode_count[i] > 1) /* have we counted this file already? */
988 return;
989 inode = Inode2 + i;
990 if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode)
991 && !S_ISLNK(inode->i_mode))
992 return;
993 for (i = 0; i < 7; i++)
994 add_zone2(i + inode->i_zone, &changed);
995 add_zone_ind2(7 + inode->i_zone, &changed);
996 add_zone_dind2(8 + inode->i_zone, &changed);
997 add_zone_tind2(9 + inode->i_zone, &changed);
998}
999#endif
1000
1001static void check_file(struct minix_inode *dir, unsigned int offset)
1002{
1003 static char blk[BLOCK_SIZE];
1004 struct minix_inode *inode;
1005 int ino;
1006 char *name;
1007 int block;
1008
1009 block = map_block(dir, offset / BLOCK_SIZE);
1010 read_block(block, blk);
1011 name = blk + (offset % BLOCK_SIZE) + 2;
1012 ino = *(unsigned short *) (name - 2);
1013 if (ino > INODES) {
1014 print_current_name();
1015 printf(" contains a bad inode number for file '");
1016 printf("%.*s'.", namelen, name);
1017 if (ask(" Remove", 1)) {
1018 *(unsigned short *) (name - 2) = 0;
1019 write_block(block, blk);
1020 }
1021 ino = 0;
1022 }
1023 if (name_depth < MAX_DEPTH)
1024 strncpy(name_list[name_depth], name, namelen);
1025 name_depth++;
1026 inode = get_inode(ino);
1027 name_depth--;
1028 if (!offset) {
1029 if (!inode || strcmp(".", name)) {
1030 print_current_name();
1031 printf(": bad directory: '.' isn't first\n");
1032 errors_uncorrected = 1;
1033 } else
1034 return;
1035 }
1036 if (offset == dirsize) {
1037 if (!inode || strcmp("..", name)) {
1038 print_current_name();
1039 printf(": bad directory: '..' isn't second\n");
1040 errors_uncorrected = 1;
1041 } else
1042 return;
1043 }
1044 if (!inode)
1045 return;
1046 if (name_depth < MAX_DEPTH)
1047 strncpy(name_list[name_depth], name, namelen);
1048 name_depth++;
1049 if (list) {
1050 if (verbose)
1051 printf("%6d %07o %3d ", ino, inode->i_mode, inode->i_nlinks);
1052 print_current_name();
1053 if (S_ISDIR(inode->i_mode))
1054 printf(":\n");
1055 else
1056 printf("\n");
1057 }
1058 check_zones(ino);
1059 if (inode && S_ISDIR(inode->i_mode))
1060 recursive_check(ino);
1061 name_depth--;
1062 return;
1063}
1064
1065#ifdef BB_FEATURE_MINIX2
1066static void check_file2(struct minix2_inode *dir, unsigned int offset)
1067{
1068 static char blk[BLOCK_SIZE];
1069 struct minix2_inode *inode;
1070 int ino;
1071 char *name;
1072 int block;
1073
1074 block = map_block2(dir, offset / BLOCK_SIZE);
1075 read_block(block, blk);
1076 name = blk + (offset % BLOCK_SIZE) + 2;
1077 ino = *(unsigned short *) (name - 2);
1078 if (ino > INODES) {
1079 print_current_name();
1080 printf(" contains a bad inode number for file '");
1081 printf("%.*s'.", namelen, name);
1082 if (ask(" Remove", 1)) {
1083 *(unsigned short *) (name - 2) = 0;
1084 write_block(block, blk);
1085 }
1086 ino = 0;
1087 }
1088 if (name_depth < MAX_DEPTH)
1089 strncpy(name_list[name_depth], name, namelen);
1090 name_depth++;
1091 inode = get_inode2(ino);
1092 name_depth--;
1093 if (!offset) {
1094 if (!inode || strcmp(".", name)) {
1095 print_current_name();
1096 printf(": bad directory: '.' isn't first\n");
1097 errors_uncorrected = 1;
1098 } else
1099 return;
1100 }
1101 if (offset == dirsize) {
1102 if (!inode || strcmp("..", name)) {
1103 print_current_name();
1104 printf(": bad directory: '..' isn't second\n");
1105 errors_uncorrected = 1;
1106 } else
1107 return;
1108 }
1109 if (!inode)
1110 return;
1111 name_depth++;
1112 if (list) {
1113 if (verbose)
1114 printf("%6d %07o %3d ", ino, inode->i_mode, inode->i_nlinks);
1115 print_current_name();
1116 if (S_ISDIR(inode->i_mode))
1117 printf(":\n");
1118 else
1119 printf("\n");
1120 }
1121 check_zones2(ino);
1122 if (inode && S_ISDIR(inode->i_mode))
1123 recursive_check2(ino);
1124 name_depth--;
1125 return;
1126}
1127#endif
1128
1129static void recursive_check(unsigned int ino)
1130{
1131 struct minix_inode *dir;
1132 unsigned int offset;
1133
1134 dir = Inode + ino;
1135 if (!S_ISDIR(dir->i_mode))
1136 die("internal error");
1137 if (dir->i_size < 2 * dirsize) {
1138 print_current_name();
1139 printf(": bad directory: size<32");
1140 errors_uncorrected = 1;
1141 }
1142 for (offset = 0; offset < dir->i_size; offset += dirsize)
1143 check_file(dir, offset);
1144}
1145
1146#ifdef BB_FEATURE_MINIX2
1147static void recursive_check2(unsigned int ino)
1148{
1149 struct minix2_inode *dir;
1150 unsigned int offset;
1151
1152 dir = Inode2 + ino;
1153 if (!S_ISDIR(dir->i_mode))
1154 die("internal error");
1155 if (dir->i_size < 2 * dirsize) {
1156 print_current_name();
1157 printf(": bad directory: size < 32");
1158 errors_uncorrected = 1;
1159 }
1160 for (offset = 0; offset < dir->i_size; offset += dirsize)
1161 check_file2(dir, offset);
1162}
1163#endif
1164
1165static int bad_zone(int i)
1166{
1167 char buffer[1024];
1168
1169 if (BLOCK_SIZE * i != lseek(IN, BLOCK_SIZE * i, SEEK_SET))
1170 die("seek failed in bad_zone");
1171 return (BLOCK_SIZE != read(IN, buffer, BLOCK_SIZE));
1172}
1173
1174static void check_counts(void)
1175{
1176 int i;
1177
1178 for (i = 1; i <= INODES; i++) {
1179 if (!inode_in_use(i) && Inode[i].i_mode && warn_mode) {
1180 printf("Inode %d mode not cleared.", i);
1181 if (ask("Clear", 1)) {
1182 Inode[i].i_mode = 0;
1183 changed = 1;
1184 }
1185 }
1186 if (!inode_count[i]) {
1187 if (!inode_in_use(i))
1188 continue;
1189 printf("Inode %d not used, marked used in the bitmap.", i);
1190 if (ask("Clear", 1))
1191 unmark_inode(i);
1192 continue;
1193 }
1194 if (!inode_in_use(i)) {
1195 printf("Inode %d used, marked unused in the bitmap.", i);
1196 if (ask("Set", 1))
1197 mark_inode(i);
1198 }
1199 if (Inode[i].i_nlinks != inode_count[i]) {
1200 printf("Inode %d (mode = %07o), i_nlinks=%d, counted=%d.",
1201 i, Inode[i].i_mode, Inode[i].i_nlinks, inode_count[i]);
1202 if (ask("Set i_nlinks to count", 1)) {
1203 Inode[i].i_nlinks = inode_count[i];
1204 changed = 1;
1205 }
1206 }
1207 }
1208 for (i = FIRSTZONE; i < ZONES; i++) {
1209 if (zone_in_use(i) == zone_count[i])
1210 continue;
1211 if (!zone_count[i]) {
1212 if (bad_zone(i))
1213 continue;
1214 printf("Zone %d: marked in use, no file uses it.", i);
1215 if (ask("Unmark", 1))
1216 unmark_zone(i);
1217 continue;
1218 }
1219 printf("Zone %d: %sin use, counted=%d\n",
1220 i, zone_in_use(i) ? "" : "not ", zone_count[i]);
1221 }
1222}
1223
1224#ifdef BB_FEATURE_MINIX2
1225static void check_counts2(void)
1226{
1227 int i;
1228
1229 for (i = 1; i <= INODES; i++) {
1230 if (!inode_in_use(i) && Inode2[i].i_mode && warn_mode) {
1231 printf("Inode %d mode not cleared.", i);
1232 if (ask("Clear", 1)) {
1233 Inode2[i].i_mode = 0;
1234 changed = 1;
1235 }
1236 }
1237 if (!inode_count[i]) {
1238 if (!inode_in_use(i))
1239 continue;
1240 printf("Inode %d not used, marked used in the bitmap.", i);
1241 if (ask("Clear", 1))
1242 unmark_inode(i);
1243 continue;
1244 }
1245 if (!inode_in_use(i)) {
1246 printf("Inode %d used, marked unused in the bitmap.", i);
1247 if (ask("Set", 1))
1248 mark_inode(i);
1249 }
1250 if (Inode2[i].i_nlinks != inode_count[i]) {
1251 printf("Inode %d (mode = %07o), i_nlinks=%d, counted=%d.",
1252 i, Inode2[i].i_mode, Inode2[i].i_nlinks,
1253 inode_count[i]);
1254 if (ask("Set i_nlinks to count", 1)) {
1255 Inode2[i].i_nlinks = inode_count[i];
1256 changed = 1;
1257 }
1258 }
1259 }
1260 for (i = FIRSTZONE; i < ZONES; i++) {
1261 if (zone_in_use(i) == zone_count[i])
1262 continue;
1263 if (!zone_count[i]) {
1264 if (bad_zone(i))
1265 continue;
1266 printf("Zone %d: marked in use, no file uses it.", i);
1267 if (ask("Unmark", 1))
1268 unmark_zone(i);
1269 continue;
1270 }
1271 printf("Zone %d: %sin use, counted=%d\n",
1272 i, zone_in_use(i) ? "" : "not ", zone_count[i]);
1273 }
1274}
1275#endif
1276
1277static void check(void)
1278{
1279 memset(inode_count, 0, (INODES + 1) * sizeof(*inode_count));
1280 memset(zone_count, 0, ZONES * sizeof(*zone_count));
1281 check_zones(ROOT_INO);
1282 recursive_check(ROOT_INO);
1283 check_counts();
1284}
1285
1286#ifdef BB_FEATURE_MINIX2
1287static void check2(void)
1288{
1289 memset(inode_count, 0, (INODES + 1) * sizeof(*inode_count));
1290 memset(zone_count, 0, ZONES * sizeof(*zone_count));
1291 check_zones2(ROOT_INO);
1292 recursive_check2(ROOT_INO);
1293 check_counts2();
1294}
1295#endif
1296
1297/* Wed Feb 9 15:17:06 MST 2000 */
1298/* dynamically allocate name_list (instead of making it static) */
1299static void alloc_name_list(void)
1300{
1301 int i;
1302
1303 name_list = xmalloc(sizeof(char *) * MAX_DEPTH);
1304 for (i = 0; i < MAX_DEPTH; i++)
1305 name_list[i] = xmalloc(sizeof(char) * BUFSIZ + 1);
1306}
1307
1308#ifdef BB_FEATURE_CLEAN_UP
1309/* execute this atexit() to deallocate name_list[] */
1310/* piptigger was here */
1311static void free_name_list(void)
1312{
1313 int i;
1314
1315 if (name_list) {
1316 for (i = 0; i < MAX_DEPTH; i++) {
1317 if (name_list[i]) {
1318 free(name_list[i]);
1319 }
1320 }
1321 free(name_list);
1322 }
1323}
1324#endif
1325
1326extern int fsck_minix_main(int argc, char **argv)
1327{
1328 struct termios tmp;
1329 int count;
1330 int retcode = 0;
1331
1332 alloc_name_list();
1333#ifdef BB_FEATURE_CLEAN_UP
1334 /* Don't bother to free memory. Exit does
1335 * that automagically, so we can save a few bytes */
1336 atexit(free_name_list);
1337#endif
1338
1339 if (INODE_SIZE * MINIX_INODES_PER_BLOCK != BLOCK_SIZE)
1340 die("bad inode size");
1341#ifdef BB_FEATURE_MINIX2
1342 if (INODE_SIZE2 * MINIX2_INODES_PER_BLOCK != BLOCK_SIZE)
1343 die("bad v2 inode size");
1344#endif
1345 while (argc-- > 1) {
1346 argv++;
1347 if (argv[0][0] != '-') {
1348 if (device_name)
1349 show_usage();
1350 else
1351 device_name = argv[0];
1352 } else
1353 while (*++argv[0])
1354 switch (argv[0][0]) {
1355 case 'l':
1356 list = 1;
1357 break;
1358 case 'a':
1359 automatic = 1;
1360 repair = 1;
1361 break;
1362 case 'r':
1363 automatic = 0;
1364 repair = 1;
1365 break;
1366 case 'v':
1367 verbose = 1;
1368 break;
1369 case 's':
1370 show = 1;
1371 break;
1372 case 'm':
1373 warn_mode = 1;
1374 break;
1375 case 'f':
1376 force = 1;
1377 break;
1378 default:
1379 show_usage();
1380 }
1381 }
1382 if (!device_name)
1383 show_usage();
1384 check_mount(); /* trying to check a mounted filesystem? */
1385 if (repair && !automatic) {
1386 if (!isatty(0) || !isatty(1))
1387 die("need terminal for interactive repairs");
1388 }
1389 IN = open(device_name, repair ? O_RDWR : O_RDONLY);
1390 if (IN < 0){
1391 fprintf(stderr,"unable to open device '%s'.\n",device_name);
1392 leave(8);
1393 }
1394 for (count = 0; count < 3; count++)
1395 sync();
1396 read_superblock();
1397
1398 /*
1399 * Determine whether or not we should continue with the checking.
1400 * This is based on the status of the filesystem valid and error
1401 * flags and whether or not the -f switch was specified on the
1402 * command line.
1403 */
1404 printf("%s, %s\n", applet_name, program_version);
1405 if (!(Super.s_state & MINIX_ERROR_FS) &&
1406 (Super.s_state & MINIX_VALID_FS) && !force) {
1407 if (repair)
1408 printf("%s is clean, no check.\n", device_name);
1409 return retcode;
1410 } else if (force)
1411 printf("Forcing filesystem check on %s.\n", device_name);
1412 else if (repair)
1413 printf("Filesystem on %s is dirty, needs checking.\n",
1414 device_name);
1415
1416 read_tables();
1417
1418 if (repair && !automatic) {
1419 tcgetattr(0, &termios);
1420 tmp = termios;
1421 tmp.c_lflag &= ~(ICANON | ECHO);
1422 tcsetattr(0, TCSANOW, &tmp);
1423 termios_set = 1;
1424 }
1425#ifdef BB_FEATURE_MINIX2
1426 if (version2) {
1427 check_root2();
1428 check2();
1429 } else
1430#endif
1431 {
1432 check_root();
1433 check();
1434 }
1435 if (verbose) {
1436 int i, free_cnt;
1437
1438 for (i = 1, free_cnt = 0; i <= INODES; i++)
1439 if (!inode_in_use(i))
1440 free_cnt++;
1441 printf("\n%6ld inodes used (%ld%%)\n", (INODES - free_cnt),
1442 100 * (INODES - free_cnt) / INODES);
1443 for (i = FIRSTZONE, free_cnt = 0; i < ZONES; i++)
1444 if (!zone_in_use(i))
1445 free_cnt++;
1446 printf("%6ld zones used (%ld%%)\n", (ZONES - free_cnt),
1447 100 * (ZONES - free_cnt) / ZONES);
1448 printf("\n%6d regular files\n"
1449 "%6d directories\n"
1450 "%6d character device files\n"
1451 "%6d block device files\n"
1452 "%6d links\n"
1453 "%6d symbolic links\n"
1454 "------\n"
1455 "%6d files\n",
1456 regular, directory, chardev, blockdev,
1457 links - 2 * directory + 1, symlinks,
1458 total - 2 * directory + 1);
1459 }
1460 if (changed) {
1461 write_tables();
1462 printf("----------------------------\n"
1463 "FILE SYSTEM HAS BEEN CHANGED\n"
1464 "----------------------------\n");
1465 for (count = 0; count < 3; count++)
1466 sync();
1467 } else if (repair)
1468 write_super_block();
1469
1470 if (repair && !automatic)
1471 tcsetattr(0, TCSANOW, &termios);
1472
1473 if (changed)
1474 retcode += 3;
1475 if (errors_uncorrected)
1476 retcode += 4;
1477 return retcode;
1478}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-08-12 12:49:30 +0000