e2fsck/unix.c

   1 /*
   2  * unix.c - The unix-specific code for e2fsck
   3  *
   4  * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
   5  *
   6  * %Begin-Header%
   7  * This file may be redistributed under the terms of the GNU Public
   8  * License.
   9  * %End-Header%
  10  */
  11
  12 #include <stdio.h>
  13 #ifdef HAVE_STDLIB_H
  14 #include <stdlib.h>
  15 #endif
  16 #include <string.h>
  17 #include <fcntl.h>
  18 #include <ctype.h>
  19 #include <termios.h>
  20 #include <time.h>
  21 #ifdef HAVE_GETOPT_H
  22 #include <getopt.h>
  23 #endif
  24 #include <unistd.h>
  25 #ifdef HAVE_ERRNO_H
  26 #include <errno.h>
  27 #endif
  28 #ifdef HAVE_MNTENT_H
  29 #include <mntent.h>
  30 #endif
  31 #include <sys/ioctl.h>
  32 #include <malloc.h>
  33
  34 #include "et/com_err.h"
  35 #include "e2fsck.h"
  36 #include "problem.h"
  37 #include "../version.h"
  38
  39 extern int isatty(int);
  40
  41 /* Command line options */
  42 static int blocksize = 0;
  43 static int swapfs = 0;
  44 static int normalize_swapfs = 0;
  45 static int cflag = 0;           /* check disk */
  46 static int show_version_only = 0;
  47 static int force = 0;
  48 static int verbose = 0;
  49
  50 static int replace_bad_blocks = 0;
  51 static char *bad_blocks_file = 0;
  52
  53 static int possible_block_sizes[] = { 1024, 2048, 4096, 8192, 0};
  54
  55 static int root_filesystem = 0;
  56 static int read_only_root = 0;
  57
  58 static void usage(e2fsck_t ctx)
  59 {
  60         fprintf(stderr,
  61                 "Usage: %s [-panyrcdfvstFSV] [-b superblock] [-B blocksize]\n"
  62                 "\t\t[-I inode_buffer_blocks] [-P process_inode_size]\n"
  63                 "\t\t[-l|-L bad_blocks_file] device\n", ctx->program_name);
  64         exit(FSCK_USAGE);
  65 }
  66
  67 static void show_stats(e2fsck_t ctx)
  68 {
  69         ext2_filsys fs = ctx->fs;
  70         int inodes, inodes_used, blocks, blocks_used;
  71         int dir_links;
  72         int num_files, num_links;
  73         int frag_percent;
  74
  75         dir_links = 2 * ctx->fs_directory_count - 1;
  76         num_files = ctx->fs_total_count - dir_links;
  77         num_links = ctx->fs_links_count - dir_links;
  78         inodes = fs->super->s_inodes_count;
  79         inodes_used = (fs->super->s_inodes_count -
  80                        fs->super->s_free_inodes_count);
  81         blocks = fs->super->s_blocks_count;
  82         blocks_used = (fs->super->s_blocks_count -
  83                        fs->super->s_free_blocks_count);
  84
  85         frag_percent = (10000 * ctx->fs_fragmented) / inodes_used;
  86         frag_percent = (frag_percent + 5) / 10;
  87
  88         if (!verbose) {
  89                 printf("%s: %d/%d files (%0d.%d%% non-contiguous), %d/%d blocks\n",
  90                        ctx->device_name, inodes_used, inodes,
  91                        frag_percent / 10, frag_percent % 10,
  92                        blocks_used, blocks);
  93                 return;
  94         }
  95         printf ("\n%8d inode%s used (%d%%)\n", inodes_used,
  96                 (inodes_used != 1) ? "s" : "",
  97                 100 * inodes_used / inodes);
  98         printf ("%8d non-contiguous inodes (%0d.%d%%)\n",
  99                 ctx->fs_fragmented, frag_percent / 10, frag_percent % 10);
 100         printf ("         # of inodes with ind/dind/tind blocks: %d/%d/%d\n",
 101                 ctx->fs_ind_count, ctx->fs_dind_count, ctx->fs_tind_count);
 102         printf ("%8d block%s used (%d%%)\n"
 103                 "%8d bad block%s\n", blocks_used,
 104                 (blocks_used != 1) ? "s" : "",
 105                 100 * blocks_used / blocks, ctx->fs_badblocks_count,
 106                 ctx->fs_badblocks_count != 1 ? "s" : "");
 107         printf ("\n%8d regular file%s\n"
 108                 "%8d director%s\n"
 109                 "%8d character device file%s\n"
 110                 "%8d block device file%s\n"
 111                 "%8d fifo%s\n"
 112                 "%8d link%s\n"
 113                 "%8d symbolic link%s (%d fast symbolic link%s)\n"
 114                 "%8d socket%s\n"
 115                 "--------\n"
 116                 "%8d file%s\n",
 117                 ctx->fs_regular_count,
 118                 (ctx->fs_regular_count != 1) ? "s" : "",
 119                 ctx->fs_directory_count,
 120                 (ctx->fs_directory_count != 1) ? "ies" : "y",
 121                 ctx->fs_chardev_count,
 122                 (ctx->fs_chardev_count != 1) ? "s" : "",
 123                 ctx->fs_blockdev_count,
 124                 (ctx->fs_blockdev_count != 1) ? "s" : "",
 125                 ctx->fs_fifo_count,
 126                 (ctx->fs_fifo_count != 1) ? "s" : "",
 127                 ctx->fs_links_count - dir_links,
 128                 ((ctx->fs_links_count - dir_links) != 1) ? "s" : "",
 129                 ctx->fs_symlinks_count,
 130                 (ctx->fs_symlinks_count != 1) ? "s" : "",
 131                 ctx->fs_fast_symlinks_count,
 132                 (ctx->fs_fast_symlinks_count != 1) ? "s" : "",
 133                 ctx->fs_sockets_count, (ctx->fs_sockets_count != 1) ? "s" : "",
 134                 ctx->fs_total_count - dir_links,
 135                 ((ctx->fs_total_count - dir_links) != 1) ? "s" : "");
 136 }
 137
 138 static void check_mount(e2fsck_t ctx)
 139 {
 140         errcode_t       retval;
 141         int             mount_flags, cont, fd;
 142
 143         retval = ext2fs_check_if_mounted(ctx->filesystem_name, &mount_flags);
 144         if (retval) {
 145                 com_err("ext2fs_check_if_mount", retval,
 146                         "while determining whether %s is mounted.",
 147                         ctx->filesystem_name);
 148                 return;
 149         }
 150         if (!(mount_flags & EXT2_MF_MOUNTED))
 151                 return;
 152
 153 #if (defined(__linux__) && defined(HAVE_MNTENT_H))
 154         /*
 155          * If the root is mounted read-only, then /etc/mtab is
 156          * probably not correct; so we won't issue a warning based on
 157          * it.
 158          */
 159         fd = open(MOUNTED, O_RDWR);
 160         if (fd < 0) {
 161                 if (errno == EROFS)
 162                         return;
 163         } else
 164                 close(fd);
 165 #endif
 166
 167         if (ctx->options & E2F_OPT_READONLY) {
 168                 printf("Warning!  %s is mounted.\n", ctx->device_name);
 169                 return;
 170         }
 171
 172         printf("%s is mounted.\n\n", ctx->device_name);
 173         printf("\007\007\007\007WARNING!!!  Running e2fsck on a mounted filesystem "
 174                "may cause\nSEVERE filesystem damage.\007\007\007\n\n");
 175         if (isatty (0) && isatty (1))
 176                 cont = ask_yn("Do you really want to continue", -1);
 177         else
 178                 cont = 0;
 179         if (!cont) {
 180                 printf ("check aborted.\n");
 181                 exit (0);
 182         }
 183         return;
 184 }
 185
 186 /*
 187  * This routine checks to see if a filesystem can be skipped; if so,
 188  * it will exit with E2FSCK_OK.  Under some conditions it will print a
 189  * message explaining why a check is being forced.
 190  */
 191 static void check_if_skip(e2fsck_t ctx)
 192 {
 193         ext2_filsys fs = ctx->fs;
 194         const char *reason = NULL;
 195
 196         if (force || bad_blocks_file || cflag || swapfs)
 197                 return;
 198
 199         if (fs->super->s_state & EXT2_ERROR_FS)
 200                 reason = "contains a file system with errors";
 201         else if ((fs->super->s_state & EXT2_VALID_FS) == 0)
 202                 reason = "was not cleanly unmounted";
 203         else if (fs->super->s_mnt_count >=
 204                  (unsigned) fs->super->s_max_mnt_count)
 205                 reason = "has reached maximal mount count";
 206         else if (fs->super->s_checkinterval &&
 207                  time(0) >= (fs->super->s_lastcheck +
 208                              fs->super->s_checkinterval))
 209                 reason = "has gone too long without being checked";
 210         if (reason) {
 211                 printf("%s %s, check forced.\n", ctx->device_name, reason);
 212                 return;
 213         }
 214         printf("%s: clean, %d/%d files, %d/%d blocks\n", ctx->device_name,
 215                fs->super->s_inodes_count - fs->super->s_free_inodes_count,
 216                fs->super->s_inodes_count,
 217                fs->super->s_blocks_count - fs->super->s_free_blocks_count,
 218                fs->super->s_blocks_count);
 219         ext2fs_close(fs);
 220         exit(FSCK_OK);
 221 }
 222
 223 /*
 224  * For completion notice
 225  */
 226 static int e2fsck_update_progress(e2fsck_t ctx, int pass,
 227                                   unsigned long cur, unsigned long max)
 228 {
 229         const char spinner[] = "\\|/-";
 230         char buf[80];
 231
 232         if (pass == 0)
 233                 return 0;
 234
 235         if (ctx->progress_fd) {
 236                 sprintf(buf, "%d %lu %lu\n", pass, cur, max);
 237                 write(ctx->progress_fd, buf, strlen(buf));
 238         } else {
 239                 ctx->progress_pos = (ctx->progress_pos+1) & 3;
 240                 fputc(spinner[ctx->progress_pos], stdout);
 241                 fputc('\b', stdout);
 242                 fflush(stdout);
 243         }
 244         return 0;
 245 }
 246
 247 #define PATH_SET "PATH=/sbin"
 248
 249 static void reserve_stdio_fds(NOARGS)
 250 {
 251         int     fd;
 252
 253         while (1) {
 254                 fd = open("/dev/null", O_RDWR);
 255                 if (fd > 2)
 256                         break;
 257                 if (fd < 0) {
 258                         fprintf(stderr, "ERROR: Couldn't open /dev/null (%s)\n",
 259                                 strerror(errno));
 260                         break;
 261                 }
 262         }
 263         close(fd);
 264 }
 265
 266 static errcode_t PRS(int argc, char *argv[], e2fsck_t *ret_ctx)
 267 {
 268         int             flush = 0;
 269         int             c;
 270 #ifdef MTRACE
 271         extern void     *mallwatch;
 272 #endif
 273         char            *oldpath = getenv("PATH");
 274         e2fsck_t        ctx;
 275         errcode_t       retval;
 276
 277         retval = e2fsck_allocate_context(&ctx);
 278         if (retval)
 279                 return retval;
 280
 281         *ret_ctx = ctx;
 282
 283         /* Update our PATH to include /sbin  */
 284         if (oldpath) {
 285                 char *newpath;
 286
 287                 newpath = (char *) malloc(sizeof (PATH_SET) + 1 +
 288                                           strlen (oldpath));
 289                 if (!newpath)
 290                         fatal_error(ctx, "Couldn't malloc() newpath");
 291                 strcpy (newpath, PATH_SET);
 292                 strcat (newpath, ":");
 293                 strcat (newpath, oldpath);
 294                 putenv (newpath);
 295         } else
 296                 putenv (PATH_SET);
 297
 298         setbuf(stdout, NULL);
 299         setbuf(stderr, NULL);
 300         initialize_ext2_error_table();
 301
 302         if (argc && *argv)
 303                 ctx->program_name = *argv;
 304         else
 305                 ctx->program_name = "e2fsck";
 306         while ((c = getopt (argc, argv, "panyrcC:B:dfvtFVM:b:I:P:l:L:N:Ss")) != EOF)
 307                 switch (c) {
 308                 case 'C':
 309                         ctx->progress = e2fsck_update_progress;
 310                         ctx->progress_fd = atoi(optarg);
 311                         break;
 312                 case 'p':
 313                 case 'a':
 314                         ctx->options |= E2F_OPT_PREEN;
 315                         ctx->options &= ~(E2F_OPT_YES|E2F_OPT_NO);
 316                         break;
 317                 case 'n':
 318                         ctx->options |= E2F_OPT_NO;
 319                         ctx->options &= ~(E2F_OPT_YES|E2F_OPT_PREEN);
 320                         break;
 321                 case 'y':
 322                         ctx->options |= E2F_OPT_YES;
 323                         ctx->options &= ~(E2F_OPT_PREEN|E2F_OPT_NO);
 324                         break;
 325                 case 't':
 326 #ifdef RESOURCE_TRACK
 327                         if (ctx->options & E2F_OPT_TIME)
 328                                 ctx->options |= E2F_OPT_TIME2;
 329                         else
 330                                 ctx->options |= E2F_OPT_TIME;
 331 #else
 332                         fprintf(stderr, "The -t option is not "
 333                                 "supported on this version of e2fsck.\n");
 334 #endif
 335                         break;
 336                 case 'c':
 337                         cflag++;
 338                         ctx->options |= E2F_OPT_CHECKBLOCKS;
 339                         break;
 340                 case 'r':
 341                         /* What we do by default, anyway! */
 342                         break;
 343                 case 'b':
 344                         ctx->use_superblock = atoi(optarg);
 345                         break;
 346                 case 'B':
 347                         blocksize = atoi(optarg);
 348                         break;
 349                 case 'I':
 350                         ctx->inode_buffer_blocks = atoi(optarg);
 351                         break;
 352                 case 'P':
 353                         ctx->process_inode_size = atoi(optarg);
 354                         break;
 355                 case 'L':
 356                         replace_bad_blocks++;
 357                 case 'l':
 358                         bad_blocks_file = (char *) malloc(strlen(optarg)+1);
 359                         if (!bad_blocks_file)
 360                                 fatal_error(ctx,
 361                                             "Couldn't malloc bad_blocks_file");
 362                         strcpy(bad_blocks_file, optarg);
 363                         break;
 364                 case 'd':
 365                         ctx->options |= E2F_OPT_DEBUG;
 366                         break;
 367                 case 'f':
 368                         force = 1;
 369                         break;
 370                 case 'F':
 371 #ifdef BLKFLSBUF
 372                         flush = 1;
 373 #else
 374                         fatal_error(ctx, "-F not supported");
 375 #endif
 376                         break;
 377                 case 'v':
 378                         verbose = 1;
 379                         break;
 380                 case 'V':
 381                         show_version_only = 1;
 382                         break;
 383 #ifdef MTRACE
 384                 case 'M':
 385                         mallwatch = (void *) strtol(optarg, NULL, 0);
 386                         break;
 387 #endif
 388                 case 'N':
 389                         ctx->device_name = optarg;
 390                         break;
 391                 case 's':
 392                         normalize_swapfs = 1;
 393                 case 'S':
 394                         swapfs = 1;
 395                         break;
 396                 default:
 397                         usage(ctx);
 398                 }
 399         if (show_version_only)
 400                 return 0;
 401         if (optind != argc - 1)
 402                 usage(ctx);
 403         if ((ctx->options & E2F_OPT_NO) && !bad_blocks_file &&
 404             !cflag && !swapfs)
 405                 ctx->options |= E2F_OPT_READONLY;
 406         ctx->filesystem_name = argv[optind];
 407         if (ctx->device_name == 0)
 408                 ctx->device_name = ctx->filesystem_name;
 409         if (flush) {
 410 #ifdef BLKFLSBUF
 411                 int     fd = open(ctx->filesystem_name, O_RDONLY, 0);
 412
 413                 if (fd < 0) {
 414                         com_err("open", errno, "while opening %s for flushing",
 415                                 ctx->filesystem_name);
 416                         exit(FSCK_ERROR);
 417                 }
 418                 if (ioctl(fd, BLKFLSBUF, 0) < 0) {
 419                         com_err("BLKFLSBUF", errno, "while trying to flush %s",
 420                                 ctx->filesystem_name);
 421                         exit(FSCK_ERROR);
 422                 }
 423                 close(fd);
 424 #else
 425                 fatal_error(ctx, "BLKFLSBUF not supported");
 426 #endif /* BLKFLSBUF */
 427         }
 428         if (swapfs) {
 429                 if (cflag || bad_blocks_file) {
 430                         fprintf(stderr, "Incompatible options not "
 431                                 "allowed when byte-swapping.\n");
 432                         exit(FSCK_ERROR);
 433                 }
 434         }
 435         return 0;
 436 }
 437
 438 static const char *my_ver_string = E2FSPROGS_VERSION;
 439 static const char *my_ver_date = E2FSPROGS_DATE;
 440
 441 int main (int argc, char *argv[])
 442 {
 443         errcode_t       retval = 0;
 444         int             exit_value = FSCK_OK;
 445         int             i;
 446         ext2_filsys     fs = 0;
 447         io_manager      io_ptr;
 448         struct ext2fs_sb *s;
 449         const char      *lib_ver_date;
 450         int             my_ver, lib_ver;
 451         e2fsck_t        ctx;
 452         struct problem_context pctx;
 453         int flags, run_result;
 454
 455         clear_problem_context(&pctx);
 456 #ifdef MTRACE
 457         mtrace();
 458 #endif
 459 #ifdef MCHECK
 460         mcheck(0);
 461 #endif
 462         my_ver = ext2fs_parse_version_string(my_ver_string);
 463         lib_ver = ext2fs_get_library_version(0, &lib_ver_date);
 464         if (my_ver > lib_ver) {
 465                 fprintf( stderr, "Error: ext2fs library version "
 466                         "out of date!\n");
 467                 show_version_only++;
 468         }
 469
 470         retval = PRS(argc, argv, &ctx);
 471         if (retval) {
 472                 com_err("e2fsck", retval,
 473                         "while trying to initialize program");
 474                 exit(1);
 475         }
 476         reserve_stdio_fds();
 477
 478 #ifdef RESOURCE_TRACK
 479         init_resource_track(&ctx->global_rtrack);
 480 #endif
 481
 482         if (!(ctx->options & E2F_OPT_PREEN) || show_version_only)
 483                 fprintf (stderr, "e2fsck %s, %s for EXT2 FS %s, %s\n",
 484                          my_ver_string, my_ver_date, EXT2FS_VERSION,
 485                          EXT2FS_DATE);
 486
 487         if (show_version_only) {
 488                 fprintf(stderr, "\tUsing %s, %s\n",
 489                         error_message(EXT2_ET_BASE), lib_ver_date);
 490                 exit(0);
 491         }
 492
 493         check_mount(ctx);
 494
 495         if (!(ctx->options & E2F_OPT_PREEN) &&
 496             !(ctx->options & E2F_OPT_NO) &&
 497             !(ctx->options & E2F_OPT_YES)) {
 498                 if (!isatty (0) || !isatty (1))
 499                         fatal_error(ctx,
 500                                     "need terminal for interactive repairs");
 501         }
 502         ctx->superblock = ctx->use_superblock;
 503 restart:
 504 #if 1
 505         io_ptr = unix_io_manager;
 506 #else
 507         io_ptr = test_io_manager;
 508         test_io_backing_manager = unix_io_manager;
 509 #endif
 510         flags = (ctx->options & E2F_OPT_READONLY) ? 0 : EXT2_FLAG_RW;
 511         if (ctx->superblock && blocksize) {
 512                 retval = ext2fs_open(ctx->filesystem_name, flags,
 513                                      ctx->superblock, blocksize, io_ptr, &fs);
 514         } else if (ctx->superblock) {
 515                 for (i=0; possible_block_sizes[i]; i++) {
 516                         retval = ext2fs_open(ctx->filesystem_name, flags,
 517                                              ctx->superblock,
 518                                              possible_block_sizes[i],
 519                                              io_ptr, &fs);
 520                         if (!retval)
 521                                 break;
 522                 }
 523         } else
 524                 retval = ext2fs_open(ctx->filesystem_name, flags,
 525                                      0, 0, io_ptr, &fs);
 526         if (!ctx->superblock && !(ctx->options & E2F_OPT_PREEN) &&
 527             ((retval == EXT2_ET_BAD_MAGIC) ||
 528              ((retval == 0) && ext2fs_check_desc(fs)))) {
 529                 if (!fs || (fs->group_desc_count > 1)) {
 530                         printf("%s trying backup blocks...\n",
 531                                retval ? "Couldn't find ext2 superblock," :
 532                                "Group descriptors look bad...");
 533                         ctx->superblock = get_backup_sb(fs);
 534                         if (fs)
 535                                 ext2fs_close(fs);
 536                         goto restart;
 537                 }
 538         }
 539         if (retval) {
 540                 com_err(ctx->program_name, retval, "while trying to open %s",
 541                         ctx->filesystem_name);
 542                 if (retval == EXT2_ET_REV_TOO_HIGH) {
 543                         printf("The filesystem revision is apparently "
 544                                "too high for this version of e2fsck.\n"
 545                                "(Or the filesystem superblock "
 546                                "is corrupt)\n\n");
 547                         fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
 548                 } else if (retval == EXT2_ET_SHORT_READ)
 549                         printf("Could this be a zero-length partition?\n");
 550                 else if ((retval == EPERM) || (retval == EACCES))
 551                         printf("You must have %s access to the "
 552                                "filesystem or be root\n",
 553                                (ctx->options & E2F_OPT_READONLY) ?
 554                                "r/o" : "r/w");
 555                 else if (retval == ENXIO)
 556                         printf("Possibly non-existent or swap device?\n");
 557 #ifdef EROFS
 558                 else if (retval == EROFS)
 559                         printf("Disk write-protected; use the -n option"
 560                                "to do a read-only\n"
 561                                "check of the device.\n");
 562 #endif
 563                 else
 564                         fix_problem(ctx, PR_0_SB_CORRUPT, &pctx);
 565                 exit(FSCK_ERROR);
 566         }
 567         ctx->fs = fs;
 568         fs->priv_data = ctx;
 569 #ifdef  EXT2_CURRENT_REV
 570         if (fs->super->s_rev_level > E2FSCK_CURRENT_REV) {
 571                 com_err(ctx->program_name, EXT2_ET_REV_TOO_HIGH,
 572                         "while trying to open %s",
 573                         ctx->filesystem_name);
 574         get_newer:
 575                 fatal_error(ctx, "Get a newer version of e2fsck!");
 576         }
 577 #endif
 578         /*
 579          * Check for compatibility with the feature sets.  We need to
 580          * be more stringent than ext2fs_open().
 581          */
 582         s = (struct ext2fs_sb *) fs->super;
 583         if ((s->s_feature_compat & ~EXT2_LIB_FEATURE_COMPAT_SUPP) ||
 584             (s->s_feature_incompat & ~EXT2_LIB_FEATURE_INCOMPAT_SUPP)) {
 585                 com_err(ctx->program_name, EXT2_ET_UNSUPP_FEATURE,
 586                         "(%s)", ctx->filesystem_name);
 587                 goto get_newer;
 588         }
 589         if (s->s_feature_ro_compat & ~EXT2_LIB_FEATURE_RO_COMPAT_SUPP) {
 590                 com_err(ctx->program_name, EXT2_ET_RO_UNSUPP_FEATURE,
 591                         "(%s)", ctx->filesystem_name);
 592                 goto get_newer;
 593         }
 594
 595         /*
 596          * If the user specified a specific superblock, presumably the
 597          * master superblock has been trashed.  So we mark the
 598          * superblock as dirty, so it can be written out.
 599          */
 600         if (ctx->superblock &&
 601             !(ctx->options & E2F_OPT_READONLY))
 602                 ext2fs_mark_super_dirty(fs);
 603
 604         /*
 605          * Don't overwrite the backup superblock and block
 606          * descriptors, until we're sure the filesystem is OK....
 607          */
 608         fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
 609
 610         ehandler_init(fs->io);
 611
 612         if (ctx->superblock)
 613                 set_latch_flags(PR_LATCH_RELOC, PRL_LATCHED, 0);
 614         check_super_block(ctx);
 615         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
 616                 exit(FSCK_ERROR);
 617         check_if_skip(ctx);
 618         if (bad_blocks_file)
 619                 read_bad_blocks_file(ctx, bad_blocks_file, replace_bad_blocks);
 620         else if (cflag)
 621                 test_disk(ctx);
 622         if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
 623                 exit(FSCK_ERROR);
 624
 625         if (normalize_swapfs) {
 626                 if ((fs->flags & EXT2_FLAG_SWAP_BYTES) ==
 627                     ext2fs_native_flag()) {
 628                         fprintf(stderr, "%s: Filesystem byte order "
 629                                 "already normalized.\n", ctx->device_name);
 630                         exit(FSCK_ERROR);
 631                 }
 632         }
 633         if (swapfs) {
 634                 swap_filesys(ctx);
 635                 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
 636                         exit(FSCK_ERROR);
 637         }
 638
 639         /*
 640          * Mark the system as valid, 'til proven otherwise
 641          */
 642         ext2fs_mark_valid(fs);
 643
 644         retval = ext2fs_read_bb_inode(fs, &fs->badblocks);
 645         if (retval) {
 646                 com_err(ctx->program_name, retval,
 647                         "while reading bad blocks inode");
 648                 preenhalt(ctx);
 649                 printf("This doesn't bode well, but we'll try to go on...\n");
 650         }
 651
 652         run_result = e2fsck_run(ctx);
 653         if (run_result == E2F_FLAG_RESTART) {
 654                 printf("Restarting e2fsck from the beginning...\n");
 655                 retval = e2fsck_reset_context(ctx);
 656                 if (retval) {
 657                         com_err(ctx->program_name, retval,
 658                                 "while resetting context");
 659                         exit(1);
 660                 }
 661                 ext2fs_close(fs);
 662                 goto restart;
 663         }
 664         if (run_result & E2F_FLAG_SIGNAL_MASK)
 665                 exit(FSCK_ERROR);
 666         if (run_result & E2F_FLAG_CANCEL)
 667                 ext2fs_unmark_valid(fs);
 668
 669 #ifdef MTRACE
 670         mtrace_print("Cleanup");
 671 #endif
 672         if (ext2fs_test_changed(fs)) {
 673                 exit_value = FSCK_NONDESTRUCT;
 674                 if (!(ctx->options & E2F_OPT_PREEN))
 675                         printf("\n%s: ***** FILE SYSTEM WAS MODIFIED *****\n",
 676                                ctx->device_name);
 677                 if (root_filesystem && !read_only_root) {
 678                         printf("%s: ***** REBOOT LINUX *****\n",
 679                                ctx->device_name);
 680                         exit_value = FSCK_REBOOT;
 681                 }
 682         }
 683         if (ext2fs_test_valid(fs))
 684                 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
 685         else
 686                 exit_value = FSCK_UNCORRECTED;
 687         if (!(ctx->options & E2F_OPT_READONLY)) {
 688                 if (ext2fs_test_valid(fs)) {
 689                         if (!(fs->super->s_state & EXT2_VALID_FS))
 690                                 exit_value = FSCK_NONDESTRUCT;
 691                         fs->super->s_state = EXT2_VALID_FS;
 692                 } else
 693                         fs->super->s_state &= ~EXT2_VALID_FS;
 694                 fs->super->s_mnt_count = 0;
 695                 fs->super->s_lastcheck = time(NULL);
 696                 ext2fs_mark_super_dirty(fs);
 697         }
 698         show_stats(ctx);
 699
 700         e2fsck_write_bitmaps(ctx);
 701
 702 #ifdef RESOURCE_TRACK
 703         if (ctx->options & E2F_OPT_TIME)
 704                 print_resource_track(NULL, &ctx->global_rtrack);
 705 #endif
 706
 707         e2fsck_free_context(ctx);
 708         ext2fs_close(fs);
 709
 710         return exit_value;
 711 }