fs/ext4/super.c

   1 /*
   2  *  linux/fs/ext4/super.c
   3  *
   4  * Copyright (C) 1992, 1993, 1994, 1995
   5  * Remy Card (card@masi.ibp.fr)
   6  * Laboratoire MASI - Institut Blaise Pascal
   7  * Universite Pierre et Marie Curie (Paris VI)
   8  *
   9  *  from
  10  *
  11  *  linux/fs/minix/inode.c
  12  *
  13  *  Copyright (C) 1991, 1992  Linus Torvalds
  14  *
  15  *  Big-endian to little-endian byte-swapping/bitmaps by
  16  *        David S. Miller (davem@caip.rutgers.edu), 1995
  17  */
  18
  19 #include <linux/module.h>
  20 #include <linux/string.h>
  21 #include <linux/fs.h>
  22 #include <linux/time.h>
  23 #include <linux/vmalloc.h>
  24 #include <linux/jbd2.h>
  25 #include <linux/slab.h>
  26 #include <linux/init.h>
  27 #include <linux/blkdev.h>
  28 #include <linux/parser.h>
  29 #include <linux/smp_lock.h>
  30 #include <linux/buffer_head.h>
  31 #include <linux/exportfs.h>
  32 #include <linux/vfs.h>
  33 #include <linux/random.h>
  34 #include <linux/mount.h>
  35 #include <linux/namei.h>
  36 #include <linux/quotaops.h>
  37 #include <linux/seq_file.h>
  38 #include <linux/proc_fs.h>
  39 #include <linux/ctype.h>
  40 #include <linux/marker.h>
  41 #include <linux/log2.h>
  42 #include <linux/crc16.h>
  43 #include <asm/uaccess.h>
  44
  45 #include "ext4.h"
  46 #include "ext4_jbd2.h"
  47 #include "xattr.h"
  48 #include "acl.h"
  49 #include "group.h"
  50
  51 struct proc_dir_entry *ext4_proc_root;
  52 static struct kset *ext4_kset;
  53
  54 static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
  55                              unsigned long journal_devnum);
  56 static int ext4_commit_super(struct super_block *sb, int sync);
  57 static void ext4_mark_recovery_complete(struct super_block *sb,
  58                                         struct ext4_super_block *es);
  59 static void ext4_clear_journal_err(struct super_block *sb,
  60                                    struct ext4_super_block *es);
  61 static int ext4_sync_fs(struct super_block *sb, int wait);
  62 static const char *ext4_decode_error(struct super_block *sb, int errno,
  63                                      char nbuf[16]);
  64 static int ext4_remount(struct super_block *sb, int *flags, char *data);
  65 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
  66 static int ext4_unfreeze(struct super_block *sb);
  67 static void ext4_write_super(struct super_block *sb);
  68 static int ext4_freeze(struct super_block *sb);
  69
  70
  71 ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
  72                                struct ext4_group_desc *bg)
  73 {
  74         return le32_to_cpu(bg->bg_block_bitmap_lo) |
  75                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
  76                 (ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
  77 }
  78
  79 ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
  80                                struct ext4_group_desc *bg)
  81 {
  82         return le32_to_cpu(bg->bg_inode_bitmap_lo) |
  83                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
  84                 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
  85 }
  86
  87 ext4_fsblk_t ext4_inode_table(struct super_block *sb,
  88                               struct ext4_group_desc *bg)
  89 {
  90         return le32_to_cpu(bg->bg_inode_table_lo) |
  91                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
  92                 (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
  93 }
  94
  95 __u32 ext4_free_blks_count(struct super_block *sb,
  96                               struct ext4_group_desc *bg)
  97 {
  98         return le16_to_cpu(bg->bg_free_blocks_count_lo) |
  99                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 100                 (__u32)le16_to_cpu(bg->bg_free_blocks_count_hi) << 16 : 0);
 101 }
 102
 103 __u32 ext4_free_inodes_count(struct super_block *sb,
 104                               struct ext4_group_desc *bg)
 105 {
 106         return le16_to_cpu(bg->bg_free_inodes_count_lo) |
 107                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 108                 (__u32)le16_to_cpu(bg->bg_free_inodes_count_hi) << 16 : 0);
 109 }
 110
 111 __u32 ext4_used_dirs_count(struct super_block *sb,
 112                               struct ext4_group_desc *bg)
 113 {
 114         return le16_to_cpu(bg->bg_used_dirs_count_lo) |
 115                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 116                 (__u32)le16_to_cpu(bg->bg_used_dirs_count_hi) << 16 : 0);
 117 }
 118
 119 __u32 ext4_itable_unused_count(struct super_block *sb,
 120                               struct ext4_group_desc *bg)
 121 {
 122         return le16_to_cpu(bg->bg_itable_unused_lo) |
 123                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 124                 (__u32)le16_to_cpu(bg->bg_itable_unused_hi) << 16 : 0);
 125 }
 126
 127 void ext4_block_bitmap_set(struct super_block *sb,
 128                            struct ext4_group_desc *bg, ext4_fsblk_t blk)
 129 {
 130         bg->bg_block_bitmap_lo = cpu_to_le32((u32)blk);
 131         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 132                 bg->bg_block_bitmap_hi = cpu_to_le32(blk >> 32);
 133 }
 134
 135 void ext4_inode_bitmap_set(struct super_block *sb,
 136                            struct ext4_group_desc *bg, ext4_fsblk_t blk)
 137 {
 138         bg->bg_inode_bitmap_lo  = cpu_to_le32((u32)blk);
 139         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 140                 bg->bg_inode_bitmap_hi = cpu_to_le32(blk >> 32);
 141 }
 142
 143 void ext4_inode_table_set(struct super_block *sb,
 144                           struct ext4_group_desc *bg, ext4_fsblk_t blk)
 145 {
 146         bg->bg_inode_table_lo = cpu_to_le32((u32)blk);
 147         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 148                 bg->bg_inode_table_hi = cpu_to_le32(blk >> 32);
 149 }
 150
 151 void ext4_free_blks_set(struct super_block *sb,
 152                           struct ext4_group_desc *bg, __u32 count)
 153 {
 154         bg->bg_free_blocks_count_lo = cpu_to_le16((__u16)count);
 155         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 156                 bg->bg_free_blocks_count_hi = cpu_to_le16(count >> 16);
 157 }
 158
 159 void ext4_free_inodes_set(struct super_block *sb,
 160                           struct ext4_group_desc *bg, __u32 count)
 161 {
 162         bg->bg_free_inodes_count_lo = cpu_to_le16((__u16)count);
 163         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 164                 bg->bg_free_inodes_count_hi = cpu_to_le16(count >> 16);
 165 }
 166
 167 void ext4_used_dirs_set(struct super_block *sb,
 168                           struct ext4_group_desc *bg, __u32 count)
 169 {
 170         bg->bg_used_dirs_count_lo = cpu_to_le16((__u16)count);
 171         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 172                 bg->bg_used_dirs_count_hi = cpu_to_le16(count >> 16);
 173 }
 174
 175 void ext4_itable_unused_set(struct super_block *sb,
 176                           struct ext4_group_desc *bg, __u32 count)
 177 {
 178         bg->bg_itable_unused_lo = cpu_to_le16((__u16)count);
 179         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 180                 bg->bg_itable_unused_hi = cpu_to_le16(count >> 16);
 181 }
 182
 183 /*
 184  * Wrappers for jbd2_journal_start/end.
 185  *
 186  * The only special thing we need to do here is to make sure that all
 187  * journal_end calls result in the superblock being marked dirty, so
 188  * that sync() will call the filesystem's write_super callback if
 189  * appropriate.
 190  */
 191 handle_t *ext4_journal_start_sb(struct super_block *sb, int nblocks)
 192 {
 193         journal_t *journal;
 194
 195         if (sb->s_flags & MS_RDONLY)
 196                 return ERR_PTR(-EROFS);
 197
 198         /* Special case here: if the journal has aborted behind our
 199          * backs (eg. EIO in the commit thread), then we still need to
 200          * take the FS itself readonly cleanly. */
 201         journal = EXT4_SB(sb)->s_journal;
 202         if (journal) {
 203                 if (is_journal_aborted(journal)) {
 204                         ext4_abort(sb, __func__,
 205                                    "Detected aborted journal");
 206                         return ERR_PTR(-EROFS);
 207                 }
 208                 return jbd2_journal_start(journal, nblocks);
 209         }
 210         /*
 211          * We're not journaling, return the appropriate indication.
 212          */
 213         current->journal_info = EXT4_NOJOURNAL_HANDLE;
 214         return current->journal_info;
 215 }
 216
 217 /*
 218  * The only special thing we need to do here is to make sure that all
 219  * jbd2_journal_stop calls result in the superblock being marked dirty, so
 220  * that sync() will call the filesystem's write_super callback if
 221  * appropriate.
 222  */
 223 int __ext4_journal_stop(const char *where, handle_t *handle)
 224 {
 225         struct super_block *sb;
 226         int err;
 227         int rc;
 228
 229         if (!ext4_handle_valid(handle)) {
 230                 /*
 231                  * Do this here since we don't call jbd2_journal_stop() in
 232                  * no-journal mode.
 233                  */
 234                 current->journal_info = NULL;
 235                 return 0;
 236         }
 237         sb = handle->h_transaction->t_journal->j_private;
 238         err = handle->h_err;
 239         rc = jbd2_journal_stop(handle);
 240
 241         if (!err)
 242                 err = rc;
 243         if (err)
 244                 __ext4_std_error(sb, where, err);
 245         return err;
 246 }
 247
 248 void ext4_journal_abort_handle(const char *caller, const char *err_fn,
 249                 struct buffer_head *bh, handle_t *handle, int err)
 250 {
 251         char nbuf[16];
 252         const char *errstr = ext4_decode_error(NULL, err, nbuf);
 253
 254         BUG_ON(!ext4_handle_valid(handle));
 255
 256         if (bh)
 257                 BUFFER_TRACE(bh, "abort");
 258
 259         if (!handle->h_err)
 260                 handle->h_err = err;
 261
 262         if (is_handle_aborted(handle))
 263                 return;
 264
 265         printk(KERN_ERR "%s: aborting transaction: %s in %s\n",
 266                caller, errstr, err_fn);
 267
 268         jbd2_journal_abort_handle(handle);
 269 }
 270
 271 /* Deal with the reporting of failure conditions on a filesystem such as
 272  * inconsistencies detected or read IO failures.
 273  *
 274  * On ext2, we can store the error state of the filesystem in the
 275  * superblock.  That is not possible on ext4, because we may have other
 276  * write ordering constraints on the superblock which prevent us from
 277  * writing it out straight away; and given that the journal is about to
 278  * be aborted, we can't rely on the current, or future, transactions to
 279  * write out the superblock safely.
 280  *
 281  * We'll just use the jbd2_journal_abort() error code to record an error in
 282  * the journal instead.  On recovery, the journal will compain about
 283  * that error until we've noted it down and cleared it.
 284  */
 285
 286 static void ext4_handle_error(struct super_block *sb)
 287 {
 288         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
 289
 290         EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
 291         es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
 292
 293         if (sb->s_flags & MS_RDONLY)
 294                 return;
 295
 296         if (!test_opt(sb, ERRORS_CONT)) {
 297                 journal_t *journal = EXT4_SB(sb)->s_journal;
 298
 299                 EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
 300                 if (journal)
 301                         jbd2_journal_abort(journal, -EIO);
 302         }
 303         if (test_opt(sb, ERRORS_RO)) {
 304                 printk(KERN_CRIT "Remounting filesystem read-only\n");
 305                 sb->s_flags |= MS_RDONLY;
 306         }
 307         ext4_commit_super(sb, 1);
 308         if (test_opt(sb, ERRORS_PANIC))
 309                 panic("EXT4-fs (device %s): panic forced after error\n",
 310                         sb->s_id);
 311 }
 312
 313 void ext4_error(struct super_block *sb, const char *function,
 314                 const char *fmt, ...)
 315 {
 316         va_list args;
 317
 318         va_start(args, fmt);
 319         printk(KERN_CRIT "EXT4-fs error (device %s): %s: ", sb->s_id, function);
 320         vprintk(fmt, args);
 321         printk("\n");
 322         va_end(args);
 323
 324         ext4_handle_error(sb);
 325 }
 326
 327 static const char *ext4_decode_error(struct super_block *sb, int errno,
 328                                      char nbuf[16])
 329 {
 330         char *errstr = NULL;
 331
 332         switch (errno) {
 333         case -EIO:
 334                 errstr = "IO failure";
 335                 break;
 336         case -ENOMEM:
 337                 errstr = "Out of memory";
 338                 break;
 339         case -EROFS:
 340                 if (!sb || EXT4_SB(sb)->s_journal->j_flags & JBD2_ABORT)
 341                         errstr = "Journal has aborted";
 342                 else
 343                         errstr = "Readonly filesystem";
 344                 break;
 345         default:
 346                 /* If the caller passed in an extra buffer for unknown
 347                  * errors, textualise them now.  Else we just return
 348                  * NULL. */
 349                 if (nbuf) {
 350                         /* Check for truncated error codes... */
 351                         if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
 352                                 errstr = nbuf;
 353                 }
 354                 break;
 355         }
 356
 357         return errstr;
 358 }
 359
 360 /* __ext4_std_error decodes expected errors from journaling functions
 361  * automatically and invokes the appropriate error response.  */
 362
 363 void __ext4_std_error(struct super_block *sb, const char *function, int errno)
 364 {
 365         char nbuf[16];
 366         const char *errstr;
 367
 368         /* Special case: if the error is EROFS, and we're not already
 369          * inside a transaction, then there's really no point in logging
 370          * an error. */
 371         if (errno == -EROFS && journal_current_handle() == NULL &&
 372             (sb->s_flags & MS_RDONLY))
 373                 return;
 374
 375         errstr = ext4_decode_error(sb, errno, nbuf);
 376         printk(KERN_CRIT "EXT4-fs error (device %s) in %s: %s\n",
 377                sb->s_id, function, errstr);
 378
 379         ext4_handle_error(sb);
 380 }
 381
 382 /*
 383  * ext4_abort is a much stronger failure handler than ext4_error.  The
 384  * abort function may be used to deal with unrecoverable failures such
 385  * as journal IO errors or ENOMEM at a critical moment in log management.
 386  *
 387  * We unconditionally force the filesystem into an ABORT|READONLY state,
 388  * unless the error response on the fs has been set to panic in which
 389  * case we take the easy way out and panic immediately.
 390  */
 391
 392 void ext4_abort(struct super_block *sb, const char *function,
 393                 const char *fmt, ...)
 394 {
 395         va_list args;
 396
 397         printk(KERN_CRIT "ext4_abort called.\n");
 398
 399         va_start(args, fmt);
 400         printk(KERN_CRIT "EXT4-fs error (device %s): %s: ", sb->s_id, function);
 401         vprintk(fmt, args);
 402         printk("\n");
 403         va_end(args);
 404
 405         if (test_opt(sb, ERRORS_PANIC))
 406                 panic("EXT4-fs panic from previous error\n");
 407
 408         if (sb->s_flags & MS_RDONLY)
 409                 return;
 410
 411         printk(KERN_CRIT "Remounting filesystem read-only\n");
 412         EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
 413         sb->s_flags |= MS_RDONLY;
 414         EXT4_SB(sb)->s_mount_opt |= EXT4_MOUNT_ABORT;
 415         if (EXT4_SB(sb)->s_journal)
 416                 jbd2_journal_abort(EXT4_SB(sb)->s_journal, -EIO);
 417 }
 418
 419 void ext4_warning(struct super_block *sb, const char *function,
 420                   const char *fmt, ...)
 421 {
 422         va_list args;
 423
 424         va_start(args, fmt);
 425         printk(KERN_WARNING "EXT4-fs warning (device %s): %s: ",
 426                sb->s_id, function);
 427         vprintk(fmt, args);
 428         printk("\n");
 429         va_end(args);
 430 }
 431
 432 void ext4_grp_locked_error(struct super_block *sb, ext4_group_t grp,
 433                                 const char *function, const char *fmt, ...)
 434 __releases(bitlock)
 435 __acquires(bitlock)
 436 {
 437         va_list args;
 438         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
 439
 440         va_start(args, fmt);
 441         printk(KERN_CRIT "EXT4-fs error (device %s): %s: ", sb->s_id, function);
 442         vprintk(fmt, args);
 443         printk("\n");
 444         va_end(args);
 445
 446         if (test_opt(sb, ERRORS_CONT)) {
 447                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
 448                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
 449                 ext4_commit_super(sb, 0);
 450                 return;
 451         }
 452         ext4_unlock_group(sb, grp);
 453         ext4_handle_error(sb);
 454         /*
 455          * We only get here in the ERRORS_RO case; relocking the group
 456          * may be dangerous, but nothing bad will happen since the
 457          * filesystem will have already been marked read/only and the
 458          * journal has been aborted.  We return 1 as a hint to callers
 459          * who might what to use the return value from
 460          * ext4_grp_locked_error() to distinguish beween the
 461          * ERRORS_CONT and ERRORS_RO case, and perhaps return more
 462          * aggressively from the ext4 function in question, with a
 463          * more appropriate error code.
 464          */
 465         ext4_lock_group(sb, grp);
 466         return;
 467 }
 468
 469
 470 void ext4_update_dynamic_rev(struct super_block *sb)
 471 {
 472         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
 473
 474         if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
 475                 return;
 476
 477         ext4_warning(sb, __func__,
 478                      "updating to rev %d because of new feature flag, "
 479                      "running e2fsck is recommended",
 480                      EXT4_DYNAMIC_REV);
 481
 482         es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
 483         es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
 484         es->s_rev_level = cpu_to_le32(EXT4_DYNAMIC_REV);
 485         /* leave es->s_feature_*compat flags alone */
 486         /* es->s_uuid will be set by e2fsck if empty */
 487
 488         /*
 489          * The rest of the superblock fields should be zero, and if not it
 490          * means they are likely already in use, so leave them alone.  We
 491          * can leave it up to e2fsck to clean up any inconsistencies there.
 492          */
 493 }
 494
 495 /*
 496  * Open the external journal device
 497  */
 498 static struct block_device *ext4_blkdev_get(dev_t dev)
 499 {
 500         struct block_device *bdev;
 501         char b[BDEVNAME_SIZE];
 502
 503         bdev = open_by_devnum(dev, FMODE_READ|FMODE_WRITE);
 504         if (IS_ERR(bdev))
 505                 goto fail;
 506         return bdev;
 507
 508 fail:
 509         printk(KERN_ERR "EXT4-fs: failed to open journal device %s: %ld\n",
 510                         __bdevname(dev, b), PTR_ERR(bdev));
 511         return NULL;
 512 }
 513
 514 /*
 515  * Release the journal device
 516  */
 517 static int ext4_blkdev_put(struct block_device *bdev)
 518 {
 519         bd_release(bdev);
 520         return blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
 521 }
 522
 523 static int ext4_blkdev_remove(struct ext4_sb_info *sbi)
 524 {
 525         struct block_device *bdev;
 526         int ret = -ENODEV;
 527
 528         bdev = sbi->journal_bdev;
 529         if (bdev) {
 530                 ret = ext4_blkdev_put(bdev);
 531                 sbi->journal_bdev = NULL;
 532         }
 533         return ret;
 534 }
 535
 536 static inline struct inode *orphan_list_entry(struct list_head *l)
 537 {
 538         return &list_entry(l, struct ext4_inode_info, i_orphan)->vfs_inode;
 539 }
 540
 541 static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
 542 {
 543         struct list_head *l;
 544
 545         printk(KERN_ERR "sb orphan head is %d\n",
 546                le32_to_cpu(sbi->s_es->s_last_orphan));
 547
 548         printk(KERN_ERR "sb_info orphan list:\n");
 549         list_for_each(l, &sbi->s_orphan) {
 550                 struct inode *inode = orphan_list_entry(l);
 551                 printk(KERN_ERR "  "
 552                        "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
 553                        inode->i_sb->s_id, inode->i_ino, inode,
 554                        inode->i_mode, inode->i_nlink,
 555                        NEXT_ORPHAN(inode));
 556         }
 557 }
 558
 559 static void ext4_put_super(struct super_block *sb)
 560 {
 561         struct ext4_sb_info *sbi = EXT4_SB(sb);
 562         struct ext4_super_block *es = sbi->s_es;
 563         int i, err;
 564
 565         ext4_mb_release(sb);
 566         ext4_ext_release(sb);
 567         ext4_xattr_put_super(sb);
 568         if (sbi->s_journal) {
 569                 err = jbd2_journal_destroy(sbi->s_journal);
 570                 sbi->s_journal = NULL;
 571                 if (err < 0)
 572                         ext4_abort(sb, __func__,
 573                                    "Couldn't clean up the journal");
 574         }
 575         if (!(sb->s_flags & MS_RDONLY)) {
 576                 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
 577                 es->s_state = cpu_to_le16(sbi->s_mount_state);
 578                 ext4_commit_super(sb, 1);
 579         }
 580         if (sbi->s_proc) {
 581                 remove_proc_entry(sb->s_id, ext4_proc_root);
 582         }
 583         kobject_del(&sbi->s_kobj);
 584
 585         for (i = 0; i < sbi->s_gdb_count; i++)
 586                 brelse(sbi->s_group_desc[i]);
 587         kfree(sbi->s_group_desc);
 588         if (is_vmalloc_addr(sbi->s_flex_groups))
 589                 vfree(sbi->s_flex_groups);
 590         else
 591                 kfree(sbi->s_flex_groups);
 592         percpu_counter_destroy(&sbi->s_freeblocks_counter);
 593         percpu_counter_destroy(&sbi->s_freeinodes_counter);
 594         percpu_counter_destroy(&sbi->s_dirs_counter);
 595         percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
 596         brelse(sbi->s_sbh);
 597 #ifdef CONFIG_QUOTA
 598         for (i = 0; i < MAXQUOTAS; i++)
 599                 kfree(sbi->s_qf_names[i]);
 600 #endif
 601
 602         /* Debugging code just in case the in-memory inode orphan list
 603          * isn't empty.  The on-disk one can be non-empty if we've
 604          * detected an error and taken the fs readonly, but the
 605          * in-memory list had better be clean by this point. */
 606         if (!list_empty(&sbi->s_orphan))
 607                 dump_orphan_list(sb, sbi);
 608         J_ASSERT(list_empty(&sbi->s_orphan));
 609
 610         invalidate_bdev(sb->s_bdev);
 611         if (sbi->journal_bdev && sbi->journal_bdev != sb->s_bdev) {
 612                 /*
 613                  * Invalidate the journal device's buffers.  We don't want them
 614                  * floating about in memory - the physical journal device may
 615                  * hotswapped, and it breaks the `ro-after' testing code.
 616                  */
 617                 sync_blockdev(sbi->journal_bdev);
 618                 invalidate_bdev(sbi->journal_bdev);
 619                 ext4_blkdev_remove(sbi);
 620         }
 621         sb->s_fs_info = NULL;
 622         /*
 623          * Now that we are completely done shutting down the
 624          * superblock, we need to actually destroy the kobject.
 625          */
 626         unlock_kernel();
 627         unlock_super(sb);
 628         kobject_put(&sbi->s_kobj);
 629         wait_for_completion(&sbi->s_kobj_unregister);
 630         lock_super(sb);
 631         lock_kernel();
 632         kfree(sbi->s_blockgroup_lock);
 633         kfree(sbi);
 634         return;
 635 }
 636
 637 static struct kmem_cache *ext4_inode_cachep;
 638
 639 /*
 640  * Called inside transaction, so use GFP_NOFS
 641  */
 642 static struct inode *ext4_alloc_inode(struct super_block *sb)
 643 {
 644         struct ext4_inode_info *ei;
 645
 646         ei = kmem_cache_alloc(ext4_inode_cachep, GFP_NOFS);
 647         if (!ei)
 648                 return NULL;
 649 #ifdef CONFIG_EXT4_FS_POSIX_ACL
 650         ei->i_acl = EXT4_ACL_NOT_CACHED;
 651         ei->i_default_acl = EXT4_ACL_NOT_CACHED;
 652 #endif
 653         ei->vfs_inode.i_version = 1;
 654         ei->vfs_inode.i_data.writeback_index = 0;
 655         memset(&ei->i_cached_extent, 0, sizeof(struct ext4_ext_cache));
 656         INIT_LIST_HEAD(&ei->i_prealloc_list);
 657         spin_lock_init(&ei->i_prealloc_lock);
 658         /*
 659          * Note:  We can be called before EXT4_SB(sb)->s_journal is set,
 660          * therefore it can be null here.  Don't check it, just initialize
 661          * jinode.
 662          */
 663         jbd2_journal_init_jbd_inode(&ei->jinode, &ei->vfs_inode);
 664         ei->i_reserved_data_blocks = 0;
 665         ei->i_reserved_meta_blocks = 0;
 666         ei->i_allocated_meta_blocks = 0;
 667         ei->i_delalloc_reserved_flag = 0;
 668         spin_lock_init(&(ei->i_block_reservation_lock));
 669         return &ei->vfs_inode;
 670 }
 671
 672 static void ext4_destroy_inode(struct inode *inode)
 673 {
 674         if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
 675                 printk("EXT4 Inode %p: orphan list check failed!\n",
 676                         EXT4_I(inode));
 677                 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
 678                                 EXT4_I(inode), sizeof(struct ext4_inode_info),
 679                                 true);
 680                 dump_stack();
 681         }
 682         kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
 683 }
 684
 685 static void init_once(void *foo)
 686 {
 687         struct ext4_inode_info *ei = (struct ext4_inode_info *) foo;
 688
 689         INIT_LIST_HEAD(&ei->i_orphan);
 690 #ifdef CONFIG_EXT4_FS_XATTR
 691         init_rwsem(&ei->xattr_sem);
 692 #endif
 693         init_rwsem(&ei->i_data_sem);
 694         inode_init_once(&ei->vfs_inode);
 695 }
 696
 697 static int init_inodecache(void)
 698 {
 699         ext4_inode_cachep = kmem_cache_create("ext4_inode_cache",
 700                                              sizeof(struct ext4_inode_info),
 701                                              0, (SLAB_RECLAIM_ACCOUNT|
 702                                                 SLAB_MEM_SPREAD),
 703                                              init_once);
 704         if (ext4_inode_cachep == NULL)
 705                 return -ENOMEM;
 706         return 0;
 707 }
 708
 709 static void destroy_inodecache(void)
 710 {
 711         kmem_cache_destroy(ext4_inode_cachep);
 712 }
 713
 714 static void ext4_clear_inode(struct inode *inode)
 715 {
 716 #ifdef CONFIG_EXT4_FS_POSIX_ACL
 717         if (EXT4_I(inode)->i_acl &&
 718                         EXT4_I(inode)->i_acl != EXT4_ACL_NOT_CACHED) {
 719                 posix_acl_release(EXT4_I(inode)->i_acl);
 720                 EXT4_I(inode)->i_acl = EXT4_ACL_NOT_CACHED;
 721         }
 722         if (EXT4_I(inode)->i_default_acl &&
 723                         EXT4_I(inode)->i_default_acl != EXT4_ACL_NOT_CACHED) {
 724                 posix_acl_release(EXT4_I(inode)->i_default_acl);
 725                 EXT4_I(inode)->i_default_acl = EXT4_ACL_NOT_CACHED;
 726         }
 727 #endif
 728         ext4_discard_preallocations(inode);
 729         if (EXT4_JOURNAL(inode))
 730                 jbd2_journal_release_jbd_inode(EXT4_SB(inode->i_sb)->s_journal,
 731                                        &EXT4_I(inode)->jinode);
 732 }
 733
 734 static inline void ext4_show_quota_options(struct seq_file *seq,
 735                                            struct super_block *sb)
 736 {
 737 #if defined(CONFIG_QUOTA)
 738         struct ext4_sb_info *sbi = EXT4_SB(sb);
 739
 740         if (sbi->s_jquota_fmt)
 741                 seq_printf(seq, ",jqfmt=%s",
 742                 (sbi->s_jquota_fmt == QFMT_VFS_OLD) ? "vfsold" : "vfsv0");
 743
 744         if (sbi->s_qf_names[USRQUOTA])
 745                 seq_printf(seq, ",usrjquota=%s", sbi->s_qf_names[USRQUOTA]);
 746
 747         if (sbi->s_qf_names[GRPQUOTA])
 748                 seq_printf(seq, ",grpjquota=%s", sbi->s_qf_names[GRPQUOTA]);
 749
 750         if (sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA)
 751                 seq_puts(seq, ",usrquota");
 752
 753         if (sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA)
 754                 seq_puts(seq, ",grpquota");
 755 #endif
 756 }
 757
 758 /*
 759  * Show an option if
 760  *  - it's set to a non-default value OR
 761  *  - if the per-sb default is different from the global default
 762  */
 763 static int ext4_show_options(struct seq_file *seq, struct vfsmount *vfs)
 764 {
 765         int def_errors;
 766         unsigned long def_mount_opts;
 767         struct super_block *sb = vfs->mnt_sb;
 768         struct ext4_sb_info *sbi = EXT4_SB(sb);
 769         struct ext4_super_block *es = sbi->s_es;
 770
 771         def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
 772         def_errors     = le16_to_cpu(es->s_errors);
 773
 774         if (sbi->s_sb_block != 1)
 775                 seq_printf(seq, ",sb=%llu", sbi->s_sb_block);
 776         if (test_opt(sb, MINIX_DF))
 777                 seq_puts(seq, ",minixdf");
 778         if (test_opt(sb, GRPID) && !(def_mount_opts & EXT4_DEFM_BSDGROUPS))
 779                 seq_puts(seq, ",grpid");
 780         if (!test_opt(sb, GRPID) && (def_mount_opts & EXT4_DEFM_BSDGROUPS))
 781                 seq_puts(seq, ",nogrpid");
 782         if (sbi->s_resuid != EXT4_DEF_RESUID ||
 783             le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID) {
 784                 seq_printf(seq, ",resuid=%u", sbi->s_resuid);
 785         }
 786         if (sbi->s_resgid != EXT4_DEF_RESGID ||
 787             le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID) {
 788                 seq_printf(seq, ",resgid=%u", sbi->s_resgid);
 789         }
 790         if (test_opt(sb, ERRORS_RO)) {
 791                 if (def_errors == EXT4_ERRORS_PANIC ||
 792                     def_errors == EXT4_ERRORS_CONTINUE) {
 793                         seq_puts(seq, ",errors=remount-ro");
 794                 }
 795         }
 796         if (test_opt(sb, ERRORS_CONT) && def_errors != EXT4_ERRORS_CONTINUE)
 797                 seq_puts(seq, ",errors=continue");
 798         if (test_opt(sb, ERRORS_PANIC) && def_errors != EXT4_ERRORS_PANIC)
 799                 seq_puts(seq, ",errors=panic");
 800         if (test_opt(sb, NO_UID32) && !(def_mount_opts & EXT4_DEFM_UID16))
 801                 seq_puts(seq, ",nouid32");
 802         if (test_opt(sb, DEBUG) && !(def_mount_opts & EXT4_DEFM_DEBUG))
 803                 seq_puts(seq, ",debug");
 804         if (test_opt(sb, OLDALLOC))
 805                 seq_puts(seq, ",oldalloc");
 806 #ifdef CONFIG_EXT4_FS_XATTR
 807         if (test_opt(sb, XATTR_USER) &&
 808                 !(def_mount_opts & EXT4_DEFM_XATTR_USER))
 809                 seq_puts(seq, ",user_xattr");
 810         if (!test_opt(sb, XATTR_USER) &&
 811             (def_mount_opts & EXT4_DEFM_XATTR_USER)) {
 812                 seq_puts(seq, ",nouser_xattr");
 813         }
 814 #endif
 815 #ifdef CONFIG_EXT4_FS_POSIX_ACL
 816         if (test_opt(sb, POSIX_ACL) && !(def_mount_opts & EXT4_DEFM_ACL))
 817                 seq_puts(seq, ",acl");
 818         if (!test_opt(sb, POSIX_ACL) && (def_mount_opts & EXT4_DEFM_ACL))
 819                 seq_puts(seq, ",noacl");
 820 #endif
 821         if (sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ) {
 822                 seq_printf(seq, ",commit=%u",
 823                            (unsigned) (sbi->s_commit_interval / HZ));
 824         }
 825         if (sbi->s_min_batch_time != EXT4_DEF_MIN_BATCH_TIME) {
 826                 seq_printf(seq, ",min_batch_time=%u",
 827                            (unsigned) sbi->s_min_batch_time);
 828         }
 829         if (sbi->s_max_batch_time != EXT4_DEF_MAX_BATCH_TIME) {
 830                 seq_printf(seq, ",max_batch_time=%u",
 831                            (unsigned) sbi->s_min_batch_time);
 832         }
 833
 834         /*
 835          * We're changing the default of barrier mount option, so
 836          * let's always display its mount state so it's clear what its
 837          * status is.
 838          */
 839         seq_puts(seq, ",barrier=");
 840         seq_puts(seq, test_opt(sb, BARRIER) ? "1" : "0");
 841         if (test_opt(sb, JOURNAL_ASYNC_COMMIT))
 842                 seq_puts(seq, ",journal_async_commit");
 843         if (test_opt(sb, NOBH))
 844                 seq_puts(seq, ",nobh");
 845         if (test_opt(sb, I_VERSION))
 846                 seq_puts(seq, ",i_version");
 847         if (!test_opt(sb, DELALLOC))
 848                 seq_puts(seq, ",nodelalloc");
 849
 850
 851         if (sbi->s_stripe)
 852                 seq_printf(seq, ",stripe=%lu", sbi->s_stripe);
 853         /*
 854          * journal mode get enabled in different ways
 855          * So just print the value even if we didn't specify it
 856          */
 857         if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
 858                 seq_puts(seq, ",data=journal");
 859         else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
 860                 seq_puts(seq, ",data=ordered");
 861         else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
 862                 seq_puts(seq, ",data=writeback");
 863
 864         if (sbi->s_inode_readahead_blks != EXT4_DEF_INODE_READAHEAD_BLKS)
 865                 seq_printf(seq, ",inode_readahead_blks=%u",
 866                            sbi->s_inode_readahead_blks);
 867
 868         if (test_opt(sb, DATA_ERR_ABORT))
 869                 seq_puts(seq, ",data_err=abort");
 870
 871         if (test_opt(sb, NO_AUTO_DA_ALLOC))
 872                 seq_puts(seq, ",noauto_da_alloc");
 873
 874         ext4_show_quota_options(seq, sb);
 875         return 0;
 876 }
 877
 878
 879 static struct inode *ext4_nfs_get_inode(struct super_block *sb,
 880                 u64 ino, u32 generation)
 881 {
 882         struct inode *inode;
 883
 884         if (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO)
 885                 return ERR_PTR(-ESTALE);
 886         if (ino > le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count))
 887                 return ERR_PTR(-ESTALE);
 888
 889         /* iget isn't really right if the inode is currently unallocated!!
 890          *
 891          * ext4_read_inode will return a bad_inode if the inode had been
 892          * deleted, so we should be safe.
 893          *
 894          * Currently we don't know the generation for parent directory, so
 895          * a generation of 0 means "accept any"
 896          */
 897         inode = ext4_iget(sb, ino);
 898         if (IS_ERR(inode))
 899                 return ERR_CAST(inode);
 900         if (generation && inode->i_generation != generation) {
 901                 iput(inode);
 902                 return ERR_PTR(-ESTALE);
 903         }
 904
 905         return inode;
 906 }
 907
 908 static struct dentry *ext4_fh_to_dentry(struct super_block *sb, struct fid *fid,
 909                 int fh_len, int fh_type)
 910 {
 911         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
 912                                     ext4_nfs_get_inode);
 913 }
 914
 915 static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
 916                 int fh_len, int fh_type)
 917 {
 918         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
 919                                     ext4_nfs_get_inode);
 920 }
 921
 922 /*
 923  * Try to release metadata pages (indirect blocks, directories) which are
 924  * mapped via the block device.  Since these pages could have journal heads
 925  * which would prevent try_to_free_buffers() from freeing them, we must use
 926  * jbd2 layer's try_to_free_buffers() function to release them.
 927  */
 928 static int bdev_try_to_free_page(struct super_block *sb, struct page *page, gfp_t wait)
 929 {
 930         journal_t *journal = EXT4_SB(sb)->s_journal;
 931
 932         WARN_ON(PageChecked(page));
 933         if (!page_has_buffers(page))
 934                 return 0;
 935         if (journal)
 936                 return jbd2_journal_try_to_free_buffers(journal, page,
 937                                                         wait & ~__GFP_WAIT);
 938         return try_to_free_buffers(page);
 939 }
 940
 941 #ifdef CONFIG_QUOTA
 942 #define QTYPE2NAME(t) ((t) == USRQUOTA ? "user" : "group")
 943 #define QTYPE2MOPT(on, t) ((t) == USRQUOTA?((on)##USRJQUOTA):((on)##GRPJQUOTA))
 944
 945 static int ext4_write_dquot(struct dquot *dquot);
 946 static int ext4_acquire_dquot(struct dquot *dquot);
 947 static int ext4_release_dquot(struct dquot *dquot);
 948 static int ext4_mark_dquot_dirty(struct dquot *dquot);
 949 static int ext4_write_info(struct super_block *sb, int type);
 950 static int ext4_quota_on(struct super_block *sb, int type, int format_id,
 951                                 char *path, int remount);
 952 static int ext4_quota_on_mount(struct super_block *sb, int type);
 953 static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
 954                                size_t len, loff_t off);
 955 static ssize_t ext4_quota_write(struct super_block *sb, int type,
 956                                 const char *data, size_t len, loff_t off);
 957
 958 static struct dquot_operations ext4_quota_operations = {
 959         .initialize     = dquot_initialize,
 960         .drop           = dquot_drop,
 961         .alloc_space    = dquot_alloc_space,
 962         .reserve_space  = dquot_reserve_space,
 963         .claim_space    = dquot_claim_space,
 964         .release_rsv    = dquot_release_reserved_space,
 965         .get_reserved_space = ext4_get_reserved_space,
 966         .alloc_inode    = dquot_alloc_inode,
 967         .free_space     = dquot_free_space,
 968         .free_inode     = dquot_free_inode,
 969         .transfer       = dquot_transfer,
 970         .write_dquot    = ext4_write_dquot,
 971         .acquire_dquot  = ext4_acquire_dquot,
 972         .release_dquot  = ext4_release_dquot,
 973         .mark_dirty     = ext4_mark_dquot_dirty,
 974         .write_info     = ext4_write_info,
 975         .alloc_dquot    = dquot_alloc,
 976         .destroy_dquot  = dquot_destroy,
 977 };
 978
 979 static struct quotactl_ops ext4_qctl_operations = {
 980         .quota_on       = ext4_quota_on,
 981         .quota_off      = vfs_quota_off,
 982         .quota_sync     = vfs_quota_sync,
 983         .get_info       = vfs_get_dqinfo,
 984         .set_info       = vfs_set_dqinfo,
 985         .get_dqblk      = vfs_get_dqblk,
 986         .set_dqblk      = vfs_set_dqblk
 987 };
 988 #endif
 989
 990 static const struct super_operations ext4_sops = {
 991         .alloc_inode    = ext4_alloc_inode,
 992         .destroy_inode  = ext4_destroy_inode,
 993         .write_inode    = ext4_write_inode,
 994         .dirty_inode    = ext4_dirty_inode,
 995         .delete_inode   = ext4_delete_inode,
 996         .put_super      = ext4_put_super,
 997         .sync_fs        = ext4_sync_fs,
 998         .freeze_fs      = ext4_freeze,
 999         .unfreeze_fs    = ext4_unfreeze,
1000         .statfs         = ext4_statfs,
1001         .remount_fs     = ext4_remount,
1002         .clear_inode    = ext4_clear_inode,
1003         .show_options   = ext4_show_options,
1004 #ifdef CONFIG_QUOTA
1005         .quota_read     = ext4_quota_read,
1006         .quota_write    = ext4_quota_write,
1007 #endif
1008         .bdev_try_to_free_page = bdev_try_to_free_page,
1009 };
1010
1011 static const struct super_operations ext4_nojournal_sops = {
1012         .alloc_inode    = ext4_alloc_inode,
1013         .destroy_inode  = ext4_destroy_inode,
1014         .write_inode    = ext4_write_inode,
1015         .dirty_inode    = ext4_dirty_inode,
1016         .delete_inode   = ext4_delete_inode,
1017         .write_super    = ext4_write_super,
1018         .put_super      = ext4_put_super,
1019         .statfs         = ext4_statfs,
1020         .remount_fs     = ext4_remount,
1021         .clear_inode    = ext4_clear_inode,
1022         .show_options   = ext4_show_options,
1023 #ifdef CONFIG_QUOTA
1024         .quota_read     = ext4_quota_read,
1025         .quota_write    = ext4_quota_write,
1026 #endif
1027         .bdev_try_to_free_page = bdev_try_to_free_page,
1028 };
1029
1030 static const struct export_operations ext4_export_ops = {
1031         .fh_to_dentry = ext4_fh_to_dentry,
1032         .fh_to_parent = ext4_fh_to_parent,
1033         .get_parent = ext4_get_parent,
1034 };
1035
1036 enum {
1037         Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
1038         Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
1039         Opt_nouid32, Opt_debug, Opt_oldalloc, Opt_orlov,
1040         Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
1041         Opt_auto_da_alloc, Opt_noauto_da_alloc, Opt_noload, Opt_nobh, Opt_bh,
1042         Opt_commit, Opt_min_batch_time, Opt_max_batch_time,
1043         Opt_journal_update, Opt_journal_dev,
1044         Opt_journal_checksum, Opt_journal_async_commit,
1045         Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
1046         Opt_data_err_abort, Opt_data_err_ignore,
1047         Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
1048         Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_quota, Opt_noquota,
1049         Opt_ignore, Opt_barrier, Opt_nobarrier, Opt_err, Opt_resize,
1050         Opt_usrquota, Opt_grpquota, Opt_i_version,
1051         Opt_stripe, Opt_delalloc, Opt_nodelalloc,
1052         Opt_inode_readahead_blks, Opt_journal_ioprio
1053 };
1054
1055 static const match_table_t tokens = {
1056         {Opt_bsd_df, "bsddf"},
1057         {Opt_minix_df, "minixdf"},
1058         {Opt_grpid, "grpid"},
1059         {Opt_grpid, "bsdgroups"},
1060         {Opt_nogrpid, "nogrpid"},
1061         {Opt_nogrpid, "sysvgroups"},
1062         {Opt_resgid, "resgid=%u"},
1063         {Opt_resuid, "resuid=%u"},
1064         {Opt_sb, "sb=%u"},
1065         {Opt_err_cont, "errors=continue"},
1066         {Opt_err_panic, "errors=panic"},
1067         {Opt_err_ro, "errors=remount-ro"},
1068         {Opt_nouid32, "nouid32"},
1069         {Opt_debug, "debug"},
1070         {Opt_oldalloc, "oldalloc"},
1071         {Opt_orlov, "orlov"},
1072         {Opt_user_xattr, "user_xattr"},
1073         {Opt_nouser_xattr, "nouser_xattr"},
1074         {Opt_acl, "acl"},
1075         {Opt_noacl, "noacl"},
1076         {Opt_noload, "noload"},
1077         {Opt_nobh, "nobh"},
1078         {Opt_bh, "bh"},
1079         {Opt_commit, "commit=%u"},
1080         {Opt_min_batch_time, "min_batch_time=%u"},
1081         {Opt_max_batch_time, "max_batch_time=%u"},
1082         {Opt_journal_update, "journal=update"},
1083         {Opt_journal_dev, "journal_dev=%u"},
1084         {Opt_journal_checksum, "journal_checksum"},
1085         {Opt_journal_async_commit, "journal_async_commit"},
1086         {Opt_abort, "abort"},
1087         {Opt_data_journal, "data=journal"},
1088         {Opt_data_ordered, "data=ordered"},
1089         {Opt_data_writeback, "data=writeback"},
1090         {Opt_data_err_abort, "data_err=abort"},
1091         {Opt_data_err_ignore, "data_err=ignore"},
1092         {Opt_offusrjquota, "usrjquota="},
1093         {Opt_usrjquota, "usrjquota=%s"},
1094         {Opt_offgrpjquota, "grpjquota="},
1095         {Opt_grpjquota, "grpjquota=%s"},
1096         {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
1097         {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
1098         {Opt_grpquota, "grpquota"},
1099         {Opt_noquota, "noquota"},
1100         {Opt_quota, "quota"},
1101         {Opt_usrquota, "usrquota"},
1102         {Opt_barrier, "barrier=%u"},
1103         {Opt_barrier, "barrier"},
1104         {Opt_nobarrier, "nobarrier"},
1105         {Opt_i_version, "i_version"},
1106         {Opt_stripe, "stripe=%u"},
1107         {Opt_resize, "resize"},
1108         {Opt_delalloc, "delalloc"},
1109         {Opt_nodelalloc, "nodelalloc"},
1110         {Opt_inode_readahead_blks, "inode_readahead_blks=%u"},
1111         {Opt_journal_ioprio, "journal_ioprio=%u"},
1112         {Opt_auto_da_alloc, "auto_da_alloc=%u"},
1113         {Opt_auto_da_alloc, "auto_da_alloc"},
1114         {Opt_noauto_da_alloc, "noauto_da_alloc"},
1115         {Opt_err, NULL},
1116 };
1117
1118 static ext4_fsblk_t get_sb_block(void **data)
1119 {
1120         ext4_fsblk_t    sb_block;
1121         char            *options = (char *) *data;
1122
1123         if (!options || strncmp(options, "sb=", 3) != 0)
1124                 return 1;       /* Default location */
1125         options += 3;
1126         /*todo: use simple_strtoll with >32bit ext4 */
1127         sb_block = simple_strtoul(options, &options, 0);
1128         if (*options && *options != ',') {
1129                 printk(KERN_ERR "EXT4-fs: Invalid sb specification: %s\n",
1130                        (char *) *data);
1131                 return 1;
1132         }
1133         if (*options == ',')
1134                 options++;
1135         *data = (void *) options;
1136         return sb_block;
1137 }
1138
1139 #define DEFAULT_JOURNAL_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 3))
1140
1141 static int parse_options(char *options, struct super_block *sb,
1142                          unsigned long *journal_devnum,
1143                          unsigned int *journal_ioprio,
1144                          ext4_fsblk_t *n_blocks_count, int is_remount)
1145 {
1146         struct ext4_sb_info *sbi = EXT4_SB(sb);
1147         char *p;
1148         substring_t args[MAX_OPT_ARGS];
1149         int data_opt = 0;
1150         int option;
1151 #ifdef CONFIG_QUOTA
1152         int qtype, qfmt;
1153         char *qname;
1154 #endif
1155
1156         if (!options)
1157                 return 1;
1158
1159         while ((p = strsep(&options, ",")) != NULL) {
1160                 int token;
1161                 if (!*p)
1162                         continue;
1163
1164                 token = match_token(p, tokens, args);
1165                 switch (token) {
1166                 case Opt_bsd_df:
1167                         clear_opt(sbi->s_mount_opt, MINIX_DF);
1168                         break;
1169                 case Opt_minix_df:
1170                         set_opt(sbi->s_mount_opt, MINIX_DF);
1171                         break;
1172                 case Opt_grpid:
1173                         set_opt(sbi->s_mount_opt, GRPID);
1174                         break;
1175                 case Opt_nogrpid:
1176                         clear_opt(sbi->s_mount_opt, GRPID);
1177                         break;
1178                 case Opt_resuid:
1179                         if (match_int(&args[0], &option))
1180                                 return 0;
1181                         sbi->s_resuid = option;
1182                         break;
1183                 case Opt_resgid:
1184                         if (match_int(&args[0], &option))
1185                                 return 0;
1186                         sbi->s_resgid = option;
1187                         break;
1188                 case Opt_sb:
1189                         /* handled by get_sb_block() instead of here */
1190                         /* *sb_block = match_int(&args[0]); */
1191                         break;
1192                 case Opt_err_panic:
1193                         clear_opt(sbi->s_mount_opt, ERRORS_CONT);
1194                         clear_opt(sbi->s_mount_opt, ERRORS_RO);
1195                         set_opt(sbi->s_mount_opt, ERRORS_PANIC);
1196                         break;
1197                 case Opt_err_ro:
1198                         clear_opt(sbi->s_mount_opt, ERRORS_CONT);
1199                         clear_opt(sbi->s_mount_opt, ERRORS_PANIC);
1200                         set_opt(sbi->s_mount_opt, ERRORS_RO);
1201                         break;
1202                 case Opt_err_cont:
1203                         clear_opt(sbi->s_mount_opt, ERRORS_RO);
1204                         clear_opt(sbi->s_mount_opt, ERRORS_PANIC);
1205                         set_opt(sbi->s_mount_opt, ERRORS_CONT);
1206                         break;
1207                 case Opt_nouid32:
1208                         set_opt(sbi->s_mount_opt, NO_UID32);
1209                         break;
1210                 case Opt_debug:
1211                         set_opt(sbi->s_mount_opt, DEBUG);
1212                         break;
1213                 case Opt_oldalloc:
1214                         set_opt(sbi->s_mount_opt, OLDALLOC);
1215                         break;
1216                 case Opt_orlov:
1217                         clear_opt(sbi->s_mount_opt, OLDALLOC);
1218                         break;
1219 #ifdef CONFIG_EXT4_FS_XATTR
1220                 case Opt_user_xattr:
1221                         set_opt(sbi->s_mount_opt, XATTR_USER);
1222                         break;
1223                 case Opt_nouser_xattr:
1224                         clear_opt(sbi->s_mount_opt, XATTR_USER);
1225                         break;
1226 #else
1227                 case Opt_user_xattr:
1228                 case Opt_nouser_xattr:
1229                         printk(KERN_ERR "EXT4 (no)user_xattr options "
1230                                "not supported\n");
1231                         break;
1232 #endif
1233 #ifdef CONFIG_EXT4_FS_POSIX_ACL
1234                 case Opt_acl:
1235                         set_opt(sbi->s_mount_opt, POSIX_ACL);
1236                         break;
1237                 case Opt_noacl:
1238                         clear_opt(sbi->s_mount_opt, POSIX_ACL);
1239                         break;
1240 #else
1241                 case Opt_acl:
1242                 case Opt_noacl:
1243                         printk(KERN_ERR "EXT4 (no)acl options "
1244                                "not supported\n");
1245                         break;
1246 #endif
1247                 case Opt_journal_update:
1248                         /* @@@ FIXME */
1249                         /* Eventually we will want to be able to create
1250                            a journal file here.  For now, only allow the
1251                            user to specify an existing inode to be the
1252                            journal file. */
1253                         if (is_remount) {
1254                                 printk(KERN_ERR "EXT4-fs: cannot specify "
1255                                        "journal on remount\n");
1256                                 return 0;
1257                         }
1258                         set_opt(sbi->s_mount_opt, UPDATE_JOURNAL);
1259                         break;
1260                 case Opt_journal_dev:
1261                         if (is_remount) {
1262                                 printk(KERN_ERR "EXT4-fs: cannot specify "
1263                                        "journal on remount\n");
1264                                 return 0;
1265                         }
1266                         if (match_int(&args[0], &option))
1267                                 return 0;
1268                         *journal_devnum = option;
1269                         break;
1270                 case Opt_journal_checksum:
1271                         set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
1272                         break;
1273                 case Opt_journal_async_commit:
1274                         set_opt(sbi->s_mount_opt, JOURNAL_ASYNC_COMMIT);
1275                         set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
1276                         break;
1277                 case Opt_noload:
1278                         set_opt(sbi->s_mount_opt, NOLOAD);
1279                         break;
1280                 case Opt_commit:
1281                         if (match_int(&args[0], &option))
1282                                 return 0;
1283                         if (option < 0)
1284                                 return 0;
1285                         if (option == 0)
1286                                 option = JBD2_DEFAULT_MAX_COMMIT_AGE;
1287                         sbi->s_commit_interval = HZ * option;
1288                         break;
1289                 case Opt_max_batch_time:
1290                         if (match_int(&args[0], &option))
1291                                 return 0;
1292                         if (option < 0)
1293                                 return 0;
1294                         if (option == 0)
1295                                 option = EXT4_DEF_MAX_BATCH_TIME;
1296                         sbi->s_max_batch_time = option;
1297                         break;
1298                 case Opt_min_batch_time:
1299                         if (match_int(&args[0], &option))
1300                                 return 0;
1301                         if (option < 0)
1302                                 return 0;
1303                         sbi->s_min_batch_time = option;
1304                         break;
1305                 case Opt_data_journal:
1306                         data_opt = EXT4_MOUNT_JOURNAL_DATA;
1307                         goto datacheck;
1308                 case Opt_data_ordered:
1309                         data_opt = EXT4_MOUNT_ORDERED_DATA;
1310                         goto datacheck;
1311                 case Opt_data_writeback:
1312                         data_opt = EXT4_MOUNT_WRITEBACK_DATA;
1313                 datacheck:
1314                         if (is_remount) {
1315                                 if ((sbi->s_mount_opt & EXT4_MOUNT_DATA_FLAGS)
1316                                                 != data_opt) {
1317                                         printk(KERN_ERR
1318                                                 "EXT4-fs: cannot change data "
1319                                                 "mode on remount\n");
1320                                         return 0;
1321                                 }
1322                         } else {
1323                                 sbi->s_mount_opt &= ~EXT4_MOUNT_DATA_FLAGS;
1324                                 sbi->s_mount_opt |= data_opt;
1325                         }
1326                         break;
1327                 case Opt_data_err_abort:
1328                         set_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
1329                         break;
1330                 case Opt_data_err_ignore:
1331                         clear_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
1332                         break;
1333 #ifdef CONFIG_QUOTA
1334                 case Opt_usrjquota:
1335                         qtype = USRQUOTA;
1336                         goto set_qf_name;
1337                 case Opt_grpjquota:
1338                         qtype = GRPQUOTA;
1339 set_qf_name:
1340                         if (sb_any_quota_loaded(sb) &&
1341                             !sbi->s_qf_names[qtype]) {
1342                                 printk(KERN_ERR
1343                                        "EXT4-fs: Cannot change journaled "
1344                                        "quota options when quota turned on.\n");
1345                                 return 0;
1346                         }
1347                         qname = match_strdup(&args[0]);
1348                         if (!qname) {
1349                                 printk(KERN_ERR
1350                                         "EXT4-fs: not enough memory for "
1351                                         "storing quotafile name.\n");
1352                                 return 0;
1353                         }
1354                         if (sbi->s_qf_names[qtype] &&
1355                             strcmp(sbi->s_qf_names[qtype], qname)) {
1356                                 printk(KERN_ERR
1357                                         "EXT4-fs: %s quota file already "
1358                                         "specified.\n", QTYPE2NAME(qtype));
1359                                 kfree(qname);
1360                                 return 0;
1361                         }
1362                         sbi->s_qf_names[qtype] = qname;
1363                         if (strchr(sbi->s_qf_names[qtype], '/')) {
1364                                 printk(KERN_ERR
1365                                         "EXT4-fs: quotafile must be on "
1366                                         "filesystem root.\n");
1367                                 kfree(sbi->s_qf_names[qtype]);
1368                                 sbi->s_qf_names[qtype] = NULL;
1369                                 return 0;
1370                         }
1371                         set_opt(sbi->s_mount_opt, QUOTA);
1372                         break;
1373                 case Opt_offusrjquota:
1374                         qtype = USRQUOTA;
1375                         goto clear_qf_name;
1376                 case Opt_offgrpjquota:
1377                         qtype = GRPQUOTA;
1378 clear_qf_name:
1379                         if (sb_any_quota_loaded(sb) &&
1380                             sbi->s_qf_names[qtype]) {
1381                                 printk(KERN_ERR "EXT4-fs: Cannot change "
1382                                         "journaled quota options when "
1383                                         "quota turned on.\n");
1384                                 return 0;
1385                         }
1386                         /*
1387                          * The space will be released later when all options
1388                          * are confirmed to be correct
1389                          */
1390                         sbi->s_qf_names[qtype] = NULL;
1391                         break;
1392                 case Opt_jqfmt_vfsold:
1393                         qfmt = QFMT_VFS_OLD;
1394                         goto set_qf_format;
1395                 case Opt_jqfmt_vfsv0:
1396                         qfmt = QFMT_VFS_V0;
1397 set_qf_format:
1398                         if (sb_any_quota_loaded(sb) &&
1399                             sbi->s_jquota_fmt != qfmt) {
1400                                 printk(KERN_ERR "EXT4-fs: Cannot change "
1401                                         "journaled quota options when "
1402                                         "quota turned on.\n");
1403                                 return 0;
1404                         }
1405                         sbi->s_jquota_fmt = qfmt;
1406                         break;
1407                 case Opt_quota:
1408                 case Opt_usrquota:
1409                         set_opt(sbi->s_mount_opt, QUOTA);
1410                         set_opt(sbi->s_mount_opt, USRQUOTA);
1411                         break;
1412                 case Opt_grpquota:
1413                         set_opt(sbi->s_mount_opt, QUOTA);
1414                         set_opt(sbi->s_mount_opt, GRPQUOTA);
1415                         break;
1416                 case Opt_noquota:
1417                         if (sb_any_quota_loaded(sb)) {
1418                                 printk(KERN_ERR "EXT4-fs: Cannot change quota "
1419                                         "options when quota turned on.\n");
1420                                 return 0;
1421                         }
1422                         clear_opt(sbi->s_mount_opt, QUOTA);
1423                         clear_opt(sbi->s_mount_opt, USRQUOTA);
1424                         clear_opt(sbi->s_mount_opt, GRPQUOTA);
1425                         break;
1426 #else
1427                 case Opt_quota:
1428                 case Opt_usrquota:
1429                 case Opt_grpquota:
1430                         printk(KERN_ERR
1431                                 "EXT4-fs: quota options not supported.\n");
1432                         break;
1433                 case Opt_usrjquota:
1434                 case Opt_grpjquota:
1435                 case Opt_offusrjquota:
1436                 case Opt_offgrpjquota:
1437                 case Opt_jqfmt_vfsold:
1438                 case Opt_jqfmt_vfsv0:
1439                         printk(KERN_ERR
1440                                 "EXT4-fs: journaled quota options not "
1441                                 "supported.\n");
1442                         break;
1443                 case Opt_noquota:
1444                         break;
1445 #endif
1446                 case Opt_abort:
1447                         set_opt(sbi->s_mount_opt, ABORT);
1448                         break;
1449                 case Opt_nobarrier:
1450                         clear_opt(sbi->s_mount_opt, BARRIER);
1451                         break;
1452                 case Opt_barrier:
1453                         if (match_int(&args[0], &option)) {
1454                                 set_opt(sbi->s_mount_opt, BARRIER);
1455                                 break;
1456                         }
1457                         if (option)
1458                                 set_opt(sbi->s_mount_opt, BARRIER);
1459                         else
1460                                 clear_opt(sbi->s_mount_opt, BARRIER);
1461                         break;
1462                 case Opt_ignore:
1463                         break;
1464                 case Opt_resize:
1465                         if (!is_remount) {
1466                                 printk("EXT4-fs: resize option only available "
1467                                         "for remount\n");
1468                                 return 0;
1469                         }
1470                         if (match_int(&args[0], &option) != 0)
1471                                 return 0;
1472                         *n_blocks_count = option;
1473                         break;
1474                 case Opt_nobh:
1475                         set_opt(sbi->s_mount_opt, NOBH);
1476                         break;
1477                 case Opt_bh:
1478                         clear_opt(sbi->s_mount_opt, NOBH);
1479                         break;
1480                 case Opt_i_version:
1481                         set_opt(sbi->s_mount_opt, I_VERSION);
1482                         sb->s_flags |= MS_I_VERSION;
1483                         break;
1484                 case Opt_nodelalloc:
1485                         clear_opt(sbi->s_mount_opt, DELALLOC);
1486                         break;
1487                 case Opt_stripe:
1488                         if (match_int(&args[0], &option))
1489                                 return 0;
1490                         if (option < 0)
1491                                 return 0;
1492                         sbi->s_stripe = option;
1493                         break;
1494                 case Opt_delalloc:
1495                         set_opt(sbi->s_mount_opt, DELALLOC);
1496                         break;
1497                 case Opt_inode_readahead_blks:
1498                         if (match_int(&args[0], &option))
1499                                 return 0;
1500                         if (option < 0 || option > (1 << 30))
1501                                 return 0;
1502                         if (!is_power_of_2(option)) {
1503                                 printk(KERN_ERR "EXT4-fs: inode_readahead_blks"
1504                                        " must be a power of 2\n");
1505                                 return 0;
1506                         }
1507                         sbi->s_inode_readahead_blks = option;
1508                         break;
1509                 case Opt_journal_ioprio:
1510                         if (match_int(&args[0], &option))
1511                                 return 0;
1512                         if (option < 0 || option > 7)
1513                                 break;
1514                         *journal_ioprio = IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE,
1515                                                             option);
1516                         break;
1517                 case Opt_noauto_da_alloc:
1518                         set_opt(sbi->s_mount_opt,NO_AUTO_DA_ALLOC);
1519                         break;
1520                 case Opt_auto_da_alloc:
1521                         if (match_int(&args[0], &option)) {
1522                                 clear_opt(sbi->s_mount_opt, NO_AUTO_DA_ALLOC);
1523                                 break;
1524                         }
1525                         if (option)
1526                                 clear_opt(sbi->s_mount_opt, NO_AUTO_DA_ALLOC);
1527                         else
1528                                 set_opt(sbi->s_mount_opt,NO_AUTO_DA_ALLOC);
1529                         break;
1530                 default:
1531                         printk(KERN_ERR
1532                                "EXT4-fs: Unrecognized mount option \"%s\" "
1533                                "or missing value\n", p);
1534                         return 0;
1535                 }
1536         }
1537 #ifdef CONFIG_QUOTA
1538         if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
1539                 if ((sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA) &&
1540                      sbi->s_qf_names[USRQUOTA])
1541                         clear_opt(sbi->s_mount_opt, USRQUOTA);
1542
1543                 if ((sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA) &&
1544                      sbi->s_qf_names[GRPQUOTA])
1545                         clear_opt(sbi->s_mount_opt, GRPQUOTA);
1546
1547                 if ((sbi->s_qf_names[USRQUOTA] &&
1548                                 (sbi->s_mount_opt & EXT4_MOUNT_GRPQUOTA)) ||
1549                     (sbi->s_qf_names[GRPQUOTA] &&
1550                                 (sbi->s_mount_opt & EXT4_MOUNT_USRQUOTA))) {
1551                         printk(KERN_ERR "EXT4-fs: old and new quota "
1552                                         "format mixing.\n");
1553                         return 0;
1554                 }
1555
1556                 if (!sbi->s_jquota_fmt) {
1557                         printk(KERN_ERR "EXT4-fs: journaled quota format "
1558                                         "not specified.\n");
1559                         return 0;
1560                 }
1561         } else {
1562                 if (sbi->s_jquota_fmt) {
1563                         printk(KERN_ERR "EXT4-fs: journaled quota format "
1564                                         "specified with no journaling "
1565                                         "enabled.\n");
1566                         return 0;
1567                 }
1568         }
1569 #endif
1570         return 1;
1571 }
1572
1573 static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
1574                             int read_only)
1575 {
1576         struct ext4_sb_info *sbi = EXT4_SB(sb);
1577         int res = 0;
1578
1579         if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
1580                 printk(KERN_ERR "EXT4-fs warning: revision level too high, "
1581                        "forcing read-only mode\n");
1582                 res = MS_RDONLY;
1583         }
1584         if (read_only)
1585                 return res;
1586         if (!(sbi->s_mount_state & EXT4_VALID_FS))
1587                 printk(KERN_WARNING "EXT4-fs warning: mounting unchecked fs, "
1588                        "running e2fsck is recommended\n");
1589         else if ((sbi->s_mount_state & EXT4_ERROR_FS))
1590                 printk(KERN_WARNING
1591                        "EXT4-fs warning: mounting fs with errors, "
1592                        "running e2fsck is recommended\n");
1593         else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
1594                  le16_to_cpu(es->s_mnt_count) >=
1595                  (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
1596                 printk(KERN_WARNING
1597                        "EXT4-fs warning: maximal mount count reached, "
1598                        "running e2fsck is recommended\n");
1599         else if (le32_to_cpu(es->s_checkinterval) &&
1600                 (le32_to_cpu(es->s_lastcheck) +
1601                         le32_to_cpu(es->s_checkinterval) <= get_seconds()))
1602                 printk(KERN_WARNING
1603                        "EXT4-fs warning: checktime reached, "
1604                        "running e2fsck is recommended\n");
1605         if (!sbi->s_journal)
1606                 es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
1607         if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
1608                 es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
1609         le16_add_cpu(&es->s_mnt_count, 1);
1610         es->s_mtime = cpu_to_le32(get_seconds());
1611         ext4_update_dynamic_rev(sb);
1612         if (sbi->s_journal)
1613                 EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
1614
1615         ext4_commit_super(sb, 1);
1616         if (test_opt(sb, DEBUG))
1617                 printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%u, "
1618                                 "bpg=%lu, ipg=%lu, mo=%04lx]\n",
1619                         sb->s_blocksize,
1620                         sbi->s_groups_count,
1621                         EXT4_BLOCKS_PER_GROUP(sb),
1622                         EXT4_INODES_PER_GROUP(sb),
1623                         sbi->s_mount_opt);
1624
1625         if (EXT4_SB(sb)->s_journal) {
1626                 printk(KERN_INFO "EXT4 FS on %s, %s journal on %s\n",
1627                        sb->s_id, EXT4_SB(sb)->s_journal->j_inode ? "internal" :
1628                        "external", EXT4_SB(sb)->s_journal->j_devname);
1629         } else {
1630                 printk(KERN_INFO "EXT4 FS on %s, no journal\n", sb->s_id);
1631         }
1632         return res;
1633 }
1634
1635 static int ext4_fill_flex_info(struct super_block *sb)
1636 {
1637         struct ext4_sb_info *sbi = EXT4_SB(sb);
1638         struct ext4_group_desc *gdp = NULL;
1639         struct buffer_head *bh;
1640         ext4_group_t flex_group_count;
1641         ext4_group_t flex_group;
1642         int groups_per_flex = 0;
1643         size_t size;
1644         int i;
1645
1646         if (!sbi->s_es->s_log_groups_per_flex) {
1647                 sbi->s_log_groups_per_flex = 0;
1648                 return 1;
1649         }
1650
1651         sbi->s_log_groups_per_flex = sbi->s_es->s_log_groups_per_flex;
1652         groups_per_flex = 1 << sbi->s_log_groups_per_flex;
1653
1654         /* We allocate both existing and potentially added groups */
1655         flex_group_count = ((sbi->s_groups_count + groups_per_flex - 1) +
1656                         ((le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) + 1) <<
1657                               EXT4_DESC_PER_BLOCK_BITS(sb))) / groups_per_flex;
1658         size = flex_group_count * sizeof(struct flex_groups);
1659         sbi->s_flex_groups = kzalloc(size, GFP_KERNEL);
1660         if (sbi->s_flex_groups == NULL) {
1661                 sbi->s_flex_groups = vmalloc(size);
1662                 if (sbi->s_flex_groups)
1663                         memset(sbi->s_flex_groups, 0, size);
1664         }
1665         if (sbi->s_flex_groups == NULL) {
1666                 printk(KERN_ERR "EXT4-fs: not enough memory for "
1667                                 "%u flex groups\n", flex_group_count);
1668                 goto failed;
1669         }
1670
1671         for (i = 0; i < sbi->s_groups_count; i++) {
1672                 gdp = ext4_get_group_desc(sb, i, &bh);
1673
1674                 flex_group = ext4_flex_group(sbi, i);
1675                 atomic_set(&sbi->s_flex_groups[flex_group].free_inodes,
1676                            ext4_free_inodes_count(sb, gdp));
1677                 atomic_set(&sbi->s_flex_groups[flex_group].free_blocks,
1678                            ext4_free_blks_count(sb, gdp));
1679                 atomic_set(&sbi->s_flex_groups[flex_group].used_dirs,
1680                            ext4_used_dirs_count(sb, gdp));
1681         }
1682
1683         return 1;
1684 failed:
1685         return 0;
1686 }
1687
1688 __le16 ext4_group_desc_csum(struct ext4_sb_info *sbi, __u32 block_group,
1689                             struct ext4_group_desc *gdp)
1690 {
1691         __u16 crc = 0;
1692
1693         if (sbi->s_es->s_feature_ro_compat &
1694             cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) {
1695                 int offset = offsetof(struct ext4_group_desc, bg_checksum);
1696                 __le32 le_group = cpu_to_le32(block_group);
1697
1698                 crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
1699                 crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
1700                 crc = crc16(crc, (__u8 *)gdp, offset);
1701                 offset += sizeof(gdp->bg_checksum); /* skip checksum */
1702                 /* for checksum of struct ext4_group_desc do the rest...*/
1703                 if ((sbi->s_es->s_feature_incompat &
1704                      cpu_to_le32(EXT4_FEATURE_INCOMPAT_64BIT)) &&
1705                     offset < le16_to_cpu(sbi->s_es->s_desc_size))
1706                         crc = crc16(crc, (__u8 *)gdp + offset,
1707                                     le16_to_cpu(sbi->s_es->s_desc_size) -
1708                                         offset);
1709         }
1710
1711         return cpu_to_le16(crc);
1712 }
1713
1714 int ext4_group_desc_csum_verify(struct ext4_sb_info *sbi, __u32 block_group,
1715                                 struct ext4_group_desc *gdp)
1716 {
1717         if ((sbi->s_es->s_feature_ro_compat &
1718              cpu_to_le32(EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) &&
1719             (gdp->bg_checksum != ext4_group_desc_csum(sbi, block_group, gdp)))
1720                 return 0;
1721
1722         return 1;
1723 }
1724
1725 /* Called at mount-time, super-block is locked */
1726 static int ext4_check_descriptors(struct super_block *sb)
1727 {
1728         struct ext4_sb_info *sbi = EXT4_SB(sb);
1729         ext4_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
1730         ext4_fsblk_t last_block;
1731         ext4_fsblk_t block_bitmap;
1732         ext4_fsblk_t inode_bitmap;
1733         ext4_fsblk_t inode_table;
1734         int flexbg_flag = 0;
1735         ext4_group_t i;
1736
1737         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
1738                 flexbg_flag = 1;
1739
1740         ext4_debug("Checking group descriptors");
1741
1742         for (i = 0; i < sbi->s_groups_count; i++) {
1743                 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
1744
1745                 if (i == sbi->s_groups_count - 1 || flexbg_flag)
1746                         last_block = ext4_blocks_count(sbi->s_es) - 1;
1747                 else
1748                         last_block = first_block +
1749                                 (EXT4_BLOCKS_PER_GROUP(sb) - 1);
1750
1751                 block_bitmap = ext4_block_bitmap(sb, gdp);
1752                 if (block_bitmap < first_block || block_bitmap > last_block) {
1753                         printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
1754                                "Block bitmap for group %u not in group "
1755                                "(block %llu)!\n", i, block_bitmap);
1756                         return 0;
1757                 }
1758                 inode_bitmap = ext4_inode_bitmap(sb, gdp);
1759                 if (inode_bitmap < first_block || inode_bitmap > last_block) {
1760                         printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
1761                                "Inode bitmap for group %u not in group "
1762                                "(block %llu)!\n", i, inode_bitmap);
1763                         return 0;
1764                 }
1765                 inode_table = ext4_inode_table(sb, gdp);
1766                 if (inode_table < first_block ||
1767                     inode_table + sbi->s_itb_per_group - 1 > last_block) {
1768                         printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
1769                                "Inode table for group %u not in group "
1770                                "(block %llu)!\n", i, inode_table);
1771                         return 0;
1772                 }
1773                 spin_lock(sb_bgl_lock(sbi, i));
1774                 if (!ext4_group_desc_csum_verify(sbi, i, gdp)) {
1775                         printk(KERN_ERR "EXT4-fs: ext4_check_descriptors: "
1776                                "Checksum for group %u failed (%u!=%u)\n",
1777                                i, le16_to_cpu(ext4_group_desc_csum(sbi, i,
1778                                gdp)), le16_to_cpu(gdp->bg_checksum));
1779                         if (!(sb->s_flags & MS_RDONLY)) {
1780                                 spin_unlock(sb_bgl_lock(sbi, i));
1781                                 return 0;
1782                         }
1783                 }
1784                 spin_unlock(sb_bgl_lock(sbi, i));
1785                 if (!flexbg_flag)
1786                         first_block += EXT4_BLOCKS_PER_GROUP(sb);
1787         }
1788
1789         ext4_free_blocks_count_set(sbi->s_es, ext4_count_free_blocks(sb));
1790         sbi->s_es->s_free_inodes_count = cpu_to_le32(ext4_count_free_inodes(sb));
1791         return 1;
1792 }
1793
1794 /* ext4_orphan_cleanup() walks a singly-linked list of inodes (starting at
1795  * the superblock) which were deleted from all directories, but held open by
1796  * a process at the time of a crash.  We walk the list and try to delete these
1797  * inodes at recovery time (only with a read-write filesystem).
1798  *
1799  * In order to keep the orphan inode chain consistent during traversal (in
1800  * case of crash during recovery), we link each inode into the superblock
1801  * orphan list_head and handle it the same way as an inode deletion during
1802  * normal operation (which journals the operations for us).
1803  *
1804  * We only do an iget() and an iput() on each inode, which is very safe if we
1805  * accidentally point at an in-use or already deleted inode.  The worst that
1806  * can happen in this case is that we get a "bit already cleared" message from
1807  * ext4_free_inode().  The only reason we would point at a wrong inode is if
1808  * e2fsck was run on this filesystem, and it must have already done the orphan
1809  * inode cleanup for us, so we can safely abort without any further action.
1810  */
1811 static void ext4_orphan_cleanup(struct super_block *sb,
1812                                 struct ext4_super_block *es)
1813 {
1814         unsigned int s_flags = sb->s_flags;
1815         int nr_orphans = 0, nr_truncates = 0;
1816 #ifdef CONFIG_QUOTA
1817         int i;
1818 #endif
1819         if (!es->s_last_orphan) {
1820                 jbd_debug(4, "no orphan inodes to clean up\n");
1821                 return;
1822         }
1823
1824         if (bdev_read_only(sb->s_bdev)) {
1825                 printk(KERN_ERR "EXT4-fs: write access "
1826                         "unavailable, skipping orphan cleanup.\n");
1827                 return;
1828         }
1829
1830         if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
1831                 if (es->s_last_orphan)
1832                         jbd_debug(1, "Errors on filesystem, "
1833                                   "clearing orphan list.\n");
1834                 es->s_last_orphan = 0;
1835                 jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
1836                 return;
1837         }
1838
1839         if (s_flags & MS_RDONLY) {
1840                 printk(KERN_INFO "EXT4-fs: %s: orphan cleanup on readonly fs\n",
1841                        sb->s_id);
1842                 sb->s_flags &= ~MS_RDONLY;
1843         }
1844 #ifdef CONFIG_QUOTA
1845         /* Needed for iput() to work correctly and not trash data */
1846         sb->s_flags |= MS_ACTIVE;
1847         /* Turn on quotas so that they are updated correctly */
1848         for (i = 0; i < MAXQUOTAS; i++) {
1849                 if (EXT4_SB(sb)->s_qf_names[i]) {
1850                         int ret = ext4_quota_on_mount(sb, i);
1851                         if (ret < 0)
1852                                 printk(KERN_ERR
1853                                         "EXT4-fs: Cannot turn on journaled "
1854                                         "quota: error %d\n", ret);
1855                 }
1856         }
1857 #endif
1858
1859         while (es->s_last_orphan) {
1860                 struct inode *inode;
1861
1862                 inode = ext4_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
1863                 if (IS_ERR(inode)) {
1864                         es->s_last_orphan = 0;
1865                         break;
1866                 }
1867
1868                 list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
1869                 vfs_dq_init(inode);
1870                 if (inode->i_nlink) {
1871                         printk(KERN_DEBUG
1872                                 "%s: truncating inode %lu to %lld bytes\n",
1873                                 __func__, inode->i_ino, inode->i_size);
1874                         jbd_debug(2, "truncating inode %lu to %lld bytes\n",
1875                                   inode->i_ino, inode->i_size);
1876                         ext4_truncate(inode);
1877                         nr_truncates++;
1878                 } else {
1879                         printk(KERN_DEBUG
1880                                 "%s: deleting unreferenced inode %lu\n",
1881                                 __func__, inode->i_ino);
1882                         jbd_debug(2, "deleting unreferenced inode %lu\n",
1883                                   inode->i_ino);
1884                         nr_orphans++;
1885                 }
1886                 iput(inode);  /* The delete magic happens here! */
1887         }
1888
1889 #define PLURAL(x) (x), ((x) == 1) ? "" : "s"
1890
1891         if (nr_orphans)
1892                 printk(KERN_INFO "EXT4-fs: %s: %d orphan inode%s deleted\n",
1893                        sb->s_id, PLURAL(nr_orphans));
1894         if (nr_truncates)
1895                 printk(KERN_INFO "EXT4-fs: %s: %d truncate%s cleaned up\n",
1896                        sb->s_id, PLURAL(nr_truncates));
1897 #ifdef CONFIG_QUOTA
1898         /* Turn quotas off */
1899         for (i = 0; i < MAXQUOTAS; i++) {
1900                 if (sb_dqopt(sb)->files[i])
1901                         vfs_quota_off(sb, i, 0);
1902         }
1903 #endif
1904         sb->s_flags = s_flags; /* Restore MS_RDONLY status */
1905 }
1906 /*
1907  * Maximal extent format file size.
1908  * Resulting logical blkno at s_maxbytes must fit in our on-disk
1909  * extent format containers, within a sector_t, and within i_blocks
1910  * in the vfs.  ext4 inode has 48 bits of i_block in fsblock units,
1911  * so that won't be a limiting factor.
1912  *
1913  * Note, this does *not* consider any metadata overhead for vfs i_blocks.
1914  */
1915 static loff_t ext4_max_size(int blkbits, int has_huge_files)
1916 {
1917         loff_t res;
1918         loff_t upper_limit = MAX_LFS_FILESIZE;
1919
1920         /* small i_blocks in vfs inode? */
1921         if (!has_huge_files || sizeof(blkcnt_t) < sizeof(u64)) {
1922                 /*
1923                  * CONFIG_LBD is not enabled implies the inode
1924                  * i_block represent total blocks in 512 bytes
1925                  * 32 == size of vfs inode i_blocks * 8
1926                  */
1927                 upper_limit = (1LL << 32) - 1;
1928
1929                 /* total blocks in file system block size */
1930                 upper_limit >>= (blkbits - 9);
1931                 upper_limit <<= blkbits;
1932         }
1933
1934         /* 32-bit extent-start container, ee_block */
1935         res = 1LL << 32;
1936         res <<= blkbits;
1937         res -= 1;
1938
1939         /* Sanity check against vm- & vfs- imposed limits */
1940         if (res > upper_limit)
1941                 res = upper_limit;
1942
1943         return res;
1944 }
1945
1946 /*
1947  * Maximal bitmap file size.  There is a direct, and {,double-,triple-}indirect
1948  * block limit, and also a limit of (2^48 - 1) 512-byte sectors in i_blocks.
1949  * We need to be 1 filesystem block less than the 2^48 sector limit.
1950  */
1951 static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
1952 {
1953         loff_t res = EXT4_NDIR_BLOCKS;
1954         int meta_blocks;
1955         loff_t upper_limit;
1956         /* This is calculated to be the largest file size for a
1957          * dense, bitmapped file such that the total number of
1958          * sectors in the file, including data and all indirect blocks,
1959          * does not exceed 2^48 -1
1960          * __u32 i_blocks_lo and _u16 i_blocks_high representing the
1961          * total number of  512 bytes blocks of the file
1962          */
1963
1964         if (!has_huge_files || sizeof(blkcnt_t) < sizeof(u64)) {
1965                 /*
1966                  * !has_huge_files or CONFIG_LBD is not enabled
1967                  * implies the inode i_block represent total blocks in
1968                  * 512 bytes 32 == size of vfs inode i_blocks * 8
1969                  */
1970                 upper_limit = (1LL << 32) - 1;
1971
1972                 /* total blocks in file system block size */
1973                 upper_limit >>= (bits - 9);
1974
1975         } else {
1976                 /*
1977                  * We use 48 bit ext4_inode i_blocks
1978                  * With EXT4_HUGE_FILE_FL set the i_blocks
1979                  * represent total number of blocks in
1980                  * file system block size
1981                  */
1982                 upper_limit = (1LL << 48) - 1;
1983
1984         }
1985
1986         /* indirect blocks */
1987         meta_blocks = 1;
1988         /* double indirect blocks */
1989         meta_blocks += 1 + (1LL << (bits-2));
1990         /* tripple indirect blocks */
1991         meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
1992
1993         upper_limit -= meta_blocks;
1994         upper_limit <<= bits;
1995
1996         res += 1LL << (bits-2);
1997         res += 1LL << (2*(bits-2));
1998         res += 1LL << (3*(bits-2));
1999         res <<= bits;
2000         if (res > upper_limit)
2001                 res = upper_limit;
2002
2003         if (res > MAX_LFS_FILESIZE)
2004                 res = MAX_LFS_FILESIZE;
2005
2006         return res;
2007 }
2008
2009 static ext4_fsblk_t descriptor_loc(struct super_block *sb,
2010                                 ext4_fsblk_t logical_sb_block, int nr)
2011 {
2012         struct ext4_sb_info *sbi = EXT4_SB(sb);
2013         ext4_group_t bg, first_meta_bg;
2014         int has_super = 0;
2015
2016         first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
2017
2018         if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_META_BG) ||
2019             nr < first_meta_bg)
2020                 return logical_sb_block + nr + 1;
2021         bg = sbi->s_desc_per_block * nr;
2022         if (ext4_bg_has_super(sb, bg))
2023                 has_super = 1;
2024         return (has_super + ext4_group_first_block_no(sb, bg));
2025 }
2026
2027 /**
2028  * ext4_get_stripe_size: Get the stripe size.
2029  * @sbi: In memory super block info
2030  *
2031  * If we have specified it via mount option, then
2032  * use the mount option value. If the value specified at mount time is
2033  * greater than the blocks per group use the super block value.
2034  * If the super block value is greater than blocks per group return 0.
2035  * Allocator needs it be less than blocks per group.
2036  *
2037  */
2038 static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
2039 {
2040         unsigned long stride = le16_to_cpu(sbi->s_es->s_raid_stride);
2041         unsigned long stripe_width =
2042                         le32_to_cpu(sbi->s_es->s_raid_stripe_width);
2043
2044         if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
2045                 return sbi->s_stripe;
2046
2047         if (stripe_width <= sbi->s_blocks_per_group)
2048                 return stripe_width;
2049
2050         if (stride <= sbi->s_blocks_per_group)
2051                 return stride;
2052
2053         return 0;
2054 }
2055
2056 /* sysfs supprt */
2057
2058 struct ext4_attr {
2059         struct attribute attr;
2060         ssize_t (*show)(struct ext4_attr *, struct ext4_sb_info *, char *);
2061         ssize_t (*store)(struct ext4_attr *, struct ext4_sb_info *,
2062                          const char *, size_t);
2063         int offset;
2064 };
2065
2066 static int parse_strtoul(const char *buf,
2067                 unsigned long max, unsigned long *value)
2068 {
2069         char *endp;
2070
2071         while (*buf && isspace(*buf))
2072                 buf++;
2073         *value = simple_strtoul(buf, &endp, 0);
2074         while (*endp && isspace(*endp))
2075                 endp++;
2076         if (*endp || *value > max)
2077                 return -EINVAL;
2078
2079         return 0;
2080 }
2081
2082 static ssize_t delayed_allocation_blocks_show(struct ext4_attr *a,
2083                                               struct ext4_sb_info *sbi,
2084                                               char *buf)
2085 {
2086         return snprintf(buf, PAGE_SIZE, "%llu\n",
2087                         (s64) percpu_counter_sum(&sbi->s_dirtyblocks_counter));
2088 }
2089
2090 static ssize_t session_write_kbytes_show(struct ext4_attr *a,
2091                                          struct ext4_sb_info *sbi, char *buf)
2092 {
2093         struct super_block *sb = sbi->s_buddy_cache->i_sb;
2094
2095         return snprintf(buf, PAGE_SIZE, "%lu\n",
2096                         (part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
2097                          sbi->s_sectors_written_start) >> 1);
2098 }
2099
2100 static ssize_t lifetime_write_kbytes_show(struct ext4_attr *a,
2101                                           struct ext4_sb_info *sbi, char *buf)
2102 {
2103         struct super_block *sb = sbi->s_buddy_cache->i_sb;
2104
2105         return snprintf(buf, PAGE_SIZE, "%llu\n",
2106                         sbi->s_kbytes_written +
2107                         ((part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
2108                           EXT4_SB(sb)->s_sectors_written_start) >> 1));
2109 }
2110
2111 static ssize_t inode_readahead_blks_store(struct ext4_attr *a,
2112                                           struct ext4_sb_info *sbi,
2113                                           const char *buf, size_t count)
2114 {
2115         unsigned long t;
2116
2117         if (parse_strtoul(buf, 0x40000000, &t))
2118                 return -EINVAL;
2119
2120         if (!is_power_of_2(t))
2121                 return -EINVAL;
2122
2123         sbi->s_inode_readahead_blks = t;
2124         return count;
2125 }
2126
2127 static ssize_t sbi_ui_show(struct ext4_attr *a,
2128                                 struct ext4_sb_info *sbi, char *buf)
2129 {
2130         unsigned int *ui = (unsigned int *) (((char *) sbi) + a->offset);
2131
2132         return snprintf(buf, PAGE_SIZE, "%u\n", *ui);
2133 }
2134
2135 static ssize_t sbi_ui_store(struct ext4_attr *a,
2136                             struct ext4_sb_info *sbi,
2137                             const char *buf, size_t count)
2138 {
2139         unsigned int *ui = (unsigned int *) (((char *) sbi) + a->offset);
2140         unsigned long t;
2141
2142         if (parse_strtoul(buf, 0xffffffff, &t))
2143                 return -EINVAL;
2144         *ui = t;
2145         return count;
2146 }
2147
2148 #define EXT4_ATTR_OFFSET(_name,_mode,_show,_store,_elname) \
2149 static struct ext4_attr ext4_attr_##_name = {                   \
2150         .attr = {.name = __stringify(_name), .mode = _mode },   \
2151         .show   = _show,                                        \
2152         .store  = _store,                                       \
2153         .offset = offsetof(struct ext4_sb_info, _elname),       \
2154 }
2155 #define EXT4_ATTR(name, mode, show, store) \
2156 static struct ext4_attr ext4_attr_##name = __ATTR(name, mode, show, store)
2157
2158 #define EXT4_RO_ATTR(name) EXT4_ATTR(name, 0444, name##_show, NULL)
2159 #define EXT4_RW_ATTR(name) EXT4_ATTR(name, 0644, name##_show, name##_store)
2160 #define EXT4_RW_ATTR_SBI_UI(name, elname)       \
2161         EXT4_ATTR_OFFSET(name, 0644, sbi_ui_show, sbi_ui_store, elname)
2162 #define ATTR_LIST(name) &ext4_attr_##name.attr
2163
2164 EXT4_RO_ATTR(delayed_allocation_blocks);
2165 EXT4_RO_ATTR(session_write_kbytes);
2166 EXT4_RO_ATTR(lifetime_write_kbytes);
2167 EXT4_ATTR_OFFSET(inode_readahead_blks, 0644, sbi_ui_show,
2168                  inode_readahead_blks_store, s_inode_readahead_blks);
2169 EXT4_RW_ATTR_SBI_UI(mb_stats, s_mb_stats);
2170 EXT4_RW_ATTR_SBI_UI(mb_max_to_scan, s_mb_max_to_scan);
2171 EXT4_RW_ATTR_SBI_UI(mb_min_to_scan, s_mb_min_to_scan);
2172 EXT4_RW_ATTR_SBI_UI(mb_order2_req, s_mb_order2_reqs);
2173 EXT4_RW_ATTR_SBI_UI(mb_stream_req, s_mb_stream_request);
2174 EXT4_RW_ATTR_SBI_UI(mb_group_prealloc, s_mb_group_prealloc);
2175
2176 static struct attribute *ext4_attrs[] = {
2177         ATTR_LIST(delayed_allocation_blocks),
2178         ATTR_LIST(session_write_kbytes),
2179         ATTR_LIST(lifetime_write_kbytes),
2180         ATTR_LIST(inode_readahead_blks),
2181         ATTR_LIST(mb_stats),
2182         ATTR_LIST(mb_max_to_scan),
2183         ATTR_LIST(mb_min_to_scan),
2184         ATTR_LIST(mb_order2_req),
2185         ATTR_LIST(mb_stream_req),
2186         ATTR_LIST(mb_group_prealloc),
2187         NULL,
2188 };
2189
2190 static ssize_t ext4_attr_show(struct kobject *kobj,
2191                               struct attribute *attr, char *buf)
2192 {
2193         struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
2194                                                 s_kobj);
2195         struct ext4_attr *a = container_of(attr, struct ext4_attr, attr);
2196
2197         return a->show ? a->show(a, sbi, buf) : 0;
2198 }
2199
2200 static ssize_t ext4_attr_store(struct kobject *kobj,
2201                                struct attribute *attr,
2202                                const char *buf, size_t len)
2203 {
2204         struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
2205                                                 s_kobj);
2206         struct ext4_attr *a = container_of(attr, struct ext4_attr, attr);
2207
2208         return a->store ? a->store(a, sbi, buf, len) : 0;
2209 }
2210
2211 static void ext4_sb_release(struct kobject *kobj)
2212 {
2213         struct ext4_sb_info *sbi = container_of(kobj, struct ext4_sb_info,
2214                                                 s_kobj);
2215         complete(&sbi->s_kobj_unregister);
2216 }
2217
2218
2219 static struct sysfs_ops ext4_attr_ops = {
2220         .show   = ext4_attr_show,
2221         .store  = ext4_attr_store,
2222 };
2223
2224 static struct kobj_type ext4_ktype = {
2225         .default_attrs  = ext4_attrs,
2226         .sysfs_ops      = &ext4_attr_ops,
2227         .release        = ext4_sb_release,
2228 };
2229
2230 static int ext4_fill_super(struct super_block *sb, void *data, int silent)
2231                                 __releases(kernel_lock)
2232                                 __acquires(kernel_lock)
2233
2234 {
2235         struct buffer_head *bh;
2236         struct ext4_super_block *es = NULL;
2237         struct ext4_sb_info *sbi;
2238         ext4_fsblk_t block;
2239         ext4_fsblk_t sb_block = get_sb_block(&data);
2240         ext4_fsblk_t logical_sb_block;
2241         unsigned long offset = 0;
2242         unsigned long journal_devnum = 0;
2243         unsigned long def_mount_opts;
2244         struct inode *root;
2245         char *cp;
2246         const char *descr;
2247         int ret = -EINVAL;
2248         int blocksize;
2249         unsigned int db_count;
2250         unsigned int i;
2251         int needs_recovery, has_huge_files;
2252         int features;
2253         __u64 blocks_count;
2254         int err;
2255         unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
2256
2257         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
2258         if (!sbi)
2259                 return -ENOMEM;
2260
2261         sbi->s_blockgroup_lock =
2262                 kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
2263         if (!sbi->s_blockgroup_lock) {
2264                 kfree(sbi);
2265                 return -ENOMEM;
2266         }
2267         sb->s_fs_info = sbi;
2268         sbi->s_mount_opt = 0;
2269         sbi->s_resuid = EXT4_DEF_RESUID;
2270         sbi->s_resgid = EXT4_DEF_RESGID;
2271         sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
2272         sbi->s_sb_block = sb_block;
2273         sbi->s_sectors_written_start = part_stat_read(sb->s_bdev->bd_part,
2274                                                       sectors[1]);
2275
2276         unlock_kernel();
2277
2278         /* Cleanup superblock name */
2279         for (cp = sb->s_id; (cp = strchr(cp, '/'));)
2280                 *cp = '!';
2281
2282         blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
2283         if (!blocksize) {
2284                 printk(KERN_ERR "EXT4-fs: unable to set blocksize\n");
2285                 goto out_fail;
2286         }
2287
2288         /*
2289          * The ext4 superblock will not be buffer aligned for other than 1kB
2290          * block sizes.  We need to calculate the offset from buffer start.
2291          */
2292         if (blocksize != EXT4_MIN_BLOCK_SIZE) {
2293                 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
2294                 offset = do_div(logical_sb_block, blocksize);
2295         } else {
2296                 logical_sb_block = sb_block;
2297         }
2298
2299         if (!(bh = sb_bread(sb, logical_sb_block))) {
2300                 printk(KERN_ERR "EXT4-fs: unable to read superblock\n");
2301                 goto out_fail;
2302         }
2303         /*
2304          * Note: s_es must be initialized as soon as possible because
2305          *       some ext4 macro-instructions depend on its value
2306          */
2307         es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
2308         sbi->s_es = es;
2309         sb->s_magic = le16_to_cpu(es->s_magic);
2310         if (sb->s_magic != EXT4_SUPER_MAGIC)
2311                 goto cantfind_ext4;
2312         sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
2313
2314         /* Set defaults before we parse the mount options */
2315         def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
2316         if (def_mount_opts & EXT4_DEFM_DEBUG)
2317                 set_opt(sbi->s_mount_opt, DEBUG);
2318         if (def_mount_opts & EXT4_DEFM_BSDGROUPS)
2319                 set_opt(sbi->s_mount_opt, GRPID);
2320         if (def_mount_opts & EXT4_DEFM_UID16)
2321                 set_opt(sbi->s_mount_opt, NO_UID32);
2322 #ifdef CONFIG_EXT4_FS_XATTR
2323         if (def_mount_opts & EXT4_DEFM_XATTR_USER)
2324                 set_opt(sbi->s_mount_opt, XATTR_USER);
2325 #endif
2326 #ifdef CONFIG_EXT4_FS_POSIX_ACL
2327         if (def_mount_opts & EXT4_DEFM_ACL)
2328                 set_opt(sbi->s_mount_opt, POSIX_ACL);
2329 #endif
2330         if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
2331                 sbi->s_mount_opt |= EXT4_MOUNT_JOURNAL_DATA;
2332         else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
2333                 sbi->s_mount_opt |= EXT4_MOUNT_ORDERED_DATA;
2334         else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_WBACK)
2335                 sbi->s_mount_opt |= EXT4_MOUNT_WRITEBACK_DATA;
2336
2337         if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_PANIC)
2338                 set_opt(sbi->s_mount_opt, ERRORS_PANIC);
2339         else if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_CONTINUE)
2340                 set_opt(sbi->s_mount_opt, ERRORS_CONT);
2341         else
2342                 set_opt(sbi->s_mount_opt, ERRORS_RO);
2343
2344         sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
2345         sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
2346         sbi->s_commit_interval = JBD2_DEFAULT_MAX_COMMIT_AGE * HZ;
2347         sbi->s_min_batch_time = EXT4_DEF_MIN_BATCH_TIME;
2348         sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
2349
2350         set_opt(sbi->s_mount_opt, BARRIER);
2351
2352         /*
2353          * enable delayed allocation by default
2354          * Use -o nodelalloc to turn it off
2355          */
2356         set_opt(sbi->s_mount_opt, DELALLOC);
2357
2358
2359         if (!parse_options((char *) data, sb, &journal_devnum,
2360                            &journal_ioprio, NULL, 0))
2361                 goto failed_mount;
2362
2363         sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
2364                 ((sbi->s_mount_opt & EXT4_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
2365
2366         if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
2367             (EXT4_HAS_COMPAT_FEATURE(sb, ~0U) ||
2368              EXT4_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
2369              EXT4_HAS_INCOMPAT_FEATURE(sb, ~0U)))
2370                 printk(KERN_WARNING
2371                        "EXT4-fs warning: feature flags set on rev 0 fs, "
2372                        "running e2fsck is recommended\n");
2373
2374         /*
2375          * Check feature flags regardless of the revision level, since we
2376          * previously didn't change the revision level when setting the flags,
2377          * so there is a chance incompat flags are set on a rev 0 filesystem.
2378          */
2379         features = EXT4_HAS_INCOMPAT_FEATURE(sb, ~EXT4_FEATURE_INCOMPAT_SUPP);
2380         if (features) {
2381                 printk(KERN_ERR "EXT4-fs: %s: couldn't mount because of "
2382                        "unsupported optional features (%x).\n", sb->s_id,
2383                         (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_incompat) &
2384                         ~EXT4_FEATURE_INCOMPAT_SUPP));
2385                 goto failed_mount;
2386         }
2387         features = EXT4_HAS_RO_COMPAT_FEATURE(sb, ~EXT4_FEATURE_RO_COMPAT_SUPP);
2388         if (!(sb->s_flags & MS_RDONLY) && features) {
2389                 printk(KERN_ERR "EXT4-fs: %s: couldn't mount RDWR because of "
2390                        "unsupported optional features (%x).\n", sb->s_id,
2391                         (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) &
2392                         ~EXT4_FEATURE_RO_COMPAT_SUPP));
2393                 goto failed_mount;
2394         }
2395         has_huge_files = EXT4_HAS_RO_COMPAT_FEATURE(sb,
2396                                     EXT4_FEATURE_RO_COMPAT_HUGE_FILE);
2397         if (has_huge_files) {
2398                 /*
2399                  * Large file size enabled file system can only be
2400                  * mount if kernel is build with CONFIG_LBD
2401                  */
2402                 if (sizeof(root->i_blocks) < sizeof(u64) &&
2403                                 !(sb->s_flags & MS_RDONLY)) {
2404                         printk(KERN_ERR "EXT4-fs: %s: Filesystem with huge "
2405                                         "files cannot be mounted read-write "
2406                                         "without CONFIG_LBD.\n", sb->s_id);
2407                         goto failed_mount;
2408                 }
2409         }
2410         blocksize = BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
2411
2412         if (blocksize < EXT4_MIN_BLOCK_SIZE ||
2413             blocksize > EXT4_MAX_BLOCK_SIZE) {
2414                 printk(KERN_ERR
2415                        "EXT4-fs: Unsupported filesystem blocksize %d on %s.\n",
2416                        blocksize, sb->s_id);
2417                 goto failed_mount;
2418         }
2419
2420         if (sb->s_blocksize != blocksize) {
2421
2422                 /* Validate the filesystem blocksize */
2423                 if (!sb_set_blocksize(sb, blocksize)) {
2424                         printk(KERN_ERR "EXT4-fs: bad block size %d.\n",
2425                                         blocksize);
2426                         goto failed_mount;
2427                 }
2428
2429                 brelse(bh);
2430                 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
2431                 offset = do_div(logical_sb_block, blocksize);
2432                 bh = sb_bread(sb, logical_sb_block);
2433                 if (!bh) {
2434                         printk(KERN_ERR
2435                                "EXT4-fs: Can't read superblock on 2nd try.\n");
2436                         goto failed_mount;
2437                 }
2438                 es = (struct ext4_super_block *)(((char *)bh->b_data) + offset);
2439                 sbi->s_es = es;
2440                 if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
2441                         printk(KERN_ERR
2442                                "EXT4-fs: Magic mismatch, very weird !\n");
2443                         goto failed_mount;
2444                 }
2445         }
2446
2447         sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits,
2448                                                       has_huge_files);
2449         sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits, has_huge_files);
2450
2451         if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
2452                 sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
2453                 sbi->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
2454         } else {
2455                 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
2456                 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
2457                 if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
2458                     (!is_power_of_2(sbi->s_inode_size)) ||
2459                     (sbi->s_inode_size > blocksize)) {
2460                         printk(KERN_ERR
2461                                "EXT4-fs: unsupported inode size: %d\n",
2462                                sbi->s_inode_size);
2463                         goto failed_mount;
2464                 }
2465                 if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE)
2466                         sb->s_time_gran = 1 << (EXT4_EPOCH_BITS - 2);
2467         }
2468         sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
2469         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT)) {
2470                 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
2471                     sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
2472                     !is_power_of_2(sbi->s_desc_size)) {
2473                         printk(KERN_ERR
2474                                "EXT4-fs: unsupported descriptor size %lu\n",
2475                                sbi->s_desc_size);
2476                         goto failed_mount;
2477                 }
2478         } else
2479                 sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
2480         sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
2481         sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
2482         if (EXT4_INODE_SIZE(sb) == 0 || EXT4_INODES_PER_GROUP(sb) == 0)
2483                 goto cantfind_ext4;
2484         sbi->s_inodes_per_block = blocksize / EXT4_INODE_SIZE(sb);
2485         if (sbi->s_inodes_per_block == 0)
2486                 goto cantfind_ext4;
2487         sbi->s_itb_per_group = sbi->s_inodes_per_group /
2488                                         sbi->s_inodes_per_block;
2489         sbi->s_desc_per_block = blocksize / EXT4_DESC_SIZE(sb);
2490         sbi->s_sbh = bh;
2491         sbi->s_mount_state = le16_to_cpu(es->s_state);
2492         sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
2493         sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
2494         for (i = 0; i < 4; i++)
2495                 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
2496         sbi->s_def_hash_version = es->s_def_hash_version;
2497         i = le32_to_cpu(es->s_flags);
2498         if (i & EXT2_FLAGS_UNSIGNED_HASH)
2499                 sbi->s_hash_unsigned = 3;
2500         else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
2501 #ifdef __CHAR_UNSIGNED__
2502                 es->s_flags |= cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
2503                 sbi->s_hash_unsigned = 3;
2504 #else
2505                 es->s_flags |= cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
2506 #endif
2507                 sb->s_dirt = 1;
2508         }
2509
2510         if (sbi->s_blocks_per_group > blocksize * 8) {
2511                 printk(KERN_ERR
2512                        "EXT4-fs: #blocks per group too big: %lu\n",
2513                        sbi->s_blocks_per_group);
2514                 goto failed_mount;
2515         }
2516         if (sbi->s_inodes_per_group > blocksize * 8) {
2517                 printk(KERN_ERR
2518                        "EXT4-fs: #inodes per group too big: %lu\n",
2519                        sbi->s_inodes_per_group);
2520                 goto failed_mount;
2521         }
2522
2523         if (ext4_blocks_count(es) >
2524                     (sector_t)(~0ULL) >> (sb->s_blocksize_bits - 9)) {
2525                 printk(KERN_ERR "EXT4-fs: filesystem on %s:"
2526                         " too large to mount safely\n", sb->s_id);
2527                 if (sizeof(sector_t) < 8)
2528                         printk(KERN_WARNING "EXT4-fs: CONFIG_LBD not "
2529                                         "enabled\n");
2530                 goto failed_mount;
2531         }
2532
2533         if (EXT4_BLOCKS_PER_GROUP(sb) == 0)
2534                 goto cantfind_ext4;
2535
2536         /* check blocks count against device size */
2537         blocks_count = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
2538         if (blocks_count && ext4_blocks_count(es) > blocks_count) {
2539                 printk(KERN_WARNING "EXT4-fs: bad geometry: block count %llu "
2540                        "exceeds size of device (%llu blocks)\n",
2541                        ext4_blocks_count(es), blocks_count);
2542                 goto failed_mount;
2543         }
2544
2545         /*
2546          * It makes no sense for the first data block to be beyond the end
2547          * of the filesystem.
2548          */
2549         if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
2550                 printk(KERN_WARNING "EXT4-fs: bad geometry: first data"
2551                        "block %u is beyond end of filesystem (%llu)\n",
2552                        le32_to_cpu(es->s_first_data_block),
2553                        ext4_blocks_count(es));
2554                 goto failed_mount;
2555         }
2556         blocks_count = (ext4_blocks_count(es) -
2557                         le32_to_cpu(es->s_first_data_block) +
2558                         EXT4_BLOCKS_PER_GROUP(sb) - 1);
2559         do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
2560         if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
2561                 printk(KERN_WARNING "EXT4-fs: groups count too large: %u "
2562                        "(block count %llu, first data block %u, "
2563                        "blocks per group %lu)\n", sbi->s_groups_count,
2564                        ext4_blocks_count(es),
2565                        le32_to_cpu(es->s_first_data_block),
2566                        EXT4_BLOCKS_PER_GROUP(sb));
2567                 goto failed_mount;
2568         }
2569         sbi->s_groups_count = blocks_count;
2570         db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
2571                    EXT4_DESC_PER_BLOCK(sb);
2572         sbi->s_group_desc = kmalloc(db_count * sizeof(struct buffer_head *),
2573                                     GFP_KERNEL);
2574         if (sbi->s_group_desc == NULL) {
2575                 printk(KERN_ERR "EXT4-fs: not enough memory\n");
2576                 goto failed_mount;
2577         }
2578
2579 #ifdef CONFIG_PROC_FS
2580         if (ext4_proc_root)
2581                 sbi->s_proc = proc_mkdir(sb->s_id, ext4_proc_root);
2582 #endif
2583
2584         bgl_lock_init(sbi->s_blockgroup_lock);
2585
2586         for (i = 0; i < db_count; i++) {
2587                 block = descriptor_loc(sb, logical_sb_block, i);
2588                 sbi->s_group_desc[i] = sb_bread(sb, block);
2589                 if (!sbi->s_group_desc[i]) {
2590                         printk(KERN_ERR "EXT4-fs: "
2591                                "can't read group descriptor %d\n", i);
2592                         db_count = i;
2593                         goto failed_mount2;
2594                 }
2595         }
2596         if (!ext4_check_descriptors(sb)) {
2597                 printk(KERN_ERR "EXT4-fs: group descriptors corrupted!\n");
2598                 goto failed_mount2;
2599         }
2600         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG))
2601                 if (!ext4_fill_flex_info(sb)) {
2602                         printk(KERN_ERR
2603                                "EXT4-fs: unable to initialize "
2604                                "flex_bg meta info!\n");
2605                         goto failed_mount2;
2606                 }
2607
2608         sbi->s_gdb_count = db_count;
2609         get_random_bytes(&sbi->s_next_generation, sizeof(u32));
2610         spin_lock_init(&sbi->s_next_gen_lock);
2611
2612         err = percpu_counter_init(&sbi->s_freeblocks_counter,
2613                         ext4_count_free_blocks(sb));
2614         if (!err) {
2615                 err = percpu_counter_init(&sbi->s_freeinodes_counter,
2616                                 ext4_count_free_inodes(sb));
2617         }
2618         if (!err) {
2619                 err = percpu_counter_init(&sbi->s_dirs_counter,
2620                                 ext4_count_dirs(sb));
2621         }
2622         if (!err) {
2623                 err = percpu_counter_init(&sbi->s_dirtyblocks_counter, 0);
2624         }
2625         if (err) {
2626                 printk(KERN_ERR "EXT4-fs: insufficient memory\n");
2627                 goto failed_mount3;
2628         }
2629
2630         sbi->s_stripe = ext4_get_stripe_size(sbi);
2631
2632         /*
2633          * set up enough so that it can read an inode
2634          */
2635         if (!test_opt(sb, NOLOAD) &&
2636             EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL))
2637                 sb->s_op = &ext4_sops;
2638         else
2639                 sb->s_op = &ext4_nojournal_sops;
2640         sb->s_export_op = &ext4_export_ops;
2641         sb->s_xattr = ext4_xattr_handlers;
2642 #ifdef CONFIG_QUOTA
2643         sb->s_qcop = &ext4_qctl_operations;
2644         sb->dq_op = &ext4_quota_operations;
2645 #endif
2646         INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
2647         mutex_init(&sbi->s_orphan_lock);
2648         mutex_init(&sbi->s_resize_lock);
2649
2650         sb->s_root = NULL;
2651
2652         needs_recovery = (es->s_last_orphan != 0 ||
2653                           EXT4_HAS_INCOMPAT_FEATURE(sb,
2654                                     EXT4_FEATURE_INCOMPAT_RECOVER));
2655
2656         /*
2657          * The first inode we look at is the journal inode.  Don't try
2658          * root first: it may be modified in the journal!
2659          */
2660         if (!test_opt(sb, NOLOAD) &&
2661             EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) {
2662                 if (ext4_load_journal(sb, es, journal_devnum))
2663                         goto failed_mount3;
2664                 if (!(sb->s_flags & MS_RDONLY) &&
2665                     EXT4_SB(sb)->s_journal->j_failed_commit) {
2666                         printk(KERN_CRIT "EXT4-fs error (device %s): "
2667                                "ext4_fill_super: Journal transaction "
2668                                "%u is corrupt\n", sb->s_id,
2669                                EXT4_SB(sb)->s_journal->j_failed_commit);
2670                         if (test_opt(sb, ERRORS_RO)) {
2671                                 printk(KERN_CRIT
2672                                        "Mounting filesystem read-only\n");
2673                                 sb->s_flags |= MS_RDONLY;
2674                                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
2675                                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
2676                         }
2677                         if (test_opt(sb, ERRORS_PANIC)) {
2678                                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
2679                                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
2680                                 ext4_commit_super(sb, 1);
2681                                 goto failed_mount4;
2682                         }
2683                 }
2684         } else if (test_opt(sb, NOLOAD) && !(sb->s_flags & MS_RDONLY) &&
2685               EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
2686                 printk(KERN_ERR "EXT4-fs: required journal recovery "
2687                        "suppressed and not mounted read-only\n");
2688                 goto failed_mount4;
2689         } else {
2690                 clear_opt(sbi->s_mount_opt, DATA_FLAGS);
2691                 set_opt(sbi->s_mount_opt, WRITEBACK_DATA);
2692                 sbi->s_journal = NULL;
2693                 needs_recovery = 0;
2694                 goto no_journal;
2695         }
2696
2697         if (ext4_blocks_count(es) > 0xffffffffULL &&
2698             !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
2699                                        JBD2_FEATURE_INCOMPAT_64BIT)) {
2700                 printk(KERN_ERR "EXT4-fs: Failed to set 64-bit journal feature\n");
2701                 goto failed_mount4;
2702         }
2703
2704         if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
2705                 jbd2_journal_set_features(sbi->s_journal,
2706                                 JBD2_FEATURE_COMPAT_CHECKSUM, 0,
2707                                 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2708         } else if (test_opt(sb, JOURNAL_CHECKSUM)) {
2709                 jbd2_journal_set_features(sbi->s_journal,
2710                                 JBD2_FEATURE_COMPAT_CHECKSUM, 0, 0);
2711                 jbd2_journal_clear_features(sbi->s_journal, 0, 0,
2712                                 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2713         } else {
2714                 jbd2_journal_clear_features(sbi->s_journal,
2715                                 JBD2_FEATURE_COMPAT_CHECKSUM, 0,
2716                                 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
2717         }
2718
2719         /* We have now updated the journal if required, so we can
2720          * validate the data journaling mode. */
2721         switch (test_opt(sb, DATA_FLAGS)) {
2722         case 0:
2723                 /* No mode set, assume a default based on the journal
2724                  * capabilities: ORDERED_DATA if the journal can
2725                  * cope, else JOURNAL_DATA
2726                  */
2727                 if (jbd2_journal_check_available_features
2728                     (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE))
2729                         set_opt(sbi->s_mount_opt, ORDERED_DATA);
2730                 else
2731                         set_opt(sbi->s_mount_opt, JOURNAL_DATA);
2732                 break;
2733
2734         case EXT4_MOUNT_ORDERED_DATA:
2735         case EXT4_MOUNT_WRITEBACK_DATA:
2736                 if (!jbd2_journal_check_available_features
2737                     (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
2738                         printk(KERN_ERR "EXT4-fs: Journal does not support "
2739                                "requested data journaling mode\n");
2740                         goto failed_mount4;
2741                 }
2742         default:
2743                 break;
2744         }
2745         set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
2746
2747 no_journal:
2748
2749         if (test_opt(sb, NOBH)) {
2750                 if (!(test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)) {
2751                         printk(KERN_WARNING "EXT4-fs: Ignoring nobh option - "
2752                                 "its supported only with writeback mode\n");
2753                         clear_opt(sbi->s_mount_opt, NOBH);
2754                 }
2755         }
2756         /*
2757          * The jbd2_journal_load will have done any necessary log recovery,
2758          * so we can safely mount the rest of the filesystem now.
2759          */
2760
2761         root = ext4_iget(sb, EXT4_ROOT_INO);
2762         if (IS_ERR(root)) {
2763                 printk(KERN_ERR "EXT4-fs: get root inode failed\n");
2764                 ret = PTR_ERR(root);
2765                 goto failed_mount4;
2766         }
2767         if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
2768                 iput(root);
2769                 printk(KERN_ERR "EXT4-fs: corrupt root inode, run e2fsck\n");
2770                 goto failed_mount4;
2771         }
2772         sb->s_root = d_alloc_root(root);
2773         if (!sb->s_root) {
2774                 printk(KERN_ERR "EXT4-fs: get root dentry failed\n");
2775                 iput(root);
2776                 ret = -ENOMEM;
2777                 goto failed_mount4;
2778         }
2779
2780         ext4_setup_super(sb, es, sb->s_flags & MS_RDONLY);
2781
2782         /* determine the minimum size of new large inodes, if present */
2783         if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
2784                 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
2785                                                      EXT4_GOOD_OLD_INODE_SIZE;
2786                 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
2787                                        EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE)) {
2788                         if (sbi->s_want_extra_isize <
2789                             le16_to_cpu(es->s_want_extra_isize))
2790                                 sbi->s_want_extra_isize =
2791                                         le16_to_cpu(es->s_want_extra_isize);
2792                         if (sbi->s_want_extra_isize <
2793                             le16_to_cpu(es->s_min_extra_isize))
2794                                 sbi->s_want_extra_isize =
2795                                         le16_to_cpu(es->s_min_extra_isize);
2796                 }
2797         }
2798         /* Check if enough inode space is available */
2799         if (EXT4_GOOD_OLD_INODE_SIZE + sbi->s_want_extra_isize >
2800                                                         sbi->s_inode_size) {
2801                 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
2802                                                        EXT4_GOOD_OLD_INODE_SIZE;
2803                 printk(KERN_INFO "EXT4-fs: required extra inode space not"
2804                         "available.\n");
2805         }
2806
2807         if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
2808                 printk(KERN_WARNING "EXT4-fs: Ignoring delalloc option - "
2809                                 "requested data journaling mode\n");
2810                 clear_opt(sbi->s_mount_opt, DELALLOC);
2811         } else if (test_opt(sb, DELALLOC))
2812                 printk(KERN_INFO "EXT4-fs: delayed allocation enabled\n");
2813
2814         ext4_ext_init(sb);
2815         err = ext4_mb_init(sb, needs_recovery);
2816         if (err) {
2817                 printk(KERN_ERR "EXT4-fs: failed to initalize mballoc (%d)\n",
2818                        err);
2819                 goto failed_mount4;
2820         }
2821
2822         sbi->s_kobj.kset = ext4_kset;
2823         init_completion(&sbi->s_kobj_unregister);
2824         err = kobject_init_and_add(&sbi->s_kobj, &ext4_ktype, NULL,
2825                                    "%s", sb->s_id);
2826         if (err) {
2827                 ext4_mb_release(sb);
2828                 ext4_ext_release(sb);
2829                 goto failed_mount4;
2830         };
2831
2832         EXT4_SB(sb)->s_mount_state |= EXT4_ORPHAN_FS;
2833         ext4_orphan_cleanup(sb, es);
2834         EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
2835         if (needs_recovery) {
2836                 printk(KERN_INFO "EXT4-fs: recovery complete.\n");
2837                 ext4_mark_recovery_complete(sb, es);
2838         }
2839         if (EXT4_SB(sb)->s_journal) {
2840                 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
2841                         descr = " journalled data mode";
2842                 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
2843                         descr = " ordered data mode";
2844                 else
2845                         descr = " writeback data mode";
2846         } else
2847                 descr = "out journal";
2848
2849         printk(KERN_INFO "EXT4-fs: mounted filesystem %s with%s\n",
2850                sb->s_id, descr);
2851
2852         lock_kernel();
2853         return 0;
2854
2855 cantfind_ext4:
2856         if (!silent)
2857                 printk(KERN_ERR "VFS: Can't find ext4 filesystem on dev %s.\n",
2858                        sb->s_id);
2859         goto failed_mount;
2860
2861 failed_mount4:
2862         printk(KERN_ERR "EXT4-fs (device %s): mount failed\n", sb->s_id);
2863         if (sbi->s_journal) {
2864                 jbd2_journal_destroy(sbi->s_journal);
2865                 sbi->s_journal = NULL;
2866         }
2867 failed_mount3:
2868         if (sbi->s_flex_groups) {
2869                 if (is_vmalloc_addr(sbi->s_flex_groups))
2870                         vfree(sbi->s_flex_groups);
2871                 else
2872                         kfree(sbi->s_flex_groups);
2873         }
2874         percpu_counter_destroy(&sbi->s_freeblocks_counter);
2875         percpu_counter_destroy(&sbi->s_freeinodes_counter);
2876         percpu_counter_destroy(&sbi->s_dirs_counter);
2877         percpu_counter_destroy(&sbi->s_dirtyblocks_counter);
2878 failed_mount2:
2879         for (i = 0; i < db_count; i++)
2880                 brelse(sbi->s_group_desc[i]);
2881         kfree(sbi->s_group_desc);
2882 failed_mount:
2883         if (sbi->s_proc) {
2884                 remove_proc_entry(sb->s_id, ext4_proc_root);
2885         }
2886 #ifdef CONFIG_QUOTA
2887         for (i = 0; i < MAXQUOTAS; i++)
2888                 kfree(sbi->s_qf_names[i]);
2889 #endif
2890         ext4_blkdev_remove(sbi);
2891         brelse(bh);
2892 out_fail:
2893         sb->s_fs_info = NULL;
2894         kfree(sbi);
2895         lock_kernel();
2896         return ret;
2897 }
2898
2899 /*
2900  * Setup any per-fs journal parameters now.  We'll do this both on
2901  * initial mount, once the journal has been initialised but before we've
2902  * done any recovery; and again on any subsequent remount.
2903  */
2904 static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
2905 {
2906         struct ext4_sb_info *sbi = EXT4_SB(sb);
2907
2908         journal->j_commit_interval = sbi->s_commit_interval;
2909         journal->j_min_batch_time = sbi->s_min_batch_time;
2910         journal->j_max_batch_time = sbi->s_max_batch_time;
2911
2912         spin_lock(&journal->j_state_lock);
2913         if (test_opt(sb, BARRIER))
2914                 journal->j_flags |= JBD2_BARRIER;
2915         else
2916                 journal->j_flags &= ~JBD2_BARRIER;
2917         if (test_opt(sb, DATA_ERR_ABORT))
2918                 journal->j_flags |= JBD2_ABORT_ON_SYNCDATA_ERR;
2919         else
2920                 journal->j_flags &= ~JBD2_ABORT_ON_SYNCDATA_ERR;
2921         spin_unlock(&journal->j_state_lock);
2922 }
2923
2924 static journal_t *ext4_get_journal(struct super_block *sb,
2925                                    unsigned int journal_inum)
2926 {
2927         struct inode *journal_inode;
2928         journal_t *journal;
2929
2930         BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
2931
2932         /* First, test for the existence of a valid inode on disk.  Bad
2933          * things happen if we iget() an unused inode, as the subsequent
2934          * iput() will try to delete it. */
2935
2936         journal_inode = ext4_iget(sb, journal_inum);
2937         if (IS_ERR(journal_inode)) {
2938                 printk(KERN_ERR "EXT4-fs: no journal found.\n");
2939                 return NULL;
2940         }
2941         if (!journal_inode->i_nlink) {
2942                 make_bad_inode(journal_inode);
2943                 iput(journal_inode);
2944                 printk(KERN_ERR "EXT4-fs: journal inode is deleted.\n");
2945                 return NULL;
2946         }
2947
2948         jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
2949                   journal_inode, journal_inode->i_size);
2950         if (!S_ISREG(journal_inode->i_mode)) {
2951                 printk(KERN_ERR "EXT4-fs: invalid journal inode.\n");
2952                 iput(journal_inode);
2953                 return NULL;
2954         }
2955
2956         journal = jbd2_journal_init_inode(journal_inode);
2957         if (!journal) {
2958                 printk(KERN_ERR "EXT4-fs: Could not load journal inode\n");
2959                 iput(journal_inode);
2960                 return NULL;
2961         }
2962         journal->j_private = sb;
2963         ext4_init_journal_params(sb, journal);
2964         return journal;
2965 }
2966
2967 static journal_t *ext4_get_dev_journal(struct super_block *sb,
2968                                        dev_t j_dev)
2969 {
2970         struct buffer_head *bh;
2971         journal_t *journal;
2972         ext4_fsblk_t start;
2973         ext4_fsblk_t len;
2974         int hblock, blocksize;
2975         ext4_fsblk_t sb_block;
2976         unsigned long offset;
2977         struct ext4_super_block *es;
2978         struct block_device *bdev;
2979
2980         BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
2981
2982         bdev = ext4_blkdev_get(j_dev);
2983         if (bdev == NULL)
2984                 return NULL;
2985
2986         if (bd_claim(bdev, sb)) {
2987                 printk(KERN_ERR
2988                         "EXT4-fs: failed to claim external journal device.\n");
2989                 blkdev_put(bdev, FMODE_READ|FMODE_WRITE);
2990                 return NULL;
2991         }
2992
2993         blocksize = sb->s_blocksize;
2994         hblock = bdev_hardsect_size(bdev);
2995         if (blocksize < hblock) {
2996                 printk(KERN_ERR
2997                         "EXT4-fs: blocksize too small for journal device.\n");
2998                 goto out_bdev;
2999         }
3000
3001         sb_block = EXT4_MIN_BLOCK_SIZE / blocksize;
3002         offset = EXT4_MIN_BLOCK_SIZE % blocksize;
3003         set_blocksize(bdev, blocksize);
3004         if (!(bh = __bread(bdev, sb_block, blocksize))) {
3005                 printk(KERN_ERR "EXT4-fs: couldn't read superblock of "
3006                        "external journal\n");
3007                 goto out_bdev;
3008         }
3009
3010         es = (struct ext4_super_block *) (((char *)bh->b_data) + offset);
3011         if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
3012             !(le32_to_cpu(es->s_feature_incompat) &
3013               EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
3014                 printk(KERN_ERR "EXT4-fs: external journal has "
3015                                         "bad superblock\n");
3016                 brelse(bh);
3017                 goto out_bdev;
3018         }
3019
3020         if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
3021                 printk(KERN_ERR "EXT4-fs: journal UUID does not match\n");
3022                 brelse(bh);
3023                 goto out_bdev;
3024         }
3025
3026         len = ext4_blocks_count(es);
3027         start = sb_block + 1;
3028         brelse(bh);     /* we're done with the superblock */
3029
3030         journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
3031                                         start, len, blocksize);
3032         if (!journal) {
3033                 printk(KERN_ERR "EXT4-fs: failed to create device journal\n");
3034                 goto out_bdev;
3035         }
3036         journal->j_private = sb;
3037         ll_rw_block(READ, 1, &journal->j_sb_buffer);
3038         wait_on_buffer(journal->j_sb_buffer);
3039         if (!buffer_uptodate(journal->j_sb_buffer)) {
3040                 printk(KERN_ERR "EXT4-fs: I/O error on journal device\n");
3041                 goto out_journal;
3042         }
3043         if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
3044                 printk(KERN_ERR "EXT4-fs: External journal has more than one "
3045                                         "user (unsupported) - %d\n",
3046                         be32_to_cpu(journal->j_superblock->s_nr_users));
3047                 goto out_journal;
3048         }
3049         EXT4_SB(sb)->journal_bdev = bdev;
3050         ext4_init_journal_params(sb, journal);
3051         return journal;
3052 out_journal:
3053         jbd2_journal_destroy(journal);
3054 out_bdev:
3055         ext4_blkdev_put(bdev);
3056         return NULL;
3057 }
3058
3059 static int ext4_load_journal(struct super_block *sb,
3060                              struct ext4_super_block *es,
3061                              unsigned long journal_devnum)
3062 {
3063         journal_t *journal;
3064         unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
3065         dev_t journal_dev;
3066         int err = 0;
3067         int really_read_only;
3068
3069         BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
3070
3071         if (journal_devnum &&
3072             journal_devnum != le32_to_cpu(es->s_journal_dev)) {
3073                 printk(KERN_INFO "EXT4-fs: external journal device major/minor "
3074                         "numbers have changed\n");
3075                 journal_dev = new_decode_dev(journal_devnum);
3076         } else
3077                 journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
3078
3079         really_read_only = bdev_read_only(sb->s_bdev);
3080
3081         /*
3082          * Are we loading a blank journal or performing recovery after a
3083          * crash?  For recovery, we need to check in advance whether we
3084          * can get read-write access to the device.
3085          */
3086
3087         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER)) {
3088                 if (sb->s_flags & MS_RDONLY) {
3089                         printk(KERN_INFO "EXT4-fs: INFO: recovery "
3090                                         "required on readonly filesystem.\n");
3091                         if (really_read_only) {
3092                                 printk(KERN_ERR "EXT4-fs: write access "
3093                                         "unavailable, cannot proceed.\n");
3094                                 return -EROFS;
3095                         }
3096                         printk(KERN_INFO "EXT4-fs: write access will "
3097                                "be enabled during recovery.\n");
3098                 }
3099         }
3100
3101         if (journal_inum && journal_dev) {
3102                 printk(KERN_ERR "EXT4-fs: filesystem has both journal "
3103                        "and inode journals!\n");
3104                 return -EINVAL;
3105         }
3106
3107         if (journal_inum) {
3108                 if (!(journal = ext4_get_journal(sb, journal_inum)))
3109                         return -EINVAL;
3110         } else {
3111                 if (!(journal = ext4_get_dev_journal(sb, journal_dev)))
3112                         return -EINVAL;
3113         }
3114
3115         if (journal->j_flags & JBD2_BARRIER)
3116                 printk(KERN_INFO "EXT4-fs: barriers enabled\n");
3117         else
3118                 printk(KERN_INFO "EXT4-fs: barriers disabled\n");
3119
3120         if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
3121                 err = jbd2_journal_update_format(journal);
3122                 if (err)  {
3123                         printk(KERN_ERR "EXT4-fs: error updating journal.\n");
3124                         jbd2_journal_destroy(journal);
3125                         return err;
3126                 }
3127         }
3128
3129         if (!EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER))
3130                 err = jbd2_journal_wipe(journal, !really_read_only);
3131         if (!err)
3132                 err = jbd2_journal_load(journal);
3133
3134         if (err) {
3135                 printk(KERN_ERR "EXT4-fs: error loading journal.\n");
3136                 jbd2_journal_destroy(journal);
3137                 return err;
3138         }
3139
3140         EXT4_SB(sb)->s_journal = journal;
3141         ext4_clear_journal_err(sb, es);
3142
3143         if (journal_devnum &&
3144             journal_devnum != le32_to_cpu(es->s_journal_dev)) {
3145                 es->s_journal_dev = cpu_to_le32(journal_devnum);
3146
3147                 /* Make sure we flush the recovery flag to disk. */
3148                 ext4_commit_super(sb, 1);
3149         }
3150
3151         return 0;
3152 }
3153
3154 static int ext4_commit_super(struct super_block *sb, int sync)
3155 {
3156         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
3157         struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
3158         int error = 0;
3159
3160         if (!sbh)
3161                 return error;
3162         if (buffer_write_io_error(sbh)) {
3163                 /*
3164                  * Oh, dear.  A previous attempt to write the
3165                  * superblock failed.  This could happen because the
3166                  * USB device was yanked out.  Or it could happen to
3167                  * be a transient write error and maybe the block will
3168                  * be remapped.  Nothing we can do but to retry the
3169                  * write and hope for the best.
3170                  */
3171                 printk(KERN_ERR "EXT4-fs: previous I/O error to "
3172                        "superblock detected for %s.\n", sb->s_id);
3173                 clear_buffer_write_io_error(sbh);
3174                 set_buffer_uptodate(sbh);
3175         }
3176         es->s_wtime = cpu_to_le32(get_seconds());
3177         es->s_kbytes_written =
3178                 cpu_to_le64(EXT4_SB(sb)->s_kbytes_written +
3179                             ((part_stat_read(sb->s_bdev->bd_part, sectors[1]) -
3180                               EXT4_SB(sb)->s_sectors_written_start) >> 1));
3181         ext4_free_blocks_count_set(es, percpu_counter_sum_positive(
3182                                         &EXT4_SB(sb)->s_freeblocks_counter));
3183         es->s_free_inodes_count = cpu_to_le32(percpu_counter_sum_positive(
3184                                         &EXT4_SB(sb)->s_freeinodes_counter));
3185         sb->s_dirt = 0;
3186         BUFFER_TRACE(sbh, "marking dirty");
3187         mark_buffer_dirty(sbh);
3188         if (sync) {
3189                 error = sync_dirty_buffer(sbh);
3190                 if (error)
3191                         return error;
3192
3193                 error = buffer_write_io_error(sbh);
3194                 if (error) {
3195                         printk(KERN_ERR "EXT4-fs: I/O error while writing "
3196                                "superblock for %s.\n", sb->s_id);
3197                         clear_buffer_write_io_error(sbh);
3198                         set_buffer_uptodate(sbh);
3199                 }
3200         }
3201         return error;
3202 }
3203
3204
3205 /*
3206  * Have we just finished recovery?  If so, and if we are mounting (or
3207  * remounting) the filesystem readonly, then we will end up with a
3208  * consistent fs on disk.  Record that fact.
3209  */
3210 static void ext4_mark_recovery_complete(struct super_block *sb,
3211                                         struct ext4_super_block *es)
3212 {
3213         journal_t *journal = EXT4_SB(sb)->s_journal;
3214
3215         if (!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) {
3216                 BUG_ON(journal != NULL);
3217                 return;
3218         }
3219         jbd2_journal_lock_updates(journal);
3220         if (jbd2_journal_flush(journal) < 0)
3221                 goto out;
3222
3223         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) &&
3224             sb->s_flags & MS_RDONLY) {
3225                 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
3226                 ext4_commit_super(sb, 1);
3227         }
3228
3229 out:
3230         jbd2_journal_unlock_updates(journal);
3231 }
3232
3233 /*
3234  * If we are mounting (or read-write remounting) a filesystem whose journal
3235  * has recorded an error from a previous lifetime, move that error to the
3236  * main filesystem now.
3237  */
3238 static void ext4_clear_journal_err(struct super_block *sb,
3239                                    struct ext4_super_block *es)
3240 {
3241         journal_t *journal;
3242         int j_errno;
3243         const char *errstr;
3244
3245         BUG_ON(!EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL));
3246
3247         journal = EXT4_SB(sb)->s_journal;
3248
3249         /*
3250          * Now check for any error status which may have been recorded in the
3251          * journal by a prior ext4_error() or ext4_abort()
3252          */
3253
3254         j_errno = jbd2_journal_errno(journal);
3255         if (j_errno) {
3256                 char nbuf[16];
3257
3258                 errstr = ext4_decode_error(sb, j_errno, nbuf);
3259                 ext4_warning(sb, __func__, "Filesystem error recorded "
3260                              "from previous mount: %s", errstr);
3261                 ext4_warning(sb, __func__, "Marking fs in need of "
3262                              "filesystem check.");
3263
3264                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
3265                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
3266                 ext4_commit_super(sb, 1);
3267
3268                 jbd2_journal_clear_err(journal);
3269         }
3270 }
3271
3272 /*
3273  * Force the running and committing transactions to commit,
3274  * and wait on the commit.
3275  */
3276 int ext4_force_commit(struct super_block *sb)
3277 {
3278         journal_t *journal;
3279         int ret = 0;
3280
3281         if (sb->s_flags & MS_RDONLY)
3282                 return 0;
3283
3284         journal = EXT4_SB(sb)->s_journal;
3285         if (journal)
3286                 ret = ext4_journal_force_commit(journal);
3287
3288         return ret;
3289 }
3290
3291 static void ext4_write_super(struct super_block *sb)
3292 {
3293         ext4_commit_super(sb, 1);
3294 }
3295
3296 static int ext4_sync_fs(struct super_block *sb, int wait)
3297 {
3298         int ret = 0;
3299         tid_t target;
3300
3301         trace_mark(ext4_sync_fs, "dev %s wait %d", sb->s_id, wait);
3302         if (jbd2_journal_start_commit(EXT4_SB(sb)->s_journal, &target)) {
3303                 if (wait)
3304                         jbd2_log_wait_commit(EXT4_SB(sb)->s_journal, target);
3305         }
3306         return ret;
3307 }
3308
3309 /*
3310  * LVM calls this function before a (read-only) snapshot is created.  This
3311  * gives us a chance to flush the journal completely and mark the fs clean.
3312  */
3313 static int ext4_freeze(struct super_block *sb)
3314 {
3315         int error = 0;
3316         journal_t *journal;
3317
3318         if (sb->s_flags & MS_RDONLY)
3319                 return 0;
3320
3321         journal = EXT4_SB(sb)->s_journal;
3322
3323         /* Now we set up the journal barrier. */
3324         jbd2_journal_lock_updates(journal);
3325
3326         /*
3327          * Don't clear the needs_recovery flag if we failed to flush
3328          * the journal.
3329          */
3330         error = jbd2_journal_flush(journal);
3331         if (error < 0) {
3332         out:
3333                 jbd2_journal_unlock_updates(journal);
3334                 return error;
3335         }
3336
3337         /* Journal blocked and flushed, clear needs_recovery flag. */
3338         EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
3339         error = ext4_commit_super(sb, 1);
3340         if (error)
3341                 goto out;
3342         return 0;
3343 }
3344
3345 /*
3346  * Called by LVM after the snapshot is done.  We need to reset the RECOVER
3347  * flag here, even though the filesystem is not technically dirty yet.
3348  */
3349 static int ext4_unfreeze(struct super_block *sb)
3350 {
3351         if (sb->s_flags & MS_RDONLY)
3352                 return 0;
3353
3354         lock_super(sb);
3355         /* Reset the needs_recovery flag before the fs is unlocked. */
3356         EXT4_SET_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
3357         ext4_commit_super(sb, 1);
3358         unlock_super(sb);
3359         jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
3360         return 0;
3361 }
3362
3363 static int ext4_remount(struct super_block *sb, int *flags, char *data)
3364 {
3365         struct ext4_super_block *es;
3366         struct ext4_sb_info *sbi = EXT4_SB(sb);
3367         ext4_fsblk_t n_blocks_count = 0;
3368         unsigned long old_sb_flags;
3369         struct ext4_mount_options old_opts;
3370         ext4_group_t g;
3371         unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
3372         int err;
3373 #ifdef CONFIG_QUOTA
3374         int i;
3375 #endif
3376
3377         /* Store the original options */
3378         old_sb_flags = sb->s_flags;
3379         old_opts.s_mount_opt = sbi->s_mount_opt;
3380         old_opts.s_resuid = sbi->s_resuid;
3381         old_opts.s_resgid = sbi->s_resgid;
3382         old_opts.s_commit_interval = sbi->s_commit_interval;
3383         old_opts.s_min_batch_time = sbi->s_min_batch_time;
3384         old_opts.s_max_batch_time = sbi->s_max_batch_time;
3385 #ifdef CONFIG_QUOTA
3386         old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
3387         for (i = 0; i < MAXQUOTAS; i++)
3388                 old_opts.s_qf_names[i] = sbi->s_qf_names[i];
3389 #endif
3390         if (sbi->s_journal && sbi->s_journal->j_task->io_context)
3391                 journal_ioprio = sbi->s_journal->j_task->io_context->ioprio;
3392
3393         /*
3394          * Allow the "check" option to be passed as a remount option.
3395          */
3396         if (!parse_options(data, sb, NULL, &journal_ioprio,
3397                            &n_blocks_count, 1)) {
3398                 err = -EINVAL;
3399                 goto restore_opts;
3400         }
3401
3402         if (sbi->s_mount_opt & EXT4_MOUNT_ABORT)
3403                 ext4_abort(sb, __func__, "Abort forced by user");
3404
3405         sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
3406                 ((sbi->s_mount_opt & EXT4_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
3407
3408         es = sbi->s_es;
3409
3410         if (sbi->s_journal) {
3411                 ext4_init_journal_params(sb, sbi->s_journal);
3412                 set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
3413         }
3414
3415         if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY) ||
3416                 n_blocks_count > ext4_blocks_count(es)) {
3417                 if (sbi->s_mount_opt & EXT4_MOUNT_ABORT) {
3418                         err = -EROFS;
3419                         goto restore_opts;
3420                 }
3421
3422                 if (*flags & MS_RDONLY) {
3423                         /*
3424                          * First of all, the unconditional stuff we have to do
3425                          * to disable replay of the journal when we next remount
3426                          */
3427                         sb->s_flags |= MS_RDONLY;
3428
3429                         /*
3430                          * OK, test if we are remounting a valid rw partition
3431                          * readonly, and if so set the rdonly flag and then
3432                          * mark the partition as valid again.
3433                          */
3434                         if (!(es->s_state & cpu_to_le16(EXT4_VALID_FS)) &&
3435                             (sbi->s_mount_state & EXT4_VALID_FS))
3436                                 es->s_state = cpu_to_le16(sbi->s_mount_state);
3437
3438                         if (sbi->s_journal)
3439                                 ext4_mark_recovery_complete(sb, es);
3440                 } else {
3441                         int ret;
3442                         if ((ret = EXT4_HAS_RO_COMPAT_FEATURE(sb,
3443                                         ~EXT4_FEATURE_RO_COMPAT_SUPP))) {
3444                                 printk(KERN_WARNING "EXT4-fs: %s: couldn't "
3445                                        "remount RDWR because of unsupported "
3446                                        "optional features (%x).\n", sb->s_id,
3447                                 (le32_to_cpu(sbi->s_es->s_feature_ro_compat) &
3448                                         ~EXT4_FEATURE_RO_COMPAT_SUPP));
3449                                 err = -EROFS;
3450                                 goto restore_opts;
3451                         }
3452
3453                         /*
3454                          * Make sure the group descriptor checksums
3455                          * are sane.  If they aren't, refuse to
3456                          * remount r/w.
3457                          */
3458                         for (g = 0; g < sbi->s_groups_count; g++) {
3459                                 struct ext4_group_desc *gdp =
3460                                         ext4_get_group_desc(sb, g, NULL);
3461
3462                                 if (!ext4_group_desc_csum_verify(sbi, g, gdp)) {
3463                                         printk(KERN_ERR
3464                "EXT4-fs: ext4_remount: "
3465                 "Checksum for group %u failed (%u!=%u)\n",
3466                 g, le16_to_cpu(ext4_group_desc_csum(sbi, g, gdp)),
3467                                                le16_to_cpu(gdp->bg_checksum));
3468                                         err = -EINVAL;
3469                                         goto restore_opts;
3470                                 }
3471                         }
3472
3473                         /*
3474                          * If we have an unprocessed orphan list hanging
3475                          * around from a previously readonly bdev mount,
3476                          * require a full umount/remount for now.
3477                          */
3478                         if (es->s_last_orphan) {
3479                                 printk(KERN_WARNING "EXT4-fs: %s: couldn't "
3480                                        "remount RDWR because of unprocessed "
3481                                        "orphan inode list.  Please "
3482                                        "umount/remount instead.\n",
3483                                        sb->s_id);
3484                                 err = -EINVAL;
3485                                 goto restore_opts;
3486                         }
3487
3488                         /*
3489                          * Mounting a RDONLY partition read-write, so reread
3490                          * and store the current valid flag.  (It may have
3491                          * been changed by e2fsck since we originally mounted
3492                          * the partition.)
3493                          */
3494                         if (sbi->s_journal)
3495                                 ext4_clear_journal_err(sb, es);
3496                         sbi->s_mount_state = le16_to_cpu(es->s_state);
3497                         if ((err = ext4_group_extend(sb, es, n_blocks_count)))
3498                                 goto restore_opts;
3499                         if (!ext4_setup_super(sb, es, 0))
3500                                 sb->s_flags &= ~MS_RDONLY;
3501                 }
3502         }
3503         if (sbi->s_journal == NULL)
3504                 ext4_commit_super(sb, 1);
3505
3506 #ifdef CONFIG_QUOTA
3507         /* Release old quota file names */
3508         for (i = 0; i < MAXQUOTAS; i++)
3509                 if (old_opts.s_qf_names[i] &&
3510                     old_opts.s_qf_names[i] != sbi->s_qf_names[i])
3511                         kfree(old_opts.s_qf_names[i]);
3512 #endif
3513         return 0;
3514 restore_opts:
3515         sb->s_flags = old_sb_flags;
3516         sbi->s_mount_opt = old_opts.s_mount_opt;
3517         sbi->s_resuid = old_opts.s_resuid;
3518         sbi->s_resgid = old_opts.s_resgid;
3519         sbi->s_commit_interval = old_opts.s_commit_interval;
3520         sbi->s_min_batch_time = old_opts.s_min_batch_time;
3521         sbi->s_max_batch_time = old_opts.s_max_batch_time;
3522 #ifdef CONFIG_QUOTA
3523         sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
3524         for (i = 0; i < MAXQUOTAS; i++) {
3525                 if (sbi->s_qf_names[i] &&
3526                     old_opts.s_qf_names[i] != sbi->s_qf_names[i])
3527                         kfree(sbi->s_qf_names[i]);
3528                 sbi->s_qf_names[i] = old_opts.s_qf_names[i];
3529         }
3530 #endif
3531         return err;
3532 }
3533
3534 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
3535 {
3536         struct super_block *sb = dentry->d_sb;
3537         struct ext4_sb_info *sbi = EXT4_SB(sb);
3538         struct ext4_super_block *es = sbi->s_es;
3539         u64 fsid;
3540
3541         if (test_opt(sb, MINIX_DF)) {
3542                 sbi->s_overhead_last = 0;
3543         } else if (sbi->s_blocks_last != ext4_blocks_count(es)) {
3544                 ext4_group_t i, ngroups = ext4_get_groups_count(sb);
3545                 ext4_fsblk_t overhead = 0;
3546
3547                 /*
3548                  * Compute the overhead (FS structures).  This is constant
3549                  * for a given filesystem unless the number of block groups
3550                  * changes so we cache the previous value until it does.
3551                  */
3552
3553                 /*
3554                  * All of the blocks before first_data_block are
3555                  * overhead
3556                  */
3557                 overhead = le32_to_cpu(es->s_first_data_block);
3558
3559                 /*
3560                  * Add the overhead attributed to the superblock and
3561                  * block group descriptors.  If the sparse superblocks
3562                  * feature is turned on, then not all groups have this.
3563                  */
3564                 for (i = 0; i < ngroups; i++) {
3565                         overhead += ext4_bg_has_super(sb, i) +
3566                                 ext4_bg_num_gdb(sb, i);
3567                         cond_resched();
3568                 }
3569
3570                 /*
3571                  * Every block group has an inode bitmap, a block
3572                  * bitmap, and an inode table.
3573                  */
3574                 overhead += ngroups * (2 + sbi->s_itb_per_group);
3575                 sbi->s_overhead_last = overhead;
3576                 smp_wmb();
3577                 sbi->s_blocks_last = ext4_blocks_count(es);
3578         }
3579
3580         buf->f_type = EXT4_SUPER_MAGIC;
3581         buf->f_bsize = sb->s_blocksize;
3582         buf->f_blocks = ext4_blocks_count(es) - sbi->s_overhead_last;
3583         buf->f_bfree = percpu_counter_sum_positive(&sbi->s_freeblocks_counter) -
3584                        percpu_counter_sum_positive(&sbi->s_dirtyblocks_counter);
3585         ext4_free_blocks_count_set(es, buf->f_bfree);
3586         buf->f_bavail = buf->f_bfree - ext4_r_blocks_count(es);
3587         if (buf->f_bfree < ext4_r_blocks_count(es))
3588                 buf->f_bavail = 0;
3589         buf->f_files = le32_to_cpu(es->s_inodes_count);
3590         buf->f_ffree = percpu_counter_sum_positive(&sbi->s_freeinodes_counter);
3591         es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
3592         buf->f_namelen = EXT4_NAME_LEN;
3593         fsid = le64_to_cpup((void *)es->s_uuid) ^
3594                le64_to_cpup((void *)es->s_uuid + sizeof(u64));
3595         buf->f_fsid.val[0] = fsid & 0xFFFFFFFFUL;
3596         buf->f_fsid.val[1] = (fsid >> 32) & 0xFFFFFFFFUL;
3597         return 0;
3598 }
3599
3600 /* Helper function for writing quotas on sync - we need to start transaction before quota file
3601  * is locked for write. Otherwise the are possible deadlocks:
3602  * Process 1                         Process 2
3603  * ext4_create()                     quota_sync()
3604  *   jbd2_journal_start()                  write_dquot()
3605  *   vfs_dq_init()                         down(dqio_mutex)
3606  *     down(dqio_mutex)                    jbd2_journal_start()
3607  *
3608  */
3609
3610 #ifdef CONFIG_QUOTA
3611
3612 static inline struct inode *dquot_to_inode(struct dquot *dquot)
3613 {
3614         return sb_dqopt(dquot->dq_sb)->files[dquot->dq_type];
3615 }
3616
3617 static int ext4_write_dquot(struct dquot *dquot)
3618 {
3619         int ret, err;
3620         handle_t *handle;
3621         struct inode *inode;
3622
3623         inode = dquot_to_inode(dquot);
3624         handle = ext4_journal_start(inode,
3625                                         EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
3626         if (IS_ERR(handle))
3627                 return PTR_ERR(handle);
3628         ret = dquot_commit(dquot);
3629         err = ext4_journal_stop(handle);
3630         if (!ret)
3631                 ret = err;
3632         return ret;
3633 }
3634
3635 static int ext4_acquire_dquot(struct dquot *dquot)
3636 {
3637         int ret, err;
3638         handle_t *handle;
3639
3640         handle = ext4_journal_start(dquot_to_inode(dquot),
3641                                         EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
3642         if (IS_ERR(handle))
3643                 return PTR_ERR(handle);
3644         ret = dquot_acquire(dquot);
3645         err = ext4_journal_stop(handle);
3646         if (!ret)
3647                 ret = err;
3648         return ret;
3649 }
3650
3651 static int ext4_release_dquot(struct dquot *dquot)
3652 {
3653         int ret, err;
3654         handle_t *handle;
3655
3656         handle = ext4_journal_start(dquot_to_inode(dquot),
3657                                         EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
3658         if (IS_ERR(handle)) {
3659                 /* Release dquot anyway to avoid endless cycle in dqput() */
3660                 dquot_release(dquot);
3661                 return PTR_ERR(handle);
3662         }
3663         ret = dquot_release(dquot);
3664         err = ext4_journal_stop(handle);
3665         if (!ret)
3666                 ret = err;
3667         return ret;
3668 }
3669
3670 static int ext4_mark_dquot_dirty(struct dquot *dquot)
3671 {
3672         /* Are we journaling quotas? */
3673         if (EXT4_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
3674             EXT4_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
3675                 dquot_mark_dquot_dirty(dquot);
3676                 return ext4_write_dquot(dquot);
3677         } else {
3678                 return dquot_mark_dquot_dirty(dquot);
3679         }
3680 }
3681
3682 static int ext4_write_info(struct super_block *sb, int type)
3683 {
3684         int ret, err;
3685         handle_t *handle;
3686
3687         /* Data block + inode block */
3688         handle = ext4_journal_start(sb->s_root->d_inode, 2);
3689         if (IS_ERR(handle))
3690                 return PTR_ERR(handle);
3691         ret = dquot_commit_info(sb, type);
3692         err = ext4_journal_stop(handle);
3693         if (!ret)
3694                 ret = err;
3695         return ret;
3696 }
3697
3698 /*
3699  * Turn on quotas during mount time - we need to find
3700  * the quota file and such...
3701  */
3702 static int ext4_quota_on_mount(struct super_block *sb, int type)
3703 {
3704         return vfs_quota_on_mount(sb, EXT4_SB(sb)->s_qf_names[type],
3705                         EXT4_SB(sb)->s_jquota_fmt, type);
3706 }
3707
3708 /*
3709  * Standard function to be called on quota_on
3710  */
3711 static int ext4_quota_on(struct super_block *sb, int type, int format_id,
3712                          char *name, int remount)
3713 {
3714         int err;
3715         struct path path;
3716
3717         if (!test_opt(sb, QUOTA))
3718                 return -EINVAL;
3719         /* When remounting, no checks are needed and in fact, name is NULL */
3720         if (remount)
3721                 return vfs_quota_on(sb, type, format_id, name, remount);
3722
3723         err = kern_path(name, LOOKUP_FOLLOW, &path);
3724         if (err)
3725                 return err;
3726
3727         /* Quotafile not on the same filesystem? */
3728         if (path.mnt->mnt_sb != sb) {
3729                 path_put(&path);
3730                 return -EXDEV;
3731         }
3732         /* Journaling quota? */
3733         if (EXT4_SB(sb)->s_qf_names[type]) {
3734                 /* Quotafile not in fs root? */
3735                 if (path.dentry->d_parent != sb->s_root)
3736                         printk(KERN_WARNING
3737                                 "EXT4-fs: Quota file not on filesystem root. "
3738                                 "Journaled quota will not work.\n");
3739         }
3740
3741         /*
3742          * When we journal data on quota file, we have to flush journal to see
3743          * all updates to the file when we bypass pagecache...
3744          */
3745         if (EXT4_SB(sb)->s_journal &&
3746             ext4_should_journal_data(path.dentry->d_inode)) {
3747                 /*
3748                  * We don't need to lock updates but journal_flush() could
3749                  * otherwise be livelocked...
3750                  */
3751                 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
3752                 err = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
3753                 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
3754                 if (err) {
3755                         path_put(&path);
3756                         return err;
3757                 }
3758         }
3759
3760         err = vfs_quota_on_path(sb, type, format_id, &path);
3761         path_put(&path);
3762         return err;
3763 }
3764
3765 /* Read data from quotafile - avoid pagecache and such because we cannot afford
3766  * acquiring the locks... As quota files are never truncated and quota code
3767  * itself serializes the operations (and noone else should touch the files)
3768  * we don't have to be afraid of races */
3769 static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
3770                                size_t len, loff_t off)
3771 {
3772         struct inode *inode = sb_dqopt(sb)->files[type];
3773         ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
3774         int err = 0;
3775         int offset = off & (sb->s_blocksize - 1);
3776         int tocopy;
3777         size_t toread;
3778         struct buffer_head *bh;
3779         loff_t i_size = i_size_read(inode);
3780
3781         if (off > i_size)
3782                 return 0;
3783         if (off+len > i_size)
3784                 len = i_size-off;
3785         toread = len;
3786         while (toread > 0) {
3787                 tocopy = sb->s_blocksize - offset < toread ?
3788                                 sb->s_blocksize - offset : toread;
3789                 bh = ext4_bread(NULL, inode, blk, 0, &err);
3790                 if (err)
3791                         return err;
3792                 if (!bh)        /* A hole? */
3793                         memset(data, 0, tocopy);
3794                 else
3795                         memcpy(data, bh->b_data+offset, tocopy);
3796                 brelse(bh);
3797                 offset = 0;
3798                 toread -= tocopy;
3799                 data += tocopy;
3800                 blk++;
3801         }
3802         return len;
3803 }
3804
3805 /* Write to quotafile (we know the transaction is already started and has
3806  * enough credits) */
3807 static ssize_t ext4_quota_write(struct super_block *sb, int type,
3808                                 const char *data, size_t len, loff_t off)
3809 {
3810         struct inode *inode = sb_dqopt(sb)->files[type];
3811         ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
3812         int err = 0;
3813         int offset = off & (sb->s_blocksize - 1);
3814         int tocopy;
3815         int journal_quota = EXT4_SB(sb)->s_qf_names[type] != NULL;
3816         size_t towrite = len;
3817         struct buffer_head *bh;
3818         handle_t *handle = journal_current_handle();
3819
3820         if (EXT4_SB(sb)->s_journal && !handle) {
3821                 printk(KERN_WARNING "EXT4-fs: Quota write (off=%llu, len=%llu)"
3822                         " cancelled because transaction is not started.\n",
3823                         (unsigned long long)off, (unsigned long long)len);
3824                 return -EIO;
3825         }
3826         mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
3827         while (towrite > 0) {
3828                 tocopy = sb->s_blocksize - offset < towrite ?
3829                                 sb->s_blocksize - offset : towrite;
3830                 bh = ext4_bread(handle, inode, blk, 1, &err);
3831                 if (!bh)
3832                         goto out;
3833                 if (journal_quota) {
3834                         err = ext4_journal_get_write_access(handle, bh);
3835                         if (err) {
3836                                 brelse(bh);
3837                                 goto out;
3838                         }
3839                 }
3840                 lock_buffer(bh);
3841                 memcpy(bh->b_data+offset, data, tocopy);
3842                 flush_dcache_page(bh->b_page);
3843                 unlock_buffer(bh);
3844                 if (journal_quota)
3845                         err = ext4_handle_dirty_metadata(handle, NULL, bh);
3846                 else {
3847                         /* Always do at least ordered writes for quotas */
3848                         err = ext4_jbd2_file_inode(handle, inode);
3849                         mark_buffer_dirty(bh);
3850                 }
3851                 brelse(bh);
3852                 if (err)
3853                         goto out;
3854                 offset = 0;
3855                 towrite -= tocopy;
3856                 data += tocopy;
3857                 blk++;
3858         }
3859 out:
3860         if (len == towrite) {
3861                 mutex_unlock(&inode->i_mutex);
3862                 return err;
3863         }
3864         if (inode->i_size < off+len-towrite) {
3865                 i_size_write(inode, off+len-towrite);
3866                 EXT4_I(inode)->i_disksize = inode->i_size;
3867         }
3868         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
3869         ext4_mark_inode_dirty(handle, inode);
3870         mutex_unlock(&inode->i_mutex);
3871         return len - towrite;
3872 }
3873
3874 #endif
3875
3876 static int ext4_get_sb(struct file_system_type *fs_type,
3877         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
3878 {
3879         return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super, mnt);
3880 }
3881
3882 static struct file_system_type ext4_fs_type = {
3883         .owner          = THIS_MODULE,
3884         .name           = "ext4",
3885         .get_sb         = ext4_get_sb,
3886         .kill_sb        = kill_block_super,
3887         .fs_flags       = FS_REQUIRES_DEV,
3888 };
3889
3890 #ifdef CONFIG_EXT4DEV_COMPAT
3891 static int ext4dev_get_sb(struct file_system_type *fs_type,
3892         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
3893 {
3894         printk(KERN_WARNING "EXT4-fs: Update your userspace programs "
3895                "to mount using ext4\n");
3896         printk(KERN_WARNING "EXT4-fs: ext4dev backwards compatibility "
3897                "will go away by 2.6.31\n");
3898         return get_sb_bdev(fs_type, flags, dev_name, data, ext4_fill_super, mnt);
3899 }
3900
3901 static struct file_system_type ext4dev_fs_type = {
3902         .owner          = THIS_MODULE,
3903         .name           = "ext4dev",
3904         .get_sb         = ext4dev_get_sb,
3905         .kill_sb        = kill_block_super,
3906         .fs_flags       = FS_REQUIRES_DEV,
3907 };
3908 MODULE_ALIAS("ext4dev");
3909 #endif
3910
3911 static int __init init_ext4_fs(void)
3912 {
3913         int err;
3914
3915         ext4_kset = kset_create_and_add("ext4", NULL, fs_kobj);
3916         if (!ext4_kset)
3917                 return -ENOMEM;
3918         ext4_proc_root = proc_mkdir("fs/ext4", NULL);
3919         err = init_ext4_mballoc();
3920         if (err)
3921                 return err;
3922
3923         err = init_ext4_xattr();
3924         if (err)
3925                 goto out2;
3926         err = init_inodecache();
3927         if (err)
3928                 goto out1;
3929         err = register_filesystem(&ext4_fs_type);
3930         if (err)
3931                 goto out;
3932 #ifdef CONFIG_EXT4DEV_COMPAT
3933         err = register_filesystem(&ext4dev_fs_type);
3934         if (err) {
3935                 unregister_filesystem(&ext4_fs_type);
3936                 goto out;
3937         }
3938 #endif
3939         return 0;
3940 out:
3941         destroy_inodecache();
3942 out1:
3943         exit_ext4_xattr();
3944 out2:
3945         exit_ext4_mballoc();
3946         return err;
3947 }
3948
3949 static void __exit exit_ext4_fs(void)
3950 {
3951         unregister_filesystem(&ext4_fs_type);
3952 #ifdef CONFIG_EXT4DEV_COMPAT
3953         unregister_filesystem(&ext4dev_fs_type);
3954 #endif
3955         destroy_inodecache();
3956         exit_ext4_xattr();
3957         exit_ext4_mballoc();
3958         remove_proc_entry("fs/ext4", NULL);
3959         kset_unregister(ext4_kset);
3960 }
3961
3962 MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
3963 MODULE_DESCRIPTION("Fourth Extended Filesystem");
3964 MODULE_LICENSE("GPL");
3965 module_init(init_ext4_fs)
3966 module_exit(exit_ext4_fs)