disk-utils/fsck.minix.c

   1 /*
   2  * fsck.minix.c - a file system consistency checker for Linux.
   3  *
   4  * (C) 1991, 1992 Linus Torvalds. This file may be redistributed
   5  * as per the GNU copyleft.
   6  */
   7
   8 /*
   9  * 09.11.91  -  made the first rudimentary functions
  10  *
  11  * 10.11.91  -  updated, does checking, no repairs yet.
  12  *              Sent out to the mailing-list for testing.
  13  *
  14  * 14.11.91  -  Testing seems to have gone well. Added some
  15  *              correction-code, and changed some functions.
  16  *
  17  * 15.11.91  -  More correction code. Hopefully it notices most
  18  *              cases now, and tries to do something about them.
  19  *
  20  * 16.11.91  -  More corrections (thanks to Mika Jalava). Most
  21  *              things seem to work now. Yeah, sure.
  22  *
  23  *
  24  * 19.04.92  -  Had to start over again from this old version, as a
  25  *              kernel bug ate my enhanced fsck in February.
  26  *
  27  * 28.02.93  -  added support for different directory entry sizes..
  28  *
  29  * Sat Mar  6 18:59:42 1993, faith@cs.unc.edu: Output namelen with
  30  *                           super-block information
  31  *
  32  * Sat Oct  9 11:17:11 1993, faith@cs.unc.edu: make exit status conform
  33  *                           to that required by fsutil
  34  *
  35  * Mon Jan  3 11:06:52 1994 - Dr. Wettstein (greg%wind.uucp@plains.nodak.edu)
  36  *                            Added support for file system valid flag.  Also
  37  *                            added program_version variable and output of
  38  *                            program name and version number when program
  39  *                            is executed.
  40  *
  41  * 30.10.94 - added support for v2 filesystem
  42  *            (Andreas Schwab, schwab@issan.informatik.uni-dortmund.de)
  43  *
  44  * 10.12.94  -  added test to prevent checking of mounted fs adapted
  45  *              from Theodore Ts'o's (tytso@athena.mit.edu) e2fsck
  46  *              program.  (Daniel Quinlan, quinlan@yggdrasil.com)
  47  *
  48  * 01.07.96  - Fixed the v2 fs stuff to use the right #defines and such
  49  *             for modern libcs (janl@math.uio.no, Nicolai Langfeldt)
  50  *
  51  * 02.07.96  - Added C bit fiddling routines from rmk@ecs.soton.ac.uk
  52  *             (Russell King).  He made them for ARM.  It would seem
  53  *             that the ARM is powerful enough to do this in C whereas
  54  *             i386 and m64k must use assembly to get it fast >:-)
  55  *             This should make minix fsck systemindependent.
  56  *             (janl@math.uio.no, Nicolai Langfeldt)
  57  *
  58  * 04.11.96  - Added minor fixes from Andreas Schwab to avoid compiler
  59  *             warnings.  Added mc68k bitops from
  60  *             Joerg Dorchain <dorchain@mpi-sb.mpg.de>.
  61  *
  62  * 06.11.96  - Added v2 code submitted by Joerg Dorchain, but written by
  63  *             Andreas Schwab.
  64  *
  65  * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL>
  66  * - added Native Language Support
  67  *
  68  * 2008-04-06 James Youngman <jay@gnu.org>
  69  * - Issue better error message if we fail to open the device.
  70  * - Restore terminal state if we get a fatal signal.
  71  *
  72  *
  73  * I've had no time to add comments - hopefully the function names
  74  * are comments enough. As with all file system checkers, this assumes
  75  * the file system is quiescent - don't use it on a mounted device
  76  * unless you can be sure nobody is writing to it (and remember that the
  77  * kernel can write to it when it searches for files).
  78  *
  79  */
  80
  81 #include <stdio.h>
  82 #include <stdarg.h>
  83 #include <errno.h>
  84 #include <unistd.h>
  85 #include <string.h>
  86 #include <fcntl.h>
  87 #include <ctype.h>
  88 #include <stdlib.h>
  89 #include <termios.h>
  90 #include <sys/stat.h>
  91 #include <signal.h>
  92 #include <getopt.h>
  93
  94 #include "c.h"
  95 #include "exitcodes.h"
  96 #include "minix_programs.h"
  97 #include "nls.h"
  98 #include "pathnames.h"
  99 #include "bitops.h"
 100 #include "ismounted.h"
 101 #include "all-io.h"
 102 #include "closestream.h"
 103 #include "rpmatch.h"
 104 #include "strutils.h"
 105
 106 #define ROOT_INO 1
 107 #define YESNO_LENGTH 64
 108
 109 /* Global variables used in minix_programs.h inline functions */
 110 int fs_version = 1;
 111 char *super_block_buffer;
 112
 113 static char *inode_buffer;
 114
 115 #define Inode (((struct minix_inode *) inode_buffer) - 1)
 116 #define Inode2 (((struct minix2_inode *) inode_buffer) - 1)
 117
 118 static char *device_name;
 119 static int device_fd;
 120 static int repair, automatic, verbose, list, show, warn_mode, force;
 121 static int directory, regular, blockdev, chardev, links, symlinks, total;
 122
 123 static int changed;             /* flags if the filesystem has been changed */
 124 static int errors_uncorrected;  /* flag if some error was not corrected */
 125 static size_t dirsize = 16;
 126 static size_t namelen = 14;
 127 static struct termios termios;
 128 static volatile sig_atomic_t termios_set;
 129
 130 /* File-name data */
 131 #define MAX_DEPTH 50
 132 static int name_depth;
 133 static char name_list[MAX_DEPTH][MINIX_NAME_MAX + 1];
 134
 135 /* Copy of the previous, just for error reporting - see get_current_name.  This
 136  * is a waste of 12kB or so.  */
 137 static char current_name[MAX_DEPTH * (MINIX_NAME_MAX + 1) + 1];
 138
 139 static unsigned char *inode_count = NULL;
 140 static unsigned char *zone_count = NULL;
 141
 142 static void recursive_check(unsigned int ino);
 143 static void recursive_check2(unsigned int ino);
 144
 145 static char *inode_map;
 146 static char *zone_map;
 147
 148 #define inode_in_use(x) (isset(inode_map,(x)) != 0)
 149 #define zone_in_use(x) (isset(zone_map,(x)-get_first_zone()+1) != 0)
 150
 151 #define mark_inode(x) (setbit(inode_map,(x)),changed=1)
 152 #define unmark_inode(x) (clrbit(inode_map,(x)),changed=1)
 153
 154 #define mark_zone(x) (setbit(zone_map,(x)-get_first_zone()+1),changed=1)
 155 #define unmark_zone(x) (clrbit(zone_map,(x)-get_first_zone()+1),changed=1)
 156
 157 static void
 158 reset(void) {
 159         if (termios_set)
 160                 tcsetattr(STDIN_FILENO, TCSANOW, &termios);
 161 }
 162
 163 static void
 164 fatalsig(int sig) {
 165         /* We received a fatal signal.  Reset the terminal.  Also reset the
 166          * signal handler and re-send the signal, so that the parent process
 167          * knows which signal actually caused our death.  */
 168         signal(sig, SIG_DFL);
 169         reset();
 170         raise(sig);
 171 }
 172
 173 static void __attribute__((__noreturn__))
 174 leave(int status) {
 175         reset();
 176         exit(status);
 177 }
 178
 179 static void __attribute__((__noreturn__))
 180 usage(void) {
 181         FILE *out = stdout;
 182         fputs(USAGE_HEADER, out);
 183         fprintf(out, _(" %s [options] <device>\n"), program_invocation_short_name);
 184         fputs(USAGE_SEPARATOR, out);
 185         fputs(_("Check the consistency of a Minix filesystem.\n"), out);
 186         fputs(USAGE_OPTIONS, out);
 187         fputs(_(" -l, --list       list all filenames\n"), out);
 188         fputs(_(" -a, --auto       automatic repair\n"), out);
 189         fputs(_(" -r, --repair     interactive repair\n"), out);
 190         fputs(_(" -v, --verbose    be verbose\n"), out);
 191         fputs(_(" -s, --super      output super-block information\n"), out);
 192         fputs(_(" -m, --uncleared  activate mode not cleared warnings\n"), out);
 193         fputs(_(" -f, --force      force check\n"), out);
 194         fputs(USAGE_SEPARATOR, out);
 195         printf(USAGE_HELP_OPTIONS(18));
 196         printf(USAGE_MAN_TAIL("fsck.minix(8)"));
 197         exit(FSCK_EX_OK);
 198 }
 199
 200 static void die(const char *fmt, ...)
 201     __attribute__ ((__format__(__printf__, 1, 2)));
 202
 203 static void
 204 die(const char *fmt, ...) {
 205         va_list ap;
 206
 207         fprintf(stderr, UTIL_LINUX_VERSION);
 208         va_start(ap, fmt);
 209         vfprintf(stderr, fmt, ap);
 210         va_end(ap);
 211         fputc('\n', stderr);
 212         leave(FSCK_EX_ERROR);
 213 }
 214
 215 /* This simply goes through the file-name data and prints out the current file.  */
 216 static void
 217 get_current_name(void) {
 218         int i = 0, ct;
 219         char *p, *q;
 220
 221         q = current_name;
 222         while (i < name_depth) {
 223                 p = name_list[i++];
 224                 ct = namelen;
 225                 *q++ = '/';
 226                 while (ct-- && *p)
 227                         *q++ = *p++;
 228         }
 229         if (i == 0)
 230                 *q++ = '/';
 231         *q = 0;
 232 }
 233
 234 static int
 235 ask(const char *string, int def) {
 236         int resp;
 237         char input[YESNO_LENGTH];
 238
 239         if (!repair) {
 240                 printf("\n");
 241                 errors_uncorrected = 1;
 242                 return 0;
 243         }
 244         if (automatic) {
 245                 printf("\n");
 246                 if (!def)
 247                         errors_uncorrected = 1;
 248                 return def;
 249         }
 250         /* TRANSLATORS: these yes no questions uses rpmatch(), and should be
 251          * translated.  */
 252         printf(def ? _("%s (y/n)? ") : _("%s (n/y)? "), string);
 253         fflush(stdout);
 254         ignore_result( fgets(input, YESNO_LENGTH, stdin) );
 255         resp = rpmatch(input);
 256         switch (resp) {
 257         case RPMATCH_INVALID:
 258                 /* def = def */
 259                 break;
 260         case RPMATCH_NO:
 261         case RPMATCH_YES:
 262                 def = resp;
 263                 break;
 264         default:
 265                 /* rpmatch bug? */
 266                 abort();
 267         }
 268         if (def)
 269                 printf(_("y\n"));
 270         else {
 271                 printf(_("n\n"));
 272                 errors_uncorrected = 1;
 273         }
 274         return def;
 275 }
 276
 277 /* Make certain that we aren't checking a filesystem that is on a mounted
 278  * partition.  Code adapted from e2fsck, Copyright (C) 1993, 1994 Theodore
 279  * Ts'o.  Also licensed under GPL.  */
 280 static void
 281 check_mount(void) {
 282         int cont;
 283
 284         if (!is_mounted(device_name))
 285                 return;
 286
 287         printf(_("%s is mounted.         "), device_name);
 288         if (isatty(STDIN_FILENO) && isatty(STDOUT_FILENO))
 289                 cont = ask(_("Do you really want to continue"), 0);
 290         else
 291                 cont = 0;
 292         if (!cont) {
 293                 printf(_("check aborted.\n"));
 294                 exit(FSCK_EX_OK);
 295         }
 296 }
 297
 298
 299 static int is_valid_zone_nr(unsigned short nr)
 300 {
 301         if (nr < get_first_zone())
 302                 return 0;
 303         if (nr >= get_nzones())
 304                 return 0;
 305         return 1;
 306 }
 307
 308 /* check_zone_nr checks to see that *nr is a valid zone nr.  If it isn't, it
 309  * will possibly be repaired.  Check_zone_nr sets *corrected if an error was
 310  * corrected, and returns the zone (0 for no zone or a bad zone-number).  */
 311 static int
 312 check_zone_nr(unsigned short *nr, int *corrected) {
 313         if (!*nr)
 314                 return 0;
 315
 316         if (*nr < get_first_zone()) {
 317                 get_current_name();
 318                 printf(_("Zone nr < FIRSTZONE in file `%s'."), current_name);
 319         } else if (*nr >= get_nzones()) {
 320                 get_current_name();
 321                 printf(_("Zone nr >= ZONES in file `%s'."), current_name);
 322         } else
 323                 return *nr;
 324
 325         if (ask(_("Remove block"), 1)) {
 326                 *nr = 0;
 327                 *corrected = 1;
 328         }
 329         return 0;
 330 }
 331
 332 static int
 333 check_zone_nr2(unsigned int *nr, int *corrected) {
 334         if (!*nr)
 335                 return 0;
 336
 337         if (*nr < get_first_zone()) {
 338                 get_current_name();
 339                 printf(_("Zone nr < FIRSTZONE in file `%s'."), current_name);
 340         } else if (*nr >= get_nzones()) {
 341                 get_current_name();
 342                 printf(_("Zone nr >= ZONES in file `%s'."), current_name);
 343         } else
 344                 return *nr;
 345
 346         if (ask(_("Remove block"), 1)) {
 347                 *nr = 0;
 348                 *corrected = 1;
 349         }
 350         return 0;
 351 }
 352
 353 /* read-block reads block nr into the buffer at addr.  */
 354 static void
 355 read_block(unsigned int nr, char *addr) {
 356         if (!nr) {
 357                 memset(addr, 0, MINIX_BLOCK_SIZE);
 358                 return;
 359         }
 360         if (MINIX_BLOCK_SIZE * nr != lseek(device_fd, MINIX_BLOCK_SIZE * nr, SEEK_SET)) {
 361                 get_current_name();
 362                 printf(_("Read error: unable to seek to block in file '%s'\n"),
 363                        current_name);
 364                 memset(addr, 0, MINIX_BLOCK_SIZE);
 365                 errors_uncorrected = 1;
 366         } else if (MINIX_BLOCK_SIZE != read(device_fd, addr, MINIX_BLOCK_SIZE)) {
 367                 get_current_name();
 368                 printf(_("Read error: bad block in file '%s'\n"), current_name);
 369                 memset(addr, 0, MINIX_BLOCK_SIZE);
 370                 errors_uncorrected = 1;
 371         }
 372 }
 373
 374 /* write_block writes block nr to disk.  */
 375 static void
 376 write_block(unsigned int nr, char *addr) {
 377         if (!nr)
 378                 return;
 379         if (nr < get_first_zone() || nr >= get_nzones()) {
 380                 printf(_("Internal error: trying to write bad block\n"
 381                          "Write request ignored\n"));
 382                 errors_uncorrected = 1;
 383                 return;
 384         }
 385         if (MINIX_BLOCK_SIZE * nr != lseek(device_fd, MINIX_BLOCK_SIZE * nr, SEEK_SET))
 386                 die(_("seek failed in write_block"));
 387         if (MINIX_BLOCK_SIZE != write(device_fd, addr, MINIX_BLOCK_SIZE)) {
 388                 get_current_name();
 389                 printf(_("Write error: bad block in file '%s'\n"),
 390                        current_name);
 391                 errors_uncorrected = 1;
 392         }
 393 }
 394
 395 /* map-block calculates the absolute block nr of a block in a file.  It sets
 396  * 'changed' if the inode has needed changing, and re-writes any indirect
 397  * blocks with errors.  */
 398 static int
 399 map_block(struct minix_inode *inode, unsigned int blknr) {
 400         unsigned short ind[MINIX_BLOCK_SIZE >> 1];
 401         unsigned short dind[MINIX_BLOCK_SIZE >> 1];
 402         int blk_chg, block, result;
 403         size_t range;
 404
 405         if (blknr < 7)
 406                 return check_zone_nr(inode->i_zone + blknr, &changed);
 407         blknr -= 7;
 408         if (blknr < 512) {
 409                 block = check_zone_nr(inode->i_zone + 7, &changed);
 410                 read_block(block, (char *)ind);
 411                 blk_chg = 0;
 412                 result = check_zone_nr(blknr + ind, &blk_chg);
 413                 if (blk_chg)
 414                         write_block(block, (char *)ind);
 415                 return result;
 416         }
 417         blknr -= 512;
 418         block = check_zone_nr(inode->i_zone + 8, &changed);
 419         read_block(block, (char *)dind);
 420         blk_chg = 0;
 421         range = blknr / 512;
 422         if (ARRAY_SIZE(dind) <= range) {
 423                 printf(_("Warning: block out of range\n"));
 424                 return 1;
 425         }
 426         result = check_zone_nr(dind + range, &blk_chg);
 427         if (blk_chg)
 428                 write_block(block, (char *)dind);
 429         block = result;
 430         read_block(block, (char *)ind);
 431         blk_chg = 0;
 432         result = check_zone_nr(ind + (blknr % 512), &blk_chg);
 433         if (blk_chg)
 434                 write_block(block, (char *)ind);
 435         return result;
 436 }
 437
 438 static int
 439 map_block2(struct minix2_inode *inode, unsigned int blknr) {
 440         unsigned int ind[MINIX_BLOCK_SIZE >> 2];
 441         unsigned int dind[MINIX_BLOCK_SIZE >> 2];
 442         unsigned int tind[MINIX_BLOCK_SIZE >> 2];
 443         int blk_chg, block, result;
 444
 445         if (blknr < 7)
 446                 return check_zone_nr2(inode->i_zone + blknr, &changed);
 447         blknr -= 7;
 448         if (blknr < 256) {
 449                 block = check_zone_nr2(inode->i_zone + 7, &changed);
 450                 read_block(block, (char *)ind);
 451                 blk_chg = 0;
 452                 result = check_zone_nr2(blknr + ind, &blk_chg);
 453                 if (blk_chg)
 454                         write_block(block, (char *)ind);
 455                 return result;
 456         }
 457         blknr -= 256;
 458         if (blknr < 256 * 256) {
 459                 block = check_zone_nr2(inode->i_zone + 8, &changed);
 460                 read_block(block, (char *)dind);
 461                 blk_chg = 0;
 462                 result = check_zone_nr2(dind + blknr / 256, &blk_chg);
 463                 if (blk_chg)
 464                         write_block(block, (char *)dind);
 465                 block = result;
 466                 read_block(block, (char *)ind);
 467                 blk_chg = 0;
 468                 result = check_zone_nr2(ind + blknr % 256, &blk_chg);
 469                 if (blk_chg)
 470                         write_block(block, (char *)ind);
 471                 return result;
 472         }
 473         blknr -= 256 * 256;
 474         block = check_zone_nr2(inode->i_zone + 9, &changed);
 475         read_block(block, (char *)tind);
 476         blk_chg = 0;
 477         result = check_zone_nr2(tind + blknr / (256 * 256), &blk_chg);
 478         if (blk_chg)
 479                 write_block(block, (char *)tind);
 480         block = result;
 481         read_block(block, (char *)dind);
 482         blk_chg = 0;
 483         result = check_zone_nr2(dind + (blknr / 256) % 256, &blk_chg);
 484         if (blk_chg)
 485                 write_block(block, (char *)dind);
 486         block = result;
 487         read_block(block, (char *)ind);
 488         blk_chg = 0;
 489         result = check_zone_nr2(ind + blknr % 256, &blk_chg);
 490         if (blk_chg)
 491                 write_block(block, (char *)ind);
 492         return result;
 493 }
 494
 495 static void
 496 write_super_block(void) {
 497         /* v3 super block does not track state */
 498         if (fs_version == 3)
 499                 return;
 500         /* Set the state of the filesystem based on whether or not there are
 501          * uncorrected errors.  The filesystem valid flag is unconditionally
 502          * set if we get this far.  */
 503         Super.s_state |= MINIX_VALID_FS;
 504         if (errors_uncorrected)
 505                 Super.s_state |= MINIX_ERROR_FS;
 506         else
 507                 Super.s_state &= ~MINIX_ERROR_FS;
 508
 509         if (MINIX_BLOCK_SIZE != lseek(device_fd, MINIX_BLOCK_SIZE, SEEK_SET))
 510                 die(_("seek failed in write_super_block"));
 511         if (MINIX_BLOCK_SIZE != write(device_fd, super_block_buffer, MINIX_BLOCK_SIZE))
 512                 die(_("unable to write super-block"));
 513 }
 514
 515 static void
 516 write_tables(void) {
 517         unsigned long buffsz = get_inode_buffer_size();
 518         unsigned long imaps = get_nimaps();
 519         unsigned long zmaps = get_nzmaps();
 520
 521         write_super_block();
 522
 523         if (write_all(device_fd, inode_map, imaps * MINIX_BLOCK_SIZE))
 524                 die(_("Unable to write inode map"));
 525
 526         if (write_all(device_fd, zone_map, zmaps * MINIX_BLOCK_SIZE))
 527                 die(_("Unable to write zone map"));
 528
 529         if (write_all(device_fd, inode_buffer, buffsz))
 530                 die(_("Unable to write inodes"));
 531 }
 532
 533 static void
 534 get_dirsize(void) {
 535         int block;
 536         char blk[MINIX_BLOCK_SIZE];
 537         size_t size;
 538
 539         if (fs_version == 2 || fs_version == 3)
 540                 block = Inode2[ROOT_INO].i_zone[0];
 541         else
 542                 block = Inode[ROOT_INO].i_zone[0];
 543         read_block(block, blk);
 544
 545         for (size = 16; size < MINIX_BLOCK_SIZE; size <<= 1) {
 546                 if (strcmp(blk + size + 2, "..") == 0) {
 547                         dirsize = size;
 548                         namelen = size - 2;
 549                         return;
 550                 }
 551         }
 552         /* use defaults */
 553 }
 554
 555 static void
 556 read_superblock(void) {
 557         if (MINIX_BLOCK_SIZE != lseek(device_fd, MINIX_BLOCK_SIZE, SEEK_SET))
 558                 die(_("seek failed"));
 559
 560         super_block_buffer = calloc(1, MINIX_BLOCK_SIZE);
 561         if (!super_block_buffer)
 562                 die(_("unable to alloc buffer for superblock"));
 563
 564         if (MINIX_BLOCK_SIZE != read(device_fd, super_block_buffer, MINIX_BLOCK_SIZE))
 565                 die(_("unable to read super block"));
 566         if (Super.s_magic == MINIX_SUPER_MAGIC) {
 567                 namelen = 14;
 568                 dirsize = 16;
 569                 fs_version = 1;
 570         } else if (Super.s_magic == MINIX_SUPER_MAGIC2) {
 571                 namelen = 30;
 572                 dirsize = 32;
 573                 fs_version = 1;
 574         } else if (Super.s_magic == MINIX2_SUPER_MAGIC) {
 575                 namelen = 14;
 576                 dirsize = 16;
 577                 fs_version = 2;
 578         } else if (Super.s_magic == MINIX2_SUPER_MAGIC2) {
 579                 namelen = 30;
 580                 dirsize = 32;
 581                 fs_version = 2;
 582         } else if (Super3.s_magic == MINIX3_SUPER_MAGIC) {
 583                 namelen = 60;
 584                 dirsize = 64;
 585                 fs_version = 3;
 586         } else
 587                 die(_("bad magic number in super-block"));
 588         if (get_zone_size() != 0 || MINIX_BLOCK_SIZE != 1024)
 589                 die(_("Only 1k blocks/zones supported"));
 590         if (get_ninodes() == 0 || get_ninodes() == UINT32_MAX)
 591                 die(_("bad s_ninodes field in super-block"));
 592         if (get_nimaps() * MINIX_BLOCK_SIZE * 8 < get_ninodes() + 1)
 593                 die(_("bad s_imap_blocks field in super-block"));
 594         if (get_first_zone() > (off_t) get_nzones())
 595                 die(_("bad s_firstdatazone field in super-block"));
 596         if (get_nzmaps() * MINIX_BLOCK_SIZE * 8 <
 597             get_nzones() - get_first_zone() + 1)
 598                 die(_("bad s_zmap_blocks field in super-block"));
 599 }
 600
 601 static void
 602 read_tables(void) {
 603         unsigned long inodes = get_ninodes();
 604         size_t buffsz = get_inode_buffer_size();
 605         off_t norm_first_zone = first_zone_data();
 606         off_t first_zone = get_first_zone();
 607         unsigned long zones = get_nzones();
 608         unsigned long imaps = get_nimaps();
 609         unsigned long zmaps = get_nzmaps();
 610         ssize_t rc;
 611
 612         inode_map = malloc(imaps * MINIX_BLOCK_SIZE);
 613         if (!inode_map)
 614                 die(_("Unable to allocate buffer for inode map"));
 615         zone_map = malloc(zmaps * MINIX_BLOCK_SIZE);
 616         if (!zone_map)
 617                 die(_("Unable to allocate buffer for zone map"));
 618         inode_buffer = malloc(buffsz);
 619         if (!inode_buffer)
 620                 die(_("Unable to allocate buffer for inodes"));
 621         inode_count = calloc(1, inodes + 1);
 622         if (!inode_count)
 623                 die(_("Unable to allocate buffer for inode count"));
 624         zone_count = calloc(1, zones);
 625         if (!zone_count)
 626                 die(_("Unable to allocate buffer for zone count"));
 627
 628         rc = read(device_fd, inode_map, imaps * MINIX_BLOCK_SIZE);
 629         if (rc < 0 || imaps * MINIX_BLOCK_SIZE != (size_t) rc)
 630                 die(_("Unable to read inode map"));
 631
 632         rc = read(device_fd, zone_map, zmaps * MINIX_BLOCK_SIZE);
 633         if (rc < 0 || zmaps * MINIX_BLOCK_SIZE != (size_t) rc)
 634                 die(_("Unable to read zone map"));
 635
 636         rc = read(device_fd, inode_buffer, buffsz);
 637         if (rc < 0 || buffsz != (size_t) rc)
 638                 die(_("Unable to read inodes"));
 639         if (norm_first_zone != first_zone) {
 640                 printf(_("Warning: Firstzone != Norm_firstzone\n"));
 641                 errors_uncorrected = 1;
 642         }
 643         get_dirsize();
 644         if (show) {
 645                 printf(_("%ld inodes\n"), inodes);
 646                 printf(_("%ld blocks\n"), zones);
 647                 printf(_("Firstdatazone=%jd (%jd)\n"),
 648                         (intmax_t)first_zone, (intmax_t)norm_first_zone);
 649                 printf(_("Zonesize=%d\n"), MINIX_BLOCK_SIZE << get_zone_size());
 650                 printf(_("Maxsize=%zu\n"), get_max_size());
 651                 if (fs_version < 3)
 652                         printf(_("Filesystem state=%d\n"), Super.s_state);
 653                 printf(_("namelen=%zd\n\n"), namelen);
 654         }
 655 }
 656
 657 static struct minix_inode *
 658 get_inode(unsigned int nr) {
 659         struct minix_inode *inode;
 660
 661         if (!nr || nr > get_ninodes())
 662                 return NULL;
 663         total++;
 664         inode = Inode + nr;
 665         if (!inode_count[nr]) {
 666                 if (!inode_in_use(nr)) {
 667                         get_current_name();
 668                         printf(_("Inode %d marked unused, "
 669                                  "but used for file '%s'\n"), nr, current_name);
 670                         if (repair) {
 671                                 if (ask(_("Mark in use"), 1))
 672                                         mark_inode(nr);
 673                         } else {
 674                                 errors_uncorrected = 1;
 675                         }
 676                 }
 677                 if (S_ISDIR(inode->i_mode))
 678                         directory++;
 679                 else if (S_ISREG(inode->i_mode))
 680                         regular++;
 681                 else if (S_ISCHR(inode->i_mode))
 682                         chardev++;
 683                 else if (S_ISBLK(inode->i_mode))
 684                         blockdev++;
 685                 else if (S_ISLNK(inode->i_mode))
 686                         symlinks++;
 687                 else if (S_ISSOCK(inode->i_mode))
 688                         ;
 689                 else if (S_ISFIFO(inode->i_mode))
 690                         ;
 691                 else {
 692                         get_current_name();
 693                         printf(_("The file `%s' has mode %05o\n"),
 694                                current_name, inode->i_mode);
 695                 }
 696
 697         } else
 698                 links++;
 699         if (!++inode_count[nr]) {
 700                 printf(_("Warning: inode count too big.\n"));
 701                 inode_count[nr]--;
 702                 errors_uncorrected = 1;
 703         }
 704         return inode;
 705 }
 706
 707 static struct minix2_inode *
 708 get_inode2(unsigned int nr) {
 709         struct minix2_inode *inode;
 710
 711         if (!nr || nr > get_ninodes())
 712                 return NULL;
 713         total++;
 714         inode = Inode2 + nr;
 715         if (!inode_count[nr]) {
 716                 if (!inode_in_use(nr)) {
 717                         get_current_name();
 718                         printf(_("Inode %d marked unused, "
 719                                  "but used for file '%s'\n"), nr, current_name);
 720                         if (repair) {
 721                                 if (ask(_("Mark in use"), 1))
 722                                         mark_inode(nr);
 723                                 else
 724                                         errors_uncorrected = 1;
 725                         }
 726                 }
 727                 if (S_ISDIR(inode->i_mode))
 728                         directory++;
 729                 else if (S_ISREG(inode->i_mode))
 730                         regular++;
 731                 else if (S_ISCHR(inode->i_mode))
 732                         chardev++;
 733                 else if (S_ISBLK(inode->i_mode))
 734                         blockdev++;
 735                 else if (S_ISLNK(inode->i_mode))
 736                         symlinks++;
 737                 else if (S_ISSOCK(inode->i_mode)) ;
 738                 else if (S_ISFIFO(inode->i_mode)) ;
 739                 else {
 740                         get_current_name();
 741                         printf(_("The file `%s' has mode %05o\n"),
 742                                current_name, inode->i_mode);
 743                 }
 744         } else
 745                 links++;
 746         if (!++inode_count[nr]) {
 747                 printf(_("Warning: inode count too big.\n"));
 748                 inode_count[nr]--;
 749                 errors_uncorrected = 1;
 750         }
 751         return inode;
 752 }
 753
 754 static void
 755 check_root(void) {
 756         struct minix_inode *inode = Inode + ROOT_INO;
 757
 758         if (!inode || !S_ISDIR(inode->i_mode))
 759                 die(_("root inode isn't a directory"));
 760 }
 761
 762 static void
 763 check_root2(void) {
 764         struct minix2_inode *inode = Inode2 + ROOT_INO;
 765
 766         if (!inode || !S_ISDIR(inode->i_mode))
 767                 die(_("root inode isn't a directory"));
 768 }
 769
 770 static int
 771 add_zone(unsigned short *znr, int *corrected) {
 772         int block;
 773
 774         block = check_zone_nr(znr, corrected);
 775         if (!block)
 776                 return 0;
 777         if (zone_count[block]) {
 778                 get_current_name();
 779                 printf(_("Block has been used before. Now in file `%s'."),
 780                        current_name);
 781                 if (ask(_("Clear"), 1)) {
 782                         *znr = 0;
 783                         block = 0;
 784                         *corrected = 1;
 785                 }
 786         }
 787         if (!block)
 788                 return 0;
 789         if (!zone_in_use(block)) {
 790                 get_current_name();
 791                 printf(_("Block %d in file `%s' is marked not in use."),
 792                        block, current_name);
 793                 if (ask(_("Correct"), 1))
 794                         mark_zone(block);
 795         }
 796         if (!++zone_count[block])
 797                 zone_count[block]--;
 798         return block;
 799 }
 800
 801 static int
 802 add_zone2(unsigned int *znr, int *corrected) {
 803         int block;
 804
 805         block = check_zone_nr2(znr, corrected);
 806         if (!block)
 807                 return 0;
 808         if (zone_count[block]) {
 809                 get_current_name();
 810                 printf(_("Block has been used before. Now in file `%s'."),
 811                        current_name);
 812                 if (ask(_("Clear"), 1)) {
 813                         *znr = 0;
 814                         block = 0;
 815                         *corrected = 1;
 816                 }
 817         }
 818         if (!block)
 819                 return 0;
 820         if (!zone_in_use(block)) {
 821                 get_current_name();
 822                 printf(_("Block %d in file `%s' is marked not in use."),
 823                        block, current_name);
 824                 if (ask(_("Correct"), 1))
 825                         mark_zone(block);
 826         }
 827         if (!++zone_count[block])
 828                 zone_count[block]--;
 829         return block;
 830 }
 831
 832 static void
 833 add_zone_ind(unsigned short *znr, int *corrected) {
 834         static char blk[MINIX_BLOCK_SIZE];
 835         int i, chg_blk = 0;
 836         int block;
 837
 838         block = add_zone(znr, corrected);
 839         if (!block)
 840                 return;
 841         read_block(block, blk);
 842         for (i = 0; i < (MINIX_BLOCK_SIZE >> 1); i++)
 843                 add_zone(i + (unsigned short *)blk, &chg_blk);
 844         if (chg_blk)
 845                 write_block(block, blk);
 846 }
 847
 848 static void
 849 add_zone_ind2(unsigned int *znr, int *corrected) {
 850         static char blk[MINIX_BLOCK_SIZE];
 851         int i, chg_blk = 0;
 852         int block;
 853
 854         block = add_zone2(znr, corrected);
 855         if (!block)
 856                 return;
 857         read_block(block, blk);
 858         for (i = 0; i < MINIX_BLOCK_SIZE >> 2; i++)
 859                 add_zone2(i + (unsigned int *)blk, &chg_blk);
 860         if (chg_blk)
 861                 write_block(block, blk);
 862 }
 863
 864 static void
 865 add_zone_dind(unsigned short *znr, int *corrected) {
 866         static char blk[MINIX_BLOCK_SIZE];
 867         int i, blk_chg = 0;
 868         int block;
 869
 870         block = add_zone(znr, corrected);
 871         if (!block)
 872                 return;
 873         read_block(block, blk);
 874         for (i = 0; i < (MINIX_BLOCK_SIZE >> 1); i++)
 875                 add_zone_ind(i + (unsigned short *)blk, &blk_chg);
 876         if (blk_chg)
 877                 write_block(block, blk);
 878 }
 879
 880 static void
 881 add_zone_dind2(unsigned int *znr, int *corrected) {
 882         static char blk[MINIX_BLOCK_SIZE];
 883         int i, blk_chg = 0;
 884         int block;
 885
 886         block = add_zone2(znr, corrected);
 887         if (!block)
 888                 return;
 889         read_block(block, blk);
 890         for (i = 0; i < MINIX_BLOCK_SIZE >> 2; i++)
 891                 add_zone_ind2(i + (unsigned int *)blk, &blk_chg);
 892         if (blk_chg)
 893                 write_block(block, blk);
 894 }
 895
 896 static void
 897 add_zone_tind2(unsigned int *znr, int *corrected) {
 898         static char blk[MINIX_BLOCK_SIZE];
 899         int i, blk_chg = 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 < MINIX_BLOCK_SIZE >> 2; i++)
 907                 add_zone_dind2(i + (unsigned int *)blk, &blk_chg);
 908         if (blk_chg)
 909                 write_block(block, blk);
 910 }
 911
 912 static void
 913 check_zones(unsigned int i) {
 914         struct minix_inode *inode;
 915
 916         if (!i || i > get_ninodes())
 917                 return;
 918         if (inode_count[i] > 1) /* have we counted this file already? */
 919                 return;
 920         inode = Inode + i;
 921         if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode) &&
 922             !S_ISLNK(inode->i_mode))
 923                 return;
 924         for (i = 0; i < 7; i++)
 925                 add_zone(i + inode->i_zone, &changed);
 926         add_zone_ind(7 + inode->i_zone, &changed);
 927         add_zone_dind(8 + inode->i_zone, &changed);
 928 }
 929
 930 static void
 931 check_zones2(unsigned int i) {
 932         struct minix2_inode *inode;
 933
 934         if (!i || i > get_ninodes())
 935                 return;
 936         if (inode_count[i] > 1) /* have we counted this file already? */
 937                 return;
 938         inode = Inode2 + i;
 939         if (!S_ISDIR(inode->i_mode) && !S_ISREG(inode->i_mode)
 940             && !S_ISLNK(inode->i_mode))
 941                 return;
 942         for (i = 0; i < 7; i++)
 943                 add_zone2(i + inode->i_zone, &changed);
 944         add_zone_ind2(7 + inode->i_zone, &changed);
 945         add_zone_dind2(8 + inode->i_zone, &changed);
 946         add_zone_tind2(9 + inode->i_zone, &changed);
 947 }
 948
 949 static void
 950 check_file(struct minix_inode *dir, unsigned int offset) {
 951         static char blk[MINIX_BLOCK_SIZE + 2];
 952         struct minix_inode *inode;
 953         unsigned int ino;
 954         char *name;
 955         int block;
 956
 957         block = map_block(dir, offset / MINIX_BLOCK_SIZE);
 958         read_block(block, blk);
 959         name = blk + (offset % MINIX_BLOCK_SIZE) + 2;
 960         ino = *(unsigned short *)(name - 2);
 961         if (ino > get_ninodes()) {
 962                 get_current_name();
 963                 printf(_("The directory '%s' contains a bad inode number "
 964                          "for file '%.*s'."), current_name, (int)namelen, name);
 965                 if (ask(_(" Remove"), 1)) {
 966                         *(unsigned short *)(name - 2) = 0;
 967                         write_block(block, blk);
 968                 }
 969                 ino = 0;
 970         }
 971         if (name_depth < MAX_DEPTH)
 972                 xstrncpy(name_list[name_depth], name, namelen);
 973         else
 974                 return;
 975         name_depth++;
 976         inode = get_inode(ino);
 977         name_depth--;
 978         if (!offset) {
 979                 if (!inode || strcmp(".", name) != 0) {
 980                         get_current_name();
 981                         printf(_("%s: bad directory: '.' isn't first\n"),
 982                                current_name);
 983                         errors_uncorrected = 1;
 984                 } else
 985                         return;
 986         }
 987         if (offset == dirsize) {
 988                 if (!inode || strcmp("..", name) != 0) {
 989                         get_current_name();
 990                         printf(_("%s: bad directory: '..' isn't second\n"),
 991                                current_name);
 992                         errors_uncorrected = 1;
 993                 } else
 994                         return;
 995         }
 996         if (!inode)
 997                 return;
 998         if (name_depth < MAX_DEPTH)
 999                 xstrncpy(name_list[name_depth], name, namelen);
1000         else
1001                 return;
1002         name_depth++;
1003         if (list) {
1004                 if (verbose)
1005                         printf("%6d %07o %3d ", ino,
1006                                inode->i_mode, inode->i_nlinks);
1007                 get_current_name();
1008                 printf("%s", current_name);
1009                 if (S_ISDIR(inode->i_mode))
1010                         printf(":\n");
1011                 else
1012                         printf("\n");
1013         }
1014         check_zones(ino);
1015         if (inode && S_ISDIR(inode->i_mode))
1016                 recursive_check(ino);
1017         name_depth--;
1018 }
1019
1020 static void
1021 check_file2(struct minix2_inode *dir, unsigned int offset) {
1022         static char blk[MINIX_BLOCK_SIZE + 4];
1023         struct minix2_inode *inode;
1024         ino_t ino;
1025         char *name;
1026         int block;
1027         const int version_offset = fs_version == 3 ? 4 : 2;
1028
1029         block = map_block2(dir, offset / MINIX_BLOCK_SIZE);
1030         read_block(block, blk);
1031         name = blk + (offset % MINIX_BLOCK_SIZE) + version_offset;
1032         ino = version_offset == 4 ? *(uint32_t *)(name - version_offset)
1033                                   : *(uint16_t *)(name - version_offset);
1034         if (ino > get_ninodes()) {
1035                 get_current_name();
1036                 printf(_("The directory '%s' contains a bad inode number "
1037                          "for file '%.*s'."), current_name, (int)namelen, name);
1038                 if (ask(_(" Remove"), 1)) {
1039                         memset(name - version_offset, 0, version_offset);
1040                         write_block(block, blk);
1041                 }
1042                 ino = 0;
1043         }
1044         if (name_depth < MAX_DEPTH)
1045                 xstrncpy(name_list[name_depth], name, namelen);
1046         else
1047                 return;
1048         name_depth++;
1049         inode = get_inode2(ino);
1050         name_depth--;
1051         if (!offset) {
1052                 if (!inode || strcmp(".", name) != 0) {
1053                         get_current_name();
1054                         printf(_("%s: bad directory: '.' isn't first\n"),
1055                                current_name);
1056                         errors_uncorrected = 1;
1057                 } else
1058                         return;
1059         }
1060         if (offset == dirsize) {
1061                 if (!inode || strcmp("..", name) != 0) {
1062                         get_current_name();
1063                         printf(_("%s: bad directory: '..' isn't second\n"),
1064                                current_name);
1065                         errors_uncorrected = 1;
1066                 } else
1067                         return;
1068         }
1069         if (!inode)
1070                 return;
1071         name_depth++;
1072         if (list) {
1073                 if (verbose)
1074                         printf("%6ju %07o %3d ", (uintmax_t)ino, inode->i_mode,
1075                                inode->i_nlinks);
1076                 get_current_name();
1077                 printf("%s", current_name);
1078                 if (S_ISDIR(inode->i_mode))
1079                         printf(":\n");
1080                 else
1081                         printf("\n");
1082         }
1083         check_zones2(ino);
1084         if (inode && S_ISDIR(inode->i_mode))
1085                 recursive_check2(ino);
1086         name_depth--;
1087 }
1088
1089 static void
1090 recursive_check(unsigned int ino) {
1091         struct minix_inode *dir;
1092         off_t offset;
1093
1094         dir = Inode + ino;
1095         if (!S_ISDIR(dir->i_mode))
1096                 die(_("internal error"));
1097         if (dir->i_size < 2 * dirsize) {
1098                 get_current_name();
1099                 printf(_("%s: bad directory: size < 32"), current_name);
1100                 errors_uncorrected = 1;
1101         }
1102
1103         if ((!repair || automatic) && !is_valid_zone_nr(*dir->i_zone)) {
1104                 get_current_name();
1105                 printf(_("%s: bad directory: invalid i_zone, use --repair to fix\n"), current_name);
1106                 return;
1107         }
1108         for (offset = 0; offset < dir->i_size; offset += dirsize)
1109                 check_file(dir, offset);
1110 }
1111
1112 static void
1113 recursive_check2(unsigned int ino) {
1114         struct minix2_inode *dir;
1115         off_t offset;
1116
1117         dir = Inode2 + ino;
1118         if (!S_ISDIR(dir->i_mode))
1119                 die(_("internal error"));
1120         if (dir->i_size < 2 * dirsize) {
1121                 get_current_name();
1122                 printf(_("%s: bad directory: size < 32"), current_name);
1123                 errors_uncorrected = 1;
1124         }
1125         for (offset = 0; offset < dir->i_size; offset += dirsize)
1126                 check_file2(dir, offset);
1127 }
1128
1129 static int
1130 bad_zone(int i) {
1131         char buffer[1024];
1132
1133         if (MINIX_BLOCK_SIZE * i != lseek(device_fd, MINIX_BLOCK_SIZE * i, SEEK_SET))
1134                 die(_("seek failed in bad_zone"));
1135         return (MINIX_BLOCK_SIZE != read(device_fd, buffer, MINIX_BLOCK_SIZE));
1136 }
1137
1138 static void
1139 check_counts(void) {
1140         unsigned long i;
1141
1142         for (i = 1; i <= get_ninodes(); i++) {
1143                 if (!inode_in_use(i) && Inode[i].i_mode && warn_mode) {
1144                         printf(_("Inode %lu mode not cleared."), i);
1145                         if (ask(_("Clear"), 1)) {
1146                                 Inode[i].i_mode = 0;
1147                                 changed = 1;
1148                         }
1149                 }
1150                 if (!inode_count[i]) {
1151                         if (!inode_in_use(i))
1152                                 continue;
1153                         printf(_("Inode %lu not used, marked used in the bitmap."), i);
1154                         if (ask(_("Clear"), 1))
1155                                 unmark_inode(i);
1156                         continue;
1157                 }
1158                 if (!inode_in_use(i)) {
1159                         printf(_("Inode %lu used, marked unused in the bitmap."), i);
1160                         if (ask(_("Set"), 1))
1161                                 mark_inode(i);
1162                 }
1163                 if (Inode[i].i_nlinks != inode_count[i]) {
1164                         printf(_("Inode %lu (mode = %07o), i_nlinks=%d, counted=%d."),
1165                                i, Inode[i].i_mode, Inode[i].i_nlinks,
1166                                inode_count[i]);
1167                         if (ask(_("Set i_nlinks to count"), 1)) {
1168                                 Inode[i].i_nlinks = inode_count[i];
1169                                 changed = 1;
1170                         }
1171                 }
1172         }
1173         for (i = get_first_zone(); i < get_nzones(); i++) {
1174                 if (zone_in_use(i) == zone_count[i])
1175                         continue;
1176                 if (!zone_count[i]) {
1177                         if (bad_zone(i))
1178                                 continue;
1179                         printf(_("Zone %lu: marked in use, no file uses it."),
1180                                i);
1181                         if (ask(_("Unmark"), 1))
1182                                 unmark_zone(i);
1183                         continue;
1184                 }
1185                 if (zone_in_use(i))
1186                         printf(_("Zone %lu: in use, counted=%d\n"),
1187                                i, zone_count[i]);
1188                 else
1189                         printf(_("Zone %lu: not in use, counted=%d\n"),
1190                                i, zone_count[i]);
1191         }
1192 }
1193
1194 static void
1195 check_counts2(void) {
1196         unsigned long i;
1197
1198         for (i = 1; i <= get_ninodes(); i++) {
1199                 if (!inode_in_use(i) && Inode2[i].i_mode && warn_mode) {
1200                         printf(_("Inode %lu mode not cleared."), i);
1201                         if (ask(_("Clear"), 1)) {
1202                                 Inode2[i].i_mode = 0;
1203                                 changed = 1;
1204                         }
1205                 }
1206                 if (!inode_count[i]) {
1207                         if (!inode_in_use(i))
1208                                 continue;
1209                         printf(_("Inode %lu not used, marked used in the bitmap."), i);
1210                         if (ask(_("Clear"), 1))
1211                                 unmark_inode(i);
1212                         continue;
1213                 }
1214                 if (!inode_in_use(i)) {
1215                         printf(_("Inode %lu used, marked unused in the bitmap."), i);
1216                         if (ask(_("Set"), 1))
1217                                 mark_inode(i);
1218                 }
1219                 if (Inode2[i].i_nlinks != inode_count[i]) {
1220                         printf(_("Inode %lu (mode = %07o), i_nlinks=%d, counted=%d."),
1221                                i, Inode2[i].i_mode, Inode2[i].i_nlinks,
1222                                inode_count[i]);
1223                         if (ask(_("Set i_nlinks to count"), 1)) {
1224                                 Inode2[i].i_nlinks = inode_count[i];
1225                                 changed = 1;
1226                         }
1227                 }
1228         }
1229         for (i = get_first_zone(); i < get_nzones(); i++) {
1230                 if (zone_in_use(i) == zone_count[i])
1231                         continue;
1232                 if (!zone_count[i]) {
1233                         if (bad_zone(i))
1234                                 continue;
1235                         printf(_("Zone %lu: marked in use, no file uses it."),
1236                                i);
1237                         if (ask(_("Unmark"), 1))
1238                                 unmark_zone(i);
1239                         continue;
1240                 }
1241                 if (zone_in_use(i))
1242                         printf(_("Zone %lu: in use, counted=%d\n"),
1243                                i, zone_count[i]);
1244                 else
1245                         printf(_("Zone %lu: not in use, counted=%d\n"),
1246                                i, zone_count[i]);
1247         }
1248 }
1249
1250 static void
1251 check(void) {
1252         memset(inode_count, 0, (get_ninodes() + 1) * sizeof(*inode_count));
1253         memset(zone_count, 0, get_nzones() * sizeof(*zone_count));
1254         check_zones(ROOT_INO);
1255         recursive_check(ROOT_INO);
1256         check_counts();
1257 }
1258
1259 static void
1260 check2(void) {
1261         memset(inode_count, 0, (get_ninodes() + 1) * sizeof(*inode_count));
1262         memset(zone_count, 0, get_nzones() * sizeof(*zone_count));
1263         check_zones2(ROOT_INO);
1264         recursive_check2(ROOT_INO);
1265         check_counts2();
1266 }
1267
1268 int
1269 main(int argc, char **argv) {
1270         struct termios tmp;
1271         int count;
1272         int retcode = FSCK_EX_OK;
1273         int i;
1274         static const struct option longopts[] = {
1275                 {"list", no_argument, NULL, 'l'},
1276                 {"auto", no_argument, NULL, 'a'},
1277                 {"repair", no_argument, NULL, 'r'},
1278                 {"verbose", no_argument, NULL, 'v'},
1279                 {"super", no_argument, NULL, 's'},
1280                 {"uncleared", no_argument, NULL, 'm'},
1281                 {"force", no_argument, NULL, 'f'},
1282                 {"version", no_argument, NULL, 'V'},
1283                 {"help", no_argument, NULL, 'h'},
1284                 {NULL, 0, NULL, 0}
1285         };
1286
1287         setlocale(LC_ALL, "");
1288         bindtextdomain(PACKAGE, LOCALEDIR);
1289         textdomain(PACKAGE);
1290         close_stdout_atexit();
1291
1292         strutils_set_exitcode(FSCK_EX_USAGE);
1293
1294         if (INODE_SIZE * MINIX_INODES_PER_BLOCK != MINIX_BLOCK_SIZE)
1295                 die(_("bad inode size"));
1296         if (INODE2_SIZE * MINIX2_INODES_PER_BLOCK != MINIX_BLOCK_SIZE)
1297                 die(_("bad v2 inode size"));
1298
1299         while ((i = getopt_long(argc, argv, "larvsmfVh", longopts, NULL)) != -1)
1300                 switch (i) {
1301                 case 'l':
1302                         list = 1;
1303                         break;
1304                 case 'a':
1305                         automatic = 1;
1306                         repair = 1;
1307                         break;
1308                 case 'r':
1309                         automatic = 0;
1310                         repair = 1;
1311                         break;
1312                 case 'v':
1313                         verbose = 1;
1314                         break;
1315                 case 's':
1316                         show = 1;
1317                         break;
1318                 case 'm':
1319                         warn_mode = 1;
1320                         break;
1321                 case 'f':
1322                         force = 1;
1323                         break;
1324                 case 'V':
1325                         print_version(FSCK_EX_OK);
1326                 case 'h':
1327                         usage();
1328                 default:
1329                         errtryhelp(FSCK_EX_USAGE);
1330                 }
1331         argc -= optind;
1332         argv += optind;
1333         if (0 < argc) {
1334                 device_name = argv[0];
1335         } else {
1336                 warnx(_("no device specified"));
1337                 errtryhelp(FSCK_EX_USAGE);
1338         }
1339         check_mount();          /* trying to check a mounted filesystem? */
1340         if (repair && !automatic && (!isatty(STDIN_FILENO) || !isatty(STDOUT_FILENO)))
1341                 die(_("need terminal for interactive repairs"));
1342
1343         device_fd = open(device_name, repair ? O_RDWR : O_RDONLY);
1344         if (device_fd < 0)
1345                 die(_("cannot open %s: %s"), device_name, strerror(errno));
1346         for (count = 0; count < 3; count++)
1347                 sync();
1348         read_superblock();
1349
1350         /* Determine whether or not we should continue with the checking.  This
1351          * is based on the status of the filesystem valid and error flags and
1352          * whether or not the -f switch was specified on the command line.  */
1353         if (fs_version < 3 && !(Super.s_state & MINIX_ERROR_FS) &&
1354             (Super.s_state & MINIX_VALID_FS) && !force) {
1355                 if (repair)
1356                         printf(_("%s is clean, no check.\n"), device_name);
1357                 return retcode;
1358         }
1359
1360         if (force)
1361                 printf(_("Forcing filesystem check on %s.\n"), device_name);
1362         else if (repair)
1363                 printf(_("Filesystem on %s is dirty, needs checking.\n"),
1364                        device_name);
1365
1366         read_tables();
1367
1368         /* Restore the terminal state on fatal signals.  We don't do this for
1369          * SIGALRM, SIGUSR1 or SIGUSR2.  */
1370         signal(SIGINT, fatalsig);
1371         signal(SIGQUIT, fatalsig);
1372         signal(SIGTERM, fatalsig);
1373
1374         if (repair && !automatic) {
1375                 tcgetattr(STDIN_FILENO, &termios);
1376                 tmp = termios;
1377                 tmp.c_lflag &= ~(ICANON | ECHO);
1378                 tcsetattr(STDIN_FILENO, TCSANOW, &tmp);
1379                 termios_set = 1;
1380         }
1381
1382         if (fs_version == 2 || fs_version == 3) {
1383                 check_root2();
1384                 check2();
1385         } else {
1386                 check_root();
1387                 check();
1388         }
1389         if (verbose) {
1390                 unsigned long inode, free;
1391
1392                 for (inode = 1, free = 0; inode <= get_ninodes(); inode++)
1393                         if (!inode_in_use(inode))
1394                                 free++;
1395                 printf(_("\n%6ld inodes used (%ld%%)\n"),
1396                        (get_ninodes() - free),
1397                        100 * (get_ninodes() - free) / get_ninodes());
1398                 for (inode = get_first_zone(), free = 0; inode < get_nzones(); inode++)
1399                         if (!zone_in_use(inode))
1400                                 free++;
1401                 printf(_("%6ld zones used (%ld%%)\n"), (get_nzones() - free),
1402                        100 * (get_nzones() - free) / get_nzones());
1403                 printf(_("\n%6d regular files\n"
1404                          "%6d directories\n"
1405                          "%6d character device files\n"
1406                          "%6d block device files\n"
1407                          "%6d links\n"
1408                          "%6d symbolic links\n"
1409                          "------\n"
1410                          "%6d files\n"),
1411                        regular, directory, chardev, blockdev,
1412                        links - 2 * directory + 1, symlinks,
1413                        total - 2 * directory + 1);
1414         }
1415         if (changed) {
1416                 write_tables();
1417                 printf(_("----------------------------\n"
1418                          "FILE SYSTEM HAS BEEN CHANGED\n"
1419                          "----------------------------\n"));
1420                 for (count = 0; count < 3; count++)
1421                         sync();
1422         } else if (repair)
1423                 write_super_block();
1424
1425         if (repair && !automatic)
1426                 tcsetattr(STDIN_FILENO, TCSANOW, &termios);
1427
1428         if (close_fd(device_fd) != 0)
1429                 err(FSCK_EX_ERROR, _("write failed"));
1430         if (changed)
1431                 retcode += 3;
1432         if (errors_uncorrected)
1433                 retcode += 4;
1434         return retcode;
1435 }