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