misc/tune2fs.c

   1 /*
   2  * tune2fs.c - Change the file system parameters on an ext2 file system
   3  *
   4  * Copyright (C) 1992, 1993, 1994  Remy Card <card@masi.ibp.fr>
   5  *                                 Laboratoire MASI, Institut Blaise Pascal
   6  *                                 Universite Pierre et Marie Curie (Paris VI)
   7  *
   8  * Copyright 1995, 1996, 1997, 1998, 1999, 2000 by Theodore Ts'o.
   9  *
  10  * %Begin-Header%
  11  * This file may be redistributed under the terms of the GNU Public
  12  * License.
  13  * %End-Header%
  14  */
  15
  16 /*
  17  * History:
  18  * 93/06/01     - Creation
  19  * 93/10/31     - Added the -c option to change the maximal mount counts
  20  * 93/12/14     - Added -l flag to list contents of superblock
  21  *                M.J.E. Mol (marcel@duteca.et.tudelft.nl)
  22  *                F.W. ten Wolde (franky@duteca.et.tudelft.nl)
  23  * 93/12/29     - Added the -e option to change errors behavior
  24  * 94/02/27     - Ported to use the ext2fs library
  25  * 94/03/06     - Added the checks interval from Uwe Ohse (uwe@tirka.gun.de)
  26  */
  27
  28 #define _XOPEN_SOURCE 600 /* for inclusion of strptime() */
  29 #include "config.h"
  30 #include <fcntl.h>
  31 #include <grp.h>
  32 #ifdef HAVE_GETOPT_H
  33 #include <getopt.h>
  34 #else
  35 extern char *optarg;
  36 extern int optind;
  37 #endif
  38 #include <pwd.h>
  39 #include <stdio.h>
  40 #ifdef HAVE_STDLIB_H
  41 #include <stdlib.h>
  42 #endif
  43 #ifdef HAVE_STRINGS_H
  44 #include <strings.h>    /* for strcasecmp() */
  45 #else
  46 #define _BSD_SOURCE     /* for inclusion of strcasecmp() via <string.h> */
  47 #endif
  48 #include <string.h>
  49 #include <time.h>
  50 #include <unistd.h>
  51 #include <sys/types.h>
  52 #include <libgen.h>
  53 #include <limits.h>
  54
  55 #include "ext2fs/ext2_fs.h"
  56 #include "ext2fs/ext2fs.h"
  57 #include "ext2fs/kernel-jbd.h"
  58 #include "et/com_err.h"
  59 #include "support/plausible.h"
  60 #include "support/quotaio.h"
  61 #include "uuid/uuid.h"
  62 #include "e2p/e2p.h"
  63 #include "util.h"
  64 #include "blkid/blkid.h"
  65
  66 #include "../version.h"
  67 #include "support/nls-enable.h"
  68
  69 #define QOPT_ENABLE     (1)
  70 #define QOPT_DISABLE    (-1)
  71
  72 extern int ask_yn(const char *string, int def);
  73
  74 const char *program_name = "tune2fs";
  75 char *device_name;
  76 char *new_label, *new_last_mounted, *new_UUID;
  77 char *io_options;
  78 static int c_flag, C_flag, e_flag, f_flag, g_flag, i_flag, l_flag, L_flag;
  79 static int m_flag, M_flag, Q_flag, r_flag, s_flag = -1, u_flag, U_flag, T_flag;
  80 static int I_flag;
  81 static int clear_mmp;
  82 static time_t last_check_time;
  83 static int print_label;
  84 static int max_mount_count, mount_count, mount_flags;
  85 static unsigned long interval;
  86 static blk64_t reserved_blocks;
  87 static double reserved_ratio;
  88 static unsigned long resgid, resuid;
  89 static unsigned short errors;
  90 static int open_flag;
  91 static char *features_cmd;
  92 static char *mntopts_cmd;
  93 static int stride, stripe_width;
  94 static int stride_set, stripe_width_set;
  95 static char *extended_cmd;
  96 static unsigned long new_inode_size;
  97 static char *ext_mount_opts;
  98 static int quota_enable[MAXQUOTAS];
  99 static int rewrite_checksums;
 100 static int feature_64bit;
 101 static int fsck_requested;
 102 static char *undo_file;
 103
 104 int journal_size, journal_flags;
 105 char *journal_device;
 106 static blk64_t journal_location = ~0LL;
 107
 108 static struct list_head blk_move_list;
 109
 110 struct blk_move {
 111         struct list_head list;
 112         blk64_t old_loc;
 113         blk64_t new_loc;
 114 };
 115
 116
 117 static const char *please_fsck = N_("Please run e2fsck on the filesystem.\n");
 118 static const char *please_dir_fsck =
 119                 N_("Please run e2fsck -D on the filesystem.\n");
 120
 121 #ifdef CONFIG_BUILD_FINDFS
 122 void do_findfs(int argc, char **argv);
 123 #endif
 124
 125 static void usage(void)
 126 {
 127         fprintf(stderr,
 128                 _("Usage: %s [-c max_mounts_count] [-e errors_behavior] "
 129                   "[-g group]\n"
 130                   "\t[-i interval[d|m|w]] [-j] [-J journal_options] [-l]\n"
 131                   "\t[-m reserved_blocks_percent] [-o [^]mount_options[,...]]\n"
 132                   "\t[-p mmp_update_interval] [-r reserved_blocks_count] "
 133                   "[-u user]\n"
 134                   "\t[-C mount_count] [-L volume_label] [-M last_mounted_dir]\n"
 135                   "\t[-O [^]feature[,...]] [-Q quota_options]\n"
 136                   "\t[-E extended-option[,...]] [-T last_check_time] "
 137                   "[-U UUID]\n\t[-I new_inode_size] [-z undo_file] device\n"),
 138                 program_name);
 139         exit(1);
 140 }
 141
 142 static __u32 ok_features[3] = {
 143         /* Compat */
 144         EXT3_FEATURE_COMPAT_HAS_JOURNAL |
 145                 EXT2_FEATURE_COMPAT_DIR_INDEX,
 146         /* Incompat */
 147         EXT2_FEATURE_INCOMPAT_FILETYPE |
 148                 EXT3_FEATURE_INCOMPAT_EXTENTS |
 149                 EXT4_FEATURE_INCOMPAT_FLEX_BG |
 150                 EXT4_FEATURE_INCOMPAT_MMP |
 151                 EXT4_FEATURE_INCOMPAT_64BIT |
 152                 EXT4_FEATURE_INCOMPAT_ENCRYPT |
 153                 EXT4_FEATURE_INCOMPAT_CSUM_SEED,
 154         /* R/O compat */
 155         EXT2_FEATURE_RO_COMPAT_LARGE_FILE |
 156                 EXT4_FEATURE_RO_COMPAT_HUGE_FILE|
 157                 EXT4_FEATURE_RO_COMPAT_DIR_NLINK|
 158                 EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE|
 159                 EXT4_FEATURE_RO_COMPAT_GDT_CSUM |
 160                 EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER |
 161                 EXT4_FEATURE_RO_COMPAT_QUOTA |
 162                 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM |
 163                 EXT4_FEATURE_RO_COMPAT_READONLY |
 164                 EXT4_FEATURE_RO_COMPAT_PROJECT
 165 };
 166
 167 static __u32 clear_ok_features[3] = {
 168         /* Compat */
 169         EXT3_FEATURE_COMPAT_HAS_JOURNAL |
 170                 EXT2_FEATURE_COMPAT_RESIZE_INODE |
 171                 EXT2_FEATURE_COMPAT_DIR_INDEX,
 172         /* Incompat */
 173         EXT2_FEATURE_INCOMPAT_FILETYPE |
 174                 EXT4_FEATURE_INCOMPAT_FLEX_BG |
 175                 EXT4_FEATURE_INCOMPAT_MMP |
 176                 EXT4_FEATURE_INCOMPAT_64BIT |
 177                 EXT4_FEATURE_INCOMPAT_CSUM_SEED,
 178         /* R/O compat */
 179         EXT2_FEATURE_RO_COMPAT_LARGE_FILE |
 180                 EXT4_FEATURE_RO_COMPAT_HUGE_FILE|
 181                 EXT4_FEATURE_RO_COMPAT_DIR_NLINK|
 182                 EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE|
 183                 EXT4_FEATURE_RO_COMPAT_GDT_CSUM |
 184                 EXT4_FEATURE_RO_COMPAT_QUOTA |
 185                 EXT4_FEATURE_RO_COMPAT_METADATA_CSUM |
 186                 EXT4_FEATURE_RO_COMPAT_READONLY
 187 };
 188
 189 /**
 190  * Try to get journal super block if any
 191  */
 192 static int get_journal_sb(ext2_filsys jfs, char buf[SUPERBLOCK_SIZE])
 193 {
 194         int retval;
 195         journal_superblock_t *jsb;
 196
 197         if (!ext2fs_has_feature_journal_dev(jfs->super)) {
 198                 return EXT2_ET_UNSUPP_FEATURE;
 199         }
 200
 201         /* Get the journal superblock */
 202         if ((retval = io_channel_read_blk64(jfs->io,
 203             ext2fs_journal_sb_start(jfs->blocksize), -SUPERBLOCK_SIZE, buf))) {
 204                 com_err(program_name, retval, "%s",
 205                 _("while reading journal superblock"));
 206                 return retval;
 207         }
 208
 209         jsb = (journal_superblock_t *) buf;
 210         if ((jsb->s_header.h_magic != (unsigned)ntohl(JFS_MAGIC_NUMBER)) ||
 211             (jsb->s_header.h_blocktype != (unsigned)ntohl(JFS_SUPERBLOCK_V2))) {
 212                 fputs(_("Journal superblock not found!\n"), stderr);
 213                 return EXT2_ET_BAD_MAGIC;
 214         }
 215
 216         return 0;
 217 }
 218
 219 static __u8 *journal_user(__u8 uuid[UUID_SIZE], __u8 s_users[JFS_USERS_SIZE],
 220                           int nr_users)
 221 {
 222         int i;
 223         for (i = 0; i < nr_users; i++) {
 224                 if (memcmp(uuid, &s_users[i * UUID_SIZE], UUID_SIZE) == 0)
 225                         return &s_users[i * UUID_SIZE];
 226         }
 227
 228         return NULL;
 229 }
 230
 231 /*
 232  * Remove an external journal from the filesystem
 233  */
 234 static int remove_journal_device(ext2_filsys fs)
 235 {
 236         char            *journal_path;
 237         ext2_filsys     jfs;
 238         char            buf[SUPERBLOCK_SIZE] __attribute__ ((aligned(8)));
 239         journal_superblock_t    *jsb;
 240         int             i, nr_users;
 241         errcode_t       retval;
 242         int             commit_remove_journal = 0;
 243         io_manager      io_ptr;
 244
 245         if (f_flag)
 246                 commit_remove_journal = 1; /* force removal even if error */
 247
 248         uuid_unparse(fs->super->s_journal_uuid, buf);
 249         journal_path = blkid_get_devname(NULL, "UUID", buf);
 250
 251         if (!journal_path) {
 252                 journal_path =
 253                         ext2fs_find_block_device(fs->super->s_journal_dev);
 254                 if (!journal_path)
 255                         goto no_valid_journal;
 256         }
 257
 258 #ifdef CONFIG_TESTIO_DEBUG
 259         if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
 260                 io_ptr = test_io_manager;
 261                 test_io_backing_manager = unix_io_manager;
 262         } else
 263 #endif
 264                 io_ptr = unix_io_manager;
 265         retval = ext2fs_open(journal_path, EXT2_FLAG_RW|
 266                              EXT2_FLAG_JOURNAL_DEV_OK, 0,
 267                              fs->blocksize, io_ptr, &jfs);
 268         if (retval) {
 269                 com_err(program_name, retval, "%s",
 270                         _("while trying to open external journal"));
 271                 goto no_valid_journal;
 272         }
 273
 274         if ((retval = get_journal_sb(jfs, buf))) {
 275                 if (retval == EXT2_ET_UNSUPP_FEATURE)
 276                         fprintf(stderr, _("%s is not a journal device.\n"),
 277                                 journal_path);
 278                 goto no_valid_journal;
 279         }
 280
 281         jsb = (journal_superblock_t *) buf;
 282         /* Find the filesystem UUID */
 283         nr_users = ntohl(jsb->s_nr_users);
 284
 285         if (!journal_user(fs->super->s_uuid, jsb->s_users, nr_users)) {
 286                 fputs(_("Filesystem's UUID not found on journal device.\n"),
 287                       stderr);
 288                 commit_remove_journal = 1;
 289                 goto no_valid_journal;
 290         }
 291         nr_users--;
 292         for (i = 0; i < nr_users; i++)
 293                 memcpy(&jsb->s_users[i * 16], &jsb->s_users[(i + 1) * 16], 16);
 294         jsb->s_nr_users = htonl(nr_users);
 295
 296         /* Write back the journal superblock */
 297         retval = io_channel_write_blk64(jfs->io,
 298                                         ext2fs_journal_sb_start(fs->blocksize),
 299                                         -SUPERBLOCK_SIZE, buf);
 300         if (retval) {
 301                 com_err(program_name, retval,
 302                         "while writing journal superblock.");
 303                 goto no_valid_journal;
 304         }
 305
 306         commit_remove_journal = 1;
 307
 308 no_valid_journal:
 309         if (commit_remove_journal == 0) {
 310                 fputs(_("Cannot locate journal device. It was NOT removed\n"
 311                         "Use -f option to remove missing journal device.\n"),
 312                       stderr);
 313                 return 1;
 314         }
 315         fs->super->s_journal_dev = 0;
 316         memset(fs->super->s_jnl_blocks, 0, sizeof(fs->super->s_jnl_blocks));
 317         uuid_clear(fs->super->s_journal_uuid);
 318         ext2fs_mark_super_dirty(fs);
 319         fputs(_("Journal removed\n"), stdout);
 320         free(journal_path);
 321
 322         return 0;
 323 }
 324
 325 /* Helper function for remove_journal_inode */
 326 static int release_blocks_proc(ext2_filsys fs, blk64_t *blocknr,
 327                                e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
 328                                blk64_t ref_block EXT2FS_ATTR((unused)),
 329                                int ref_offset EXT2FS_ATTR((unused)),
 330                                void *private EXT2FS_ATTR((unused)))
 331 {
 332         blk64_t block;
 333         int     group;
 334
 335         block = *blocknr;
 336         ext2fs_unmark_block_bitmap2(fs->block_map, block);
 337         group = ext2fs_group_of_blk2(fs, block);
 338         ext2fs_bg_free_blocks_count_set(fs, group, ext2fs_bg_free_blocks_count(fs, group) + 1);
 339         ext2fs_group_desc_csum_set(fs, group);
 340         ext2fs_free_blocks_count_add(fs->super, EXT2FS_CLUSTER_RATIO(fs));
 341         return 0;
 342 }
 343
 344 /*
 345  * Remove the journal inode from the filesystem
 346  */
 347 static errcode_t remove_journal_inode(ext2_filsys fs)
 348 {
 349         struct ext2_inode       inode;
 350         errcode_t               retval;
 351         ino_t                   ino = fs->super->s_journal_inum;
 352
 353         retval = ext2fs_read_inode(fs, ino,  &inode);
 354         if (retval) {
 355                 com_err(program_name, retval, "%s",
 356                         _("while reading journal inode"));
 357                 return retval;
 358         }
 359         if (ino == EXT2_JOURNAL_INO) {
 360                 retval = ext2fs_read_bitmaps(fs);
 361                 if (retval) {
 362                         com_err(program_name, retval, "%s",
 363                                 _("while reading bitmaps"));
 364                         return retval;
 365                 }
 366                 retval = ext2fs_block_iterate3(fs, ino,
 367                                                BLOCK_FLAG_READ_ONLY, NULL,
 368                                                release_blocks_proc, NULL);
 369                 if (retval) {
 370                         com_err(program_name, retval, "%s",
 371                                 _("while clearing journal inode"));
 372                         return retval;
 373                 }
 374                 memset(&inode, 0, sizeof(inode));
 375                 ext2fs_mark_bb_dirty(fs);
 376                 fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
 377         } else
 378                 inode.i_flags &= ~EXT2_IMMUTABLE_FL;
 379         retval = ext2fs_write_inode(fs, ino, &inode);
 380         if (retval) {
 381                 com_err(program_name, retval, "%s",
 382                         _("while writing journal inode"));
 383                 return retval;
 384         }
 385         fs->super->s_journal_inum = 0;
 386         memset(fs->super->s_jnl_blocks, 0, sizeof(fs->super->s_jnl_blocks));
 387         ext2fs_mark_super_dirty(fs);
 388
 389         return 0;
 390 }
 391
 392 /*
 393  * Update the default mount options
 394  */
 395 static int update_mntopts(ext2_filsys fs, char *mntopts)
 396 {
 397         struct ext2_super_block *sb = fs->super;
 398
 399         if (e2p_edit_mntopts(mntopts, &sb->s_default_mount_opts, ~0)) {
 400                 fprintf(stderr, _("Invalid mount option set: %s\n"),
 401                         mntopts);
 402                 return 1;
 403         }
 404         ext2fs_mark_super_dirty(fs);
 405
 406         return 0;
 407 }
 408
 409 static int check_fsck_needed(ext2_filsys fs)
 410 {
 411         if (fs->super->s_state & EXT2_VALID_FS)
 412                 return 0;
 413         printf("\n%s\n", _(please_fsck));
 414         if (mount_flags & EXT2_MF_READONLY)
 415                 printf("%s", _("(and reboot afterwards!)\n"));
 416         return 1;
 417 }
 418
 419 static void request_dir_fsck_afterwards(ext2_filsys fs)
 420 {
 421         static int requested;
 422
 423         if (requested++)
 424                 return;
 425         fsck_requested++;
 426         fs->super->s_state &= ~EXT2_VALID_FS;
 427         printf("\n%s\n", _(please_dir_fsck));
 428         if (mount_flags & EXT2_MF_READONLY)
 429                 printf("%s", _("(and reboot afterwards!)\n"));
 430 }
 431
 432 static void request_fsck_afterwards(ext2_filsys fs)
 433 {
 434         static int requested = 0;
 435
 436         if (requested++)
 437                 return;
 438         fsck_requested++;
 439         fs->super->s_state &= ~EXT2_VALID_FS;
 440         printf("\n%s\n", _(please_fsck));
 441         if (mount_flags & EXT2_MF_READONLY)
 442                 printf("%s", _("(and reboot afterwards!)\n"));
 443 }
 444
 445 static void convert_64bit(ext2_filsys fs, int direction)
 446 {
 447         if (!direction)
 448                 return;
 449
 450         /*
 451          * Is resize2fs going to demand a fsck run? Might as well tell the
 452          * user now.
 453          */
 454         if (!fsck_requested &&
 455             ((fs->super->s_state & EXT2_ERROR_FS) ||
 456              !(fs->super->s_state & EXT2_VALID_FS) ||
 457              fs->super->s_lastcheck < fs->super->s_mtime))
 458                 request_fsck_afterwards(fs);
 459         if (fsck_requested)
 460                 fprintf(stderr, _("After running e2fsck, please run `resize2fs %s %s"),
 461                         direction > 0 ? "-b" : "-s", fs->device_name);
 462         else
 463                 fprintf(stderr, _("Please run `resize2fs %s %s"),
 464                         direction > 0 ? "-b" : "-s", fs->device_name);
 465
 466         if (undo_file)
 467                 fprintf(stderr, _(" -z \"%s\""), undo_file);
 468         if (direction > 0)
 469                 fprintf(stderr, _("' to enable 64-bit mode.\n"));
 470         else
 471                 fprintf(stderr, _("' to disable 64-bit mode.\n"));
 472 }
 473
 474 /* Rewrite extents */
 475 static errcode_t rewrite_extents(ext2_filsys fs, ext2_ino_t ino,
 476                                  struct ext2_inode *inode)
 477 {
 478         ext2_extent_handle_t    handle;
 479         struct ext2fs_extent    extent;
 480         errcode_t               errcode;
 481         struct ext2_extent_info info;
 482
 483         if (!(inode->i_flags & EXT4_EXTENTS_FL) ||
 484             !ext2fs_has_feature_metadata_csum(fs->super))
 485                 return 0;
 486
 487         errcode = ext2fs_extent_open(fs, ino, &handle);
 488         if (errcode)
 489                 return errcode;
 490
 491         errcode = ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent);
 492         if (errcode)
 493                 goto out;
 494
 495         do {
 496                 errcode = ext2fs_extent_get_info(handle, &info);
 497                 if (errcode)
 498                         break;
 499
 500                 /*
 501                  * If this is the first extent in an extent block that we
 502                  * haven't visited, rewrite the extent to force the ETB
 503                  * checksum to be rewritten.
 504                  */
 505                 if (info.curr_entry == 1 && info.curr_level != 0 &&
 506                     !(extent.e_flags & EXT2_EXTENT_FLAGS_SECOND_VISIT)) {
 507                         errcode = ext2fs_extent_replace(handle, 0, &extent);
 508                         if (errcode)
 509                                 break;
 510                 }
 511
 512                 /* Skip to the end of a block of leaf nodes */
 513                 if (extent.e_flags & EXT2_EXTENT_FLAGS_LEAF) {
 514                         errcode = ext2fs_extent_get(handle,
 515                                                     EXT2_EXTENT_LAST_SIB,
 516                                                     &extent);
 517                         if (errcode)
 518                                 break;
 519                 }
 520
 521                 errcode = ext2fs_extent_get(handle, EXT2_EXTENT_NEXT, &extent);
 522         } while (errcode == 0);
 523
 524 out:
 525         /* Ok if we run off the end */
 526         if (errcode == EXT2_ET_EXTENT_NO_NEXT)
 527                 errcode = 0;
 528         ext2fs_extent_free(handle);
 529         return errcode;
 530 }
 531
 532 /*
 533  * Rewrite directory blocks with checksums
 534  */
 535 struct rewrite_dir_context {
 536         char *buf;
 537         errcode_t errcode;
 538         ext2_ino_t dir;
 539         int is_htree;
 540 };
 541
 542 static int rewrite_dir_block(ext2_filsys fs,
 543                              blk64_t    *blocknr,
 544                              e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
 545                              blk64_t    ref_block EXT2FS_ATTR((unused)),
 546                              int        ref_offset EXT2FS_ATTR((unused)),
 547                              void       *priv_data)
 548 {
 549         struct ext2_dx_countlimit *dcl = NULL;
 550         struct rewrite_dir_context *ctx = priv_data;
 551         int dcl_offset, changed = 0;
 552
 553         ctx->errcode = ext2fs_read_dir_block4(fs, *blocknr, ctx->buf, 0,
 554                                               ctx->dir);
 555         if (ctx->errcode)
 556                 return BLOCK_ABORT;
 557
 558         /* if htree node... */
 559         if (ctx->is_htree)
 560                 ext2fs_get_dx_countlimit(fs, (struct ext2_dir_entry *)ctx->buf,
 561                                          &dcl, &dcl_offset);
 562         if (dcl) {
 563                 if (!ext2fs_has_feature_metadata_csum(fs->super)) {
 564                         /* Ensure limit is the max size */
 565                         int max_entries = (fs->blocksize - dcl_offset) /
 566                                           sizeof(struct ext2_dx_entry);
 567                         if (ext2fs_le16_to_cpu(dcl->limit) != max_entries) {
 568                                 changed = 1;
 569                                 dcl->limit = ext2fs_cpu_to_le16(max_entries);
 570                         }
 571                 } else {
 572                         /* If htree block is full then rebuild the dir */
 573                         if (ext2fs_le16_to_cpu(dcl->count) ==
 574                             ext2fs_le16_to_cpu(dcl->limit)) {
 575                                 request_dir_fsck_afterwards(fs);
 576                                 return 0;
 577                         }
 578                         /*
 579                          * Ensure dcl->limit is small enough to leave room for
 580                          * the checksum tail.
 581                          */
 582                         int max_entries = (fs->blocksize - (dcl_offset +
 583                                                 sizeof(struct ext2_dx_tail))) /
 584                                           sizeof(struct ext2_dx_entry);
 585                         if (ext2fs_le16_to_cpu(dcl->limit) != max_entries)
 586                                 dcl->limit = ext2fs_cpu_to_le16(max_entries);
 587                         /* Always rewrite checksum */
 588                         changed = 1;
 589                 }
 590         } else {
 591                 unsigned int rec_len, name_size;
 592                 char *top = ctx->buf + fs->blocksize;
 593                 struct ext2_dir_entry *de = (struct ext2_dir_entry *)ctx->buf;
 594                 struct ext2_dir_entry *last_de = NULL, *penultimate_de = NULL;
 595
 596                 /* Find last and penultimate dirent */
 597                 while ((char *)de < top) {
 598                         penultimate_de = last_de;
 599                         last_de = de;
 600                         ctx->errcode = ext2fs_get_rec_len(fs, de, &rec_len);
 601                         if (!ctx->errcode && !rec_len)
 602                                 ctx->errcode = EXT2_ET_DIR_CORRUPTED;
 603                         if (ctx->errcode)
 604                                 return BLOCK_ABORT;
 605                         de = (struct ext2_dir_entry *)(((char *)de) + rec_len);
 606                 }
 607                 ctx->errcode = ext2fs_get_rec_len(fs, last_de, &rec_len);
 608                 if (ctx->errcode)
 609                         return BLOCK_ABORT;
 610                 name_size = ext2fs_dirent_name_len(last_de);
 611
 612                 if (!ext2fs_has_feature_metadata_csum(fs->super)) {
 613                         if (!penultimate_de)
 614                                 return 0;
 615                         if (last_de->inode ||
 616                             name_size ||
 617                             rec_len != sizeof(struct ext2_dir_entry_tail))
 618                                 return 0;
 619                         /*
 620                          * The last dirent is unused and the right length to
 621                          * have stored a checksum.  Erase it.
 622                          */
 623                         ctx->errcode = ext2fs_get_rec_len(fs, penultimate_de,
 624                                                           &rec_len);
 625                         if (!rec_len)
 626                                 ctx->errcode = EXT2_ET_DIR_CORRUPTED;
 627                         if (ctx->errcode)
 628                                 return BLOCK_ABORT;
 629                         ext2fs_set_rec_len(fs, rec_len +
 630                                         sizeof(struct ext2_dir_entry_tail),
 631                                         penultimate_de);
 632                         changed = 1;
 633                 } else {
 634                         unsigned csum_size = sizeof(struct ext2_dir_entry_tail);
 635                         struct ext2_dir_entry_tail *t;
 636
 637                         /*
 638                          * If the last dirent looks like the tail, just update
 639                          * the checksum.
 640                          */
 641                         if (!last_de->inode &&
 642                             rec_len == csum_size) {
 643                                 t = (struct ext2_dir_entry_tail *)last_de;
 644                                 t->det_reserved_name_len =
 645                                                 EXT2_DIR_NAME_LEN_CSUM;
 646                                 changed = 1;
 647                                 goto out;
 648                         }
 649                         if (name_size & 3)
 650                                 name_size = (name_size & ~3) + 4;
 651                         /* If there's not enough space for the tail, e2fsck */
 652                         if (rec_len <= (8 + name_size + csum_size)) {
 653                                 request_dir_fsck_afterwards(fs);
 654                                 return 0;
 655                         }
 656                         /* Shorten that last de and insert the tail */
 657                         ext2fs_set_rec_len(fs, rec_len - csum_size, last_de);
 658                         t = EXT2_DIRENT_TAIL(ctx->buf, fs->blocksize);
 659                         ext2fs_initialize_dirent_tail(fs, t);
 660
 661                         /* Always update checksum */
 662                         changed = 1;
 663                 }
 664         }
 665
 666 out:
 667         if (!changed)
 668                 return 0;
 669
 670         ctx->errcode = ext2fs_write_dir_block4(fs, *blocknr, ctx->buf,
 671                                                0, ctx->dir);
 672         if (ctx->errcode)
 673                 return BLOCK_ABORT;
 674
 675         return 0;
 676 }
 677
 678 static errcode_t rewrite_directory(ext2_filsys fs, ext2_ino_t dir,
 679                                    struct ext2_inode *inode)
 680 {
 681         errcode_t       retval;
 682         struct rewrite_dir_context ctx;
 683
 684         retval = ext2fs_get_mem(fs->blocksize, &ctx.buf);
 685         if (retval)
 686                 return retval;
 687
 688         ctx.is_htree = (inode->i_flags & EXT2_INDEX_FL);
 689         ctx.dir = dir;
 690         ctx.errcode = 0;
 691         retval = ext2fs_block_iterate3(fs, dir, BLOCK_FLAG_READ_ONLY |
 692                                                 BLOCK_FLAG_DATA_ONLY,
 693                                        0, rewrite_dir_block, &ctx);
 694
 695         ext2fs_free_mem(&ctx.buf);
 696         if (retval)
 697                 return retval;
 698
 699         return ctx.errcode;
 700 }
 701
 702 /*
 703  * Forcibly set checksums in all inodes.
 704  */
 705 static void rewrite_inodes(ext2_filsys fs)
 706 {
 707         int length = EXT2_INODE_SIZE(fs->super);
 708         struct ext2_inode *inode, *zero;
 709         char            *ea_buf;
 710         ext2_inode_scan scan;
 711         errcode_t       retval;
 712         ext2_ino_t      ino;
 713         blk64_t         file_acl_block;
 714         int             inode_dirty;
 715
 716         if (fs->super->s_creator_os != EXT2_OS_LINUX)
 717                 return;
 718
 719         retval = ext2fs_open_inode_scan(fs, 0, &scan);
 720         if (retval) {
 721                 com_err("set_csum", retval, "while opening inode scan");
 722                 exit(1);
 723         }
 724
 725         retval = ext2fs_get_mem(length, &inode);
 726         if (retval) {
 727                 com_err("set_csum", retval, "while allocating memory");
 728                 exit(1);
 729         }
 730
 731         retval = ext2fs_get_memzero(length, &zero);
 732         if (retval) {
 733                 com_err("set_csum", retval, "while allocating memory");
 734                 exit(1);
 735         }
 736
 737         retval = ext2fs_get_mem(fs->blocksize, &ea_buf);
 738         if (retval) {
 739                 com_err("set_csum", retval, "while allocating memory");
 740                 exit(1);
 741         }
 742
 743         do {
 744                 retval = ext2fs_get_next_inode_full(scan, &ino, inode, length);
 745                 if (retval) {
 746                         com_err("set_csum", retval, "while getting next inode");
 747                         exit(1);
 748                 }
 749                 if (!ino)
 750                         break;
 751                 if (ext2fs_test_inode_bitmap2(fs->inode_map, ino)) {
 752                         inode_dirty = 1;
 753                 } else {
 754                         if (memcmp(inode, zero, length) != 0) {
 755                                 memset(inode, 0, length);
 756                                 inode_dirty = 1;
 757                         } else {
 758                                 inode_dirty = 0;
 759                         }
 760                 }
 761
 762                 if (inode_dirty) {
 763                         retval = ext2fs_write_inode_full(fs, ino, inode,
 764                                                          length);
 765                         if (retval) {
 766                                 com_err("set_csum", retval, "while writing "
 767                                         "inode");
 768                                 exit(1);
 769                         }
 770                 }
 771
 772                 retval = rewrite_extents(fs, ino, inode);
 773                 if (retval) {
 774                         com_err("rewrite_extents", retval,
 775                                 "while rewriting extents");
 776                         exit(1);
 777                 }
 778
 779                 if (LINUX_S_ISDIR(inode->i_mode) &&
 780                     ext2fs_inode_has_valid_blocks2(fs, inode)) {
 781                         retval = rewrite_directory(fs, ino, inode);
 782                         if (retval) {
 783                                 com_err("rewrite_directory", retval,
 784                                         "while rewriting directories");
 785                                 exit(1);
 786                         }
 787                 }
 788
 789                 file_acl_block = ext2fs_file_acl_block(fs, inode);
 790                 if (!file_acl_block)
 791                         continue;
 792                 retval = ext2fs_read_ext_attr3(fs, file_acl_block, ea_buf, ino);
 793                 if (retval) {
 794                         com_err("rewrite_eablock", retval,
 795                                 "while rewriting extended attribute");
 796                         exit(1);
 797                 }
 798                 retval = ext2fs_write_ext_attr3(fs, file_acl_block, ea_buf,
 799                                                 ino);
 800                 if (retval) {
 801                         com_err("rewrite_eablock", retval,
 802                                 "while rewriting extended attribute");
 803                         exit(1);
 804                 }
 805         } while (ino);
 806
 807         ext2fs_free_mem(&zero);
 808         ext2fs_free_mem(&inode);
 809         ext2fs_free_mem(&ea_buf);
 810         ext2fs_close_inode_scan(scan);
 811 }
 812
 813 static void rewrite_metadata_checksums(ext2_filsys fs)
 814 {
 815         errcode_t retval;
 816         dgrp_t i;
 817
 818         fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
 819         ext2fs_init_csum_seed(fs);
 820         for (i = 0; i < fs->group_desc_count; i++)
 821                 ext2fs_group_desc_csum_set(fs, i);
 822         retval = ext2fs_read_bitmaps(fs);
 823         if (retval) {
 824                 com_err("rewrite_metadata_checksums", retval,
 825                         "while reading bitmaps");
 826                 exit(1);
 827         }
 828         rewrite_inodes(fs);
 829         ext2fs_mark_ib_dirty(fs);
 830         ext2fs_mark_bb_dirty(fs);
 831         ext2fs_mmp_update2(fs, 1);
 832         fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
 833         fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
 834         if (ext2fs_has_feature_metadata_csum(fs->super))
 835                 fs->super->s_checksum_type = EXT2_CRC32C_CHKSUM;
 836         else
 837                 fs->super->s_checksum_type = 0;
 838         ext2fs_mark_super_dirty(fs);
 839 }
 840
 841 static void enable_uninit_bg(ext2_filsys fs)
 842 {
 843         struct ext2_group_desc *gd;
 844         dgrp_t i;
 845
 846         for (i = 0; i < fs->group_desc_count; i++) {
 847                 gd = ext2fs_group_desc(fs, fs->group_desc, i);
 848                 gd->bg_itable_unused = 0;
 849                 gd->bg_flags = EXT2_BG_INODE_ZEROED;
 850                 ext2fs_group_desc_csum_set(fs, i);
 851         }
 852         fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
 853 }
 854
 855 static errcode_t zero_empty_inodes(ext2_filsys fs)
 856 {
 857         int length = EXT2_INODE_SIZE(fs->super);
 858         struct ext2_inode *inode = NULL;
 859         ext2_inode_scan scan;
 860         errcode_t       retval;
 861         ext2_ino_t      ino;
 862
 863         retval = ext2fs_open_inode_scan(fs, 0, &scan);
 864         if (retval)
 865                 goto out;
 866
 867         retval = ext2fs_get_mem(length, &inode);
 868         if (retval)
 869                 goto out;
 870
 871         do {
 872                 retval = ext2fs_get_next_inode_full(scan, &ino, inode, length);
 873                 if (retval)
 874                         goto out;
 875                 if (!ino)
 876                         break;
 877                 if (!ext2fs_test_inode_bitmap2(fs->inode_map, ino)) {
 878                         memset(inode, 0, length);
 879                         retval = ext2fs_write_inode_full(fs, ino, inode,
 880                                                          length);
 881                         if (retval)
 882                                 goto out;
 883                 }
 884         } while (1);
 885
 886 out:
 887         ext2fs_free_mem(&inode);
 888         ext2fs_close_inode_scan(scan);
 889         return retval;
 890 }
 891
 892 static errcode_t disable_uninit_bg(ext2_filsys fs, __u32 csum_feature_flag)
 893 {
 894         struct ext2_group_desc *gd;
 895         dgrp_t i;
 896         errcode_t retval;
 897         blk64_t b, c, d;
 898
 899         /* Load bitmaps to ensure that the uninit ones get written out */
 900         fs->super->s_feature_ro_compat |= csum_feature_flag;
 901         retval = ext2fs_read_bitmaps(fs);
 902         fs->super->s_feature_ro_compat &= ~csum_feature_flag;
 903         if (retval) {
 904                 com_err("disable_uninit_bg", retval,
 905                         "while reading bitmaps");
 906                 request_fsck_afterwards(fs);
 907                 return retval;
 908         }
 909         ext2fs_mark_ib_dirty(fs);
 910         ext2fs_mark_bb_dirty(fs);
 911
 912         /* If we're only turning off uninit_bg, zero the inodes */
 913         if (csum_feature_flag == EXT4_FEATURE_RO_COMPAT_GDT_CSUM) {
 914                 retval = zero_empty_inodes(fs);
 915                 if (retval) {
 916                         com_err("disable_uninit_bg", retval,
 917                                 "while zeroing unused inodes");
 918                         request_fsck_afterwards(fs);
 919                         return retval;
 920                 }
 921         }
 922
 923         /* The bbitmap is zeroed; we must mark group metadata blocks in use */
 924         for (i = 0; i < fs->group_desc_count; i++) {
 925                 b = ext2fs_block_bitmap_loc(fs, i);
 926                 ext2fs_mark_block_bitmap2(fs->block_map, b);
 927                 b = ext2fs_inode_bitmap_loc(fs, i);
 928                 ext2fs_mark_block_bitmap2(fs->block_map, b);
 929
 930                 retval = ext2fs_super_and_bgd_loc2(fs, i, &b, &c, &d, NULL);
 931                 if (retval == 0 && b)
 932                         ext2fs_mark_block_bitmap2(fs->block_map, b);
 933                 if (retval == 0 && c)
 934                         ext2fs_mark_block_bitmap2(fs->block_map, c);
 935                 if (retval == 0 && d)
 936                         ext2fs_mark_block_bitmap2(fs->block_map, d);
 937                 if (retval) {
 938                         com_err("disable_uninit_bg", retval,
 939                                 "while initializing block bitmaps");
 940                         request_fsck_afterwards(fs);
 941                 }
 942
 943                 gd = ext2fs_group_desc(fs, fs->group_desc, i);
 944                 gd->bg_itable_unused = 0;
 945                 gd->bg_flags = 0;
 946                 ext2fs_group_desc_csum_set(fs, i);
 947         }
 948         fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
 949         ext2fs_mark_super_dirty(fs);
 950
 951         return 0;
 952 }
 953
 954 static void
 955 try_confirm_csum_seed_support(void)
 956 {
 957         if (access("/sys/fs/ext4/features/metadata_csum_seed", R_OK))
 958                 fputs(_("WARNING: Could not confirm kernel support for "
 959                         "metadata_csum_seed.\n  This requires Linux >= "
 960                         "v4.4.\n"), stderr);
 961 }
 962
 963 /*
 964  * Update the feature set as provided by the user.
 965  */
 966 static int update_feature_set(ext2_filsys fs, char *features)
 967 {
 968         struct ext2_super_block *sb = fs->super;
 969         __u32           old_features[3];
 970         int             type_err;
 971         unsigned int    mask_err;
 972         errcode_t       err;
 973         enum quota_type qtype;
 974
 975 #define FEATURE_ON(type, mask) (!(old_features[(type)] & (mask)) && \
 976                                 ((&sb->s_feature_compat)[(type)] & (mask)))
 977 #define FEATURE_OFF(type, mask) ((old_features[(type)] & (mask)) && \
 978                                  !((&sb->s_feature_compat)[(type)] & (mask)))
 979 #define FEATURE_CHANGED(type, mask) ((mask) & \
 980                      (old_features[(type)] ^ (&sb->s_feature_compat)[(type)]))
 981
 982         old_features[E2P_FEATURE_COMPAT] = sb->s_feature_compat;
 983         old_features[E2P_FEATURE_INCOMPAT] = sb->s_feature_incompat;
 984         old_features[E2P_FEATURE_RO_INCOMPAT] = sb->s_feature_ro_compat;
 985
 986         if (e2p_edit_feature2(features, &sb->s_feature_compat,
 987                               ok_features, clear_ok_features,
 988                               &type_err, &mask_err)) {
 989                 if (!mask_err)
 990                         fprintf(stderr,
 991                                 _("Invalid filesystem option set: %s\n"),
 992                                 features);
 993                 else if (type_err & E2P_FEATURE_NEGATE_FLAG)
 994                         fprintf(stderr, _("Clearing filesystem feature '%s' "
 995                                           "not supported.\n"),
 996                                 e2p_feature2string(type_err &
 997                                                    E2P_FEATURE_TYPE_MASK,
 998                                                    mask_err));
 999                 else
1000                         fprintf(stderr, _("Setting filesystem feature '%s' "
1001                                           "not supported.\n"),
1002                                 e2p_feature2string(type_err, mask_err));
1003                 return 1;
1004         }
1005
1006         if (FEATURE_OFF(E2P_FEATURE_COMPAT, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
1007                 if ((mount_flags & EXT2_MF_MOUNTED) &&
1008                     !(mount_flags & EXT2_MF_READONLY)) {
1009                         fputs(_("The has_journal feature may only be "
1010                                 "cleared when the filesystem is\n"
1011                                 "unmounted or mounted "
1012                                 "read-only.\n"), stderr);
1013                         return 1;
1014                 }
1015                 if (ext2fs_has_feature_journal_needs_recovery(sb) &&
1016                     f_flag < 2) {
1017                         fputs(_("The needs_recovery flag is set.  "
1018                                 "Please run e2fsck before clearing\n"
1019                                 "the has_journal flag.\n"), stderr);
1020                         return 1;
1021                 }
1022                 if (sb->s_journal_inum) {
1023                         if (remove_journal_inode(fs))
1024                                 return 1;
1025                 }
1026                 if (sb->s_journal_dev) {
1027                         if (remove_journal_device(fs))
1028                                 return 1;
1029                 }
1030         }
1031
1032         if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT,
1033                 EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER)) {
1034                 if (ext2fs_has_feature_meta_bg(sb)) {
1035                         fputs(_("Setting filesystem feature 'sparse_super' "
1036                                 "not supported\nfor filesystems with "
1037                                 "the meta_bg feature enabled.\n"),
1038                                 stderr);
1039                         return 1;
1040                 }
1041         }
1042
1043         if (FEATURE_ON(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_MMP)) {
1044                 int error;
1045
1046                 if ((mount_flags & EXT2_MF_MOUNTED) ||
1047                     (mount_flags & EXT2_MF_READONLY)) {
1048                         fputs(_("The multiple mount protection feature can't\n"
1049                                 "be set if the filesystem is mounted or\n"
1050                                 "read-only.\n"), stderr);
1051                         return 1;
1052                 }
1053
1054                 error = ext2fs_mmp_init(fs);
1055                 if (error) {
1056                         fputs(_("\nError while enabling multiple mount "
1057                                 "protection feature."), stderr);
1058                         return 1;
1059                 }
1060
1061                 /*
1062                  * We want to update group desc with the new free blocks count
1063                  */
1064                 fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
1065
1066                 printf(_("Multiple mount protection has been enabled "
1067                          "with update interval %ds.\n"),
1068                        sb->s_mmp_update_interval);
1069         }
1070
1071         if (FEATURE_OFF(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_MMP)) {
1072                 int error;
1073
1074                 if (mount_flags & EXT2_MF_READONLY) {
1075                         fputs(_("The multiple mount protection feature cannot\n"
1076                                 "be disabled if the filesystem is readonly.\n"),
1077                                 stderr);
1078                         return 1;
1079                 }
1080
1081                 error = ext2fs_read_bitmaps(fs);
1082                 if (error) {
1083                         fputs(_("Error while reading bitmaps\n"), stderr);
1084                         return 1;
1085                 }
1086
1087                 error = ext2fs_mmp_read(fs, sb->s_mmp_block, NULL);
1088                 if (error) {
1089                         struct mmp_struct *mmp_cmp = fs->mmp_cmp;
1090
1091                         if (error == EXT2_ET_MMP_MAGIC_INVALID)
1092                                 printf(_("Magic number in MMP block does not "
1093                                          "match. expected: %x, actual: %x\n"),
1094                                          EXT4_MMP_MAGIC, mmp_cmp->mmp_magic);
1095                         else
1096                                 com_err(program_name, error, "%s",
1097                                         _("while reading MMP block."));
1098                         goto mmp_error;
1099                 }
1100
1101                 /* We need to force out the group descriptors as well */
1102                 fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
1103                 ext2fs_block_alloc_stats2(fs, sb->s_mmp_block, -1);
1104 mmp_error:
1105                 sb->s_mmp_block = 0;
1106                 sb->s_mmp_update_interval = 0;
1107         }
1108
1109         if (FEATURE_ON(E2P_FEATURE_COMPAT, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
1110                 /*
1111                  * If adding a journal flag, let the create journal
1112                  * code below handle setting the flag and creating the
1113                  * journal.  We supply a default size if necessary.
1114                  */
1115                 if (!journal_size)
1116                         journal_size = -1;
1117                 ext2fs_clear_feature_journal(sb);
1118         }
1119
1120         if (FEATURE_ON(E2P_FEATURE_COMPAT, EXT2_FEATURE_COMPAT_DIR_INDEX)) {
1121                 if (!sb->s_def_hash_version)
1122                         sb->s_def_hash_version = EXT2_HASH_HALF_MD4;
1123                 if (uuid_is_null((unsigned char *) sb->s_hash_seed))
1124                         uuid_generate((unsigned char *) sb->s_hash_seed);
1125         }
1126
1127         if (FEATURE_OFF(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
1128                 if (ext2fs_check_desc(fs)) {
1129                         fputs(_("Clearing the flex_bg flag would "
1130                                 "cause the the filesystem to be\n"
1131                                 "inconsistent.\n"), stderr);
1132                         return 1;
1133                 }
1134         }
1135
1136         if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT,
1137                             EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
1138                 if ((mount_flags & EXT2_MF_MOUNTED) &&
1139                     !(mount_flags & EXT2_MF_READONLY)) {
1140                         fputs(_("The huge_file feature may only be "
1141                                 "cleared when the filesystem is\n"
1142                                 "unmounted or mounted "
1143                                 "read-only.\n"), stderr);
1144                         return 1;
1145                 }
1146         }
1147
1148         if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT,
1149                        EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
1150                 if (check_fsck_needed(fs))
1151                         exit(1);
1152                 if (mount_flags & EXT2_MF_MOUNTED) {
1153                         fputs(_("Cannot enable metadata_csum on a mounted "
1154                                 "filesystem!\n"), stderr);
1155                         exit(1);
1156                 }
1157                 if (!ext2fs_has_feature_extents(fs->super))
1158                         printf("%s",
1159                                _("Extents are not enabled.  The file extent "
1160                                  "tree can be checksummed, whereas block maps "
1161                                  "cannot.  Not enabling extents reduces the "
1162                                  "coverage of metadata checksumming.  "
1163                                  "Re-run with -O extent to rectify.\n"));
1164                 if (!ext2fs_has_feature_64bit(fs->super))
1165                         printf("%s",
1166                                _("64-bit filesystem support is not enabled.  "
1167                                  "The larger fields afforded by this feature "
1168                                  "enable full-strength checksumming.  "
1169                                  "Run resize2fs -b to rectify.\n"));
1170                 rewrite_checksums = 1;
1171                 /* metadata_csum supersedes uninit_bg */
1172                 ext2fs_clear_feature_gdt_csum(fs->super);
1173
1174                 /* if uninit_bg was previously off, rewrite group desc */
1175                 if (!(old_features[E2P_FEATURE_RO_INCOMPAT] &
1176                       EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
1177                         enable_uninit_bg(fs);
1178
1179                 /*
1180                  * Since metadata_csum supersedes uninit_bg, pretend like
1181                  * uninit_bg has been off all along.
1182                  */
1183                 old_features[E2P_FEATURE_RO_INCOMPAT] &=
1184                         ~EXT4_FEATURE_RO_COMPAT_GDT_CSUM;
1185         }
1186
1187         if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT,
1188                         EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
1189                 __u32   test_features[3];
1190
1191                 if (check_fsck_needed(fs))
1192                         exit(1);
1193                 if (mount_flags & EXT2_MF_MOUNTED) {
1194                         fputs(_("Cannot disable metadata_csum on a mounted "
1195                                 "filesystem!\n"), stderr);
1196                         exit(1);
1197                 }
1198                 rewrite_checksums = 1;
1199
1200                 /* Enable uninit_bg unless the user expressly turned it off */
1201                 memcpy(test_features, old_features, sizeof(test_features));
1202                 test_features[E2P_FEATURE_RO_INCOMPAT] |=
1203                                                 EXT4_FEATURE_RO_COMPAT_GDT_CSUM;
1204                 e2p_edit_feature2(features, test_features, ok_features,
1205                                   clear_ok_features, NULL, NULL);
1206                 if (test_features[E2P_FEATURE_RO_INCOMPAT] &
1207                                                 EXT4_FEATURE_RO_COMPAT_GDT_CSUM)
1208                         ext2fs_set_feature_gdt_csum(fs->super);
1209
1210                 /*
1211                  * If we're turning off metadata_csum and not turning on
1212                  * uninit_bg, rewrite group desc.
1213                  */
1214                 if (!ext2fs_has_feature_gdt_csum(fs->super)) {
1215                         err = disable_uninit_bg(fs,
1216                                         EXT4_FEATURE_RO_COMPAT_METADATA_CSUM);
1217                         if (err)
1218                                 return 1;
1219                 } else
1220                         /*
1221                          * metadata_csum previously provided uninit_bg, so if
1222                          * we're also setting the uninit_bg feature bit,
1223                          * pretend like it was previously enabled.  Checksums
1224                          * will be rewritten with crc16 later.
1225                          */
1226                         old_features[E2P_FEATURE_RO_INCOMPAT] |=
1227                                 EXT4_FEATURE_RO_COMPAT_GDT_CSUM;
1228                 fs->super->s_checksum_seed = 0;
1229                 ext2fs_clear_feature_csum_seed(fs->super);
1230         }
1231
1232         if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT,
1233                        EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
1234                 /* Do not enable uninit_bg when metadata_csum enabled */
1235                 if (ext2fs_has_feature_metadata_csum(fs->super))
1236                         ext2fs_clear_feature_gdt_csum(fs->super);
1237                 else
1238                         enable_uninit_bg(fs);
1239         }
1240
1241         if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT,
1242                         EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
1243                 err = disable_uninit_bg(fs,
1244                                 EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
1245                 if (err)
1246                         return 1;
1247         }
1248
1249         /*
1250          * We don't actually toggle 64bit; resize2fs does that.  But this
1251          * must come after the metadata_csum feature_on so that it won't
1252          * complain about the lack of 64bit.
1253          */
1254         if (FEATURE_ON(E2P_FEATURE_INCOMPAT,
1255                        EXT4_FEATURE_INCOMPAT_64BIT)) {
1256                 if (mount_flags & EXT2_MF_MOUNTED) {
1257                         fprintf(stderr, _("Cannot enable 64-bit mode "
1258                                           "while mounted!\n"));
1259                         exit(1);
1260                 }
1261                 ext2fs_clear_feature_64bit(sb);
1262                 feature_64bit = 1;
1263         }
1264         if (FEATURE_OFF(E2P_FEATURE_INCOMPAT,
1265                         EXT4_FEATURE_INCOMPAT_64BIT)) {
1266                 if (mount_flags & EXT2_MF_MOUNTED) {
1267                         fprintf(stderr, _("Cannot disable 64-bit mode "
1268                                           "while mounted!\n"));
1269                         exit(1);
1270                 }
1271                 ext2fs_set_feature_64bit(sb);
1272                 feature_64bit = -1;
1273         }
1274
1275         if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT,
1276                                 EXT4_FEATURE_RO_COMPAT_QUOTA)) {
1277                 /*
1278                  * Set the Q_flag here and handle the quota options in the code
1279                  * below.
1280                  */
1281                 if (!Q_flag) {
1282                         Q_flag = 1;
1283                         /* Enable usr/grp quota by default */
1284                         for (qtype = 0; qtype < MAXQUOTAS; qtype++) {
1285                                 if (qtype != PRJQUOTA)
1286                                         quota_enable[qtype] = QOPT_ENABLE;
1287                                 else
1288                                         quota_enable[qtype] = QOPT_DISABLE;
1289                         }
1290                 }
1291                 ext2fs_clear_feature_quota(sb);
1292         }
1293
1294         if (FEATURE_ON(E2P_FEATURE_RO_INCOMPAT,
1295                                 EXT4_FEATURE_RO_COMPAT_PROJECT)) {
1296                 if (!Q_flag && !ext2fs_has_feature_quota(sb))
1297                         fputs(_("\nWarning: enabled project without quota together\n"),
1298                                 stderr);
1299                 Q_flag = 1;
1300                 quota_enable[PRJQUOTA] = QOPT_ENABLE;
1301         }
1302
1303         if (FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT,
1304                                 EXT4_FEATURE_RO_COMPAT_QUOTA)) {
1305                 /*
1306                  * Set the Q_flag here and handle the quota options in the code
1307                  * below.
1308                  */
1309                 if (Q_flag)
1310                         fputs(_("\nWarning: '^quota' option overrides '-Q'"
1311                                 "arguments.\n"), stderr);
1312                 Q_flag = 1;
1313                 /* Disable all quota by default */
1314                 for (qtype = 0; qtype < MAXQUOTAS; qtype++)
1315                         quota_enable[qtype] = QOPT_DISABLE;
1316         }
1317
1318         if (FEATURE_ON(E2P_FEATURE_INCOMPAT, EXT4_FEATURE_INCOMPAT_ENCRYPT)) {
1319                 fs->super->s_encrypt_algos[0] =
1320                         EXT4_ENCRYPTION_MODE_AES_256_XTS;
1321                 fs->super->s_encrypt_algos[1] =
1322                         EXT4_ENCRYPTION_MODE_AES_256_CTS;
1323         }
1324
1325         if (FEATURE_ON(E2P_FEATURE_INCOMPAT,
1326                 EXT4_FEATURE_INCOMPAT_CSUM_SEED)) {
1327                 if (!ext2fs_has_feature_metadata_csum(sb)) {
1328                         fputs(_("Setting feature 'metadata_csum_seed' "
1329                                 "is only supported\non filesystems with "
1330                                 "the metadata_csum feature enabled.\n"),
1331                                 stderr);
1332                         return 1;
1333                 }
1334                 try_confirm_csum_seed_support();
1335                 fs->super->s_checksum_seed = fs->csum_seed;
1336         }
1337
1338         if (FEATURE_OFF(E2P_FEATURE_INCOMPAT,
1339                 EXT4_FEATURE_INCOMPAT_CSUM_SEED)) {
1340                 __le32 uuid_seed;
1341
1342                 uuid_seed = ext2fs_crc32c_le(~0, fs->super->s_uuid,
1343                                         sizeof(fs->super->s_uuid));
1344                 if (fs->super->s_checksum_seed != uuid_seed &&
1345                     (mount_flags & EXT2_MF_MOUNTED)) {
1346                         fputs(_("UUID has changed since enabling "
1347                                 "metadata_csum.  Filesystem must be unmounted "
1348                                 "\nto safely rewrite all metadata to "
1349                                 "match the new UUID.\n"), stderr);
1350                         return 1;
1351                 }
1352
1353                 rewrite_checksums = 1;
1354         }
1355
1356         if (sb->s_rev_level == EXT2_GOOD_OLD_REV &&
1357             (sb->s_feature_compat || sb->s_feature_ro_compat ||
1358              sb->s_feature_incompat))
1359                 ext2fs_update_dynamic_rev(fs);
1360
1361         if (FEATURE_CHANGED(E2P_FEATURE_RO_INCOMPAT,
1362                             EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER) ||
1363             FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT,
1364                         EXT4_FEATURE_RO_COMPAT_HUGE_FILE) ||
1365             FEATURE_CHANGED(E2P_FEATURE_INCOMPAT,
1366                             EXT2_FEATURE_INCOMPAT_FILETYPE) ||
1367             FEATURE_CHANGED(E2P_FEATURE_COMPAT,
1368                             EXT2_FEATURE_COMPAT_RESIZE_INODE) ||
1369             FEATURE_OFF(E2P_FEATURE_RO_INCOMPAT,
1370                         EXT2_FEATURE_RO_COMPAT_LARGE_FILE))
1371                 request_fsck_afterwards(fs);
1372
1373         if ((old_features[E2P_FEATURE_COMPAT] != sb->s_feature_compat) ||
1374             (old_features[E2P_FEATURE_INCOMPAT] != sb->s_feature_incompat) ||
1375             (old_features[E2P_FEATURE_RO_INCOMPAT] != sb->s_feature_ro_compat))
1376                 ext2fs_mark_super_dirty(fs);
1377
1378         return 0;
1379 }
1380
1381 /*
1382  * Add a journal to the filesystem.
1383  */
1384 static int add_journal(ext2_filsys fs)
1385 {
1386         unsigned long journal_blocks;
1387         errcode_t       retval;
1388         ext2_filsys     jfs;
1389         io_manager      io_ptr;
1390
1391         if (ext2fs_has_feature_journal(fs->super)) {
1392                 fputs(_("The filesystem already has a journal.\n"), stderr);
1393                 goto err;
1394         }
1395         if (journal_device) {
1396                 if (!check_plausibility(journal_device, CHECK_BLOCK_DEV,
1397                                         NULL))
1398                         proceed_question(-1);
1399                 check_mount(journal_device, 0, _("journal"));
1400 #ifdef CONFIG_TESTIO_DEBUG
1401                 if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_BLOCK")) {
1402                         io_ptr = test_io_manager;
1403                         test_io_backing_manager = unix_io_manager;
1404                 } else
1405 #endif
1406                         io_ptr = unix_io_manager;
1407                 retval = ext2fs_open(journal_device, EXT2_FLAG_RW|
1408                                      EXT2_FLAG_JOURNAL_DEV_OK, 0,
1409                                      fs->blocksize, io_ptr, &jfs);
1410                 if (retval) {
1411                         com_err(program_name, retval,
1412                                 _("\n\twhile trying to open journal on %s\n"),
1413                                 journal_device);
1414                         goto err;
1415                 }
1416                 printf(_("Creating journal on device %s: "),
1417                        journal_device);
1418                 fflush(stdout);
1419
1420                 retval = ext2fs_add_journal_device(fs, jfs);
1421                 ext2fs_close_free(&jfs);
1422                 if (retval) {
1423                         com_err(program_name, retval,
1424                                 _("while adding filesystem to journal on %s"),
1425                                 journal_device);
1426                         goto err;
1427                 }
1428                 fputs(_("done\n"), stdout);
1429         } else if (journal_size) {
1430                 fputs(_("Creating journal inode: "), stdout);
1431                 fflush(stdout);
1432                 journal_blocks = figure_journal_size(journal_size, fs);
1433
1434                 if (journal_location_string)
1435                         journal_location =
1436                                 parse_num_blocks2(journal_location_string,
1437                                                   fs->super->s_log_block_size);
1438                 retval = ext2fs_add_journal_inode2(fs, journal_blocks,
1439                                                    journal_location,
1440                                                    journal_flags);
1441                 if (retval) {
1442                         fprintf(stderr, "\n");
1443                         com_err(program_name, retval, "%s",
1444                                 _("\n\twhile trying to create journal file"));
1445                         return retval;
1446                 } else
1447                         fputs(_("done\n"), stdout);
1448                 /*
1449                  * If the filesystem wasn't mounted, we need to force
1450                  * the block group descriptors out.
1451                  */
1452                 if ((mount_flags & EXT2_MF_MOUNTED) == 0)
1453                         fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
1454         }
1455         print_check_message(fs->super->s_max_mnt_count,
1456                             fs->super->s_checkinterval);
1457         return 0;
1458
1459 err:
1460         free(journal_device);
1461         return 1;
1462 }
1463
1464 static void handle_quota_options(ext2_filsys fs)
1465 {
1466         quota_ctx_t qctx;
1467         ext2_ino_t qf_ino;
1468         enum quota_type qtype;
1469         int enable = 0;
1470
1471         for (qtype = 0 ; qtype < MAXQUOTAS; qtype++)
1472                 if (quota_enable[qtype] != 0)
1473                         break;
1474         if (qtype == MAXQUOTAS)
1475                 /* Nothing to do. */
1476                 return;
1477
1478         quota_init_context(&qctx, fs, QUOTA_ALL_BIT);
1479         for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) {
1480                 if (quota_enable[qtype] == QOPT_ENABLE) {
1481                         enable = 1;
1482                         break;
1483                 }
1484         }
1485         if (enable)
1486                 quota_compute_usage(qctx);
1487
1488         for (qtype = 0 ; qtype < MAXQUOTAS; qtype++) {
1489                 if (quota_enable[qtype] == QOPT_ENABLE &&
1490                     *quota_sb_inump(fs->super, qtype) == 0) {
1491                         if ((qf_ino = quota_file_exists(fs, qtype)) > 0)
1492                                 quota_update_limits(qctx, qf_ino, qtype);
1493                         quota_write_inode(qctx, 1 << qtype);
1494                 } else if (quota_enable[qtype] == QOPT_DISABLE) {
1495                         quota_remove_inode(fs, qtype);
1496                 }
1497         }
1498
1499         quota_release_context(&qctx);
1500
1501         if (enable) {
1502                 ext2fs_set_feature_quota(fs->super);
1503                 ext2fs_mark_super_dirty(fs);
1504         } else {
1505                 for (qtype = 0 ; qtype < MAXQUOTAS; qtype++)
1506                         if (*quota_sb_inump(fs->super, qtype) != 0)
1507                                 break;
1508                 if (qtype == MAXQUOTAS) {
1509                         fs->super->s_feature_ro_compat &=
1510                                         ~EXT4_FEATURE_RO_COMPAT_QUOTA;
1511                         ext2fs_mark_super_dirty(fs);
1512                 }
1513         }
1514
1515         return;
1516 }
1517
1518 static int option_handle_function(char *token, void *data)
1519 {
1520         if (strncmp(token, "usr", 3) == 0) {
1521                 quota_enable[USRQUOTA] = QOPT_ENABLE;
1522         } else if (strncmp(token, "^usr", 4) == 0) {
1523                 quota_enable[USRQUOTA] = QOPT_DISABLE;
1524         } else if (strncmp(token, "grp", 3) == 0) {
1525                 quota_enable[GRPQUOTA] = QOPT_ENABLE;
1526         } else if (strncmp(token, "^grp", 4) == 0) {
1527                 quota_enable[GRPQUOTA] = QOPT_DISABLE;
1528         } else if (strncmp(token, "prj", 3) == 0) {
1529                 quota_enable[PRJQUOTA] = QOPT_ENABLE;
1530         } else if (strncmp(token, "^prj", 4) == 0) {
1531                 quota_enable[PRJQUOTA] = QOPT_DISABLE;
1532         } else {
1533                 fputs(_("\nBad quota options specified.\n\n"
1534                         "Following valid quota options are available "
1535                         "(pass by separating with comma):\n"
1536                         "\t[^]usr[quota]\n"
1537                         "\t[^]grp[quota]\n"
1538                         "\t[^]prj[quota]\n"
1539                         "\n\n"), stderr);
1540                 return 1;
1541         }
1542         return 0;
1543 }
1544
1545 static void parse_e2label_options(int argc, char ** argv)
1546 {
1547         if ((argc < 2) || (argc > 3)) {
1548                 fputs(_("Usage: e2label device [newlabel]\n"), stderr);
1549                 exit(1);
1550         }
1551         io_options = strchr(argv[1], '?');
1552         if (io_options)
1553                 *io_options++ = 0;
1554         device_name = blkid_get_devname(NULL, argv[1], NULL);
1555         if (!device_name) {
1556                 com_err("e2label", 0, _("Unable to resolve '%s'"),
1557                         argv[1]);
1558                 exit(1);
1559         }
1560         open_flag = EXT2_FLAG_JOURNAL_DEV_OK;
1561         if (argc == 3) {
1562                 open_flag |= EXT2_FLAG_RW;
1563                 L_flag = 1;
1564                 new_label = argv[2];
1565         } else
1566                 print_label++;
1567 }
1568
1569 static time_t parse_time(char *str)
1570 {
1571         struct  tm      ts;
1572
1573         if (strcmp(str, "now") == 0) {
1574                 return (time(0));
1575         }
1576         memset(&ts, 0, sizeof(ts));
1577 #ifdef HAVE_STRPTIME
1578         strptime(str, "%Y%m%d%H%M%S", &ts);
1579 #else
1580         sscanf(str, "%4d%2d%2d%2d%2d%2d", &ts.tm_year, &ts.tm_mon,
1581                &ts.tm_mday, &ts.tm_hour, &ts.tm_min, &ts.tm_sec);
1582         ts.tm_year -= 1900;
1583         ts.tm_mon -= 1;
1584         if (ts.tm_year < 0 || ts.tm_mon < 0 || ts.tm_mon > 11 ||
1585             ts.tm_mday < 0 || ts.tm_mday > 31 || ts.tm_hour > 23 ||
1586             ts.tm_min > 59 || ts.tm_sec > 61)
1587                 ts.tm_mday = 0;
1588 #endif
1589         if (ts.tm_mday == 0) {
1590                 com_err(program_name, 0,
1591                         _("Couldn't parse date/time specifier: %s"),
1592                         str);
1593                 usage();
1594         }
1595         ts.tm_isdst = -1;
1596         return (mktime(&ts));
1597 }
1598
1599 static void parse_tune2fs_options(int argc, char **argv)
1600 {
1601         int c;
1602         char *tmp;
1603         struct group *gr;
1604         struct passwd *pw;
1605         int ret;
1606         char optstring[100] = "c:e:fg:i:jlm:o:r:s:u:C:E:I:J:L:M:O:T:U:z:Q:";
1607
1608         open_flag = 0;
1609         printf("tune2fs %s (%s)\n", E2FSPROGS_VERSION, E2FSPROGS_DATE);
1610         while ((c = getopt(argc, argv, optstring)) != EOF)
1611                 switch (c) {
1612                 case 'c':
1613                         max_mount_count = strtol(optarg, &tmp, 0);
1614                         if (*tmp || max_mount_count > 16000) {
1615                                 com_err(program_name, 0,
1616                                         _("bad mounts count - %s"),
1617                                         optarg);
1618                                 usage();
1619                         }
1620                         if (max_mount_count == 0)
1621                                 max_mount_count = -1;
1622                         c_flag = 1;
1623                         open_flag = EXT2_FLAG_RW;
1624                         break;
1625                 case 'C':
1626                         mount_count = strtoul(optarg, &tmp, 0);
1627                         if (*tmp || mount_count > 16000) {
1628                                 com_err(program_name, 0,
1629                                         _("bad mounts count - %s"),
1630                                         optarg);
1631                                 usage();
1632                         }
1633                         C_flag = 1;
1634                         open_flag = EXT2_FLAG_RW;
1635                         break;
1636                 case 'e':
1637                         if (strcmp(optarg, "continue") == 0)
1638                                 errors = EXT2_ERRORS_CONTINUE;
1639                         else if (strcmp(optarg, "remount-ro") == 0)
1640                                 errors = EXT2_ERRORS_RO;
1641                         else if (strcmp(optarg, "panic") == 0)
1642                                 errors = EXT2_ERRORS_PANIC;
1643                         else {
1644                                 com_err(program_name, 0,
1645                                         _("bad error behavior - %s"),
1646                                         optarg);
1647                                 usage();
1648                         }
1649                         e_flag = 1;
1650                         open_flag = EXT2_FLAG_RW;
1651                         break;
1652                 case 'E':
1653                         extended_cmd = optarg;
1654                         open_flag |= EXT2_FLAG_RW;
1655                         break;
1656                 case 'f': /* Force */
1657                         f_flag++;
1658                         break;
1659                 case 'g':
1660                         resgid = strtoul(optarg, &tmp, 0);
1661                         if (*tmp) {
1662                                 gr = getgrnam(optarg);
1663                                 if (gr == NULL)
1664                                         tmp = optarg;
1665                                 else {
1666                                         resgid = gr->gr_gid;
1667                                         *tmp = 0;
1668                                 }
1669                         }
1670                         if (*tmp) {
1671                                 com_err(program_name, 0,
1672                                         _("bad gid/group name - %s"),
1673                                         optarg);
1674                                 usage();
1675                         }
1676                         g_flag = 1;
1677                         open_flag = EXT2_FLAG_RW;
1678                         break;
1679                 case 'i':
1680                         interval = strtoul(optarg, &tmp, 0);
1681                         switch (*tmp) {
1682                         case 's':
1683                                 tmp++;
1684                                 break;
1685                         case '\0':
1686                         case 'd':
1687                         case 'D': /* days */
1688                                 interval *= 86400;
1689                                 if (*tmp != '\0')
1690                                         tmp++;
1691                                 break;
1692                         case 'm':
1693                         case 'M': /* months! */
1694                                 interval *= 86400 * 30;
1695                                 tmp++;
1696                                 break;
1697                         case 'w':
1698                         case 'W': /* weeks */
1699                                 interval *= 86400 * 7;
1700                                 tmp++;
1701                                 break;
1702                         }
1703                         if (*tmp) {
1704                                 com_err(program_name, 0,
1705                                         _("bad interval - %s"), optarg);
1706                                 usage();
1707                         }
1708                         i_flag = 1;
1709                         open_flag = EXT2_FLAG_RW;
1710                         break;
1711                 case 'j':
1712                         if (!journal_size)
1713                                 journal_size = -1;
1714                         open_flag = EXT2_FLAG_RW;
1715                         break;
1716                 case 'J':
1717                         parse_journal_opts(optarg);
1718                         open_flag = EXT2_FLAG_RW;
1719                         break;
1720                 case 'l':
1721                         l_flag = 1;
1722                         break;
1723                 case 'L':
1724                         new_label = optarg;
1725                         L_flag = 1;
1726                         open_flag |= EXT2_FLAG_RW |
1727                                 EXT2_FLAG_JOURNAL_DEV_OK;
1728                         break;
1729                 case 'm':
1730                         reserved_ratio = strtod(optarg, &tmp);
1731                         if (*tmp || reserved_ratio > 50 ||
1732                             reserved_ratio < 0) {
1733                                 com_err(program_name, 0,
1734                                         _("bad reserved block ratio - %s"),
1735                                         optarg);
1736                                 usage();
1737                         }
1738                         m_flag = 1;
1739                         open_flag = EXT2_FLAG_RW;
1740                         break;
1741                 case 'M':
1742                         new_last_mounted = optarg;
1743                         M_flag = 1;
1744                         open_flag = EXT2_FLAG_RW;
1745                         break;
1746                 case 'o':
1747                         if (mntopts_cmd) {
1748                                 com_err(program_name, 0, "%s",
1749                                         _("-o may only be specified once"));
1750                                 usage();
1751                         }
1752                         mntopts_cmd = optarg;
1753                         open_flag = EXT2_FLAG_RW;
1754                         break;
1755                 case 'O':
1756                         if (features_cmd) {
1757                                 com_err(program_name, 0, "%s",
1758                                         _("-O may only be specified once"));
1759                                 usage();
1760                         }
1761                         features_cmd = optarg;
1762                         open_flag = EXT2_FLAG_RW;
1763                         break;
1764                 case 'Q':
1765                         Q_flag = 1;
1766                         ret = parse_quota_opts(optarg, option_handle_function,
1767                                                NULL);
1768                         if (ret)
1769                                 exit(1);
1770                         open_flag = EXT2_FLAG_RW;
1771                         break;
1772                 case 'r':
1773                         reserved_blocks = strtoul(optarg, &tmp, 0);
1774                         if (*tmp) {
1775                                 com_err(program_name, 0,
1776                                         _("bad reserved blocks count - %s"),
1777                                         optarg);
1778                                 usage();
1779                         }
1780                         r_flag = 1;
1781                         open_flag = EXT2_FLAG_RW;
1782                         break;
1783                 case 's': /* Deprecated */
1784                         s_flag = atoi(optarg);
1785                         open_flag = EXT2_FLAG_RW;
1786                         break;
1787                 case 'T':
1788                         T_flag = 1;
1789                         last_check_time = parse_time(optarg);
1790                         open_flag = EXT2_FLAG_RW;
1791                         break;
1792                 case 'u':
1793                                 resuid = strtoul(optarg, &tmp, 0);
1794                                 if (*tmp) {
1795                                         pw = getpwnam(optarg);
1796                                         if (pw == NULL)
1797                                                 tmp = optarg;
1798                                         else {
1799                                                 resuid = pw->pw_uid;
1800                                                 *tmp = 0;
1801                                         }
1802                                 }
1803                                 if (*tmp) {
1804                                         com_err(program_name, 0,
1805                                                 _("bad uid/user name - %s"),
1806                                                 optarg);
1807                                         usage();
1808                                 }
1809                                 u_flag = 1;
1810                                 open_flag = EXT2_FLAG_RW;
1811                                 break;
1812                 case 'U':
1813                         new_UUID = optarg;
1814                         U_flag = 1;
1815                         open_flag = EXT2_FLAG_RW |
1816                                 EXT2_FLAG_JOURNAL_DEV_OK;
1817                         break;
1818                 case 'I':
1819                         new_inode_size = strtoul(optarg, &tmp, 0);
1820                         if (*tmp) {
1821                                 com_err(program_name, 0,
1822                                         _("bad inode size - %s"),
1823                                         optarg);
1824                                 usage();
1825                         }
1826                         if (!((new_inode_size &
1827                                (new_inode_size - 1)) == 0)) {
1828                                 com_err(program_name, 0,
1829                                         _("Inode size must be a "
1830                                           "power of two- %s"),
1831                                         optarg);
1832                                 usage();
1833                         }
1834                         open_flag = EXT2_FLAG_RW;
1835                         I_flag = 1;
1836                         break;
1837                 case 'z':
1838                         undo_file = optarg;
1839                         break;
1840                 default:
1841                         usage();
1842                 }
1843         if (optind < argc - 1 || optind == argc)
1844                 usage();
1845         if (!open_flag && !l_flag)
1846                 usage();
1847         io_options = strchr(argv[optind], '?');
1848         if (io_options)
1849                 *io_options++ = 0;
1850         device_name = blkid_get_devname(NULL, argv[optind], NULL);
1851         if (!device_name) {
1852                 com_err(program_name, 0, _("Unable to resolve '%s'"),
1853                         argv[optind]);
1854                 exit(1);
1855         }
1856 }
1857
1858 #ifdef CONFIG_BUILD_FINDFS
1859 void do_findfs(int argc, char **argv)
1860 {
1861         char    *dev;
1862
1863         if ((argc != 2) ||
1864             (strncmp(argv[1], "LABEL=", 6) && strncmp(argv[1], "UUID=", 5))) {
1865                 fprintf(stderr, "Usage: findfs LABEL=<label>|UUID=<uuid>\n");
1866                 exit(2);
1867         }
1868         dev = blkid_get_devname(NULL, argv[1], NULL);
1869         if (!dev) {
1870                 com_err("findfs", 0, _("Unable to resolve '%s'"),
1871                         argv[1]);
1872                 exit(1);
1873         }
1874         puts(dev);
1875         exit(0);
1876 }
1877 #endif
1878
1879 static int parse_extended_opts(ext2_filsys fs, const char *opts)
1880 {
1881         char    *buf, *token, *next, *p, *arg;
1882         int     len, hash_alg;
1883         int     r_usage = 0;
1884
1885         len = strlen(opts);
1886         buf = malloc(len+1);
1887         if (!buf) {
1888                 fprintf(stderr, "%s",
1889                         _("Couldn't allocate memory to parse options!\n"));
1890                 return 1;
1891         }
1892         strcpy(buf, opts);
1893         for (token = buf; token && *token; token = next) {
1894                 p = strchr(token, ',');
1895                 next = 0;
1896                 if (p) {
1897                         *p = 0;
1898                         next = p+1;
1899                 }
1900                 arg = strchr(token, '=');
1901                 if (arg) {
1902                         *arg = 0;
1903                         arg++;
1904                 }
1905                 if (strcmp(token, "clear-mmp") == 0 ||
1906                     strcmp(token, "clear_mmp") == 0) {
1907                         clear_mmp = 1;
1908                 } else if (strcmp(token, "mmp_update_interval") == 0) {
1909                         unsigned long intv;
1910                         if (!arg) {
1911                                 r_usage++;
1912                                 continue;
1913                         }
1914                         intv = strtoul(arg, &p, 0);
1915                         if (*p) {
1916                                 fprintf(stderr,
1917                                         _("Invalid mmp_update_interval: %s\n"),
1918                                         arg);
1919                                 r_usage++;
1920                                 continue;
1921                         }
1922                         if (intv == 0) {
1923                                 intv = EXT4_MMP_UPDATE_INTERVAL;
1924                         } else if (intv > EXT4_MMP_MAX_UPDATE_INTERVAL) {
1925                                 fprintf(stderr,
1926                                         _("mmp_update_interval too big: %lu\n"),
1927                                         intv);
1928                                 r_usage++;
1929                                 continue;
1930                         }
1931                         printf(P_("Setting multiple mount protection update "
1932                                   "interval to %lu second\n",
1933                                   "Setting multiple mount protection update "
1934                                   "interval to %lu seconds\n", intv),
1935                                intv);
1936                         fs->super->s_mmp_update_interval = intv;
1937                         ext2fs_mark_super_dirty(fs);
1938                 } else if (!strcmp(token, "test_fs")) {
1939                         fs->super->s_flags |= EXT2_FLAGS_TEST_FILESYS;
1940                         printf("Setting test filesystem flag\n");
1941                         ext2fs_mark_super_dirty(fs);
1942                 } else if (!strcmp(token, "^test_fs")) {
1943                         fs->super->s_flags &= ~EXT2_FLAGS_TEST_FILESYS;
1944                         printf("Clearing test filesystem flag\n");
1945                         ext2fs_mark_super_dirty(fs);
1946                 } else if (strcmp(token, "stride") == 0) {
1947                         if (!arg) {
1948                                 r_usage++;
1949                                 continue;
1950                         }
1951                         stride = strtoul(arg, &p, 0);
1952                         if (*p) {
1953                                 fprintf(stderr,
1954                                         _("Invalid RAID stride: %s\n"),
1955                                         arg);
1956                                 r_usage++;
1957                                 continue;
1958                         }
1959                         stride_set = 1;
1960                 } else if (strcmp(token, "stripe-width") == 0 ||
1961                            strcmp(token, "stripe_width") == 0) {
1962                         if (!arg) {
1963                                 r_usage++;
1964                                 continue;
1965                         }
1966                         stripe_width = strtoul(arg, &p, 0);
1967                         if (*p) {
1968                                 fprintf(stderr,
1969                                         _("Invalid RAID stripe-width: %s\n"),
1970                                         arg);
1971                                 r_usage++;
1972                                 continue;
1973                         }
1974                         stripe_width_set = 1;
1975                 } else if (strcmp(token, "hash_alg") == 0 ||
1976                            strcmp(token, "hash-alg") == 0) {
1977                         if (!arg) {
1978                                 r_usage++;
1979                                 continue;
1980                         }
1981                         hash_alg = e2p_string2hash(arg);
1982                         if (hash_alg < 0) {
1983                                 fprintf(stderr,
1984                                         _("Invalid hash algorithm: %s\n"),
1985                                         arg);
1986                                 r_usage++;
1987                                 continue;
1988                         }
1989                         fs->super->s_def_hash_version = hash_alg;
1990                         printf(_("Setting default hash algorithm "
1991                                  "to %s (%d)\n"),
1992                                arg, hash_alg);
1993                         ext2fs_mark_super_dirty(fs);
1994                 } else if (!strcmp(token, "mount_opts")) {
1995                         if (!arg) {
1996                                 r_usage++;
1997                                 continue;
1998                         }
1999                         if (strlen(arg) >= sizeof(fs->super->s_mount_opts)) {
2000                                 fprintf(stderr,
2001                                         "Extended mount options too long\n");
2002                                 continue;
2003                         }
2004                         ext_mount_opts = strdup(arg);
2005                 } else
2006                         r_usage++;
2007         }
2008         if (r_usage) {
2009                 fprintf(stderr, "%s", _("\nBad options specified.\n\n"
2010                         "Extended options are separated by commas, "
2011                         "and may take an argument which\n"
2012                         "\tis set off by an equals ('=') sign.\n\n"
2013                         "Valid extended options are:\n"
2014                         "\tclear_mmp\n"
2015                         "\thash_alg=<hash algorithm>\n"
2016                         "\tmount_opts=<extended default mount options>\n"
2017                         "\tstride=<RAID per-disk chunk size in blocks>\n"
2018                         "\tstripe_width=<RAID stride*data disks in blocks>\n"
2019                         "\ttest_fs\n"
2020                         "\t^test_fs\n"));
2021                 free(buf);
2022                 return 1;
2023         }
2024         free(buf);
2025
2026         return 0;
2027 }
2028
2029 /*
2030  * Fill in the block bitmap bmap with the information regarding the
2031  * blocks to be moved
2032  */
2033 static int get_move_bitmaps(ext2_filsys fs, int new_ino_blks_per_grp,
2034                             ext2fs_block_bitmap bmap)
2035 {
2036         dgrp_t i;
2037         int retval;
2038         ext2_badblocks_list bb_list = 0;
2039         blk64_t j, needed_blocks = 0;
2040         blk64_t start_blk, end_blk;
2041
2042         retval = ext2fs_read_bb_inode(fs, &bb_list);
2043         if (retval)
2044                 return retval;
2045
2046         for (i = 0; i < fs->group_desc_count; i++) {
2047                 start_blk = ext2fs_inode_table_loc(fs, i) +
2048                                         fs->inode_blocks_per_group;
2049
2050                 end_blk = ext2fs_inode_table_loc(fs, i) +
2051                                         new_ino_blks_per_grp;
2052
2053                 for (j = start_blk; j < end_blk; j++) {
2054                         if (ext2fs_test_block_bitmap2(fs->block_map, j)) {
2055                                 /*
2056                                  * IF the block is a bad block we fail
2057                                  */
2058                                 if (ext2fs_badblocks_list_test(bb_list, j)) {
2059                                         ext2fs_badblocks_list_free(bb_list);
2060                                         return ENOSPC;
2061                                 }
2062
2063                                 ext2fs_mark_block_bitmap2(bmap, j);
2064                         } else {
2065                                 /*
2066                                  * We are going to use this block for
2067                                  * inode table. So mark them used.
2068                                  */
2069                                 ext2fs_mark_block_bitmap2(fs->block_map, j);
2070                         }
2071                 }
2072                 needed_blocks += end_blk - start_blk;
2073         }
2074
2075         ext2fs_badblocks_list_free(bb_list);
2076         if (needed_blocks > ext2fs_free_blocks_count(fs->super))
2077                 return ENOSPC;
2078
2079         return 0;
2080 }
2081
2082 static int ext2fs_is_meta_block(ext2_filsys fs, blk64_t blk)
2083 {
2084         dgrp_t group;
2085         group = ext2fs_group_of_blk2(fs, blk);
2086         if (ext2fs_block_bitmap_loc(fs, group) == blk)
2087                 return 1;
2088         if (ext2fs_inode_bitmap_loc(fs, group) == blk)
2089                 return 1;
2090         return 0;
2091 }
2092
2093 static int ext2fs_is_block_in_group(ext2_filsys fs, dgrp_t group, blk64_t blk)
2094 {
2095         blk64_t start_blk, end_blk;
2096         start_blk = fs->super->s_first_data_block +
2097                         EXT2_GROUPS_TO_BLOCKS(fs->super, group);
2098         /*
2099          * We cannot get new block beyond end_blk for for the last block group
2100          * so we can check with EXT2_BLOCKS_PER_GROUP even for last block group
2101          */
2102         end_blk   = start_blk + EXT2_BLOCKS_PER_GROUP(fs->super);
2103         if (blk >= start_blk && blk <= end_blk)
2104                 return 1;
2105         return 0;
2106 }
2107
2108 static int move_block(ext2_filsys fs, ext2fs_block_bitmap bmap)
2109 {
2110
2111         char *buf;
2112         dgrp_t group = 0;
2113         errcode_t retval;
2114         int meta_data = 0;
2115         blk64_t blk, new_blk, goal;
2116         struct blk_move *bmv;
2117
2118         retval = ext2fs_get_mem(fs->blocksize, &buf);
2119         if (retval)
2120                 return retval;
2121
2122         for (new_blk = blk = fs->super->s_first_data_block;
2123              blk < ext2fs_blocks_count(fs->super); blk++) {
2124                 if (!ext2fs_test_block_bitmap2(bmap, blk))
2125                         continue;
2126
2127                 if (ext2fs_is_meta_block(fs, blk)) {
2128                         /*
2129                          * If the block is mapping a fs meta data block
2130                          * like group desc/block bitmap/inode bitmap. We
2131                          * should find a block in the same group and fix
2132                          * the respective fs metadata pointers. Otherwise
2133                          * fail
2134                          */
2135                         group = ext2fs_group_of_blk2(fs, blk);
2136                         goal = ext2fs_group_first_block2(fs, group);
2137                         meta_data = 1;
2138
2139                 } else {
2140                         goal = new_blk;
2141                 }
2142                 retval = ext2fs_new_block2(fs, goal, NULL, &new_blk);
2143                 if (retval)
2144                         goto err_out;
2145
2146                 /* new fs meta data block should be in the same group */
2147                 if (meta_data && !ext2fs_is_block_in_group(fs, group, new_blk)) {
2148                         retval = ENOSPC;
2149                         goto err_out;
2150                 }
2151
2152                 /* Mark this block as allocated */
2153                 ext2fs_mark_block_bitmap2(fs->block_map, new_blk);
2154
2155                 /* Add it to block move list */
2156                 retval = ext2fs_get_mem(sizeof(struct blk_move), &bmv);
2157                 if (retval)
2158                         goto err_out;
2159
2160                 bmv->old_loc = blk;
2161                 bmv->new_loc = new_blk;
2162
2163                 list_add(&(bmv->list), &blk_move_list);
2164
2165                 retval = io_channel_read_blk64(fs->io, blk, 1, buf);
2166                 if (retval)
2167                         goto err_out;
2168
2169                 retval = io_channel_write_blk64(fs->io, new_blk, 1, buf);
2170                 if (retval)
2171                         goto err_out;
2172         }
2173
2174 err_out:
2175         ext2fs_free_mem(&buf);
2176         return retval;
2177 }
2178
2179 static blk64_t translate_block(blk64_t blk)
2180 {
2181         struct list_head *entry;
2182         struct blk_move *bmv;
2183
2184         list_for_each(entry, &blk_move_list) {
2185                 bmv = list_entry(entry, struct blk_move, list);
2186                 if (bmv->old_loc == blk)
2187                         return bmv->new_loc;
2188         }
2189
2190         return 0;
2191 }
2192
2193 static int process_block(ext2_filsys fs EXT2FS_ATTR((unused)),
2194                          blk64_t *block_nr,
2195                          e2_blkcnt_t blockcnt EXT2FS_ATTR((unused)),
2196                          blk64_t ref_block EXT2FS_ATTR((unused)),
2197                          int ref_offset EXT2FS_ATTR((unused)),
2198                          void *priv_data)
2199 {
2200         int ret = 0;
2201         blk64_t new_blk;
2202         ext2fs_block_bitmap bmap = (ext2fs_block_bitmap) priv_data;
2203
2204         if (!ext2fs_test_block_bitmap2(bmap, *block_nr))
2205                 return 0;
2206         new_blk = translate_block(*block_nr);
2207         if (new_blk) {
2208                 *block_nr = new_blk;
2209                 /*
2210                  * This will force the ext2fs_write_inode in the iterator
2211                  */
2212                 ret |= BLOCK_CHANGED;
2213         }
2214
2215         return ret;
2216 }
2217
2218 static int inode_scan_and_fix(ext2_filsys fs, ext2fs_block_bitmap bmap)
2219 {
2220         errcode_t retval = 0;
2221         ext2_ino_t ino;
2222         blk64_t blk;
2223         char *block_buf = 0;
2224         struct ext2_inode inode;
2225         ext2_inode_scan scan = NULL;
2226
2227         retval = ext2fs_get_mem(fs->blocksize * 3, &block_buf);
2228         if (retval)
2229                 return retval;
2230
2231         retval = ext2fs_open_inode_scan(fs, 0, &scan);
2232         if (retval)
2233                 goto err_out;
2234
2235         while (1) {
2236                 retval = ext2fs_get_next_inode(scan, &ino, &inode);
2237                 if (retval)
2238                         goto err_out;
2239
2240                 if (!ino)
2241                         break;
2242
2243                 if (inode.i_links_count == 0)
2244                         continue; /* inode not in use */
2245
2246                 /* FIXME!!
2247                  * If we end up modifying the journal inode
2248                  * the sb->s_jnl_blocks will differ. But a
2249                  * subsequent e2fsck fixes that.
2250                  * Do we need to fix this ??
2251                  */
2252
2253                 if (ext2fs_file_acl_block(fs, &inode) &&
2254                     ext2fs_test_block_bitmap2(bmap,
2255                                         ext2fs_file_acl_block(fs, &inode))) {
2256                         blk = translate_block(ext2fs_file_acl_block(fs,
2257                                                                     &inode));
2258                         if (!blk)
2259                                 continue;
2260
2261                         ext2fs_file_acl_block_set(fs, &inode, blk);
2262
2263                         /*
2264                          * Write the inode to disk so that inode table
2265                          * resizing can work
2266                          */
2267                         retval = ext2fs_write_inode(fs, ino, &inode);
2268                         if (retval)
2269                                 goto err_out;
2270                 }
2271
2272                 if (!ext2fs_inode_has_valid_blocks2(fs, &inode))
2273                         continue;
2274
2275                 retval = ext2fs_block_iterate3(fs, ino, 0, block_buf,
2276                                                process_block, bmap);
2277                 if (retval)
2278                         goto err_out;
2279
2280         }
2281
2282 err_out:
2283         ext2fs_free_mem(&block_buf);
2284         ext2fs_close_inode_scan(scan);
2285
2286         return retval;
2287 }
2288
2289 /*
2290  * We need to scan for inode and block bitmaps that may need to be
2291  * moved.  This can take place if the filesystem was formatted for
2292  * RAID arrays using the mke2fs's extended option "stride".
2293  */
2294 static int group_desc_scan_and_fix(ext2_filsys fs, ext2fs_block_bitmap bmap)
2295 {
2296         dgrp_t i;
2297         blk64_t blk, new_blk;
2298
2299         for (i = 0; i < fs->group_desc_count; i++) {
2300                 blk = ext2fs_block_bitmap_loc(fs, i);
2301                 if (ext2fs_test_block_bitmap2(bmap, blk)) {
2302                         new_blk = translate_block(blk);
2303                         if (!new_blk)
2304                                 continue;
2305                         ext2fs_block_bitmap_loc_set(fs, i, new_blk);
2306                 }
2307
2308                 blk = ext2fs_inode_bitmap_loc(fs, i);
2309                 if (ext2fs_test_block_bitmap2(bmap, blk)) {
2310                         new_blk = translate_block(blk);
2311                         if (!new_blk)
2312                                 continue;
2313                         ext2fs_inode_bitmap_loc_set(fs, i, new_blk);
2314                 }
2315         }
2316         return 0;
2317 }
2318
2319 static int expand_inode_table(ext2_filsys fs, unsigned long new_ino_size)
2320 {
2321         dgrp_t i;
2322         blk64_t blk;
2323         errcode_t retval;
2324         int new_ino_blks_per_grp;
2325         unsigned int j;
2326         char *old_itable = NULL, *new_itable = NULL;
2327         char *tmp_old_itable = NULL, *tmp_new_itable = NULL;
2328         unsigned long old_ino_size;
2329         int old_itable_size, new_itable_size;
2330
2331         old_itable_size = fs->inode_blocks_per_group * fs->blocksize;
2332         old_ino_size = EXT2_INODE_SIZE(fs->super);
2333
2334         new_ino_blks_per_grp = ext2fs_div_ceil(
2335                                         EXT2_INODES_PER_GROUP(fs->super) *
2336                                         new_ino_size,
2337                                         fs->blocksize);
2338
2339         new_itable_size = new_ino_blks_per_grp * fs->blocksize;
2340
2341         retval = ext2fs_get_mem(old_itable_size, &old_itable);
2342         if (retval)
2343                 return retval;
2344
2345         retval = ext2fs_get_mem(new_itable_size, &new_itable);
2346         if (retval)
2347                 goto err_out;
2348
2349         tmp_old_itable = old_itable;
2350         tmp_new_itable = new_itable;
2351
2352         for (i = 0; i < fs->group_desc_count; i++) {
2353                 blk = ext2fs_inode_table_loc(fs, i);
2354                 retval = io_channel_read_blk64(fs->io, blk,
2355                                 fs->inode_blocks_per_group, old_itable);
2356                 if (retval)
2357                         goto err_out;
2358
2359                 for (j = 0; j < EXT2_INODES_PER_GROUP(fs->super); j++) {
2360                         memcpy(new_itable, old_itable, old_ino_size);
2361
2362                         memset(new_itable+old_ino_size, 0,
2363                                         new_ino_size - old_ino_size);
2364
2365                         new_itable += new_ino_size;
2366                         old_itable += old_ino_size;
2367                 }
2368
2369                 /* reset the pointer */
2370                 old_itable = tmp_old_itable;
2371                 new_itable = tmp_new_itable;
2372
2373                 retval = io_channel_write_blk64(fs->io, blk,
2374                                         new_ino_blks_per_grp, new_itable);
2375                 if (retval)
2376                         goto err_out;
2377         }
2378
2379         /* Update the meta data */
2380         fs->inode_blocks_per_group = new_ino_blks_per_grp;
2381         ext2fs_free_inode_cache(fs->icache);
2382         fs->icache = 0;
2383         fs->super->s_inode_size = new_ino_size;
2384
2385 err_out:
2386         if (old_itable)
2387                 ext2fs_free_mem(&old_itable);
2388
2389         if (new_itable)
2390                 ext2fs_free_mem(&new_itable);
2391
2392         return retval;
2393 }
2394
2395 static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs)
2396 {
2397         blk64_t         blk;
2398         ext2_ino_t      ino;
2399         unsigned int    group = 0;
2400         unsigned int    count = 0;
2401         int             total_free = 0;
2402         int             group_free = 0;
2403
2404         /*
2405          * First calculate the block statistics
2406          */
2407         for (blk = fs->super->s_first_data_block;
2408              blk < ext2fs_blocks_count(fs->super); blk++) {
2409                 if (!ext2fs_fast_test_block_bitmap2(fs->block_map, blk)) {
2410                         group_free++;
2411                         total_free++;
2412                 }
2413                 count++;
2414                 if ((count == fs->super->s_blocks_per_group) ||
2415                     (blk == ext2fs_blocks_count(fs->super)-1)) {
2416                         ext2fs_bg_free_blocks_count_set(fs, group++,
2417                                                         group_free);
2418                         count = 0;
2419                         group_free = 0;
2420                 }
2421         }
2422         total_free = EXT2FS_C2B(fs, total_free);
2423         ext2fs_free_blocks_count_set(fs->super, total_free);
2424
2425         /*
2426          * Next, calculate the inode statistics
2427          */
2428         group_free = 0;
2429         total_free = 0;
2430         count = 0;
2431         group = 0;
2432
2433         /* Protect loop from wrap-around if s_inodes_count maxed */
2434         for (ino = 1; ino <= fs->super->s_inodes_count && ino > 0; ino++) {
2435                 if (!ext2fs_fast_test_inode_bitmap2(fs->inode_map, ino)) {
2436                         group_free++;
2437                         total_free++;
2438                 }
2439                 count++;
2440                 if ((count == fs->super->s_inodes_per_group) ||
2441                     (ino == fs->super->s_inodes_count)) {
2442                         ext2fs_bg_free_inodes_count_set(fs, group++,
2443                                                         group_free);
2444                         count = 0;
2445                         group_free = 0;
2446                 }
2447         }
2448         fs->super->s_free_inodes_count = total_free;
2449         ext2fs_mark_super_dirty(fs);
2450         return 0;
2451 }
2452
2453 #define list_for_each_safe(pos, pnext, head) \
2454         for (pos = (head)->next, pnext = pos->next; pos != (head); \
2455              pos = pnext, pnext = pos->next)
2456
2457 static void free_blk_move_list(void)
2458 {
2459         struct list_head *entry, *tmp;
2460         struct blk_move *bmv;
2461
2462         list_for_each_safe(entry, tmp, &blk_move_list) {
2463                 bmv = list_entry(entry, struct blk_move, list);
2464                 list_del(entry);
2465                 ext2fs_free_mem(&bmv);
2466         }
2467         return;
2468 }
2469
2470 static int resize_inode(ext2_filsys fs, unsigned long new_size)
2471 {
2472         errcode_t retval;
2473         int new_ino_blks_per_grp;
2474         ext2fs_block_bitmap bmap;
2475
2476         retval = ext2fs_read_inode_bitmap(fs);
2477         if (retval) {
2478                 fputs(_("Failed to read inode bitmap\n"), stderr);
2479                 return retval;
2480         }
2481         retval = ext2fs_read_block_bitmap(fs);
2482         if (retval) {
2483                 fputs(_("Failed to read block bitmap\n"), stderr);
2484                 return retval;
2485         }
2486         INIT_LIST_HEAD(&blk_move_list);
2487
2488
2489         new_ino_blks_per_grp = ext2fs_div_ceil(
2490                                         EXT2_INODES_PER_GROUP(fs->super)*
2491                                         new_size,
2492                                         fs->blocksize);
2493
2494         /* We may change the file system.
2495          * Mark the file system as invalid so that
2496          * the user is prompted to run fsck.
2497          */
2498         fs->super->s_state &= ~EXT2_VALID_FS;
2499
2500         retval = ext2fs_allocate_block_bitmap(fs, _("blocks to be moved"),
2501                                                 &bmap);
2502         if (retval) {
2503                 fputs(_("Failed to allocate block bitmap when "
2504                                 "increasing inode size\n"), stderr);
2505                 return retval;
2506         }
2507         retval = get_move_bitmaps(fs, new_ino_blks_per_grp, bmap);
2508         if (retval) {
2509                 fputs(_("Not enough space to increase inode size \n"), stderr);
2510                 goto err_out;
2511         }
2512         retval = move_block(fs, bmap);
2513         if (retval) {
2514                 fputs(_("Failed to relocate blocks during inode resize \n"),
2515                       stderr);
2516                 goto err_out;
2517         }
2518         retval = inode_scan_and_fix(fs, bmap);
2519         if (retval)
2520                 goto err_out_undo;
2521
2522         retval = group_desc_scan_and_fix(fs, bmap);
2523         if (retval)
2524                 goto err_out_undo;
2525
2526         retval = expand_inode_table(fs, new_size);
2527         if (retval)
2528                 goto err_out_undo;
2529
2530         ext2fs_calculate_summary_stats(fs);
2531
2532         fs->super->s_state |= EXT2_VALID_FS;
2533         /* mark super block and block bitmap as dirty */
2534         ext2fs_mark_super_dirty(fs);
2535         ext2fs_mark_bb_dirty(fs);
2536
2537 err_out:
2538         free_blk_move_list();
2539         ext2fs_free_block_bitmap(bmap);
2540
2541         return retval;
2542
2543 err_out_undo:
2544         free_blk_move_list();
2545         ext2fs_free_block_bitmap(bmap);
2546         fputs(_("Error in resizing the inode size.\n"
2547                         "Run e2undo to undo the "
2548                         "file system changes. \n"), stderr);
2549
2550         return retval;
2551 }
2552
2553 static int tune2fs_setup_tdb(const char *name, io_manager *io_ptr)
2554 {
2555         errcode_t retval = 0;
2556         const char *tdb_dir;
2557         char *tdb_file = NULL;
2558         char *dev_name, *tmp_name;
2559
2560         /* (re)open a specific undo file */
2561         if (undo_file && undo_file[0] != 0) {
2562                 retval = set_undo_io_backing_manager(*io_ptr);
2563                 if (retval)
2564                         goto err;
2565                 *io_ptr = undo_io_manager;
2566                 retval = set_undo_io_backup_file(undo_file);
2567                 if (retval)
2568                         goto err;
2569                 printf(_("Overwriting existing filesystem; this can be undone "
2570                          "using the command:\n"
2571                          "    e2undo %s %s\n\n"),
2572                          undo_file, name);
2573                 return retval;
2574         }
2575
2576         /*
2577          * Configuration via a conf file would be
2578          * nice
2579          */
2580         tdb_dir = getenv("E2FSPROGS_UNDO_DIR");
2581         if (!tdb_dir)
2582                 tdb_dir = "/var/lib/e2fsprogs";
2583
2584         if (!strcmp(tdb_dir, "none") || (tdb_dir[0] == 0) ||
2585             access(tdb_dir, W_OK))
2586                 return 0;
2587
2588         tmp_name = strdup(name);
2589         if (!tmp_name)
2590                 goto errout;
2591         dev_name = basename(tmp_name);
2592         tdb_file = malloc(strlen(tdb_dir) + 9 + strlen(dev_name) + 7 + 1);
2593         if (!tdb_file) {
2594                 free(tmp_name);
2595                 goto errout;
2596         }
2597         sprintf(tdb_file, "%s/tune2fs-%s.e2undo", tdb_dir, dev_name);
2598         free(tmp_name);
2599
2600         if ((unlink(tdb_file) < 0) && (errno != ENOENT)) {
2601                 retval = errno;
2602                 com_err(program_name, retval,
2603                         _("while trying to delete %s"), tdb_file);
2604                 goto errout;
2605         }
2606
2607         retval = set_undo_io_backing_manager(*io_ptr);
2608         if (retval)
2609                 goto errout;
2610         *io_ptr = undo_io_manager;
2611         retval = set_undo_io_backup_file(tdb_file);
2612         if (retval)
2613                 goto errout;
2614         printf(_("Overwriting existing filesystem; this can be undone "
2615                  "using the command:\n"
2616                  "    e2undo %s %s\n\n"),
2617                  tdb_file, name);
2618
2619         free(tdb_file);
2620         return 0;
2621 errout:
2622         free(tdb_file);
2623 err:
2624         com_err("tune2fs", retval, "while trying to setup undo file\n");
2625         return retval;
2626 }
2627
2628 static int
2629 fs_update_journal_user(struct ext2_super_block *sb, __u8 old_uuid[UUID_SIZE])
2630 {
2631         int retval, nr_users, start;
2632         journal_superblock_t *jsb;
2633         ext2_filsys jfs;
2634         __u8 *j_uuid;
2635         char *journal_path;
2636         char uuid[UUID_STR_SIZE];
2637         char buf[SUPERBLOCK_SIZE] __attribute__ ((aligned(8)));
2638
2639         if (!ext2fs_has_feature_journal(sb) || uuid_is_null(sb->s_journal_uuid))
2640                 return 0;
2641
2642         uuid_unparse(sb->s_journal_uuid, uuid);
2643         journal_path = blkid_get_devname(NULL, "UUID", uuid);
2644         if (!journal_path)
2645                 return 0;
2646
2647         retval = ext2fs_open2(journal_path, io_options,
2648                               EXT2_FLAG_JOURNAL_DEV_OK | EXT2_FLAG_RW,
2649                               0, 0, unix_io_manager, &jfs);
2650         if (retval) {
2651                 com_err(program_name, retval,
2652                         _("while trying to open %s"),
2653                         journal_path);
2654                 return retval;
2655         }
2656
2657         retval = get_journal_sb(jfs, buf);
2658         if (retval != 0) {
2659                 if (retval == EXT2_ET_UNSUPP_FEATURE)
2660                         fprintf(stderr, _("%s is not a journal device.\n"),
2661                                 journal_path);
2662                 return retval;
2663         }
2664
2665         jsb = (journal_superblock_t *) buf;
2666         /* Find the filesystem UUID */
2667         nr_users = ntohl(jsb->s_nr_users);
2668
2669         j_uuid = journal_user(old_uuid, jsb->s_users, nr_users);
2670         if (j_uuid == NULL) {
2671                 fputs(_("Filesystem's UUID not found on journal device.\n"),
2672                       stderr);
2673                 return EXT2_ET_LOAD_EXT_JOURNAL;
2674         }
2675
2676         memcpy(j_uuid, sb->s_uuid, UUID_SIZE);
2677
2678         start = ext2fs_journal_sb_start(jfs->blocksize);
2679         /* Write back the journal superblock */
2680         retval = io_channel_write_blk64(jfs->io, start, -SUPERBLOCK_SIZE, buf);
2681         if (retval != 0) {
2682                 com_err(program_name, retval,
2683                         "while writing journal superblock.");
2684                 return retval;
2685         }
2686
2687         ext2fs_close(jfs);
2688
2689         return 0;
2690 }
2691
2692 #ifndef BUILD_AS_LIB
2693 int main(int argc, char **argv)
2694 #else
2695 int tune2fs_main(int argc, char **argv)
2696 #endif  /* BUILD_AS_LIB */
2697 {
2698         errcode_t retval;
2699         ext2_filsys fs;
2700         struct ext2_super_block *sb;
2701         io_manager io_ptr, io_ptr_orig = NULL;
2702         int rc = 0;
2703         char default_undo_file[1] = { 0 };
2704
2705 #ifdef ENABLE_NLS
2706         setlocale(LC_MESSAGES, "");
2707         setlocale(LC_CTYPE, "");
2708         bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
2709         textdomain(NLS_CAT_NAME);
2710         set_com_err_gettext(gettext);
2711 #endif
2712         if (argc && *argv)
2713                 program_name = *argv;
2714         add_error_table(&et_ext2_error_table);
2715
2716 #ifdef CONFIG_BUILD_FINDFS
2717         if (strcmp(get_progname(argv[0]), "findfs") == 0)
2718                 do_findfs(argc, argv);
2719 #endif
2720         if (strcmp(get_progname(argv[0]), "e2label") == 0)
2721                 parse_e2label_options(argc, argv);
2722         else
2723                 parse_tune2fs_options(argc, argv);
2724
2725 #ifdef CONFIG_TESTIO_DEBUG
2726         if (getenv("TEST_IO_FLAGS") || getenv("TEST_IO_DEBUG")) {
2727                 io_ptr = test_io_manager;
2728                 test_io_backing_manager = unix_io_manager;
2729         } else
2730 #endif
2731                 io_ptr = unix_io_manager;
2732
2733 retry_open:
2734         if ((open_flag & EXT2_FLAG_RW) == 0 || f_flag)
2735                 open_flag |= EXT2_FLAG_SKIP_MMP;
2736
2737         open_flag |= EXT2_FLAG_64BITS | EXT2_FLAG_JOURNAL_DEV_OK;
2738
2739         /* keep the filesystem struct around to dump MMP data */
2740         open_flag |= EXT2_FLAG_NOFREE_ON_ERROR;
2741
2742         retval = ext2fs_open2(device_name, io_options, open_flag,
2743                               0, 0, io_ptr, &fs);
2744         if (retval) {
2745                 com_err(program_name, retval,
2746                         _("while trying to open %s"),
2747                         device_name);
2748                 if (retval == EXT2_ET_MMP_FSCK_ON ||
2749                     retval == EXT2_ET_MMP_UNKNOWN_SEQ)
2750                         dump_mmp_msg(fs->mmp_buf,
2751                                      _("If you are sure the filesystem "
2752                                        "is not in use on any node, run:\n"
2753                                        "'tune2fs -f -E clear_mmp {device}'\n"));
2754                 else if (retval == EXT2_ET_MMP_FAILED)
2755                         dump_mmp_msg(fs->mmp_buf, NULL);
2756                 else if (retval == EXT2_ET_MMP_MAGIC_INVALID)
2757                         fprintf(stderr,
2758                                 _("MMP block magic is bad. Try to fix it by "
2759                                   "running:\n'e2fsck -f %s'\n"), device_name);
2760                 else if (retval == EXT2_ET_BAD_MAGIC)
2761                         check_plausibility(device_name, CHECK_FS_EXIST, NULL);
2762                 else if (retval != EXT2_ET_MMP_FAILED)
2763                         fprintf(stderr, "%s",
2764                              _("Couldn't find valid filesystem superblock.\n"));
2765
2766                 ext2fs_free(fs);
2767                 exit(1);
2768         }
2769         if (ext2fs_has_feature_journal_dev(fs->super)) {
2770                 fprintf(stderr, "%s", _("Cannot modify a journal device.\n"));
2771                 ext2fs_free(fs);
2772                 exit(1);
2773         }
2774         fs->default_bitmap_type = EXT2FS_BMAP64_RBTREE;
2775
2776         if (I_flag) {
2777                 /*
2778                  * Check the inode size is right so we can issue an
2779                  * error message and bail before setting up the tdb
2780                  * file.
2781                  */
2782                 if (new_inode_size == EXT2_INODE_SIZE(fs->super)) {
2783                         fprintf(stderr, _("The inode size is already %lu\n"),
2784                                 new_inode_size);
2785                         rc = 1;
2786                         goto closefs;
2787                 }
2788                 if (new_inode_size < EXT2_INODE_SIZE(fs->super)) {
2789                         fprintf(stderr, "%s",
2790                                 _("Shrinking inode size is not supported\n"));
2791                         rc = 1;
2792                         goto closefs;
2793                 }
2794                 if (new_inode_size > fs->blocksize) {
2795                         fprintf(stderr, _("Invalid inode size %lu (max %d)\n"),
2796                                 new_inode_size, fs->blocksize);
2797                         rc = 1;
2798                         goto closefs;
2799                 }
2800                 /*
2801                  * If inode resize is requested use the
2802                  * Undo I/O manager
2803                  */
2804                 undo_file = default_undo_file;
2805         }
2806
2807         /* Set up an undo file */
2808         if (undo_file && io_ptr_orig == NULL) {
2809                 io_ptr_orig = io_ptr;
2810                 retval = tune2fs_setup_tdb(device_name, &io_ptr);
2811                 if (retval) {
2812                         rc = 1;
2813                         goto closefs;
2814                 }
2815                 if (io_ptr != io_ptr_orig) {
2816                         ext2fs_close_free(&fs);
2817                         goto retry_open;
2818                 }
2819         }
2820
2821         sb = fs->super;
2822         fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY;
2823
2824         if (print_label) {
2825                 /* For e2label emulation */
2826                 printf("%.*s\n", (int) sizeof(sb->s_volume_name),
2827                        sb->s_volume_name);
2828                 remove_error_table(&et_ext2_error_table);
2829                 goto closefs;
2830         }
2831
2832         retval = ext2fs_check_if_mounted(device_name, &mount_flags);
2833         if (retval) {
2834                 com_err("ext2fs_check_if_mount", retval,
2835                         _("while determining whether %s is mounted."),
2836                         device_name);
2837                 rc = 1;
2838                 goto closefs;
2839         }
2840         /* Normally we only need to write out the superblock */
2841         fs->flags |= EXT2_FLAG_SUPER_ONLY;
2842
2843         if (c_flag) {
2844                 sb->s_max_mnt_count = max_mount_count;
2845                 ext2fs_mark_super_dirty(fs);
2846                 printf(_("Setting maximal mount count to %d\n"),
2847                        max_mount_count);
2848         }
2849         if (C_flag) {
2850                 sb->s_mnt_count = mount_count;
2851                 ext2fs_mark_super_dirty(fs);
2852                 printf(_("Setting current mount count to %d\n"), mount_count);
2853         }
2854         if (e_flag) {
2855                 sb->s_errors = errors;
2856                 ext2fs_mark_super_dirty(fs);
2857                 printf(_("Setting error behavior to %d\n"), errors);
2858         }
2859         if (g_flag) {
2860                 sb->s_def_resgid = resgid;
2861                 ext2fs_mark_super_dirty(fs);
2862                 printf(_("Setting reserved blocks gid to %lu\n"), resgid);
2863         }
2864         if (i_flag) {
2865                 if ((unsigned long long)interval >= (1ULL << 32)) {
2866                         com_err(program_name, 0,
2867                                 _("interval between checks is too big (%lu)"),
2868                                 interval);
2869                         rc = 1;
2870                         goto closefs;
2871                 }
2872                 sb->s_checkinterval = interval;
2873                 ext2fs_mark_super_dirty(fs);
2874                 printf(_("Setting interval between checks to %lu seconds\n"),
2875                        interval);
2876         }
2877         if (m_flag) {
2878                 ext2fs_r_blocks_count_set(sb, reserved_ratio *
2879                                           ext2fs_blocks_count(sb) / 100.0);
2880                 ext2fs_mark_super_dirty(fs);
2881                 printf (_("Setting reserved blocks percentage to %g%% (%llu blocks)\n"),
2882                         reserved_ratio, ext2fs_r_blocks_count(sb));
2883         }
2884         if (r_flag) {
2885                 if (reserved_blocks > ext2fs_blocks_count(sb)/2) {
2886                         com_err(program_name, 0,
2887                                 _("reserved blocks count is too big (%llu)"),
2888                                 reserved_blocks);
2889                         rc = 1;
2890                         goto closefs;
2891                 }
2892                 ext2fs_r_blocks_count_set(sb, reserved_blocks);
2893                 ext2fs_mark_super_dirty(fs);
2894                 printf(_("Setting reserved blocks count to %llu\n"),
2895                        reserved_blocks);
2896         }
2897         if (s_flag == 1) {
2898                 if (ext2fs_has_feature_sparse_super(sb)) {
2899                         fputs(_("\nThe filesystem already has sparse "
2900                                 "superblocks.\n"), stderr);
2901                 } else if (ext2fs_has_feature_meta_bg(sb)) {
2902                         fputs(_("\nSetting the sparse superblock flag not "
2903                                 "supported\nfor filesystems with "
2904                                 "the meta_bg feature enabled.\n"),
2905                                 stderr);
2906                         rc = 1;
2907                         goto closefs;
2908                 } else {
2909                         ext2fs_set_feature_sparse_super(sb);
2910                         sb->s_state &= ~EXT2_VALID_FS;
2911                         ext2fs_mark_super_dirty(fs);
2912                         printf(_("\nSparse superblock flag set.  %s"),
2913                                _(please_fsck));
2914                 }
2915         }
2916         if (s_flag == 0) {
2917                 fputs(_("\nClearing the sparse superblock flag not supported.\n"),
2918                       stderr);
2919                 rc = 1;
2920                 goto closefs;
2921         }
2922         if (T_flag) {
2923                 sb->s_lastcheck = last_check_time;
2924                 ext2fs_mark_super_dirty(fs);
2925                 printf(_("Setting time filesystem last checked to %s\n"),
2926                        ctime(&last_check_time));
2927         }
2928         if (u_flag) {
2929                 sb->s_def_resuid = resuid;
2930                 ext2fs_mark_super_dirty(fs);
2931                 printf(_("Setting reserved blocks uid to %lu\n"), resuid);
2932         }
2933         if (L_flag) {
2934                 if (strlen(new_label) > sizeof(sb->s_volume_name))
2935                         fputs(_("Warning: label too long, truncating.\n"),
2936                               stderr);
2937                 memset(sb->s_volume_name, 0, sizeof(sb->s_volume_name));
2938                 strncpy(sb->s_volume_name, new_label,
2939                         sizeof(sb->s_volume_name));
2940                 ext2fs_mark_super_dirty(fs);
2941         }
2942         if (M_flag) {
2943                 memset(sb->s_last_mounted, 0, sizeof(sb->s_last_mounted));
2944                 strncpy(sb->s_last_mounted, new_last_mounted,
2945                         sizeof(sb->s_last_mounted));
2946                 ext2fs_mark_super_dirty(fs);
2947         }
2948         if (mntopts_cmd) {
2949                 rc = update_mntopts(fs, mntopts_cmd);
2950                 if (rc)
2951                         goto closefs;
2952         }
2953         if (features_cmd) {
2954                 rc = update_feature_set(fs, features_cmd);
2955                 if (rc)
2956                         goto closefs;
2957         }
2958         if (extended_cmd) {
2959                 rc = parse_extended_opts(fs, extended_cmd);
2960                 if (rc)
2961                         goto closefs;
2962                 if (clear_mmp && !f_flag) {
2963                         fputs(_("Error in using clear_mmp. "
2964                                 "It must be used with -f\n"),
2965                               stderr);
2966                         goto closefs;
2967                 }
2968         }
2969         if (clear_mmp) {
2970                 rc = ext2fs_mmp_clear(fs);
2971                 goto closefs;
2972         }
2973         if (journal_size || journal_device) {
2974                 rc = add_journal(fs);
2975                 if (rc)
2976                         goto closefs;
2977         }
2978
2979         if (Q_flag) {
2980                 if (mount_flags & EXT2_MF_MOUNTED) {
2981                         fputs(_("The quota feature may only be changed when "
2982                                 "the filesystem is unmounted.\n"), stderr);
2983                         rc = 1;
2984                         goto closefs;
2985                 }
2986                 handle_quota_options(fs);
2987         }
2988
2989         if (U_flag) {
2990                 int set_csum = 0;
2991                 dgrp_t i;
2992                 char buf[SUPERBLOCK_SIZE] __attribute__ ((aligned(8)));
2993                 __u8 old_uuid[UUID_SIZE];
2994
2995                 if (ext2fs_has_group_desc_csum(fs)) {
2996                         /*
2997                          * Changing the UUID on a metadata_csum FS requires
2998                          * rewriting all metadata, which can race with a
2999                          * mounted fs.  Don't allow that unless we're saving
3000                          * the checksum seed.
3001                          */
3002                         if ((mount_flags & EXT2_MF_MOUNTED) &&
3003                             !ext2fs_has_feature_csum_seed(fs->super) &&
3004                             ext2fs_has_feature_metadata_csum(fs->super)) {
3005                                 fputs(_("The UUID may only be "
3006                                         "changed when the filesystem is "
3007                                         "unmounted.\n"), stderr);
3008                                 fputs(_("If you only use kernels newer than "
3009                                         "v4.4, run 'tune2fs -O "
3010                                         "metadata_csum_seed' and re-run this "
3011                                         "command.\n"), stderr);
3012                                 try_confirm_csum_seed_support();
3013                                 exit(1);
3014                         }
3015                         if (check_fsck_needed(fs))
3016                                 exit(1);
3017
3018                         /*
3019                          * Determine if the block group checksums are
3020                          * correct so we know whether or not to set
3021                          * them later on.
3022                          */
3023                         for (i = 0; i < fs->group_desc_count; i++)
3024                                 if (!ext2fs_group_desc_csum_verify(fs, i))
3025                                         break;
3026                         if (i >= fs->group_desc_count)
3027                                 set_csum = 1;
3028                 }
3029
3030                 memcpy(old_uuid, sb->s_uuid, UUID_SIZE);
3031                 if ((strcasecmp(new_UUID, "null") == 0) ||
3032                     (strcasecmp(new_UUID, "clear") == 0)) {
3033                         uuid_clear(sb->s_uuid);
3034                 } else if (strcasecmp(new_UUID, "time") == 0) {
3035                         uuid_generate_time(sb->s_uuid);
3036                 } else if (strcasecmp(new_UUID, "random") == 0) {
3037                         uuid_generate(sb->s_uuid);
3038                 } else if (uuid_parse(new_UUID, sb->s_uuid)) {
3039                         com_err(program_name, 0, "%s",
3040                                 _("Invalid UUID format\n"));
3041                         rc = 1;
3042                         goto closefs;
3043                 }
3044                 ext2fs_init_csum_seed(fs);
3045                 if (set_csum) {
3046                         for (i = 0; i < fs->group_desc_count; i++)
3047                                 ext2fs_group_desc_csum_set(fs, i);
3048                         fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
3049                 }
3050
3051                 /* If this is a journal dev, we need to copy UUID into jsb */
3052                 if (!(rc = get_journal_sb(fs, buf))) {
3053                         journal_superblock_t *jsb;
3054
3055                         jsb = (journal_superblock_t *) buf;
3056                         fputs(_("Need to update journal superblock.\n"), stdout);
3057                         memcpy(jsb->s_uuid, sb->s_uuid, sizeof(sb->s_uuid));
3058
3059                         /* Writeback the journal superblock */
3060                         if ((rc = io_channel_write_blk64(fs->io,
3061                                 ext2fs_journal_sb_start(fs->blocksize),
3062                                         -SUPERBLOCK_SIZE, buf)))
3063                                 goto closefs;
3064                 } else if (rc != EXT2_ET_UNSUPP_FEATURE)
3065                         goto closefs;
3066                 else {
3067                         rc = 0; /** Reset rc to avoid ext2fs_mmp_stop() */
3068
3069                         if ((rc = fs_update_journal_user(sb, old_uuid)))
3070                                 goto closefs;
3071                 }
3072
3073                 ext2fs_mark_super_dirty(fs);
3074                 if (ext2fs_has_feature_metadata_csum(fs->super) &&
3075                     !ext2fs_has_feature_csum_seed(fs->super))
3076                         rewrite_checksums = 1;
3077         }
3078
3079         if (I_flag) {
3080                 if (mount_flags & EXT2_MF_MOUNTED) {
3081                         fputs(_("The inode size may only be "
3082                                 "changed when the filesystem is "
3083                                 "unmounted.\n"), stderr);
3084                         rc = 1;
3085                         goto closefs;
3086                 }
3087                 if (ext2fs_has_feature_flex_bg(fs->super)) {
3088                         fputs(_("Changing the inode size not supported for "
3089                                 "filesystems with the flex_bg\n"
3090                                 "feature enabled.\n"),
3091                               stderr);
3092                         rc = 1;
3093                         goto closefs;
3094                 }
3095                 /*
3096                  * We want to update group descriptor also
3097                  * with the new free inode count
3098                  */
3099                 if (rewrite_checksums)
3100                         fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
3101                 fs->flags &= ~EXT2_FLAG_SUPER_ONLY;
3102                 retval = resize_inode(fs, new_inode_size);
3103                 if (rewrite_checksums)
3104                         fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
3105                 if (retval == 0) {
3106                         printf(_("Setting inode size %lu\n"),
3107                                                         new_inode_size);
3108                         rewrite_checksums = 1;
3109                 } else {
3110                         printf("%s", _("Failed to change inode size\n"));
3111                         rc = 1;
3112                         goto closefs;
3113                 }
3114         }
3115
3116         if (rewrite_checksums)
3117                 rewrite_metadata_checksums(fs);
3118
3119         if (l_flag)
3120                 list_super(sb);
3121         if (stride_set) {
3122                 sb->s_raid_stride = stride;
3123                 ext2fs_mark_super_dirty(fs);
3124                 printf(_("Setting stride size to %d\n"), stride);
3125         }
3126         if (stripe_width_set) {
3127                 sb->s_raid_stripe_width = stripe_width;
3128                 ext2fs_mark_super_dirty(fs);
3129                 printf(_("Setting stripe width to %d\n"), stripe_width);
3130         }
3131         if (ext_mount_opts) {
3132                 strncpy((char *)(fs->super->s_mount_opts), ext_mount_opts,
3133                         sizeof(fs->super->s_mount_opts));
3134                 fs->super->s_mount_opts[sizeof(fs->super->s_mount_opts)-1] = 0;
3135                 ext2fs_mark_super_dirty(fs);
3136                 printf(_("Setting extended default mount options to '%s'\n"),
3137                        ext_mount_opts);
3138                 free(ext_mount_opts);
3139         }
3140
3141         /* Warn if file system needs recovery and it is opened for writing. */
3142         if ((open_flag & EXT2_FLAG_RW) && !(mount_flags & EXT2_MF_MOUNTED) &&
3143             (sb->s_feature_compat & EXT3_FEATURE_COMPAT_HAS_JOURNAL) &&
3144             (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_RECOVER)) {
3145                 fprintf(stderr,
3146 _("Warning: The journal is dirty. You may wish to replay the journal like:\n\n"
3147   "\te2fsck -E journal_only %s\n\n"
3148   "then rerun this command.  Otherwise, any changes made may be overwritten\n"
3149   "by journal recovery.\n"), device_name);
3150         }
3151
3152         free(device_name);
3153         remove_error_table(&et_ext2_error_table);
3154
3155 closefs:
3156         if (rc) {
3157                 ext2fs_mmp_stop(fs);
3158 #ifndef BUILD_AS_LIB
3159                 exit(1);
3160 #endif
3161         }
3162
3163         convert_64bit(fs, feature_64bit);
3164         return (ext2fs_close_free(&fs) ? 1 : 0);
3165 }