fs/ext4/super.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/ext4/super.c
   4  *
   5  * Copyright (C) 1992, 1993, 1994, 1995
   6  * Remy Card (card@masi.ibp.fr)
   7  * Laboratoire MASI - Institut Blaise Pascal
   8  * Universite Pierre et Marie Curie (Paris VI)
   9  *
  10  *  from
  11  *
  12  *  linux/fs/minix/inode.c
  13  *
  14  *  Copyright (C) 1991, 1992  Linus Torvalds
  15  *
  16  *  Big-endian to little-endian byte-swapping/bitmaps by
  17  *        David S. Miller (davem@caip.rutgers.edu), 1995
  18  */
  19
  20 #include <linux/module.h>
  21 #include <linux/string.h>
  22 #include <linux/fs.h>
  23 #include <linux/time.h>
  24 #include <linux/vmalloc.h>
  25 #include <linux/slab.h>
  26 #include <linux/init.h>
  27 #include <linux/blkdev.h>
  28 #include <linux/backing-dev.h>
  29 #include <linux/parser.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/ctype.h>
  39 #include <linux/log2.h>
  40 #include <linux/crc16.h>
  41 #include <linux/dax.h>
  42 #include <linux/cleancache.h>
  43 #include <linux/uaccess.h>
  44 #include <linux/iversion.h>
  45 #include <linux/unicode.h>
  46 #include <linux/part_stat.h>
  47 #include <linux/kthread.h>
  48 #include <linux/freezer.h>
  49
  50 #include "ext4.h"
  51 #include "ext4_extents.h"       /* Needed for trace points definition */
  52 #include "ext4_jbd2.h"
  53 #include "xattr.h"
  54 #include "acl.h"
  55 #include "mballoc.h"
  56 #include "fsmap.h"
  57
  58 #define CREATE_TRACE_POINTS
  59 #include <trace/events/ext4.h>
  60
  61 static struct ext4_lazy_init *ext4_li_info;
  62 static struct mutex ext4_li_mtx;
  63 static struct ratelimit_state ext4_mount_msg_ratelimit;
  64
  65 static int ext4_load_journal(struct super_block *, struct ext4_super_block *,
  66                              unsigned long journal_devnum);
  67 static int ext4_show_options(struct seq_file *seq, struct dentry *root);
  68 static int ext4_commit_super(struct super_block *sb, int sync);
  69 static int ext4_mark_recovery_complete(struct super_block *sb,
  70                                         struct ext4_super_block *es);
  71 static int ext4_clear_journal_err(struct super_block *sb,
  72                                   struct ext4_super_block *es);
  73 static int ext4_sync_fs(struct super_block *sb, int wait);
  74 static int ext4_remount(struct super_block *sb, int *flags, char *data);
  75 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf);
  76 static int ext4_unfreeze(struct super_block *sb);
  77 static int ext4_freeze(struct super_block *sb);
  78 static struct dentry *ext4_mount(struct file_system_type *fs_type, int flags,
  79                        const char *dev_name, void *data);
  80 static inline int ext2_feature_set_ok(struct super_block *sb);
  81 static inline int ext3_feature_set_ok(struct super_block *sb);
  82 static int ext4_feature_set_ok(struct super_block *sb, int readonly);
  83 static void ext4_destroy_lazyinit_thread(void);
  84 static void ext4_unregister_li_request(struct super_block *sb);
  85 static void ext4_clear_request_list(void);
  86 static struct inode *ext4_get_journal_inode(struct super_block *sb,
  87                                             unsigned int journal_inum);
  88
  89 /*
  90  * Lock ordering
  91  *
  92  * Note the difference between i_mmap_sem (EXT4_I(inode)->i_mmap_sem) and
  93  * i_mmap_rwsem (inode->i_mmap_rwsem)!
  94  *
  95  * page fault path:
  96  * mmap_lock -> sb_start_pagefault -> i_mmap_sem (r) -> transaction start ->
  97  *   page lock -> i_data_sem (rw)
  98  *
  99  * buffered write path:
 100  * sb_start_write -> i_mutex -> mmap_lock
 101  * sb_start_write -> i_mutex -> transaction start -> page lock ->
 102  *   i_data_sem (rw)
 103  *
 104  * truncate:
 105  * sb_start_write -> i_mutex -> i_mmap_sem (w) -> i_mmap_rwsem (w) -> page lock
 106  * sb_start_write -> i_mutex -> i_mmap_sem (w) -> transaction start ->
 107  *   i_data_sem (rw)
 108  *
 109  * direct IO:
 110  * sb_start_write -> i_mutex -> mmap_lock
 111  * sb_start_write -> i_mutex -> transaction start -> i_data_sem (rw)
 112  *
 113  * writepages:
 114  * transaction start -> page lock(s) -> i_data_sem (rw)
 115  */
 116
 117 #if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2)
 118 static struct file_system_type ext2_fs_type = {
 119         .owner          = THIS_MODULE,
 120         .name           = "ext2",
 121         .mount          = ext4_mount,
 122         .kill_sb        = kill_block_super,
 123         .fs_flags       = FS_REQUIRES_DEV,
 124 };
 125 MODULE_ALIAS_FS("ext2");
 126 MODULE_ALIAS("ext2");
 127 #define IS_EXT2_SB(sb) ((sb)->s_bdev->bd_holder == &ext2_fs_type)
 128 #else
 129 #define IS_EXT2_SB(sb) (0)
 130 #endif
 131
 132
 133 static struct file_system_type ext3_fs_type = {
 134         .owner          = THIS_MODULE,
 135         .name           = "ext3",
 136         .mount          = ext4_mount,
 137         .kill_sb        = kill_block_super,
 138         .fs_flags       = FS_REQUIRES_DEV,
 139 };
 140 MODULE_ALIAS_FS("ext3");
 141 MODULE_ALIAS("ext3");
 142 #define IS_EXT3_SB(sb) ((sb)->s_bdev->bd_holder == &ext3_fs_type)
 143
 144
 145 static inline void __ext4_read_bh(struct buffer_head *bh, int op_flags,
 146                                   bh_end_io_t *end_io)
 147 {
 148         /*
 149          * buffer's verified bit is no longer valid after reading from
 150          * disk again due to write out error, clear it to make sure we
 151          * recheck the buffer contents.
 152          */
 153         clear_buffer_verified(bh);
 154
 155         bh->b_end_io = end_io ? end_io : end_buffer_read_sync;
 156         get_bh(bh);
 157         submit_bh(REQ_OP_READ, op_flags, bh);
 158 }
 159
 160 void ext4_read_bh_nowait(struct buffer_head *bh, int op_flags,
 161                          bh_end_io_t *end_io)
 162 {
 163         BUG_ON(!buffer_locked(bh));
 164
 165         if (ext4_buffer_uptodate(bh)) {
 166                 unlock_buffer(bh);
 167                 return;
 168         }
 169         __ext4_read_bh(bh, op_flags, end_io);
 170 }
 171
 172 int ext4_read_bh(struct buffer_head *bh, int op_flags, bh_end_io_t *end_io)
 173 {
 174         BUG_ON(!buffer_locked(bh));
 175
 176         if (ext4_buffer_uptodate(bh)) {
 177                 unlock_buffer(bh);
 178                 return 0;
 179         }
 180
 181         __ext4_read_bh(bh, op_flags, end_io);
 182
 183         wait_on_buffer(bh);
 184         if (buffer_uptodate(bh))
 185                 return 0;
 186         return -EIO;
 187 }
 188
 189 int ext4_read_bh_lock(struct buffer_head *bh, int op_flags, bool wait)
 190 {
 191         if (trylock_buffer(bh)) {
 192                 if (wait)
 193                         return ext4_read_bh(bh, op_flags, NULL);
 194                 ext4_read_bh_nowait(bh, op_flags, NULL);
 195                 return 0;
 196         }
 197         if (wait) {
 198                 wait_on_buffer(bh);
 199                 if (buffer_uptodate(bh))
 200                         return 0;
 201                 return -EIO;
 202         }
 203         return 0;
 204 }
 205
 206 /*
 207  * This works like __bread_gfp() except it uses ERR_PTR for error
 208  * returns.  Currently with sb_bread it's impossible to distinguish
 209  * between ENOMEM and EIO situations (since both result in a NULL
 210  * return.
 211  */
 212 static struct buffer_head *__ext4_sb_bread_gfp(struct super_block *sb,
 213                                                sector_t block, int op_flags,
 214                                                gfp_t gfp)
 215 {
 216         struct buffer_head *bh;
 217         int ret;
 218
 219         bh = sb_getblk_gfp(sb, block, gfp);
 220         if (bh == NULL)
 221                 return ERR_PTR(-ENOMEM);
 222         if (ext4_buffer_uptodate(bh))
 223                 return bh;
 224
 225         ret = ext4_read_bh_lock(bh, REQ_META | op_flags, true);
 226         if (ret) {
 227                 put_bh(bh);
 228                 return ERR_PTR(ret);
 229         }
 230         return bh;
 231 }
 232
 233 struct buffer_head *ext4_sb_bread(struct super_block *sb, sector_t block,
 234                                    int op_flags)
 235 {
 236         return __ext4_sb_bread_gfp(sb, block, op_flags, __GFP_MOVABLE);
 237 }
 238
 239 struct buffer_head *ext4_sb_bread_unmovable(struct super_block *sb,
 240                                             sector_t block)
 241 {
 242         return __ext4_sb_bread_gfp(sb, block, 0, 0);
 243 }
 244
 245 void ext4_sb_breadahead_unmovable(struct super_block *sb, sector_t block)
 246 {
 247         struct buffer_head *bh = sb_getblk_gfp(sb, block, 0);
 248
 249         if (likely(bh)) {
 250                 ext4_read_bh_lock(bh, REQ_RAHEAD, false);
 251                 brelse(bh);
 252         }
 253 }
 254
 255 static int ext4_verify_csum_type(struct super_block *sb,
 256                                  struct ext4_super_block *es)
 257 {
 258         if (!ext4_has_feature_metadata_csum(sb))
 259                 return 1;
 260
 261         return es->s_checksum_type == EXT4_CRC32C_CHKSUM;
 262 }
 263
 264 static __le32 ext4_superblock_csum(struct super_block *sb,
 265                                    struct ext4_super_block *es)
 266 {
 267         struct ext4_sb_info *sbi = EXT4_SB(sb);
 268         int offset = offsetof(struct ext4_super_block, s_checksum);
 269         __u32 csum;
 270
 271         csum = ext4_chksum(sbi, ~0, (char *)es, offset);
 272
 273         return cpu_to_le32(csum);
 274 }
 275
 276 static int ext4_superblock_csum_verify(struct super_block *sb,
 277                                        struct ext4_super_block *es)
 278 {
 279         if (!ext4_has_metadata_csum(sb))
 280                 return 1;
 281
 282         return es->s_checksum == ext4_superblock_csum(sb, es);
 283 }
 284
 285 void ext4_superblock_csum_set(struct super_block *sb)
 286 {
 287         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
 288
 289         if (!ext4_has_metadata_csum(sb))
 290                 return;
 291
 292         es->s_checksum = ext4_superblock_csum(sb, es);
 293 }
 294
 295 ext4_fsblk_t ext4_block_bitmap(struct super_block *sb,
 296                                struct ext4_group_desc *bg)
 297 {
 298         return le32_to_cpu(bg->bg_block_bitmap_lo) |
 299                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 300                  (ext4_fsblk_t)le32_to_cpu(bg->bg_block_bitmap_hi) << 32 : 0);
 301 }
 302
 303 ext4_fsblk_t ext4_inode_bitmap(struct super_block *sb,
 304                                struct ext4_group_desc *bg)
 305 {
 306         return le32_to_cpu(bg->bg_inode_bitmap_lo) |
 307                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 308                  (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_bitmap_hi) << 32 : 0);
 309 }
 310
 311 ext4_fsblk_t ext4_inode_table(struct super_block *sb,
 312                               struct ext4_group_desc *bg)
 313 {
 314         return le32_to_cpu(bg->bg_inode_table_lo) |
 315                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 316                  (ext4_fsblk_t)le32_to_cpu(bg->bg_inode_table_hi) << 32 : 0);
 317 }
 318
 319 __u32 ext4_free_group_clusters(struct super_block *sb,
 320                                struct ext4_group_desc *bg)
 321 {
 322         return le16_to_cpu(bg->bg_free_blocks_count_lo) |
 323                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 324                  (__u32)le16_to_cpu(bg->bg_free_blocks_count_hi) << 16 : 0);
 325 }
 326
 327 __u32 ext4_free_inodes_count(struct super_block *sb,
 328                               struct ext4_group_desc *bg)
 329 {
 330         return le16_to_cpu(bg->bg_free_inodes_count_lo) |
 331                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 332                  (__u32)le16_to_cpu(bg->bg_free_inodes_count_hi) << 16 : 0);
 333 }
 334
 335 __u32 ext4_used_dirs_count(struct super_block *sb,
 336                               struct ext4_group_desc *bg)
 337 {
 338         return le16_to_cpu(bg->bg_used_dirs_count_lo) |
 339                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 340                  (__u32)le16_to_cpu(bg->bg_used_dirs_count_hi) << 16 : 0);
 341 }
 342
 343 __u32 ext4_itable_unused_count(struct super_block *sb,
 344                               struct ext4_group_desc *bg)
 345 {
 346         return le16_to_cpu(bg->bg_itable_unused_lo) |
 347                 (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT ?
 348                  (__u32)le16_to_cpu(bg->bg_itable_unused_hi) << 16 : 0);
 349 }
 350
 351 void ext4_block_bitmap_set(struct super_block *sb,
 352                            struct ext4_group_desc *bg, ext4_fsblk_t blk)
 353 {
 354         bg->bg_block_bitmap_lo = cpu_to_le32((u32)blk);
 355         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 356                 bg->bg_block_bitmap_hi = cpu_to_le32(blk >> 32);
 357 }
 358
 359 void ext4_inode_bitmap_set(struct super_block *sb,
 360                            struct ext4_group_desc *bg, ext4_fsblk_t blk)
 361 {
 362         bg->bg_inode_bitmap_lo  = cpu_to_le32((u32)blk);
 363         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 364                 bg->bg_inode_bitmap_hi = cpu_to_le32(blk >> 32);
 365 }
 366
 367 void ext4_inode_table_set(struct super_block *sb,
 368                           struct ext4_group_desc *bg, ext4_fsblk_t blk)
 369 {
 370         bg->bg_inode_table_lo = cpu_to_le32((u32)blk);
 371         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 372                 bg->bg_inode_table_hi = cpu_to_le32(blk >> 32);
 373 }
 374
 375 void ext4_free_group_clusters_set(struct super_block *sb,
 376                                   struct ext4_group_desc *bg, __u32 count)
 377 {
 378         bg->bg_free_blocks_count_lo = cpu_to_le16((__u16)count);
 379         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 380                 bg->bg_free_blocks_count_hi = cpu_to_le16(count >> 16);
 381 }
 382
 383 void ext4_free_inodes_set(struct super_block *sb,
 384                           struct ext4_group_desc *bg, __u32 count)
 385 {
 386         bg->bg_free_inodes_count_lo = cpu_to_le16((__u16)count);
 387         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 388                 bg->bg_free_inodes_count_hi = cpu_to_le16(count >> 16);
 389 }
 390
 391 void ext4_used_dirs_set(struct super_block *sb,
 392                           struct ext4_group_desc *bg, __u32 count)
 393 {
 394         bg->bg_used_dirs_count_lo = cpu_to_le16((__u16)count);
 395         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 396                 bg->bg_used_dirs_count_hi = cpu_to_le16(count >> 16);
 397 }
 398
 399 void ext4_itable_unused_set(struct super_block *sb,
 400                           struct ext4_group_desc *bg, __u32 count)
 401 {
 402         bg->bg_itable_unused_lo = cpu_to_le16((__u16)count);
 403         if (EXT4_DESC_SIZE(sb) >= EXT4_MIN_DESC_SIZE_64BIT)
 404                 bg->bg_itable_unused_hi = cpu_to_le16(count >> 16);
 405 }
 406
 407 static void __ext4_update_tstamp(__le32 *lo, __u8 *hi, time64_t now)
 408 {
 409         now = clamp_val(now, 0, (1ull << 40) - 1);
 410
 411         *lo = cpu_to_le32(lower_32_bits(now));
 412         *hi = upper_32_bits(now);
 413 }
 414
 415 static time64_t __ext4_get_tstamp(__le32 *lo, __u8 *hi)
 416 {
 417         return ((time64_t)(*hi) << 32) + le32_to_cpu(*lo);
 418 }
 419 #define ext4_update_tstamp(es, tstamp) \
 420         __ext4_update_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi, \
 421                              ktime_get_real_seconds())
 422 #define ext4_get_tstamp(es, tstamp) \
 423         __ext4_get_tstamp(&(es)->tstamp, &(es)->tstamp ## _hi)
 424
 425 /*
 426  * The del_gendisk() function uninitializes the disk-specific data
 427  * structures, including the bdi structure, without telling anyone
 428  * else.  Once this happens, any attempt to call mark_buffer_dirty()
 429  * (for example, by ext4_commit_super), will cause a kernel OOPS.
 430  * This is a kludge to prevent these oops until we can put in a proper
 431  * hook in del_gendisk() to inform the VFS and file system layers.
 432  */
 433 static int block_device_ejected(struct super_block *sb)
 434 {
 435         struct inode *bd_inode = sb->s_bdev->bd_inode;
 436         struct backing_dev_info *bdi = inode_to_bdi(bd_inode);
 437
 438         return bdi->dev == NULL;
 439 }
 440
 441 static void ext4_journal_commit_callback(journal_t *journal, transaction_t *txn)
 442 {
 443         struct super_block              *sb = journal->j_private;
 444         struct ext4_sb_info             *sbi = EXT4_SB(sb);
 445         int                             error = is_journal_aborted(journal);
 446         struct ext4_journal_cb_entry    *jce;
 447
 448         BUG_ON(txn->t_state == T_FINISHED);
 449
 450         ext4_process_freed_data(sb, txn->t_tid);
 451
 452         spin_lock(&sbi->s_md_lock);
 453         while (!list_empty(&txn->t_private_list)) {
 454                 jce = list_entry(txn->t_private_list.next,
 455                                  struct ext4_journal_cb_entry, jce_list);
 456                 list_del_init(&jce->jce_list);
 457                 spin_unlock(&sbi->s_md_lock);
 458                 jce->jce_func(sb, jce, error);
 459                 spin_lock(&sbi->s_md_lock);
 460         }
 461         spin_unlock(&sbi->s_md_lock);
 462 }
 463
 464 /*
 465  * This writepage callback for write_cache_pages()
 466  * takes care of a few cases after page cleaning.
 467  *
 468  * write_cache_pages() already checks for dirty pages
 469  * and calls clear_page_dirty_for_io(), which we want,
 470  * to write protect the pages.
 471  *
 472  * However, we may have to redirty a page (see below.)
 473  */
 474 static int ext4_journalled_writepage_callback(struct page *page,
 475                                               struct writeback_control *wbc,
 476                                               void *data)
 477 {
 478         transaction_t *transaction = (transaction_t *) data;
 479         struct buffer_head *bh, *head;
 480         struct journal_head *jh;
 481
 482         bh = head = page_buffers(page);
 483         do {
 484                 /*
 485                  * We have to redirty a page in these cases:
 486                  * 1) If buffer is dirty, it means the page was dirty because it
 487                  * contains a buffer that needs checkpointing. So the dirty bit
 488                  * needs to be preserved so that checkpointing writes the buffer
 489                  * properly.
 490                  * 2) If buffer is not part of the committing transaction
 491                  * (we may have just accidentally come across this buffer because
 492                  * inode range tracking is not exact) or if the currently running
 493                  * transaction already contains this buffer as well, dirty bit
 494                  * needs to be preserved so that the buffer gets writeprotected
 495                  * properly on running transaction's commit.
 496                  */
 497                 jh = bh2jh(bh);
 498                 if (buffer_dirty(bh) ||
 499                     (jh && (jh->b_transaction != transaction ||
 500                             jh->b_next_transaction))) {
 501                         redirty_page_for_writepage(wbc, page);
 502                         goto out;
 503                 }
 504         } while ((bh = bh->b_this_page) != head);
 505
 506 out:
 507         return AOP_WRITEPAGE_ACTIVATE;
 508 }
 509
 510 static int ext4_journalled_submit_inode_data_buffers(struct jbd2_inode *jinode)
 511 {
 512         struct address_space *mapping = jinode->i_vfs_inode->i_mapping;
 513         struct writeback_control wbc = {
 514                 .sync_mode =  WB_SYNC_ALL,
 515                 .nr_to_write = LONG_MAX,
 516                 .range_start = jinode->i_dirty_start,
 517                 .range_end = jinode->i_dirty_end,
 518         };
 519
 520         return write_cache_pages(mapping, &wbc,
 521                                  ext4_journalled_writepage_callback,
 522                                  jinode->i_transaction);
 523 }
 524
 525 static int ext4_journal_submit_inode_data_buffers(struct jbd2_inode *jinode)
 526 {
 527         int ret;
 528
 529         if (ext4_should_journal_data(jinode->i_vfs_inode))
 530                 ret = ext4_journalled_submit_inode_data_buffers(jinode);
 531         else
 532                 ret = jbd2_journal_submit_inode_data_buffers(jinode);
 533
 534         return ret;
 535 }
 536
 537 static int ext4_journal_finish_inode_data_buffers(struct jbd2_inode *jinode)
 538 {
 539         int ret = 0;
 540
 541         if (!ext4_should_journal_data(jinode->i_vfs_inode))
 542                 ret = jbd2_journal_finish_inode_data_buffers(jinode);
 543
 544         return ret;
 545 }
 546
 547 static bool system_going_down(void)
 548 {
 549         return system_state == SYSTEM_HALT || system_state == SYSTEM_POWER_OFF
 550                 || system_state == SYSTEM_RESTART;
 551 }
 552
 553 struct ext4_err_translation {
 554         int code;
 555         int errno;
 556 };
 557
 558 #define EXT4_ERR_TRANSLATE(err) { .code = EXT4_ERR_##err, .errno = err }
 559
 560 static struct ext4_err_translation err_translation[] = {
 561         EXT4_ERR_TRANSLATE(EIO),
 562         EXT4_ERR_TRANSLATE(ENOMEM),
 563         EXT4_ERR_TRANSLATE(EFSBADCRC),
 564         EXT4_ERR_TRANSLATE(EFSCORRUPTED),
 565         EXT4_ERR_TRANSLATE(ENOSPC),
 566         EXT4_ERR_TRANSLATE(ENOKEY),
 567         EXT4_ERR_TRANSLATE(EROFS),
 568         EXT4_ERR_TRANSLATE(EFBIG),
 569         EXT4_ERR_TRANSLATE(EEXIST),
 570         EXT4_ERR_TRANSLATE(ERANGE),
 571         EXT4_ERR_TRANSLATE(EOVERFLOW),
 572         EXT4_ERR_TRANSLATE(EBUSY),
 573         EXT4_ERR_TRANSLATE(ENOTDIR),
 574         EXT4_ERR_TRANSLATE(ENOTEMPTY),
 575         EXT4_ERR_TRANSLATE(ESHUTDOWN),
 576         EXT4_ERR_TRANSLATE(EFAULT),
 577 };
 578
 579 static int ext4_errno_to_code(int errno)
 580 {
 581         int i;
 582
 583         for (i = 0; i < ARRAY_SIZE(err_translation); i++)
 584                 if (err_translation[i].errno == errno)
 585                         return err_translation[i].code;
 586         return EXT4_ERR_UNKNOWN;
 587 }
 588
 589 static void __save_error_info(struct super_block *sb, int error,
 590                               __u32 ino, __u64 block,
 591                               const char *func, unsigned int line)
 592 {
 593         struct ext4_sb_info *sbi = EXT4_SB(sb);
 594
 595         EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
 596         if (bdev_read_only(sb->s_bdev))
 597                 return;
 598         /* We default to EFSCORRUPTED error... */
 599         if (error == 0)
 600                 error = EFSCORRUPTED;
 601
 602         spin_lock(&sbi->s_error_lock);
 603         sbi->s_add_error_count++;
 604         sbi->s_last_error_code = error;
 605         sbi->s_last_error_line = line;
 606         sbi->s_last_error_ino = ino;
 607         sbi->s_last_error_block = block;
 608         sbi->s_last_error_func = func;
 609         sbi->s_last_error_time = ktime_get_real_seconds();
 610         if (!sbi->s_first_error_time) {
 611                 sbi->s_first_error_code = error;
 612                 sbi->s_first_error_line = line;
 613                 sbi->s_first_error_ino = ino;
 614                 sbi->s_first_error_block = block;
 615                 sbi->s_first_error_func = func;
 616                 sbi->s_first_error_time = sbi->s_last_error_time;
 617         }
 618         spin_unlock(&sbi->s_error_lock);
 619 }
 620
 621 static void save_error_info(struct super_block *sb, int error,
 622                             __u32 ino, __u64 block,
 623                             const char *func, unsigned int line)
 624 {
 625         __save_error_info(sb, error, ino, block, func, line);
 626         if (!bdev_read_only(sb->s_bdev))
 627                 ext4_commit_super(sb, 1);
 628 }
 629
 630 /* Deal with the reporting of failure conditions on a filesystem such as
 631  * inconsistencies detected or read IO failures.
 632  *
 633  * On ext2, we can store the error state of the filesystem in the
 634  * superblock.  That is not possible on ext4, because we may have other
 635  * write ordering constraints on the superblock which prevent us from
 636  * writing it out straight away; and given that the journal is about to
 637  * be aborted, we can't rely on the current, or future, transactions to
 638  * write out the superblock safely.
 639  *
 640  * We'll just use the jbd2_journal_abort() error code to record an error in
 641  * the journal instead.  On recovery, the journal will complain about
 642  * that error until we've noted it down and cleared it.
 643  *
 644  * If force_ro is set, we unconditionally force the filesystem into an
 645  * ABORT|READONLY state, unless the error response on the fs has been set to
 646  * panic in which case we take the easy way out and panic immediately. This is
 647  * used to deal with unrecoverable failures such as journal IO errors or ENOMEM
 648  * at a critical moment in log management.
 649  */
 650 static void ext4_handle_error(struct super_block *sb, bool force_ro)
 651 {
 652         journal_t *journal = EXT4_SB(sb)->s_journal;
 653
 654         if (test_opt(sb, WARN_ON_ERROR))
 655                 WARN_ON_ONCE(1);
 656
 657         if (sb_rdonly(sb) || (!force_ro && test_opt(sb, ERRORS_CONT)))
 658                 return;
 659
 660         ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
 661         if (journal)
 662                 jbd2_journal_abort(journal, -EIO);
 663         /*
 664          * We force ERRORS_RO behavior when system is rebooting. Otherwise we
 665          * could panic during 'reboot -f' as the underlying device got already
 666          * disabled.
 667          */
 668         if (test_opt(sb, ERRORS_PANIC) && !system_going_down()) {
 669                 panic("EXT4-fs (device %s): panic forced after error\n",
 670                         sb->s_id);
 671         }
 672         ext4_msg(sb, KERN_CRIT, "Remounting filesystem read-only");
 673         /*
 674          * Make sure updated value of ->s_mount_flags will be visible before
 675          * ->s_flags update
 676          */
 677         smp_wmb();
 678         sb->s_flags |= SB_RDONLY;
 679 }
 680
 681 static void flush_stashed_error_work(struct work_struct *work)
 682 {
 683         struct ext4_sb_info *sbi = container_of(work, struct ext4_sb_info,
 684                                                 s_error_work);
 685
 686         ext4_commit_super(sbi->s_sb, 1);
 687 }
 688
 689 #define ext4_error_ratelimit(sb)                                        \
 690                 ___ratelimit(&(EXT4_SB(sb)->s_err_ratelimit_state),     \
 691                              "EXT4-fs error")
 692
 693 void __ext4_error(struct super_block *sb, const char *function,
 694                   unsigned int line, bool force_ro, int error, __u64 block,
 695                   const char *fmt, ...)
 696 {
 697         struct va_format vaf;
 698         va_list args;
 699
 700         if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
 701                 return;
 702
 703         trace_ext4_error(sb, function, line);
 704         if (ext4_error_ratelimit(sb)) {
 705                 va_start(args, fmt);
 706                 vaf.fmt = fmt;
 707                 vaf.va = &args;
 708                 printk(KERN_CRIT
 709                        "EXT4-fs error (device %s): %s:%d: comm %s: %pV\n",
 710                        sb->s_id, function, line, current->comm, &vaf);
 711                 va_end(args);
 712         }
 713         save_error_info(sb, error, 0, block, function, line);
 714         ext4_handle_error(sb, force_ro);
 715 }
 716
 717 void __ext4_error_inode(struct inode *inode, const char *function,
 718                         unsigned int line, ext4_fsblk_t block, int error,
 719                         const char *fmt, ...)
 720 {
 721         va_list args;
 722         struct va_format vaf;
 723
 724         if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
 725                 return;
 726
 727         trace_ext4_error(inode->i_sb, function, line);
 728         if (ext4_error_ratelimit(inode->i_sb)) {
 729                 va_start(args, fmt);
 730                 vaf.fmt = fmt;
 731                 vaf.va = &args;
 732                 if (block)
 733                         printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
 734                                "inode #%lu: block %llu: comm %s: %pV\n",
 735                                inode->i_sb->s_id, function, line, inode->i_ino,
 736                                block, current->comm, &vaf);
 737                 else
 738                         printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
 739                                "inode #%lu: comm %s: %pV\n",
 740                                inode->i_sb->s_id, function, line, inode->i_ino,
 741                                current->comm, &vaf);
 742                 va_end(args);
 743         }
 744         save_error_info(inode->i_sb, error, inode->i_ino, block,
 745                         function, line);
 746         ext4_handle_error(inode->i_sb, false);
 747 }
 748
 749 void __ext4_error_file(struct file *file, const char *function,
 750                        unsigned int line, ext4_fsblk_t block,
 751                        const char *fmt, ...)
 752 {
 753         va_list args;
 754         struct va_format vaf;
 755         struct inode *inode = file_inode(file);
 756         char pathname[80], *path;
 757
 758         if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
 759                 return;
 760
 761         trace_ext4_error(inode->i_sb, function, line);
 762         if (ext4_error_ratelimit(inode->i_sb)) {
 763                 path = file_path(file, pathname, sizeof(pathname));
 764                 if (IS_ERR(path))
 765                         path = "(unknown)";
 766                 va_start(args, fmt);
 767                 vaf.fmt = fmt;
 768                 vaf.va = &args;
 769                 if (block)
 770                         printk(KERN_CRIT
 771                                "EXT4-fs error (device %s): %s:%d: inode #%lu: "
 772                                "block %llu: comm %s: path %s: %pV\n",
 773                                inode->i_sb->s_id, function, line, inode->i_ino,
 774                                block, current->comm, path, &vaf);
 775                 else
 776                         printk(KERN_CRIT
 777                                "EXT4-fs error (device %s): %s:%d: inode #%lu: "
 778                                "comm %s: path %s: %pV\n",
 779                                inode->i_sb->s_id, function, line, inode->i_ino,
 780                                current->comm, path, &vaf);
 781                 va_end(args);
 782         }
 783         save_error_info(inode->i_sb, EFSCORRUPTED, inode->i_ino, block,
 784                         function, line);
 785         ext4_handle_error(inode->i_sb, false);
 786 }
 787
 788 const char *ext4_decode_error(struct super_block *sb, int errno,
 789                               char nbuf[16])
 790 {
 791         char *errstr = NULL;
 792
 793         switch (errno) {
 794         case -EFSCORRUPTED:
 795                 errstr = "Corrupt filesystem";
 796                 break;
 797         case -EFSBADCRC:
 798                 errstr = "Filesystem failed CRC";
 799                 break;
 800         case -EIO:
 801                 errstr = "IO failure";
 802                 break;
 803         case -ENOMEM:
 804                 errstr = "Out of memory";
 805                 break;
 806         case -EROFS:
 807                 if (!sb || (EXT4_SB(sb)->s_journal &&
 808                             EXT4_SB(sb)->s_journal->j_flags & JBD2_ABORT))
 809                         errstr = "Journal has aborted";
 810                 else
 811                         errstr = "Readonly filesystem";
 812                 break;
 813         default:
 814                 /* If the caller passed in an extra buffer for unknown
 815                  * errors, textualise them now.  Else we just return
 816                  * NULL. */
 817                 if (nbuf) {
 818                         /* Check for truncated error codes... */
 819                         if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
 820                                 errstr = nbuf;
 821                 }
 822                 break;
 823         }
 824
 825         return errstr;
 826 }
 827
 828 /* __ext4_std_error decodes expected errors from journaling functions
 829  * automatically and invokes the appropriate error response.  */
 830
 831 void __ext4_std_error(struct super_block *sb, const char *function,
 832                       unsigned int line, int errno)
 833 {
 834         char nbuf[16];
 835         const char *errstr;
 836
 837         if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
 838                 return;
 839
 840         /* Special case: if the error is EROFS, and we're not already
 841          * inside a transaction, then there's really no point in logging
 842          * an error. */
 843         if (errno == -EROFS && journal_current_handle() == NULL && sb_rdonly(sb))
 844                 return;
 845
 846         if (ext4_error_ratelimit(sb)) {
 847                 errstr = ext4_decode_error(sb, errno, nbuf);
 848                 printk(KERN_CRIT "EXT4-fs error (device %s) in %s:%d: %s\n",
 849                        sb->s_id, function, line, errstr);
 850         }
 851
 852         save_error_info(sb, -errno, 0, 0, function, line);
 853         ext4_handle_error(sb, false);
 854 }
 855
 856 void __ext4_msg(struct super_block *sb,
 857                 const char *prefix, const char *fmt, ...)
 858 {
 859         struct va_format vaf;
 860         va_list args;
 861
 862         atomic_inc(&EXT4_SB(sb)->s_msg_count);
 863         if (!___ratelimit(&(EXT4_SB(sb)->s_msg_ratelimit_state), "EXT4-fs"))
 864                 return;
 865
 866         va_start(args, fmt);
 867         vaf.fmt = fmt;
 868         vaf.va = &args;
 869         printk("%sEXT4-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
 870         va_end(args);
 871 }
 872
 873 static int ext4_warning_ratelimit(struct super_block *sb)
 874 {
 875         atomic_inc(&EXT4_SB(sb)->s_warning_count);
 876         return ___ratelimit(&(EXT4_SB(sb)->s_warning_ratelimit_state),
 877                             "EXT4-fs warning");
 878 }
 879
 880 void __ext4_warning(struct super_block *sb, const char *function,
 881                     unsigned int line, const char *fmt, ...)
 882 {
 883         struct va_format vaf;
 884         va_list args;
 885
 886         if (!ext4_warning_ratelimit(sb))
 887                 return;
 888
 889         va_start(args, fmt);
 890         vaf.fmt = fmt;
 891         vaf.va = &args;
 892         printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: %pV\n",
 893                sb->s_id, function, line, &vaf);
 894         va_end(args);
 895 }
 896
 897 void __ext4_warning_inode(const struct inode *inode, const char *function,
 898                           unsigned int line, const char *fmt, ...)
 899 {
 900         struct va_format vaf;
 901         va_list args;
 902
 903         if (!ext4_warning_ratelimit(inode->i_sb))
 904                 return;
 905
 906         va_start(args, fmt);
 907         vaf.fmt = fmt;
 908         vaf.va = &args;
 909         printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: "
 910                "inode #%lu: comm %s: %pV\n", inode->i_sb->s_id,
 911                function, line, inode->i_ino, current->comm, &vaf);
 912         va_end(args);
 913 }
 914
 915 void __ext4_grp_locked_error(const char *function, unsigned int line,
 916                              struct super_block *sb, ext4_group_t grp,
 917                              unsigned long ino, ext4_fsblk_t block,
 918                              const char *fmt, ...)
 919 __releases(bitlock)
 920 __acquires(bitlock)
 921 {
 922         struct va_format vaf;
 923         va_list args;
 924
 925         if (unlikely(ext4_forced_shutdown(EXT4_SB(sb))))
 926                 return;
 927
 928         trace_ext4_error(sb, function, line);
 929         if (ext4_error_ratelimit(sb)) {
 930                 va_start(args, fmt);
 931                 vaf.fmt = fmt;
 932                 vaf.va = &args;
 933                 printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u, ",
 934                        sb->s_id, function, line, grp);
 935                 if (ino)
 936                         printk(KERN_CONT "inode %lu: ", ino);
 937                 if (block)
 938                         printk(KERN_CONT "block %llu:",
 939                                (unsigned long long) block);
 940                 printk(KERN_CONT "%pV\n", &vaf);
 941                 va_end(args);
 942         }
 943
 944         if (test_opt(sb, ERRORS_CONT)) {
 945                 if (test_opt(sb, WARN_ON_ERROR))
 946                         WARN_ON_ONCE(1);
 947                 __save_error_info(sb, EFSCORRUPTED, ino, block, function, line);
 948                 schedule_work(&EXT4_SB(sb)->s_error_work);
 949                 return;
 950         }
 951         ext4_unlock_group(sb, grp);
 952         save_error_info(sb, EFSCORRUPTED, ino, block, function, line);
 953         ext4_handle_error(sb, false);
 954         /*
 955          * We only get here in the ERRORS_RO case; relocking the group
 956          * may be dangerous, but nothing bad will happen since the
 957          * filesystem will have already been marked read/only and the
 958          * journal has been aborted.  We return 1 as a hint to callers
 959          * who might what to use the return value from
 960          * ext4_grp_locked_error() to distinguish between the
 961          * ERRORS_CONT and ERRORS_RO case, and perhaps return more
 962          * aggressively from the ext4 function in question, with a
 963          * more appropriate error code.
 964          */
 965         ext4_lock_group(sb, grp);
 966         return;
 967 }
 968
 969 void ext4_mark_group_bitmap_corrupted(struct super_block *sb,
 970                                      ext4_group_t group,
 971                                      unsigned int flags)
 972 {
 973         struct ext4_sb_info *sbi = EXT4_SB(sb);
 974         struct ext4_group_info *grp = ext4_get_group_info(sb, group);
 975         struct ext4_group_desc *gdp = ext4_get_group_desc(sb, group, NULL);
 976         int ret;
 977
 978         if (flags & EXT4_GROUP_INFO_BBITMAP_CORRUPT) {
 979                 ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
 980                                             &grp->bb_state);
 981                 if (!ret)
 982                         percpu_counter_sub(&sbi->s_freeclusters_counter,
 983                                            grp->bb_free);
 984         }
 985
 986         if (flags & EXT4_GROUP_INFO_IBITMAP_CORRUPT) {
 987                 ret = ext4_test_and_set_bit(EXT4_GROUP_INFO_IBITMAP_CORRUPT_BIT,
 988                                             &grp->bb_state);
 989                 if (!ret && gdp) {
 990                         int count;
 991
 992                         count = ext4_free_inodes_count(sb, gdp);
 993                         percpu_counter_sub(&sbi->s_freeinodes_counter,
 994                                            count);
 995                 }
 996         }
 997 }
 998
 999 void ext4_update_dynamic_rev(struct super_block *sb)
1000 {
1001         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
1002
1003         if (le32_to_cpu(es->s_rev_level) > EXT4_GOOD_OLD_REV)
1004                 return;
1005
1006         ext4_warning(sb,
1007                      "updating to rev %d because of new feature flag, "
1008                      "running e2fsck is recommended",
1009                      EXT4_DYNAMIC_REV);
1010
1011         es->s_first_ino = cpu_to_le32(EXT4_GOOD_OLD_FIRST_INO);
1012         es->s_inode_size = cpu_to_le16(EXT4_GOOD_OLD_INODE_SIZE);
1013         es->s_rev_level = cpu_to_le32(EXT4_DYNAMIC_REV);
1014         /* leave es->s_feature_*compat flags alone */
1015         /* es->s_uuid will be set by e2fsck if empty */
1016
1017         /*
1018          * The rest of the superblock fields should be zero, and if not it
1019          * means they are likely already in use, so leave them alone.  We
1020          * can leave it up to e2fsck to clean up any inconsistencies there.
1021          */
1022 }
1023
1024 /*
1025  * Open the external journal device
1026  */
1027 static struct block_device *ext4_blkdev_get(dev_t dev, struct super_block *sb)
1028 {
1029         struct block_device *bdev;
1030
1031         bdev = blkdev_get_by_dev(dev, FMODE_READ|FMODE_WRITE|FMODE_EXCL, sb);
1032         if (IS_ERR(bdev))
1033                 goto fail;
1034         return bdev;
1035
1036 fail:
1037         ext4_msg(sb, KERN_ERR,
1038                  "failed to open journal device unknown-block(%u,%u) %ld",
1039                  MAJOR(dev), MINOR(dev), PTR_ERR(bdev));
1040         return NULL;
1041 }
1042
1043 /*
1044  * Release the journal device
1045  */
1046 static void ext4_blkdev_put(struct block_device *bdev)
1047 {
1048         blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
1049 }
1050
1051 static void ext4_blkdev_remove(struct ext4_sb_info *sbi)
1052 {
1053         struct block_device *bdev;
1054         bdev = sbi->s_journal_bdev;
1055         if (bdev) {
1056                 ext4_blkdev_put(bdev);
1057                 sbi->s_journal_bdev = NULL;
1058         }
1059 }
1060
1061 static inline struct inode *orphan_list_entry(struct list_head *l)
1062 {
1063         return &list_entry(l, struct ext4_inode_info, i_orphan)->vfs_inode;
1064 }
1065
1066 static void dump_orphan_list(struct super_block *sb, struct ext4_sb_info *sbi)
1067 {
1068         struct list_head *l;
1069
1070         ext4_msg(sb, KERN_ERR, "sb orphan head is %d",
1071                  le32_to_cpu(sbi->s_es->s_last_orphan));
1072
1073         printk(KERN_ERR "sb_info orphan list:\n");
1074         list_for_each(l, &sbi->s_orphan) {
1075                 struct inode *inode = orphan_list_entry(l);
1076                 printk(KERN_ERR "  "
1077                        "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
1078                        inode->i_sb->s_id, inode->i_ino, inode,
1079                        inode->i_mode, inode->i_nlink,
1080                        NEXT_ORPHAN(inode));
1081         }
1082 }
1083
1084 #ifdef CONFIG_QUOTA
1085 static int ext4_quota_off(struct super_block *sb, int type);
1086
1087 static inline void ext4_quota_off_umount(struct super_block *sb)
1088 {
1089         int type;
1090
1091         /* Use our quota_off function to clear inode flags etc. */
1092         for (type = 0; type < EXT4_MAXQUOTAS; type++)
1093                 ext4_quota_off(sb, type);
1094 }
1095
1096 /*
1097  * This is a helper function which is used in the mount/remount
1098  * codepaths (which holds s_umount) to fetch the quota file name.
1099  */
1100 static inline char *get_qf_name(struct super_block *sb,
1101                                 struct ext4_sb_info *sbi,
1102                                 int type)
1103 {
1104         return rcu_dereference_protected(sbi->s_qf_names[type],
1105                                          lockdep_is_held(&sb->s_umount));
1106 }
1107 #else
1108 static inline void ext4_quota_off_umount(struct super_block *sb)
1109 {
1110 }
1111 #endif
1112
1113 static void ext4_put_super(struct super_block *sb)
1114 {
1115         struct ext4_sb_info *sbi = EXT4_SB(sb);
1116         struct ext4_super_block *es = sbi->s_es;
1117         struct buffer_head **group_desc;
1118         struct flex_groups **flex_groups;
1119         int aborted = 0;
1120         int i, err;
1121
1122         ext4_unregister_li_request(sb);
1123         ext4_quota_off_umount(sb);
1124
1125         flush_work(&sbi->s_error_work);
1126         destroy_workqueue(sbi->rsv_conversion_wq);
1127
1128         /*
1129          * Unregister sysfs before destroying jbd2 journal.
1130          * Since we could still access attr_journal_task attribute via sysfs
1131          * path which could have sbi->s_journal->j_task as NULL
1132          */
1133         ext4_unregister_sysfs(sb);
1134
1135         if (sbi->s_journal) {
1136                 aborted = is_journal_aborted(sbi->s_journal);
1137                 err = jbd2_journal_destroy(sbi->s_journal);
1138                 sbi->s_journal = NULL;
1139                 if ((err < 0) && !aborted) {
1140                         ext4_abort(sb, -err, "Couldn't clean up the journal");
1141                 }
1142         }
1143
1144         ext4_es_unregister_shrinker(sbi);
1145         del_timer_sync(&sbi->s_err_report);
1146         ext4_release_system_zone(sb);
1147         ext4_mb_release(sb);
1148         ext4_ext_release(sb);
1149
1150         if (!sb_rdonly(sb) && !aborted) {
1151                 ext4_clear_feature_journal_needs_recovery(sb);
1152                 es->s_state = cpu_to_le16(sbi->s_mount_state);
1153         }
1154         if (!sb_rdonly(sb))
1155                 ext4_commit_super(sb, 1);
1156
1157         rcu_read_lock();
1158         group_desc = rcu_dereference(sbi->s_group_desc);
1159         for (i = 0; i < sbi->s_gdb_count; i++)
1160                 brelse(group_desc[i]);
1161         kvfree(group_desc);
1162         flex_groups = rcu_dereference(sbi->s_flex_groups);
1163         if (flex_groups) {
1164                 for (i = 0; i < sbi->s_flex_groups_allocated; i++)
1165                         kvfree(flex_groups[i]);
1166                 kvfree(flex_groups);
1167         }
1168         rcu_read_unlock();
1169         percpu_counter_destroy(&sbi->s_freeclusters_counter);
1170         percpu_counter_destroy(&sbi->s_freeinodes_counter);
1171         percpu_counter_destroy(&sbi->s_dirs_counter);
1172         percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
1173         percpu_free_rwsem(&sbi->s_writepages_rwsem);
1174 #ifdef CONFIG_QUOTA
1175         for (i = 0; i < EXT4_MAXQUOTAS; i++)
1176                 kfree(get_qf_name(sb, sbi, i));
1177 #endif
1178
1179         /* Debugging code just in case the in-memory inode orphan list
1180          * isn't empty.  The on-disk one can be non-empty if we've
1181          * detected an error and taken the fs readonly, but the
1182          * in-memory list had better be clean by this point. */
1183         if (!list_empty(&sbi->s_orphan))
1184                 dump_orphan_list(sb, sbi);
1185         ASSERT(list_empty(&sbi->s_orphan));
1186
1187         sync_blockdev(sb->s_bdev);
1188         invalidate_bdev(sb->s_bdev);
1189         if (sbi->s_journal_bdev && sbi->s_journal_bdev != sb->s_bdev) {
1190                 /*
1191                  * Invalidate the journal device's buffers.  We don't want them
1192                  * floating about in memory - the physical journal device may
1193                  * hotswapped, and it breaks the `ro-after' testing code.
1194                  */
1195                 sync_blockdev(sbi->s_journal_bdev);
1196                 invalidate_bdev(sbi->s_journal_bdev);
1197                 ext4_blkdev_remove(sbi);
1198         }
1199
1200         ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
1201         sbi->s_ea_inode_cache = NULL;
1202
1203         ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
1204         sbi->s_ea_block_cache = NULL;
1205
1206         if (sbi->s_mmp_tsk)
1207                 kthread_stop(sbi->s_mmp_tsk);
1208         brelse(sbi->s_sbh);
1209         sb->s_fs_info = NULL;
1210         /*
1211          * Now that we are completely done shutting down the
1212          * superblock, we need to actually destroy the kobject.
1213          */
1214         kobject_put(&sbi->s_kobj);
1215         wait_for_completion(&sbi->s_kobj_unregister);
1216         if (sbi->s_chksum_driver)
1217                 crypto_free_shash(sbi->s_chksum_driver);
1218         kfree(sbi->s_blockgroup_lock);
1219         fs_put_dax(sbi->s_daxdev);
1220         fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
1221 #ifdef CONFIG_UNICODE
1222         utf8_unload(sb->s_encoding);
1223 #endif
1224         kfree(sbi);
1225 }
1226
1227 static struct kmem_cache *ext4_inode_cachep;
1228
1229 /*
1230  * Called inside transaction, so use GFP_NOFS
1231  */
1232 static struct inode *ext4_alloc_inode(struct super_block *sb)
1233 {
1234         struct ext4_inode_info *ei;
1235
1236         ei = kmem_cache_alloc(ext4_inode_cachep, GFP_NOFS);
1237         if (!ei)
1238                 return NULL;
1239
1240         inode_set_iversion(&ei->vfs_inode, 1);
1241         spin_lock_init(&ei->i_raw_lock);
1242         INIT_LIST_HEAD(&ei->i_prealloc_list);
1243         atomic_set(&ei->i_prealloc_active, 0);
1244         spin_lock_init(&ei->i_prealloc_lock);
1245         ext4_es_init_tree(&ei->i_es_tree);
1246         rwlock_init(&ei->i_es_lock);
1247         INIT_LIST_HEAD(&ei->i_es_list);
1248         ei->i_es_all_nr = 0;
1249         ei->i_es_shk_nr = 0;
1250         ei->i_es_shrink_lblk = 0;
1251         ei->i_reserved_data_blocks = 0;
1252         spin_lock_init(&(ei->i_block_reservation_lock));
1253         ext4_init_pending_tree(&ei->i_pending_tree);
1254 #ifdef CONFIG_QUOTA
1255         ei->i_reserved_quota = 0;
1256         memset(&ei->i_dquot, 0, sizeof(ei->i_dquot));
1257 #endif
1258         ei->jinode = NULL;
1259         INIT_LIST_HEAD(&ei->i_rsv_conversion_list);
1260         spin_lock_init(&ei->i_completed_io_lock);
1261         ei->i_sync_tid = 0;
1262         ei->i_datasync_tid = 0;
1263         atomic_set(&ei->i_unwritten, 0);
1264         INIT_WORK(&ei->i_rsv_conversion_work, ext4_end_io_rsv_work);
1265         ext4_fc_init_inode(&ei->vfs_inode);
1266         mutex_init(&ei->i_fc_lock);
1267         return &ei->vfs_inode;
1268 }
1269
1270 static int ext4_drop_inode(struct inode *inode)
1271 {
1272         int drop = generic_drop_inode(inode);
1273
1274         if (!drop)
1275                 drop = fscrypt_drop_inode(inode);
1276
1277         trace_ext4_drop_inode(inode, drop);
1278         return drop;
1279 }
1280
1281 static void ext4_free_in_core_inode(struct inode *inode)
1282 {
1283         fscrypt_free_inode(inode);
1284         if (!list_empty(&(EXT4_I(inode)->i_fc_list))) {
1285                 pr_warn("%s: inode %ld still in fc list",
1286                         __func__, inode->i_ino);
1287         }
1288         kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
1289 }
1290
1291 static void ext4_destroy_inode(struct inode *inode)
1292 {
1293         if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
1294                 ext4_msg(inode->i_sb, KERN_ERR,
1295                          "Inode %lu (%p): orphan list check failed!",
1296                          inode->i_ino, EXT4_I(inode));
1297                 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
1298                                 EXT4_I(inode), sizeof(struct ext4_inode_info),
1299                                 true);
1300                 dump_stack();
1301         }
1302 }
1303
1304 static void init_once(void *foo)
1305 {
1306         struct ext4_inode_info *ei = (struct ext4_inode_info *) foo;
1307
1308         INIT_LIST_HEAD(&ei->i_orphan);
1309         init_rwsem(&ei->xattr_sem);
1310         init_rwsem(&ei->i_data_sem);
1311         init_rwsem(&ei->i_mmap_sem);
1312         inode_init_once(&ei->vfs_inode);
1313         ext4_fc_init_inode(&ei->vfs_inode);
1314 }
1315
1316 static int __init init_inodecache(void)
1317 {
1318         ext4_inode_cachep = kmem_cache_create_usercopy("ext4_inode_cache",
1319                                 sizeof(struct ext4_inode_info), 0,
1320                                 (SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD|
1321                                         SLAB_ACCOUNT),
1322                                 offsetof(struct ext4_inode_info, i_data),
1323                                 sizeof_field(struct ext4_inode_info, i_data),
1324                                 init_once);
1325         if (ext4_inode_cachep == NULL)
1326                 return -ENOMEM;
1327         return 0;
1328 }
1329
1330 static void destroy_inodecache(void)
1331 {
1332         /*
1333          * Make sure all delayed rcu free inodes are flushed before we
1334          * destroy cache.
1335          */
1336         rcu_barrier();
1337         kmem_cache_destroy(ext4_inode_cachep);
1338 }
1339
1340 void ext4_clear_inode(struct inode *inode)
1341 {
1342         ext4_fc_del(inode);
1343         invalidate_inode_buffers(inode);
1344         clear_inode(inode);
1345         ext4_discard_preallocations(inode, 0);
1346         ext4_es_remove_extent(inode, 0, EXT_MAX_BLOCKS);
1347         dquot_drop(inode);
1348         if (EXT4_I(inode)->jinode) {
1349                 jbd2_journal_release_jbd_inode(EXT4_JOURNAL(inode),
1350                                                EXT4_I(inode)->jinode);
1351                 jbd2_free_inode(EXT4_I(inode)->jinode);
1352                 EXT4_I(inode)->jinode = NULL;
1353         }
1354         fscrypt_put_encryption_info(inode);
1355         fsverity_cleanup_inode(inode);
1356 }
1357
1358 static struct inode *ext4_nfs_get_inode(struct super_block *sb,
1359                                         u64 ino, u32 generation)
1360 {
1361         struct inode *inode;
1362
1363         /*
1364          * Currently we don't know the generation for parent directory, so
1365          * a generation of 0 means "accept any"
1366          */
1367         inode = ext4_iget(sb, ino, EXT4_IGET_HANDLE);
1368         if (IS_ERR(inode))
1369                 return ERR_CAST(inode);
1370         if (generation && inode->i_generation != generation) {
1371                 iput(inode);
1372                 return ERR_PTR(-ESTALE);
1373         }
1374
1375         return inode;
1376 }
1377
1378 static struct dentry *ext4_fh_to_dentry(struct super_block *sb, struct fid *fid,
1379                                         int fh_len, int fh_type)
1380 {
1381         return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
1382                                     ext4_nfs_get_inode);
1383 }
1384
1385 static struct dentry *ext4_fh_to_parent(struct super_block *sb, struct fid *fid,
1386                                         int fh_len, int fh_type)
1387 {
1388         return generic_fh_to_parent(sb, fid, fh_len, fh_type,
1389                                     ext4_nfs_get_inode);
1390 }
1391
1392 static int ext4_nfs_commit_metadata(struct inode *inode)
1393 {
1394         struct writeback_control wbc = {
1395                 .sync_mode = WB_SYNC_ALL
1396         };
1397
1398         trace_ext4_nfs_commit_metadata(inode);
1399         return ext4_write_inode(inode, &wbc);
1400 }
1401
1402 /*
1403  * Try to release metadata pages (indirect blocks, directories) which are
1404  * mapped via the block device.  Since these pages could have journal heads
1405  * which would prevent try_to_free_buffers() from freeing them, we must use
1406  * jbd2 layer's try_to_free_buffers() function to release them.
1407  */
1408 static int bdev_try_to_free_page(struct super_block *sb, struct page *page,
1409                                  gfp_t wait)
1410 {
1411         journal_t *journal = EXT4_SB(sb)->s_journal;
1412
1413         WARN_ON(PageChecked(page));
1414         if (!page_has_buffers(page))
1415                 return 0;
1416         if (journal)
1417                 return jbd2_journal_try_to_free_buffers(journal, page);
1418
1419         return try_to_free_buffers(page);
1420 }
1421
1422 #ifdef CONFIG_FS_ENCRYPTION
1423 static int ext4_get_context(struct inode *inode, void *ctx, size_t len)
1424 {
1425         return ext4_xattr_get(inode, EXT4_XATTR_INDEX_ENCRYPTION,
1426                                  EXT4_XATTR_NAME_ENCRYPTION_CONTEXT, ctx, len);
1427 }
1428
1429 static int ext4_set_context(struct inode *inode, const void *ctx, size_t len,
1430                                                         void *fs_data)
1431 {
1432         handle_t *handle = fs_data;
1433         int res, res2, credits, retries = 0;
1434
1435         /*
1436          * Encrypting the root directory is not allowed because e2fsck expects
1437          * lost+found to exist and be unencrypted, and encrypting the root
1438          * directory would imply encrypting the lost+found directory as well as
1439          * the filename "lost+found" itself.
1440          */
1441         if (inode->i_ino == EXT4_ROOT_INO)
1442                 return -EPERM;
1443
1444         if (WARN_ON_ONCE(IS_DAX(inode) && i_size_read(inode)))
1445                 return -EINVAL;
1446
1447         if (ext4_test_inode_flag(inode, EXT4_INODE_DAX))
1448                 return -EOPNOTSUPP;
1449
1450         res = ext4_convert_inline_data(inode);
1451         if (res)
1452                 return res;
1453
1454         /*
1455          * If a journal handle was specified, then the encryption context is
1456          * being set on a new inode via inheritance and is part of a larger
1457          * transaction to create the inode.  Otherwise the encryption context is
1458          * being set on an existing inode in its own transaction.  Only in the
1459          * latter case should the "retry on ENOSPC" logic be used.
1460          */
1461
1462         if (handle) {
1463                 res = ext4_xattr_set_handle(handle, inode,
1464                                             EXT4_XATTR_INDEX_ENCRYPTION,
1465                                             EXT4_XATTR_NAME_ENCRYPTION_CONTEXT,
1466                                             ctx, len, 0);
1467                 if (!res) {
1468                         ext4_set_inode_flag(inode, EXT4_INODE_ENCRYPT);
1469                         ext4_clear_inode_state(inode,
1470                                         EXT4_STATE_MAY_INLINE_DATA);
1471                         /*
1472                          * Update inode->i_flags - S_ENCRYPTED will be enabled,
1473                          * S_DAX may be disabled
1474                          */
1475                         ext4_set_inode_flags(inode, false);
1476                 }
1477                 return res;
1478         }
1479
1480         res = dquot_initialize(inode);
1481         if (res)
1482                 return res;
1483 retry:
1484         res = ext4_xattr_set_credits(inode, len, false /* is_create */,
1485                                      &credits);
1486         if (res)
1487                 return res;
1488
1489         handle = ext4_journal_start(inode, EXT4_HT_MISC, credits);
1490         if (IS_ERR(handle))
1491                 return PTR_ERR(handle);
1492
1493         res = ext4_xattr_set_handle(handle, inode, EXT4_XATTR_INDEX_ENCRYPTION,
1494                                     EXT4_XATTR_NAME_ENCRYPTION_CONTEXT,
1495                                     ctx, len, 0);
1496         if (!res) {
1497                 ext4_set_inode_flag(inode, EXT4_INODE_ENCRYPT);
1498                 /*
1499                  * Update inode->i_flags - S_ENCRYPTED will be enabled,
1500                  * S_DAX may be disabled
1501                  */
1502                 ext4_set_inode_flags(inode, false);
1503                 res = ext4_mark_inode_dirty(handle, inode);
1504                 if (res)
1505                         EXT4_ERROR_INODE(inode, "Failed to mark inode dirty");
1506         }
1507         res2 = ext4_journal_stop(handle);
1508
1509         if (res == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
1510                 goto retry;
1511         if (!res)
1512                 res = res2;
1513         return res;
1514 }
1515
1516 static const union fscrypt_policy *ext4_get_dummy_policy(struct super_block *sb)
1517 {
1518         return EXT4_SB(sb)->s_dummy_enc_policy.policy;
1519 }
1520
1521 static bool ext4_has_stable_inodes(struct super_block *sb)
1522 {
1523         return ext4_has_feature_stable_inodes(sb);
1524 }
1525
1526 static void ext4_get_ino_and_lblk_bits(struct super_block *sb,
1527                                        int *ino_bits_ret, int *lblk_bits_ret)
1528 {
1529         *ino_bits_ret = 8 * sizeof(EXT4_SB(sb)->s_es->s_inodes_count);
1530         *lblk_bits_ret = 8 * sizeof(ext4_lblk_t);
1531 }
1532
1533 static const struct fscrypt_operations ext4_cryptops = {
1534         .key_prefix             = "ext4:",
1535         .get_context            = ext4_get_context,
1536         .set_context            = ext4_set_context,
1537         .get_dummy_policy       = ext4_get_dummy_policy,
1538         .empty_dir              = ext4_empty_dir,
1539         .max_namelen            = EXT4_NAME_LEN,
1540         .has_stable_inodes      = ext4_has_stable_inodes,
1541         .get_ino_and_lblk_bits  = ext4_get_ino_and_lblk_bits,
1542 };
1543 #endif
1544
1545 #ifdef CONFIG_QUOTA
1546 static const char * const quotatypes[] = INITQFNAMES;
1547 #define QTYPE2NAME(t) (quotatypes[t])
1548
1549 static int ext4_write_dquot(struct dquot *dquot);
1550 static int ext4_acquire_dquot(struct dquot *dquot);
1551 static int ext4_release_dquot(struct dquot *dquot);
1552 static int ext4_mark_dquot_dirty(struct dquot *dquot);
1553 static int ext4_write_info(struct super_block *sb, int type);
1554 static int ext4_quota_on(struct super_block *sb, int type, int format_id,
1555                          const struct path *path);
1556 static int ext4_quota_on_mount(struct super_block *sb, int type);
1557 static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
1558                                size_t len, loff_t off);
1559 static ssize_t ext4_quota_write(struct super_block *sb, int type,
1560                                 const char *data, size_t len, loff_t off);
1561 static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
1562                              unsigned int flags);
1563 static int ext4_enable_quotas(struct super_block *sb);
1564
1565 static struct dquot **ext4_get_dquots(struct inode *inode)
1566 {
1567         return EXT4_I(inode)->i_dquot;
1568 }
1569
1570 static const struct dquot_operations ext4_quota_operations = {
1571         .get_reserved_space     = ext4_get_reserved_space,
1572         .write_dquot            = ext4_write_dquot,
1573         .acquire_dquot          = ext4_acquire_dquot,
1574         .release_dquot          = ext4_release_dquot,
1575         .mark_dirty             = ext4_mark_dquot_dirty,
1576         .write_info             = ext4_write_info,
1577         .alloc_dquot            = dquot_alloc,
1578         .destroy_dquot          = dquot_destroy,
1579         .get_projid             = ext4_get_projid,
1580         .get_inode_usage        = ext4_get_inode_usage,
1581         .get_next_id            = dquot_get_next_id,
1582 };
1583
1584 static const struct quotactl_ops ext4_qctl_operations = {
1585         .quota_on       = ext4_quota_on,
1586         .quota_off      = ext4_quota_off,
1587         .quota_sync     = dquot_quota_sync,
1588         .get_state      = dquot_get_state,
1589         .set_info       = dquot_set_dqinfo,
1590         .get_dqblk      = dquot_get_dqblk,
1591         .set_dqblk      = dquot_set_dqblk,
1592         .get_nextdqblk  = dquot_get_next_dqblk,
1593 };
1594 #endif
1595
1596 static const struct super_operations ext4_sops = {
1597         .alloc_inode    = ext4_alloc_inode,
1598         .free_inode     = ext4_free_in_core_inode,
1599         .destroy_inode  = ext4_destroy_inode,
1600         .write_inode    = ext4_write_inode,
1601         .dirty_inode    = ext4_dirty_inode,
1602         .drop_inode     = ext4_drop_inode,
1603         .evict_inode    = ext4_evict_inode,
1604         .put_super      = ext4_put_super,
1605         .sync_fs        = ext4_sync_fs,
1606         .freeze_fs      = ext4_freeze,
1607         .unfreeze_fs    = ext4_unfreeze,
1608         .statfs         = ext4_statfs,
1609         .remount_fs     = ext4_remount,
1610         .show_options   = ext4_show_options,
1611 #ifdef CONFIG_QUOTA
1612         .quota_read     = ext4_quota_read,
1613         .quota_write    = ext4_quota_write,
1614         .get_dquots     = ext4_get_dquots,
1615 #endif
1616         .bdev_try_to_free_page = bdev_try_to_free_page,
1617 };
1618
1619 static const struct export_operations ext4_export_ops = {
1620         .fh_to_dentry = ext4_fh_to_dentry,
1621         .fh_to_parent = ext4_fh_to_parent,
1622         .get_parent = ext4_get_parent,
1623         .commit_metadata = ext4_nfs_commit_metadata,
1624 };
1625
1626 enum {
1627         Opt_bsd_df, Opt_minix_df, Opt_grpid, Opt_nogrpid,
1628         Opt_resgid, Opt_resuid, Opt_sb, Opt_err_cont, Opt_err_panic, Opt_err_ro,
1629         Opt_nouid32, Opt_debug, Opt_removed,
1630         Opt_user_xattr, Opt_nouser_xattr, Opt_acl, Opt_noacl,
1631         Opt_auto_da_alloc, Opt_noauto_da_alloc, Opt_noload,
1632         Opt_commit, Opt_min_batch_time, Opt_max_batch_time, Opt_journal_dev,
1633         Opt_journal_path, Opt_journal_checksum, Opt_journal_async_commit,
1634         Opt_abort, Opt_data_journal, Opt_data_ordered, Opt_data_writeback,
1635         Opt_data_err_abort, Opt_data_err_ignore, Opt_test_dummy_encryption,
1636         Opt_inlinecrypt,
1637         Opt_usrjquota, Opt_grpjquota, Opt_offusrjquota, Opt_offgrpjquota,
1638         Opt_jqfmt_vfsold, Opt_jqfmt_vfsv0, Opt_jqfmt_vfsv1, Opt_quota,
1639         Opt_noquota, Opt_barrier, Opt_nobarrier, Opt_err,
1640         Opt_usrquota, Opt_grpquota, Opt_prjquota, Opt_i_version,
1641         Opt_dax, Opt_dax_always, Opt_dax_inode, Opt_dax_never,
1642         Opt_stripe, Opt_delalloc, Opt_nodelalloc, Opt_warn_on_error,
1643         Opt_nowarn_on_error, Opt_mblk_io_submit,
1644         Opt_lazytime, Opt_nolazytime, Opt_debug_want_extra_isize,
1645         Opt_nomblk_io_submit, Opt_block_validity, Opt_noblock_validity,
1646         Opt_inode_readahead_blks, Opt_journal_ioprio,
1647         Opt_dioread_nolock, Opt_dioread_lock,
1648         Opt_discard, Opt_nodiscard, Opt_init_itable, Opt_noinit_itable,
1649         Opt_max_dir_size_kb, Opt_nojournal_checksum, Opt_nombcache,
1650         Opt_prefetch_block_bitmaps,
1651 #ifdef CONFIG_EXT4_DEBUG
1652         Opt_fc_debug_max_replay, Opt_fc_debug_force
1653 #endif
1654 };
1655
1656 static const match_table_t tokens = {
1657         {Opt_bsd_df, "bsddf"},
1658         {Opt_minix_df, "minixdf"},
1659         {Opt_grpid, "grpid"},
1660         {Opt_grpid, "bsdgroups"},
1661         {Opt_nogrpid, "nogrpid"},
1662         {Opt_nogrpid, "sysvgroups"},
1663         {Opt_resgid, "resgid=%u"},
1664         {Opt_resuid, "resuid=%u"},
1665         {Opt_sb, "sb=%u"},
1666         {Opt_err_cont, "errors=continue"},
1667         {Opt_err_panic, "errors=panic"},
1668         {Opt_err_ro, "errors=remount-ro"},
1669         {Opt_nouid32, "nouid32"},
1670         {Opt_debug, "debug"},
1671         {Opt_removed, "oldalloc"},
1672         {Opt_removed, "orlov"},
1673         {Opt_user_xattr, "user_xattr"},
1674         {Opt_nouser_xattr, "nouser_xattr"},
1675         {Opt_acl, "acl"},
1676         {Opt_noacl, "noacl"},
1677         {Opt_noload, "norecovery"},
1678         {Opt_noload, "noload"},
1679         {Opt_removed, "nobh"},
1680         {Opt_removed, "bh"},
1681         {Opt_commit, "commit=%u"},
1682         {Opt_min_batch_time, "min_batch_time=%u"},
1683         {Opt_max_batch_time, "max_batch_time=%u"},
1684         {Opt_journal_dev, "journal_dev=%u"},
1685         {Opt_journal_path, "journal_path=%s"},
1686         {Opt_journal_checksum, "journal_checksum"},
1687         {Opt_nojournal_checksum, "nojournal_checksum"},
1688         {Opt_journal_async_commit, "journal_async_commit"},
1689         {Opt_abort, "abort"},
1690         {Opt_data_journal, "data=journal"},
1691         {Opt_data_ordered, "data=ordered"},
1692         {Opt_data_writeback, "data=writeback"},
1693         {Opt_data_err_abort, "data_err=abort"},
1694         {Opt_data_err_ignore, "data_err=ignore"},
1695         {Opt_offusrjquota, "usrjquota="},
1696         {Opt_usrjquota, "usrjquota=%s"},
1697         {Opt_offgrpjquota, "grpjquota="},
1698         {Opt_grpjquota, "grpjquota=%s"},
1699         {Opt_jqfmt_vfsold, "jqfmt=vfsold"},
1700         {Opt_jqfmt_vfsv0, "jqfmt=vfsv0"},
1701         {Opt_jqfmt_vfsv1, "jqfmt=vfsv1"},
1702         {Opt_grpquota, "grpquota"},
1703         {Opt_noquota, "noquota"},
1704         {Opt_quota, "quota"},
1705         {Opt_usrquota, "usrquota"},
1706         {Opt_prjquota, "prjquota"},
1707         {Opt_barrier, "barrier=%u"},
1708         {Opt_barrier, "barrier"},
1709         {Opt_nobarrier, "nobarrier"},
1710         {Opt_i_version, "i_version"},
1711         {Opt_dax, "dax"},
1712         {Opt_dax_always, "dax=always"},
1713         {Opt_dax_inode, "dax=inode"},
1714         {Opt_dax_never, "dax=never"},
1715         {Opt_stripe, "stripe=%u"},
1716         {Opt_delalloc, "delalloc"},
1717         {Opt_warn_on_error, "warn_on_error"},
1718         {Opt_nowarn_on_error, "nowarn_on_error"},
1719         {Opt_lazytime, "lazytime"},
1720         {Opt_nolazytime, "nolazytime"},
1721         {Opt_debug_want_extra_isize, "debug_want_extra_isize=%u"},
1722         {Opt_nodelalloc, "nodelalloc"},
1723         {Opt_removed, "mblk_io_submit"},
1724         {Opt_removed, "nomblk_io_submit"},
1725         {Opt_block_validity, "block_validity"},
1726         {Opt_noblock_validity, "noblock_validity"},
1727         {Opt_inode_readahead_blks, "inode_readahead_blks=%u"},
1728         {Opt_journal_ioprio, "journal_ioprio=%u"},
1729         {Opt_auto_da_alloc, "auto_da_alloc=%u"},
1730         {Opt_auto_da_alloc, "auto_da_alloc"},
1731         {Opt_noauto_da_alloc, "noauto_da_alloc"},
1732         {Opt_dioread_nolock, "dioread_nolock"},
1733         {Opt_dioread_lock, "nodioread_nolock"},
1734         {Opt_dioread_lock, "dioread_lock"},
1735         {Opt_discard, "discard"},
1736         {Opt_nodiscard, "nodiscard"},
1737         {Opt_init_itable, "init_itable=%u"},
1738         {Opt_init_itable, "init_itable"},
1739         {Opt_noinit_itable, "noinit_itable"},
1740 #ifdef CONFIG_EXT4_DEBUG
1741         {Opt_fc_debug_force, "fc_debug_force"},
1742         {Opt_fc_debug_max_replay, "fc_debug_max_replay=%u"},
1743 #endif
1744         {Opt_max_dir_size_kb, "max_dir_size_kb=%u"},
1745         {Opt_test_dummy_encryption, "test_dummy_encryption=%s"},
1746         {Opt_test_dummy_encryption, "test_dummy_encryption"},
1747         {Opt_inlinecrypt, "inlinecrypt"},
1748         {Opt_nombcache, "nombcache"},
1749         {Opt_nombcache, "no_mbcache"},  /* for backward compatibility */
1750         {Opt_prefetch_block_bitmaps, "prefetch_block_bitmaps"},
1751         {Opt_removed, "check=none"},    /* mount option from ext2/3 */
1752         {Opt_removed, "nocheck"},       /* mount option from ext2/3 */
1753         {Opt_removed, "reservation"},   /* mount option from ext2/3 */
1754         {Opt_removed, "noreservation"}, /* mount option from ext2/3 */
1755         {Opt_removed, "journal=%u"},    /* mount option from ext2/3 */
1756         {Opt_err, NULL},
1757 };
1758
1759 static ext4_fsblk_t get_sb_block(void **data)
1760 {
1761         ext4_fsblk_t    sb_block;
1762         char            *options = (char *) *data;
1763
1764         if (!options || strncmp(options, "sb=", 3) != 0)
1765                 return 1;       /* Default location */
1766
1767         options += 3;
1768         /* TODO: use simple_strtoll with >32bit ext4 */
1769         sb_block = simple_strtoul(options, &options, 0);
1770         if (*options && *options != ',') {
1771                 printk(KERN_ERR "EXT4-fs: Invalid sb specification: %s\n",
1772                        (char *) *data);
1773                 return 1;
1774         }
1775         if (*options == ',')
1776                 options++;
1777         *data = (void *) options;
1778
1779         return sb_block;
1780 }
1781
1782 #define DEFAULT_JOURNAL_IOPRIO (IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, 3))
1783 static const char deprecated_msg[] =
1784         "Mount option \"%s\" will be removed by %s\n"
1785         "Contact linux-ext4@vger.kernel.org if you think we should keep it.\n";
1786
1787 #ifdef CONFIG_QUOTA
1788 static int set_qf_name(struct super_block *sb, int qtype, substring_t *args)
1789 {
1790         struct ext4_sb_info *sbi = EXT4_SB(sb);
1791         char *qname, *old_qname = get_qf_name(sb, sbi, qtype);
1792         int ret = -1;
1793
1794         if (sb_any_quota_loaded(sb) && !old_qname) {
1795                 ext4_msg(sb, KERN_ERR,
1796                         "Cannot change journaled "
1797                         "quota options when quota turned on");
1798                 return -1;
1799         }
1800         if (ext4_has_feature_quota(sb)) {
1801                 ext4_msg(sb, KERN_INFO, "Journaled quota options "
1802                          "ignored when QUOTA feature is enabled");
1803                 return 1;
1804         }
1805         qname = match_strdup(args);
1806         if (!qname) {
1807                 ext4_msg(sb, KERN_ERR,
1808                         "Not enough memory for storing quotafile name");
1809                 return -1;
1810         }
1811         if (old_qname) {
1812                 if (strcmp(old_qname, qname) == 0)
1813                         ret = 1;
1814                 else
1815                         ext4_msg(sb, KERN_ERR,
1816                                  "%s quota file already specified",
1817                                  QTYPE2NAME(qtype));
1818                 goto errout;
1819         }
1820         if (strchr(qname, '/')) {
1821                 ext4_msg(sb, KERN_ERR,
1822                         "quotafile must be on filesystem root");
1823                 goto errout;
1824         }
1825         rcu_assign_pointer(sbi->s_qf_names[qtype], qname);
1826         set_opt(sb, QUOTA);
1827         return 1;
1828 errout:
1829         kfree(qname);
1830         return ret;
1831 }
1832
1833 static int clear_qf_name(struct super_block *sb, int qtype)
1834 {
1835
1836         struct ext4_sb_info *sbi = EXT4_SB(sb);
1837         char *old_qname = get_qf_name(sb, sbi, qtype);
1838
1839         if (sb_any_quota_loaded(sb) && old_qname) {
1840                 ext4_msg(sb, KERN_ERR, "Cannot change journaled quota options"
1841                         " when quota turned on");
1842                 return -1;
1843         }
1844         rcu_assign_pointer(sbi->s_qf_names[qtype], NULL);
1845         synchronize_rcu();
1846         kfree(old_qname);
1847         return 1;
1848 }
1849 #endif
1850
1851 #define MOPT_SET        0x0001
1852 #define MOPT_CLEAR      0x0002
1853 #define MOPT_NOSUPPORT  0x0004
1854 #define MOPT_EXPLICIT   0x0008
1855 #define MOPT_CLEAR_ERR  0x0010
1856 #define MOPT_GTE0       0x0020
1857 #ifdef CONFIG_QUOTA
1858 #define MOPT_Q          0
1859 #define MOPT_QFMT       0x0040
1860 #else
1861 #define MOPT_Q          MOPT_NOSUPPORT
1862 #define MOPT_QFMT       MOPT_NOSUPPORT
1863 #endif
1864 #define MOPT_DATAJ      0x0080
1865 #define MOPT_NO_EXT2    0x0100
1866 #define MOPT_NO_EXT3    0x0200
1867 #define MOPT_EXT4_ONLY  (MOPT_NO_EXT2 | MOPT_NO_EXT3)
1868 #define MOPT_STRING     0x0400
1869 #define MOPT_SKIP       0x0800
1870 #define MOPT_2          0x1000
1871
1872 static const struct mount_opts {
1873         int     token;
1874         int     mount_opt;
1875         int     flags;
1876 } ext4_mount_opts[] = {
1877         {Opt_minix_df, EXT4_MOUNT_MINIX_DF, MOPT_SET},
1878         {Opt_bsd_df, EXT4_MOUNT_MINIX_DF, MOPT_CLEAR},
1879         {Opt_grpid, EXT4_MOUNT_GRPID, MOPT_SET},
1880         {Opt_nogrpid, EXT4_MOUNT_GRPID, MOPT_CLEAR},
1881         {Opt_block_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_SET},
1882         {Opt_noblock_validity, EXT4_MOUNT_BLOCK_VALIDITY, MOPT_CLEAR},
1883         {Opt_dioread_nolock, EXT4_MOUNT_DIOREAD_NOLOCK,
1884          MOPT_EXT4_ONLY | MOPT_SET},
1885         {Opt_dioread_lock, EXT4_MOUNT_DIOREAD_NOLOCK,
1886          MOPT_EXT4_ONLY | MOPT_CLEAR},
1887         {Opt_discard, EXT4_MOUNT_DISCARD, MOPT_SET},
1888         {Opt_nodiscard, EXT4_MOUNT_DISCARD, MOPT_CLEAR},
1889         {Opt_delalloc, EXT4_MOUNT_DELALLOC,
1890          MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1891         {Opt_nodelalloc, EXT4_MOUNT_DELALLOC,
1892          MOPT_EXT4_ONLY | MOPT_CLEAR},
1893         {Opt_warn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_SET},
1894         {Opt_nowarn_on_error, EXT4_MOUNT_WARN_ON_ERROR, MOPT_CLEAR},
1895         {Opt_nojournal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1896          MOPT_EXT4_ONLY | MOPT_CLEAR},
1897         {Opt_journal_checksum, EXT4_MOUNT_JOURNAL_CHECKSUM,
1898          MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1899         {Opt_journal_async_commit, (EXT4_MOUNT_JOURNAL_ASYNC_COMMIT |
1900                                     EXT4_MOUNT_JOURNAL_CHECKSUM),
1901          MOPT_EXT4_ONLY | MOPT_SET | MOPT_EXPLICIT},
1902         {Opt_noload, EXT4_MOUNT_NOLOAD, MOPT_NO_EXT2 | MOPT_SET},
1903         {Opt_err_panic, EXT4_MOUNT_ERRORS_PANIC, MOPT_SET | MOPT_CLEAR_ERR},
1904         {Opt_err_ro, EXT4_MOUNT_ERRORS_RO, MOPT_SET | MOPT_CLEAR_ERR},
1905         {Opt_err_cont, EXT4_MOUNT_ERRORS_CONT, MOPT_SET | MOPT_CLEAR_ERR},
1906         {Opt_data_err_abort, EXT4_MOUNT_DATA_ERR_ABORT,
1907          MOPT_NO_EXT2},
1908         {Opt_data_err_ignore, EXT4_MOUNT_DATA_ERR_ABORT,
1909          MOPT_NO_EXT2},
1910         {Opt_barrier, EXT4_MOUNT_BARRIER, MOPT_SET},
1911         {Opt_nobarrier, EXT4_MOUNT_BARRIER, MOPT_CLEAR},
1912         {Opt_noauto_da_alloc, EXT4_MOUNT_NO_AUTO_DA_ALLOC, MOPT_SET},
1913         {Opt_auto_da_alloc, EXT4_MOUNT_NO_AUTO_DA_ALLOC, MOPT_CLEAR},
1914         {Opt_noinit_itable, EXT4_MOUNT_INIT_INODE_TABLE, MOPT_CLEAR},
1915         {Opt_commit, 0, MOPT_GTE0},
1916         {Opt_max_batch_time, 0, MOPT_GTE0},
1917         {Opt_min_batch_time, 0, MOPT_GTE0},
1918         {Opt_inode_readahead_blks, 0, MOPT_GTE0},
1919         {Opt_init_itable, 0, MOPT_GTE0},
1920         {Opt_dax, EXT4_MOUNT_DAX_ALWAYS, MOPT_SET | MOPT_SKIP},
1921         {Opt_dax_always, EXT4_MOUNT_DAX_ALWAYS,
1922                 MOPT_EXT4_ONLY | MOPT_SET | MOPT_SKIP},
1923         {Opt_dax_inode, EXT4_MOUNT2_DAX_INODE,
1924                 MOPT_EXT4_ONLY | MOPT_SET | MOPT_SKIP},
1925         {Opt_dax_never, EXT4_MOUNT2_DAX_NEVER,
1926                 MOPT_EXT4_ONLY | MOPT_SET | MOPT_SKIP},
1927         {Opt_stripe, 0, MOPT_GTE0},
1928         {Opt_resuid, 0, MOPT_GTE0},
1929         {Opt_resgid, 0, MOPT_GTE0},
1930         {Opt_journal_dev, 0, MOPT_NO_EXT2 | MOPT_GTE0},
1931         {Opt_journal_path, 0, MOPT_NO_EXT2 | MOPT_STRING},
1932         {Opt_journal_ioprio, 0, MOPT_NO_EXT2 | MOPT_GTE0},
1933         {Opt_data_journal, EXT4_MOUNT_JOURNAL_DATA, MOPT_NO_EXT2 | MOPT_DATAJ},
1934         {Opt_data_ordered, EXT4_MOUNT_ORDERED_DATA, MOPT_NO_EXT2 | MOPT_DATAJ},
1935         {Opt_data_writeback, EXT4_MOUNT_WRITEBACK_DATA,
1936          MOPT_NO_EXT2 | MOPT_DATAJ},
1937         {Opt_user_xattr, EXT4_MOUNT_XATTR_USER, MOPT_SET},
1938         {Opt_nouser_xattr, EXT4_MOUNT_XATTR_USER, MOPT_CLEAR},
1939 #ifdef CONFIG_EXT4_FS_POSIX_ACL
1940         {Opt_acl, EXT4_MOUNT_POSIX_ACL, MOPT_SET},
1941         {Opt_noacl, EXT4_MOUNT_POSIX_ACL, MOPT_CLEAR},
1942 #else
1943         {Opt_acl, 0, MOPT_NOSUPPORT},
1944         {Opt_noacl, 0, MOPT_NOSUPPORT},
1945 #endif
1946         {Opt_nouid32, EXT4_MOUNT_NO_UID32, MOPT_SET},
1947         {Opt_debug, EXT4_MOUNT_DEBUG, MOPT_SET},
1948         {Opt_debug_want_extra_isize, 0, MOPT_GTE0},
1949         {Opt_quota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA, MOPT_SET | MOPT_Q},
1950         {Opt_usrquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA,
1951                                                         MOPT_SET | MOPT_Q},
1952         {Opt_grpquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_GRPQUOTA,
1953                                                         MOPT_SET | MOPT_Q},
1954         {Opt_prjquota, EXT4_MOUNT_QUOTA | EXT4_MOUNT_PRJQUOTA,
1955                                                         MOPT_SET | MOPT_Q},
1956         {Opt_noquota, (EXT4_MOUNT_QUOTA | EXT4_MOUNT_USRQUOTA |
1957                        EXT4_MOUNT_GRPQUOTA | EXT4_MOUNT_PRJQUOTA),
1958                                                         MOPT_CLEAR | MOPT_Q},
1959         {Opt_usrjquota, 0, MOPT_Q | MOPT_STRING},
1960         {Opt_grpjquota, 0, MOPT_Q | MOPT_STRING},
1961         {Opt_offusrjquota, 0, MOPT_Q},
1962         {Opt_offgrpjquota, 0, MOPT_Q},
1963         {Opt_jqfmt_vfsold, QFMT_VFS_OLD, MOPT_QFMT},
1964         {Opt_jqfmt_vfsv0, QFMT_VFS_V0, MOPT_QFMT},
1965         {Opt_jqfmt_vfsv1, QFMT_VFS_V1, MOPT_QFMT},
1966         {Opt_max_dir_size_kb, 0, MOPT_GTE0},
1967         {Opt_test_dummy_encryption, 0, MOPT_STRING},
1968         {Opt_nombcache, EXT4_MOUNT_NO_MBCACHE, MOPT_SET},
1969         {Opt_prefetch_block_bitmaps, EXT4_MOUNT_PREFETCH_BLOCK_BITMAPS,
1970          MOPT_SET},
1971 #ifdef CONFIG_EXT4_DEBUG
1972         {Opt_fc_debug_force, EXT4_MOUNT2_JOURNAL_FAST_COMMIT,
1973          MOPT_SET | MOPT_2 | MOPT_EXT4_ONLY},
1974         {Opt_fc_debug_max_replay, 0, MOPT_GTE0},
1975 #endif
1976         {Opt_err, 0, 0}
1977 };
1978
1979 #ifdef CONFIG_UNICODE
1980 static const struct ext4_sb_encodings {
1981         __u16 magic;
1982         char *name;
1983         char *version;
1984 } ext4_sb_encoding_map[] = {
1985         {EXT4_ENC_UTF8_12_1, "utf8", "12.1.0"},
1986 };
1987
1988 static int ext4_sb_read_encoding(const struct ext4_super_block *es,
1989                                  const struct ext4_sb_encodings **encoding,
1990                                  __u16 *flags)
1991 {
1992         __u16 magic = le16_to_cpu(es->s_encoding);
1993         int i;
1994
1995         for (i = 0; i < ARRAY_SIZE(ext4_sb_encoding_map); i++)
1996                 if (magic == ext4_sb_encoding_map[i].magic)
1997                         break;
1998
1999         if (i >= ARRAY_SIZE(ext4_sb_encoding_map))
2000                 return -EINVAL;
2001
2002         *encoding = &ext4_sb_encoding_map[i];
2003         *flags = le16_to_cpu(es->s_encoding_flags);
2004
2005         return 0;
2006 }
2007 #endif
2008
2009 static int ext4_set_test_dummy_encryption(struct super_block *sb,
2010                                           const char *opt,
2011                                           const substring_t *arg,
2012                                           bool is_remount)
2013 {
2014 #ifdef CONFIG_FS_ENCRYPTION
2015         struct ext4_sb_info *sbi = EXT4_SB(sb);
2016         int err;
2017
2018         /*
2019          * This mount option is just for testing, and it's not worthwhile to
2020          * implement the extra complexity (e.g. RCU protection) that would be
2021          * needed to allow it to be set or changed during remount.  We do allow
2022          * it to be specified during remount, but only if there is no change.
2023          */
2024         if (is_remount && !sbi->s_dummy_enc_policy.policy) {
2025                 ext4_msg(sb, KERN_WARNING,
2026                          "Can't set test_dummy_encryption on remount");
2027                 return -1;
2028         }
2029         err = fscrypt_set_test_dummy_encryption(sb, arg->from,
2030                                                 &sbi->s_dummy_enc_policy);
2031         if (err) {
2032                 if (err == -EEXIST)
2033                         ext4_msg(sb, KERN_WARNING,
2034                                  "Can't change test_dummy_encryption on remount");
2035                 else if (err == -EINVAL)
2036                         ext4_msg(sb, KERN_WARNING,
2037                                  "Value of option \"%s\" is unrecognized", opt);
2038                 else
2039                         ext4_msg(sb, KERN_WARNING,
2040                                  "Error processing option \"%s\" [%d]",
2041                                  opt, err);
2042                 return -1;
2043         }
2044         ext4_msg(sb, KERN_WARNING, "Test dummy encryption mode enabled");
2045 #else
2046         ext4_msg(sb, KERN_WARNING,
2047                  "Test dummy encryption mount option ignored");
2048 #endif
2049         return 1;
2050 }
2051
2052 static int handle_mount_opt(struct super_block *sb, char *opt, int token,
2053                             substring_t *args, unsigned long *journal_devnum,
2054                             unsigned int *journal_ioprio, int is_remount)
2055 {
2056         struct ext4_sb_info *sbi = EXT4_SB(sb);
2057         const struct mount_opts *m;
2058         kuid_t uid;
2059         kgid_t gid;
2060         int arg = 0;
2061
2062 #ifdef CONFIG_QUOTA
2063         if (token == Opt_usrjquota)
2064                 return set_qf_name(sb, USRQUOTA, &args[0]);
2065         else if (token == Opt_grpjquota)
2066                 return set_qf_name(sb, GRPQUOTA, &args[0]);
2067         else if (token == Opt_offusrjquota)
2068                 return clear_qf_name(sb, USRQUOTA);
2069         else if (token == Opt_offgrpjquota)
2070                 return clear_qf_name(sb, GRPQUOTA);
2071 #endif
2072         switch (token) {
2073         case Opt_noacl:
2074         case Opt_nouser_xattr:
2075                 ext4_msg(sb, KERN_WARNING, deprecated_msg, opt, "3.5");
2076                 break;
2077         case Opt_sb:
2078                 return 1;       /* handled by get_sb_block() */
2079         case Opt_removed:
2080                 ext4_msg(sb, KERN_WARNING, "Ignoring removed %s option", opt);
2081                 return 1;
2082         case Opt_abort:
2083                 ext4_set_mount_flag(sb, EXT4_MF_FS_ABORTED);
2084                 return 1;
2085         case Opt_i_version:
2086                 sb->s_flags |= SB_I_VERSION;
2087                 return 1;
2088         case Opt_lazytime:
2089                 sb->s_flags |= SB_LAZYTIME;
2090                 return 1;
2091         case Opt_nolazytime:
2092                 sb->s_flags &= ~SB_LAZYTIME;
2093                 return 1;
2094         case Opt_inlinecrypt:
2095 #ifdef CONFIG_FS_ENCRYPTION_INLINE_CRYPT
2096                 sb->s_flags |= SB_INLINECRYPT;
2097 #else
2098                 ext4_msg(sb, KERN_ERR, "inline encryption not supported");
2099 #endif
2100                 return 1;
2101         }
2102
2103         for (m = ext4_mount_opts; m->token != Opt_err; m++)
2104                 if (token == m->token)
2105                         break;
2106
2107         if (m->token == Opt_err) {
2108                 ext4_msg(sb, KERN_ERR, "Unrecognized mount option \"%s\" "
2109                          "or missing value", opt);
2110                 return -1;
2111         }
2112
2113         if ((m->flags & MOPT_NO_EXT2) && IS_EXT2_SB(sb)) {
2114                 ext4_msg(sb, KERN_ERR,
2115                          "Mount option \"%s\" incompatible with ext2", opt);
2116                 return -1;
2117         }
2118         if ((m->flags & MOPT_NO_EXT3) && IS_EXT3_SB(sb)) {
2119                 ext4_msg(sb, KERN_ERR,
2120                          "Mount option \"%s\" incompatible with ext3", opt);
2121                 return -1;
2122         }
2123
2124         if (args->from && !(m->flags & MOPT_STRING) && match_int(args, &arg))
2125                 return -1;
2126         if (args->from && (m->flags & MOPT_GTE0) && (arg < 0))
2127                 return -1;
2128         if (m->flags & MOPT_EXPLICIT) {
2129                 if (m->mount_opt & EXT4_MOUNT_DELALLOC) {
2130                         set_opt2(sb, EXPLICIT_DELALLOC);
2131                 } else if (m->mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) {
2132                         set_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM);
2133                 } else
2134                         return -1;
2135         }
2136         if (m->flags & MOPT_CLEAR_ERR)
2137                 clear_opt(sb, ERRORS_MASK);
2138         if (token == Opt_noquota && sb_any_quota_loaded(sb)) {
2139                 ext4_msg(sb, KERN_ERR, "Cannot change quota "
2140                          "options when quota turned on");
2141                 return -1;
2142         }
2143
2144         if (m->flags & MOPT_NOSUPPORT) {
2145                 ext4_msg(sb, KERN_ERR, "%s option not supported", opt);
2146         } else if (token == Opt_commit) {
2147                 if (arg == 0)
2148                         arg = JBD2_DEFAULT_MAX_COMMIT_AGE;
2149                 else if (arg > INT_MAX / HZ) {
2150                         ext4_msg(sb, KERN_ERR,
2151                                  "Invalid commit interval %d, "
2152                                  "must be smaller than %d",
2153                                  arg, INT_MAX / HZ);
2154                         return -1;
2155                 }
2156                 sbi->s_commit_interval = HZ * arg;
2157         } else if (token == Opt_debug_want_extra_isize) {
2158                 if ((arg & 1) ||
2159                     (arg < 4) ||
2160                     (arg > (sbi->s_inode_size - EXT4_GOOD_OLD_INODE_SIZE))) {
2161                         ext4_msg(sb, KERN_ERR,
2162                                  "Invalid want_extra_isize %d", arg);
2163                         return -1;
2164                 }
2165                 sbi->s_want_extra_isize = arg;
2166         } else if (token == Opt_max_batch_time) {
2167                 sbi->s_max_batch_time = arg;
2168         } else if (token == Opt_min_batch_time) {
2169                 sbi->s_min_batch_time = arg;
2170         } else if (token == Opt_inode_readahead_blks) {
2171                 if (arg && (arg > (1 << 30) || !is_power_of_2(arg))) {
2172                         ext4_msg(sb, KERN_ERR,
2173                                  "EXT4-fs: inode_readahead_blks must be "
2174                                  "0 or a power of 2 smaller than 2^31");
2175                         return -1;
2176                 }
2177                 sbi->s_inode_readahead_blks = arg;
2178         } else if (token == Opt_init_itable) {
2179                 set_opt(sb, INIT_INODE_TABLE);
2180                 if (!args->from)
2181                         arg = EXT4_DEF_LI_WAIT_MULT;
2182                 sbi->s_li_wait_mult = arg;
2183         } else if (token == Opt_max_dir_size_kb) {
2184                 sbi->s_max_dir_size_kb = arg;
2185 #ifdef CONFIG_EXT4_DEBUG
2186         } else if (token == Opt_fc_debug_max_replay) {
2187                 sbi->s_fc_debug_max_replay = arg;
2188 #endif
2189         } else if (token == Opt_stripe) {
2190                 sbi->s_stripe = arg;
2191         } else if (token == Opt_resuid) {
2192                 uid = make_kuid(current_user_ns(), arg);
2193                 if (!uid_valid(uid)) {
2194                         ext4_msg(sb, KERN_ERR, "Invalid uid value %d", arg);
2195                         return -1;
2196                 }
2197                 sbi->s_resuid = uid;
2198         } else if (token == Opt_resgid) {
2199                 gid = make_kgid(current_user_ns(), arg);
2200                 if (!gid_valid(gid)) {
2201                         ext4_msg(sb, KERN_ERR, "Invalid gid value %d", arg);
2202                         return -1;
2203                 }
2204                 sbi->s_resgid = gid;
2205         } else if (token == Opt_journal_dev) {
2206                 if (is_remount) {
2207                         ext4_msg(sb, KERN_ERR,
2208                                  "Cannot specify journal on remount");
2209                         return -1;
2210                 }
2211                 *journal_devnum = arg;
2212         } else if (token == Opt_journal_path) {
2213                 char *journal_path;
2214                 struct inode *journal_inode;
2215                 struct path path;
2216                 int error;
2217
2218                 if (is_remount) {
2219                         ext4_msg(sb, KERN_ERR,
2220                                  "Cannot specify journal on remount");
2221                         return -1;
2222                 }
2223                 journal_path = match_strdup(&args[0]);
2224                 if (!journal_path) {
2225                         ext4_msg(sb, KERN_ERR, "error: could not dup "
2226                                 "journal device string");
2227                         return -1;
2228                 }
2229
2230                 error = kern_path(journal_path, LOOKUP_FOLLOW, &path);
2231                 if (error) {
2232                         ext4_msg(sb, KERN_ERR, "error: could not find "
2233                                 "journal device path: error %d", error);
2234                         kfree(journal_path);
2235                         return -1;
2236                 }
2237
2238                 journal_inode = d_inode(path.dentry);
2239                 if (!S_ISBLK(journal_inode->i_mode)) {
2240                         ext4_msg(sb, KERN_ERR, "error: journal path %s "
2241                                 "is not a block device", journal_path);
2242                         path_put(&path);
2243                         kfree(journal_path);
2244                         return -1;
2245                 }
2246
2247                 *journal_devnum = new_encode_dev(journal_inode->i_rdev);
2248                 path_put(&path);
2249                 kfree(journal_path);
2250         } else if (token == Opt_journal_ioprio) {
2251                 if (arg > 7) {
2252                         ext4_msg(sb, KERN_ERR, "Invalid journal IO priority"
2253                                  " (must be 0-7)");
2254                         return -1;
2255                 }
2256                 *journal_ioprio =
2257                         IOPRIO_PRIO_VALUE(IOPRIO_CLASS_BE, arg);
2258         } else if (token == Opt_test_dummy_encryption) {
2259                 return ext4_set_test_dummy_encryption(sb, opt, &args[0],
2260                                                       is_remount);
2261         } else if (m->flags & MOPT_DATAJ) {
2262                 if (is_remount) {
2263                         if (!sbi->s_journal)
2264                                 ext4_msg(sb, KERN_WARNING, "Remounting file system with no journal so ignoring journalled data option");
2265                         else if (test_opt(sb, DATA_FLAGS) != m->mount_opt) {
2266                                 ext4_msg(sb, KERN_ERR,
2267                                          "Cannot change data mode on remount");
2268                                 return -1;
2269                         }
2270                 } else {
2271                         clear_opt(sb, DATA_FLAGS);
2272                         sbi->s_mount_opt |= m->mount_opt;
2273                 }
2274 #ifdef CONFIG_QUOTA
2275         } else if (m->flags & MOPT_QFMT) {
2276                 if (sb_any_quota_loaded(sb) &&
2277                     sbi->s_jquota_fmt != m->mount_opt) {
2278                         ext4_msg(sb, KERN_ERR, "Cannot change journaled "
2279                                  "quota options when quota turned on");
2280                         return -1;
2281                 }
2282                 if (ext4_has_feature_quota(sb)) {
2283                         ext4_msg(sb, KERN_INFO,
2284                                  "Quota format mount options ignored "
2285                                  "when QUOTA feature is enabled");
2286                         return 1;
2287                 }
2288                 sbi->s_jquota_fmt = m->mount_opt;
2289 #endif
2290         } else if (token == Opt_dax || token == Opt_dax_always ||
2291                    token == Opt_dax_inode || token == Opt_dax_never) {
2292 #ifdef CONFIG_FS_DAX
2293                 switch (token) {
2294                 case Opt_dax:
2295                 case Opt_dax_always:
2296                         if (is_remount &&
2297                             (!(sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) ||
2298                              (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER))) {
2299                         fail_dax_change_remount:
2300                                 ext4_msg(sb, KERN_ERR, "can't change "
2301                                          "dax mount option while remounting");
2302                                 return -1;
2303                         }
2304                         if (is_remount &&
2305                             (test_opt(sb, DATA_FLAGS) ==
2306                              EXT4_MOUNT_JOURNAL_DATA)) {
2307                                     ext4_msg(sb, KERN_ERR, "can't mount with "
2308                                              "both data=journal and dax");
2309                                     return -1;
2310                         }
2311                         ext4_msg(sb, KERN_WARNING,
2312                                 "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
2313                         sbi->s_mount_opt |= EXT4_MOUNT_DAX_ALWAYS;
2314                         sbi->s_mount_opt2 &= ~EXT4_MOUNT2_DAX_NEVER;
2315                         break;
2316                 case Opt_dax_never:
2317                         if (is_remount &&
2318                             (!(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) ||
2319                              (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS)))
2320                                 goto fail_dax_change_remount;
2321                         sbi->s_mount_opt2 |= EXT4_MOUNT2_DAX_NEVER;
2322                         sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
2323                         break;
2324                 case Opt_dax_inode:
2325                         if (is_remount &&
2326                             ((sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) ||
2327                              (sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_NEVER) ||
2328                              !(sbi->s_mount_opt2 & EXT4_MOUNT2_DAX_INODE)))
2329                                 goto fail_dax_change_remount;
2330                         sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
2331                         sbi->s_mount_opt2 &= ~EXT4_MOUNT2_DAX_NEVER;
2332                         /* Strictly for printing options */
2333                         sbi->s_mount_opt2 |= EXT4_MOUNT2_DAX_INODE;
2334                         break;
2335                 }
2336 #else
2337                 ext4_msg(sb, KERN_INFO, "dax option not supported");
2338                 sbi->s_mount_opt2 |= EXT4_MOUNT2_DAX_NEVER;
2339                 sbi->s_mount_opt &= ~EXT4_MOUNT_DAX_ALWAYS;
2340                 return -1;
2341 #endif
2342         } else if (token == Opt_data_err_abort) {
2343                 sbi->s_mount_opt |= m->mount_opt;
2344         } else if (token == Opt_data_err_ignore) {
2345                 sbi->s_mount_opt &= ~m->mount_opt;
2346         } else {
2347                 if (!args->from)
2348                         arg = 1;
2349                 if (m->flags & MOPT_CLEAR)
2350                         arg = !arg;
2351                 else if (unlikely(!(m->flags & MOPT_SET))) {
2352                         ext4_msg(sb, KERN_WARNING,
2353                                  "buggy handling of option %s", opt);
2354                         WARN_ON(1);
2355                         return -1;
2356                 }
2357                 if (m->flags & MOPT_2) {
2358                         if (arg != 0)
2359                                 sbi->s_mount_opt2 |= m->mount_opt;
2360                         else
2361                                 sbi->s_mount_opt2 &= ~m->mount_opt;
2362                 } else {
2363                         if (arg != 0)
2364                                 sbi->s_mount_opt |= m->mount_opt;
2365                         else
2366                                 sbi->s_mount_opt &= ~m->mount_opt;
2367                 }
2368         }
2369         return 1;
2370 }
2371
2372 static int parse_options(char *options, struct super_block *sb,
2373                          unsigned long *journal_devnum,
2374                          unsigned int *journal_ioprio,
2375                          int is_remount)
2376 {
2377         struct ext4_sb_info __maybe_unused *sbi = EXT4_SB(sb);
2378         char *p, __maybe_unused *usr_qf_name, __maybe_unused *grp_qf_name;
2379         substring_t args[MAX_OPT_ARGS];
2380         int token;
2381
2382         if (!options)
2383                 return 1;
2384
2385         while ((p = strsep(&options, ",")) != NULL) {
2386                 if (!*p)
2387                         continue;
2388                 /*
2389                  * Initialize args struct so we know whether arg was
2390                  * found; some options take optional arguments.
2391                  */
2392                 args[0].to = args[0].from = NULL;
2393                 token = match_token(p, tokens, args);
2394                 if (handle_mount_opt(sb, p, token, args, journal_devnum,
2395                                      journal_ioprio, is_remount) < 0)
2396                         return 0;
2397         }
2398 #ifdef CONFIG_QUOTA
2399         /*
2400          * We do the test below only for project quotas. 'usrquota' and
2401          * 'grpquota' mount options are allowed even without quota feature
2402          * to support legacy quotas in quota files.
2403          */
2404         if (test_opt(sb, PRJQUOTA) && !ext4_has_feature_project(sb)) {
2405                 ext4_msg(sb, KERN_ERR, "Project quota feature not enabled. "
2406                          "Cannot enable project quota enforcement.");
2407                 return 0;
2408         }
2409         usr_qf_name = get_qf_name(sb, sbi, USRQUOTA);
2410         grp_qf_name = get_qf_name(sb, sbi, GRPQUOTA);
2411         if (usr_qf_name || grp_qf_name) {
2412                 if (test_opt(sb, USRQUOTA) && usr_qf_name)
2413                         clear_opt(sb, USRQUOTA);
2414
2415                 if (test_opt(sb, GRPQUOTA) && grp_qf_name)
2416                         clear_opt(sb, GRPQUOTA);
2417
2418                 if (test_opt(sb, GRPQUOTA) || test_opt(sb, USRQUOTA)) {
2419                         ext4_msg(sb, KERN_ERR, "old and new quota "
2420                                         "format mixing");
2421                         return 0;
2422                 }
2423
2424                 if (!sbi->s_jquota_fmt) {
2425                         ext4_msg(sb, KERN_ERR, "journaled quota format "
2426                                         "not specified");
2427                         return 0;
2428                 }
2429         }
2430 #endif
2431         if (test_opt(sb, DIOREAD_NOLOCK)) {
2432                 int blocksize =
2433                         BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size);
2434                 if (blocksize < PAGE_SIZE)
2435                         ext4_msg(sb, KERN_WARNING, "Warning: mounting with an "
2436                                  "experimental mount option 'dioread_nolock' "
2437                                  "for blocksize < PAGE_SIZE");
2438         }
2439         return 1;
2440 }
2441
2442 static inline void ext4_show_quota_options(struct seq_file *seq,
2443                                            struct super_block *sb)
2444 {
2445 #if defined(CONFIG_QUOTA)
2446         struct ext4_sb_info *sbi = EXT4_SB(sb);
2447         char *usr_qf_name, *grp_qf_name;
2448
2449         if (sbi->s_jquota_fmt) {
2450                 char *fmtname = "";
2451
2452                 switch (sbi->s_jquota_fmt) {
2453                 case QFMT_VFS_OLD:
2454                         fmtname = "vfsold";
2455                         break;
2456                 case QFMT_VFS_V0:
2457                         fmtname = "vfsv0";
2458                         break;
2459                 case QFMT_VFS_V1:
2460                         fmtname = "vfsv1";
2461                         break;
2462                 }
2463                 seq_printf(seq, ",jqfmt=%s", fmtname);
2464         }
2465
2466         rcu_read_lock();
2467         usr_qf_name = rcu_dereference(sbi->s_qf_names[USRQUOTA]);
2468         grp_qf_name = rcu_dereference(sbi->s_qf_names[GRPQUOTA]);
2469         if (usr_qf_name)
2470                 seq_show_option(seq, "usrjquota", usr_qf_name);
2471         if (grp_qf_name)
2472                 seq_show_option(seq, "grpjquota", grp_qf_name);
2473         rcu_read_unlock();
2474 #endif
2475 }
2476
2477 static const char *token2str(int token)
2478 {
2479         const struct match_token *t;
2480
2481         for (t = tokens; t->token != Opt_err; t++)
2482                 if (t->token == token && !strchr(t->pattern, '='))
2483                         break;
2484         return t->pattern;
2485 }
2486
2487 /*
2488  * Show an option if
2489  *  - it's set to a non-default value OR
2490  *  - if the per-sb default is different from the global default
2491  */
2492 static int _ext4_show_options(struct seq_file *seq, struct super_block *sb,
2493                               int nodefs)
2494 {
2495         struct ext4_sb_info *sbi = EXT4_SB(sb);
2496         struct ext4_super_block *es = sbi->s_es;
2497         int def_errors, def_mount_opt = sbi->s_def_mount_opt;
2498         const struct mount_opts *m;
2499         char sep = nodefs ? '\n' : ',';
2500
2501 #define SEQ_OPTS_PUTS(str) seq_printf(seq, "%c" str, sep)
2502 #define SEQ_OPTS_PRINT(str, arg) seq_printf(seq, "%c" str, sep, arg)
2503
2504         if (sbi->s_sb_block != 1)
2505                 SEQ_OPTS_PRINT("sb=%llu", sbi->s_sb_block);
2506
2507         for (m = ext4_mount_opts; m->token != Opt_err; m++) {
2508                 int want_set = m->flags & MOPT_SET;
2509                 if (((m->flags & (MOPT_SET|MOPT_CLEAR)) == 0) ||
2510                     (m->flags & MOPT_CLEAR_ERR) || m->flags & MOPT_SKIP)
2511                         continue;
2512                 if (!nodefs && !(m->mount_opt & (sbi->s_mount_opt ^ def_mount_opt)))
2513                         continue; /* skip if same as the default */
2514                 if ((want_set &&
2515                      (sbi->s_mount_opt & m->mount_opt) != m->mount_opt) ||
2516                     (!want_set && (sbi->s_mount_opt & m->mount_opt)))
2517                         continue; /* select Opt_noFoo vs Opt_Foo */
2518                 SEQ_OPTS_PRINT("%s", token2str(m->token));
2519         }
2520
2521         if (nodefs || !uid_eq(sbi->s_resuid, make_kuid(&init_user_ns, EXT4_DEF_RESUID)) ||
2522             le16_to_cpu(es->s_def_resuid) != EXT4_DEF_RESUID)
2523                 SEQ_OPTS_PRINT("resuid=%u",
2524                                 from_kuid_munged(&init_user_ns, sbi->s_resuid));
2525         if (nodefs || !gid_eq(sbi->s_resgid, make_kgid(&init_user_ns, EXT4_DEF_RESGID)) ||
2526             le16_to_cpu(es->s_def_resgid) != EXT4_DEF_RESGID)
2527                 SEQ_OPTS_PRINT("resgid=%u",
2528                                 from_kgid_munged(&init_user_ns, sbi->s_resgid));
2529         def_errors = nodefs ? -1 : le16_to_cpu(es->s_errors);
2530         if (test_opt(sb, ERRORS_RO) && def_errors != EXT4_ERRORS_RO)
2531                 SEQ_OPTS_PUTS("errors=remount-ro");
2532         if (test_opt(sb, ERRORS_CONT) && def_errors != EXT4_ERRORS_CONTINUE)
2533                 SEQ_OPTS_PUTS("errors=continue");
2534         if (test_opt(sb, ERRORS_PANIC) && def_errors != EXT4_ERRORS_PANIC)
2535                 SEQ_OPTS_PUTS("errors=panic");
2536         if (nodefs || sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ)
2537                 SEQ_OPTS_PRINT("commit=%lu", sbi->s_commit_interval / HZ);
2538         if (nodefs || sbi->s_min_batch_time != EXT4_DEF_MIN_BATCH_TIME)
2539                 SEQ_OPTS_PRINT("min_batch_time=%u", sbi->s_min_batch_time);
2540         if (nodefs || sbi->s_max_batch_time != EXT4_DEF_MAX_BATCH_TIME)
2541                 SEQ_OPTS_PRINT("max_batch_time=%u", sbi->s_max_batch_time);
2542         if (sb->s_flags & SB_I_VERSION)
2543                 SEQ_OPTS_PUTS("i_version");
2544         if (nodefs || sbi->s_stripe)
2545                 SEQ_OPTS_PRINT("stripe=%lu", sbi->s_stripe);
2546         if (nodefs || EXT4_MOUNT_DATA_FLAGS &
2547                         (sbi->s_mount_opt ^ def_mount_opt)) {
2548                 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
2549                         SEQ_OPTS_PUTS("data=journal");
2550                 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
2551                         SEQ_OPTS_PUTS("data=ordered");
2552                 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_WRITEBACK_DATA)
2553                         SEQ_OPTS_PUTS("data=writeback");
2554         }
2555         if (nodefs ||
2556             sbi->s_inode_readahead_blks != EXT4_DEF_INODE_READAHEAD_BLKS)
2557                 SEQ_OPTS_PRINT("inode_readahead_blks=%u",
2558                                sbi->s_inode_readahead_blks);
2559
2560         if (test_opt(sb, INIT_INODE_TABLE) && (nodefs ||
2561                        (sbi->s_li_wait_mult != EXT4_DEF_LI_WAIT_MULT)))
2562                 SEQ_OPTS_PRINT("init_itable=%u", sbi->s_li_wait_mult);
2563         if (nodefs || sbi->s_max_dir_size_kb)
2564                 SEQ_OPTS_PRINT("max_dir_size_kb=%u", sbi->s_max_dir_size_kb);
2565         if (test_opt(sb, DATA_ERR_ABORT))
2566                 SEQ_OPTS_PUTS("data_err=abort");
2567
2568         fscrypt_show_test_dummy_encryption(seq, sep, sb);
2569
2570         if (sb->s_flags & SB_INLINECRYPT)
2571                 SEQ_OPTS_PUTS("inlinecrypt");
2572
2573         if (test_opt(sb, DAX_ALWAYS)) {
2574                 if (IS_EXT2_SB(sb))
2575                         SEQ_OPTS_PUTS("dax");
2576                 else
2577                         SEQ_OPTS_PUTS("dax=always");
2578         } else if (test_opt2(sb, DAX_NEVER)) {
2579                 SEQ_OPTS_PUTS("dax=never");
2580         } else if (test_opt2(sb, DAX_INODE)) {
2581                 SEQ_OPTS_PUTS("dax=inode");
2582         }
2583         ext4_show_quota_options(seq, sb);
2584         return 0;
2585 }
2586
2587 static int ext4_show_options(struct seq_file *seq, struct dentry *root)
2588 {
2589         return _ext4_show_options(seq, root->d_sb, 0);
2590 }
2591
2592 int ext4_seq_options_show(struct seq_file *seq, void *offset)
2593 {
2594         struct super_block *sb = seq->private;
2595         int rc;
2596
2597         seq_puts(seq, sb_rdonly(sb) ? "ro" : "rw");
2598         rc = _ext4_show_options(seq, sb, 1);
2599         seq_puts(seq, "\n");
2600         return rc;
2601 }
2602
2603 static int ext4_setup_super(struct super_block *sb, struct ext4_super_block *es,
2604                             int read_only)
2605 {
2606         struct ext4_sb_info *sbi = EXT4_SB(sb);
2607         int err = 0;
2608
2609         if (le32_to_cpu(es->s_rev_level) > EXT4_MAX_SUPP_REV) {
2610                 ext4_msg(sb, KERN_ERR, "revision level too high, "
2611                          "forcing read-only mode");
2612                 err = -EROFS;
2613                 goto done;
2614         }
2615         if (read_only)
2616                 goto done;
2617         if (!(sbi->s_mount_state & EXT4_VALID_FS))
2618                 ext4_msg(sb, KERN_WARNING, "warning: mounting unchecked fs, "
2619                          "running e2fsck is recommended");
2620         else if (sbi->s_mount_state & EXT4_ERROR_FS)
2621                 ext4_msg(sb, KERN_WARNING,
2622                          "warning: mounting fs with errors, "
2623                          "running e2fsck is recommended");
2624         else if ((__s16) le16_to_cpu(es->s_max_mnt_count) > 0 &&
2625                  le16_to_cpu(es->s_mnt_count) >=
2626                  (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
2627                 ext4_msg(sb, KERN_WARNING,
2628                          "warning: maximal mount count reached, "
2629                          "running e2fsck is recommended");
2630         else if (le32_to_cpu(es->s_checkinterval) &&
2631                  (ext4_get_tstamp(es, s_lastcheck) +
2632                   le32_to_cpu(es->s_checkinterval) <= ktime_get_real_seconds()))
2633                 ext4_msg(sb, KERN_WARNING,
2634                          "warning: checktime reached, "
2635                          "running e2fsck is recommended");
2636         if (!sbi->s_journal)
2637                 es->s_state &= cpu_to_le16(~EXT4_VALID_FS);
2638         if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
2639                 es->s_max_mnt_count = cpu_to_le16(EXT4_DFL_MAX_MNT_COUNT);
2640         le16_add_cpu(&es->s_mnt_count, 1);
2641         ext4_update_tstamp(es, s_mtime);
2642         if (sbi->s_journal)
2643                 ext4_set_feature_journal_needs_recovery(sb);
2644
2645         err = ext4_commit_super(sb, 1);
2646 done:
2647         if (test_opt(sb, DEBUG))
2648                 printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%u, "
2649                                 "bpg=%lu, ipg=%lu, mo=%04x, mo2=%04x]\n",
2650                         sb->s_blocksize,
2651                         sbi->s_groups_count,
2652                         EXT4_BLOCKS_PER_GROUP(sb),
2653                         EXT4_INODES_PER_GROUP(sb),
2654                         sbi->s_mount_opt, sbi->s_mount_opt2);
2655
2656         cleancache_init_fs(sb);
2657         return err;
2658 }
2659
2660 int ext4_alloc_flex_bg_array(struct super_block *sb, ext4_group_t ngroup)
2661 {
2662         struct ext4_sb_info *sbi = EXT4_SB(sb);
2663         struct flex_groups **old_groups, **new_groups;
2664         int size, i, j;
2665
2666         if (!sbi->s_log_groups_per_flex)
2667                 return 0;
2668
2669         size = ext4_flex_group(sbi, ngroup - 1) + 1;
2670         if (size <= sbi->s_flex_groups_allocated)
2671                 return 0;
2672
2673         new_groups = kvzalloc(roundup_pow_of_two(size *
2674                               sizeof(*sbi->s_flex_groups)), GFP_KERNEL);
2675         if (!new_groups) {
2676                 ext4_msg(sb, KERN_ERR,
2677                          "not enough memory for %d flex group pointers", size);
2678                 return -ENOMEM;
2679         }
2680         for (i = sbi->s_flex_groups_allocated; i < size; i++) {
2681                 new_groups[i] = kvzalloc(roundup_pow_of_two(
2682                                          sizeof(struct flex_groups)),
2683                                          GFP_KERNEL);
2684                 if (!new_groups[i]) {
2685                         for (j = sbi->s_flex_groups_allocated; j < i; j++)
2686                                 kvfree(new_groups[j]);
2687                         kvfree(new_groups);
2688                         ext4_msg(sb, KERN_ERR,
2689                                  "not enough memory for %d flex groups", size);
2690                         return -ENOMEM;
2691                 }
2692         }
2693         rcu_read_lock();
2694         old_groups = rcu_dereference(sbi->s_flex_groups);
2695         if (old_groups)
2696                 memcpy(new_groups, old_groups,
2697                        (sbi->s_flex_groups_allocated *
2698                         sizeof(struct flex_groups *)));
2699         rcu_read_unlock();
2700         rcu_assign_pointer(sbi->s_flex_groups, new_groups);
2701         sbi->s_flex_groups_allocated = size;
2702         if (old_groups)
2703                 ext4_kvfree_array_rcu(old_groups);
2704         return 0;
2705 }
2706
2707 static int ext4_fill_flex_info(struct super_block *sb)
2708 {
2709         struct ext4_sb_info *sbi = EXT4_SB(sb);
2710         struct ext4_group_desc *gdp = NULL;
2711         struct flex_groups *fg;
2712         ext4_group_t flex_group;
2713         int i, err;
2714
2715         sbi->s_log_groups_per_flex = sbi->s_es->s_log_groups_per_flex;
2716         if (sbi->s_log_groups_per_flex < 1 || sbi->s_log_groups_per_flex > 31) {
2717                 sbi->s_log_groups_per_flex = 0;
2718                 return 1;
2719         }
2720
2721         err = ext4_alloc_flex_bg_array(sb, sbi->s_groups_count);
2722         if (err)
2723                 goto failed;
2724
2725         for (i = 0; i < sbi->s_groups_count; i++) {
2726                 gdp = ext4_get_group_desc(sb, i, NULL);
2727
2728                 flex_group = ext4_flex_group(sbi, i);
2729                 fg = sbi_array_rcu_deref(sbi, s_flex_groups, flex_group);
2730                 atomic_add(ext4_free_inodes_count(sb, gdp), &fg->free_inodes);
2731                 atomic64_add(ext4_free_group_clusters(sb, gdp),
2732                              &fg->free_clusters);
2733                 atomic_add(ext4_used_dirs_count(sb, gdp), &fg->used_dirs);
2734         }
2735
2736         return 1;
2737 failed:
2738         return 0;
2739 }
2740
2741 static __le16 ext4_group_desc_csum(struct super_block *sb, __u32 block_group,
2742                                    struct ext4_group_desc *gdp)
2743 {
2744         int offset = offsetof(struct ext4_group_desc, bg_checksum);
2745         __u16 crc = 0;
2746         __le32 le_group = cpu_to_le32(block_group);
2747         struct ext4_sb_info *sbi = EXT4_SB(sb);
2748
2749         if (ext4_has_metadata_csum(sbi->s_sb)) {
2750                 /* Use new metadata_csum algorithm */
2751                 __u32 csum32;
2752                 __u16 dummy_csum = 0;
2753
2754                 csum32 = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&le_group,
2755                                      sizeof(le_group));
2756                 csum32 = ext4_chksum(sbi, csum32, (__u8 *)gdp, offset);
2757                 csum32 = ext4_chksum(sbi, csum32, (__u8 *)&dummy_csum,
2758                                      sizeof(dummy_csum));
2759                 offset += sizeof(dummy_csum);
2760                 if (offset < sbi->s_desc_size)
2761                         csum32 = ext4_chksum(sbi, csum32, (__u8 *)gdp + offset,
2762                                              sbi->s_desc_size - offset);
2763
2764                 crc = csum32 & 0xFFFF;
2765                 goto out;
2766         }
2767
2768         /* old crc16 code */
2769         if (!ext4_has_feature_gdt_csum(sb))
2770                 return 0;
2771
2772         crc = crc16(~0, sbi->s_es->s_uuid, sizeof(sbi->s_es->s_uuid));
2773         crc = crc16(crc, (__u8 *)&le_group, sizeof(le_group));
2774         crc = crc16(crc, (__u8 *)gdp, offset);
2775         offset += sizeof(gdp->bg_checksum); /* skip checksum */
2776         /* for checksum of struct ext4_group_desc do the rest...*/
2777         if (ext4_has_feature_64bit(sb) &&
2778             offset < le16_to_cpu(sbi->s_es->s_desc_size))
2779                 crc = crc16(crc, (__u8 *)gdp + offset,
2780                             le16_to_cpu(sbi->s_es->s_desc_size) -
2781                                 offset);
2782
2783 out:
2784         return cpu_to_le16(crc);
2785 }
2786
2787 int ext4_group_desc_csum_verify(struct super_block *sb, __u32 block_group,
2788                                 struct ext4_group_desc *gdp)
2789 {
2790         if (ext4_has_group_desc_csum(sb) &&
2791             (gdp->bg_checksum != ext4_group_desc_csum(sb, block_group, gdp)))
2792                 return 0;
2793
2794         return 1;
2795 }
2796
2797 void ext4_group_desc_csum_set(struct super_block *sb, __u32 block_group,
2798                               struct ext4_group_desc *gdp)
2799 {
2800         if (!ext4_has_group_desc_csum(sb))
2801                 return;
2802         gdp->bg_checksum = ext4_group_desc_csum(sb, block_group, gdp);
2803 }
2804
2805 /* Called at mount-time, super-block is locked */
2806 static int ext4_check_descriptors(struct super_block *sb,
2807                                   ext4_fsblk_t sb_block,
2808                                   ext4_group_t *first_not_zeroed)
2809 {
2810         struct ext4_sb_info *sbi = EXT4_SB(sb);
2811         ext4_fsblk_t first_block = le32_to_cpu(sbi->s_es->s_first_data_block);
2812         ext4_fsblk_t last_block;
2813         ext4_fsblk_t last_bg_block = sb_block + ext4_bg_num_gdb(sb, 0);
2814         ext4_fsblk_t block_bitmap;
2815         ext4_fsblk_t inode_bitmap;
2816         ext4_fsblk_t inode_table;
2817         int flexbg_flag = 0;
2818         ext4_group_t i, grp = sbi->s_groups_count;
2819
2820         if (ext4_has_feature_flex_bg(sb))
2821                 flexbg_flag = 1;
2822
2823         ext4_debug("Checking group descriptors");
2824
2825         for (i = 0; i < sbi->s_groups_count; i++) {
2826                 struct ext4_group_desc *gdp = ext4_get_group_desc(sb, i, NULL);
2827
2828                 if (i == sbi->s_groups_count - 1 || flexbg_flag)
2829                         last_block = ext4_blocks_count(sbi->s_es) - 1;
2830                 else
2831                         last_block = first_block +
2832                                 (EXT4_BLOCKS_PER_GROUP(sb) - 1);
2833
2834                 if ((grp == sbi->s_groups_count) &&
2835                    !(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
2836                         grp = i;
2837
2838                 block_bitmap = ext4_block_bitmap(sb, gdp);
2839                 if (block_bitmap == sb_block) {
2840                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2841                                  "Block bitmap for group %u overlaps "
2842                                  "superblock", i);
2843                         if (!sb_rdonly(sb))
2844                                 return 0;
2845                 }
2846                 if (block_bitmap >= sb_block + 1 &&
2847                     block_bitmap <= last_bg_block) {
2848                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2849                                  "Block bitmap for group %u overlaps "
2850                                  "block group descriptors", i);
2851                         if (!sb_rdonly(sb))
2852                                 return 0;
2853                 }
2854                 if (block_bitmap < first_block || block_bitmap > last_block) {
2855                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2856                                "Block bitmap for group %u not in group "
2857                                "(block %llu)!", i, block_bitmap);
2858                         return 0;
2859                 }
2860                 inode_bitmap = ext4_inode_bitmap(sb, gdp);
2861                 if (inode_bitmap == sb_block) {
2862                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2863                                  "Inode bitmap for group %u overlaps "
2864                                  "superblock", i);
2865                         if (!sb_rdonly(sb))
2866                                 return 0;
2867                 }
2868                 if (inode_bitmap >= sb_block + 1 &&
2869                     inode_bitmap <= last_bg_block) {
2870                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2871                                  "Inode bitmap for group %u overlaps "
2872                                  "block group descriptors", i);
2873                         if (!sb_rdonly(sb))
2874                                 return 0;
2875                 }
2876                 if (inode_bitmap < first_block || inode_bitmap > last_block) {
2877                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2878                                "Inode bitmap for group %u not in group "
2879                                "(block %llu)!", i, inode_bitmap);
2880                         return 0;
2881                 }
2882                 inode_table = ext4_inode_table(sb, gdp);
2883                 if (inode_table == sb_block) {
2884                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2885                                  "Inode table for group %u overlaps "
2886                                  "superblock", i);
2887                         if (!sb_rdonly(sb))
2888                                 return 0;
2889                 }
2890                 if (inode_table >= sb_block + 1 &&
2891                     inode_table <= last_bg_block) {
2892                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2893                                  "Inode table for group %u overlaps "
2894                                  "block group descriptors", i);
2895                         if (!sb_rdonly(sb))
2896                                 return 0;
2897                 }
2898                 if (inode_table < first_block ||
2899                     inode_table + sbi->s_itb_per_group - 1 > last_block) {
2900                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2901                                "Inode table for group %u not in group "
2902                                "(block %llu)!", i, inode_table);
2903                         return 0;
2904                 }
2905                 ext4_lock_group(sb, i);
2906                 if (!ext4_group_desc_csum_verify(sb, i, gdp)) {
2907                         ext4_msg(sb, KERN_ERR, "ext4_check_descriptors: "
2908                                  "Checksum for group %u failed (%u!=%u)",
2909                                  i, le16_to_cpu(ext4_group_desc_csum(sb, i,
2910                                      gdp)), le16_to_cpu(gdp->bg_checksum));
2911                         if (!sb_rdonly(sb)) {
2912                                 ext4_unlock_group(sb, i);
2913                                 return 0;
2914                         }
2915                 }
2916                 ext4_unlock_group(sb, i);
2917                 if (!flexbg_flag)
2918                         first_block += EXT4_BLOCKS_PER_GROUP(sb);
2919         }
2920         if (NULL != first_not_zeroed)
2921                 *first_not_zeroed = grp;
2922         return 1;
2923 }
2924
2925 /* ext4_orphan_cleanup() walks a singly-linked list of inodes (starting at
2926  * the superblock) which were deleted from all directories, but held open by
2927  * a process at the time of a crash.  We walk the list and try to delete these
2928  * inodes at recovery time (only with a read-write filesystem).
2929  *
2930  * In order to keep the orphan inode chain consistent during traversal (in
2931  * case of crash during recovery), we link each inode into the superblock
2932  * orphan list_head and handle it the same way as an inode deletion during
2933  * normal operation (which journals the operations for us).
2934  *
2935  * We only do an iget() and an iput() on each inode, which is very safe if we
2936  * accidentally point at an in-use or already deleted inode.  The worst that
2937  * can happen in this case is that we get a "bit already cleared" message from
2938  * ext4_free_inode().  The only reason we would point at a wrong inode is if
2939  * e2fsck was run on this filesystem, and it must have already done the orphan
2940  * inode cleanup for us, so we can safely abort without any further action.
2941  */
2942 static void ext4_orphan_cleanup(struct super_block *sb,
2943                                 struct ext4_super_block *es)
2944 {
2945         unsigned int s_flags = sb->s_flags;
2946         int ret, nr_orphans = 0, nr_truncates = 0;
2947 #ifdef CONFIG_QUOTA
2948         int quota_update = 0;
2949         int i;
2950 #endif
2951         if (!es->s_last_orphan) {
2952                 jbd_debug(4, "no orphan inodes to clean up\n");
2953                 return;
2954         }
2955
2956         if (bdev_read_only(sb->s_bdev)) {
2957                 ext4_msg(sb, KERN_ERR, "write access "
2958                         "unavailable, skipping orphan cleanup");
2959                 return;
2960         }
2961
2962         /* Check if feature set would not allow a r/w mount */
2963         if (!ext4_feature_set_ok(sb, 0)) {
2964                 ext4_msg(sb, KERN_INFO, "Skipping orphan cleanup due to "
2965                          "unknown ROCOMPAT features");
2966                 return;
2967         }
2968
2969         if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
2970                 /* don't clear list on RO mount w/ errors */
2971                 if (es->s_last_orphan && !(s_flags & SB_RDONLY)) {
2972                         ext4_msg(sb, KERN_INFO, "Errors on filesystem, "
2973                                   "clearing orphan list.\n");
2974                         es->s_last_orphan = 0;
2975                 }
2976                 jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
2977                 return;
2978         }
2979
2980         if (s_flags & SB_RDONLY) {
2981                 ext4_msg(sb, KERN_INFO, "orphan cleanup on readonly fs");
2982                 sb->s_flags &= ~SB_RDONLY;
2983         }
2984 #ifdef CONFIG_QUOTA
2985         /* Needed for iput() to work correctly and not trash data */
2986         sb->s_flags |= SB_ACTIVE;
2987
2988         /*
2989          * Turn on quotas which were not enabled for read-only mounts if
2990          * filesystem has quota feature, so that they are updated correctly.
2991          */
2992         if (ext4_has_feature_quota(sb) && (s_flags & SB_RDONLY)) {
2993                 int ret = ext4_enable_quotas(sb);
2994
2995                 if (!ret)
2996                         quota_update = 1;
2997                 else
2998                         ext4_msg(sb, KERN_ERR,
2999                                 "Cannot turn on quotas: error %d", ret);
3000         }
3001
3002         /* Turn on journaled quotas used for old sytle */
3003         for (i = 0; i < EXT4_MAXQUOTAS; i++) {
3004                 if (EXT4_SB(sb)->s_qf_names[i]) {
3005                         int ret = ext4_quota_on_mount(sb, i);
3006
3007                         if (!ret)
3008                                 quota_update = 1;
3009                         else
3010                                 ext4_msg(sb, KERN_ERR,
3011                                         "Cannot turn on journaled "
3012                                         "quota: type %d: error %d", i, ret);
3013                 }
3014         }
3015 #endif
3016
3017         while (es->s_last_orphan) {
3018                 struct inode *inode;
3019
3020                 /*
3021                  * We may have encountered an error during cleanup; if
3022                  * so, skip the rest.
3023                  */
3024                 if (EXT4_SB(sb)->s_mount_state & EXT4_ERROR_FS) {
3025                         jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
3026                         es->s_last_orphan = 0;
3027                         break;
3028                 }
3029
3030                 inode = ext4_orphan_get(sb, le32_to_cpu(es->s_last_orphan));
3031                 if (IS_ERR(inode)) {
3032                         es->s_last_orphan = 0;
3033                         break;
3034                 }
3035
3036                 list_add(&EXT4_I(inode)->i_orphan, &EXT4_SB(sb)->s_orphan);
3037                 dquot_initialize(inode);
3038                 if (inode->i_nlink) {
3039                         if (test_opt(sb, DEBUG))
3040                                 ext4_msg(sb, KERN_DEBUG,
3041                                         "%s: truncating inode %lu to %lld bytes",
3042                                         __func__, inode->i_ino, inode->i_size);
3043                         jbd_debug(2, "truncating inode %lu to %lld bytes\n",
3044                                   inode->i_ino, inode->i_size);
3045                         inode_lock(inode);
3046                         truncate_inode_pages(inode->i_mapping, inode->i_size);
3047                         ret = ext4_truncate(inode);
3048                         if (ret)
3049                                 ext4_std_error(inode->i_sb, ret);
3050                         inode_unlock(inode);
3051                         nr_truncates++;
3052                 } else {
3053                         if (test_opt(sb, DEBUG))
3054                                 ext4_msg(sb, KERN_DEBUG,
3055                                         "%s: deleting unreferenced inode %lu",
3056                                         __func__, inode->i_ino);
3057                         jbd_debug(2, "deleting unreferenced inode %lu\n",
3058                                   inode->i_ino);
3059                         nr_orphans++;
3060                 }
3061                 iput(inode);  /* The delete magic happens here! */
3062         }
3063
3064 #define PLURAL(x) (x), ((x) == 1) ? "" : "s"
3065
3066         if (nr_orphans)
3067                 ext4_msg(sb, KERN_INFO, "%d orphan inode%s deleted",
3068                        PLURAL(nr_orphans));
3069         if (nr_truncates)
3070                 ext4_msg(sb, KERN_INFO, "%d truncate%s cleaned up",
3071                        PLURAL(nr_truncates));
3072 #ifdef CONFIG_QUOTA
3073         /* Turn off quotas if they were enabled for orphan cleanup */
3074         if (quota_update) {
3075                 for (i = 0; i < EXT4_MAXQUOTAS; i++) {
3076                         if (sb_dqopt(sb)->files[i])
3077                                 dquot_quota_off(sb, i);
3078                 }
3079         }
3080 #endif
3081         sb->s_flags = s_flags; /* Restore SB_RDONLY status */
3082 }
3083
3084 /*
3085  * Maximal extent format file size.
3086  * Resulting logical blkno at s_maxbytes must fit in our on-disk
3087  * extent format containers, within a sector_t, and within i_blocks
3088  * in the vfs.  ext4 inode has 48 bits of i_block in fsblock units,
3089  * so that won't be a limiting factor.
3090  *
3091  * However there is other limiting factor. We do store extents in the form
3092  * of starting block and length, hence the resulting length of the extent
3093  * covering maximum file size must fit into on-disk format containers as
3094  * well. Given that length is always by 1 unit bigger than max unit (because
3095  * we count 0 as well) we have to lower the s_maxbytes by one fs block.
3096  *
3097  * Note, this does *not* consider any metadata overhead for vfs i_blocks.
3098  */
3099 static loff_t ext4_max_size(int blkbits, int has_huge_files)
3100 {
3101         loff_t res;
3102         loff_t upper_limit = MAX_LFS_FILESIZE;
3103
3104         BUILD_BUG_ON(sizeof(blkcnt_t) < sizeof(u64));
3105
3106         if (!has_huge_files) {
3107                 upper_limit = (1LL << 32) - 1;
3108
3109                 /* total blocks in file system block size */
3110                 upper_limit >>= (blkbits - 9);
3111                 upper_limit <<= blkbits;
3112         }
3113
3114         /*
3115          * 32-bit extent-start container, ee_block. We lower the maxbytes
3116          * by one fs block, so ee_len can cover the extent of maximum file
3117          * size
3118          */
3119         res = (1LL << 32) - 1;
3120         res <<= blkbits;
3121
3122         /* Sanity check against vm- & vfs- imposed limits */
3123         if (res > upper_limit)
3124                 res = upper_limit;
3125
3126         return res;
3127 }
3128
3129 /*
3130  * Maximal bitmap file size.  There is a direct, and {,double-,triple-}indirect
3131  * block limit, and also a limit of (2^48 - 1) 512-byte sectors in i_blocks.
3132  * We need to be 1 filesystem block less than the 2^48 sector limit.
3133  */
3134 static loff_t ext4_max_bitmap_size(int bits, int has_huge_files)
3135 {
3136         loff_t res = EXT4_NDIR_BLOCKS;
3137         int meta_blocks;
3138         loff_t upper_limit;
3139         /* This is calculated to be the largest file size for a dense, block
3140          * mapped file such that the file's total number of 512-byte sectors,
3141          * including data and all indirect blocks, does not exceed (2^48 - 1).
3142          *
3143          * __u32 i_blocks_lo and _u16 i_blocks_high represent the total
3144          * number of 512-byte sectors of the file.
3145          */
3146
3147         if (!has_huge_files) {
3148                 /*
3149                  * !has_huge_files or implies that the inode i_block field
3150                  * represents total file blocks in 2^32 512-byte sectors ==
3151                  * size of vfs inode i_blocks * 8
3152                  */
3153                 upper_limit = (1LL << 32) - 1;
3154
3155                 /* total blocks in file system block size */
3156                 upper_limit >>= (bits - 9);
3157
3158         } else {
3159                 /*
3160                  * We use 48 bit ext4_inode i_blocks
3161                  * With EXT4_HUGE_FILE_FL set the i_blocks
3162                  * represent total number of blocks in
3163                  * file system block size
3164                  */
3165                 upper_limit = (1LL << 48) - 1;
3166
3167         }
3168
3169         /* indirect blocks */
3170         meta_blocks = 1;
3171         /* double indirect blocks */
3172         meta_blocks += 1 + (1LL << (bits-2));
3173         /* tripple indirect blocks */
3174         meta_blocks += 1 + (1LL << (bits-2)) + (1LL << (2*(bits-2)));
3175
3176         upper_limit -= meta_blocks;
3177         upper_limit <<= bits;
3178
3179         res += 1LL << (bits-2);
3180         res += 1LL << (2*(bits-2));
3181         res += 1LL << (3*(bits-2));
3182         res <<= bits;
3183         if (res > upper_limit)
3184                 res = upper_limit;
3185
3186         if (res > MAX_LFS_FILESIZE)
3187                 res = MAX_LFS_FILESIZE;
3188
3189         return res;
3190 }
3191
3192 static ext4_fsblk_t descriptor_loc(struct super_block *sb,
3193                                    ext4_fsblk_t logical_sb_block, int nr)
3194 {
3195         struct ext4_sb_info *sbi = EXT4_SB(sb);
3196         ext4_group_t bg, first_meta_bg;
3197         int has_super = 0;
3198
3199         first_meta_bg = le32_to_cpu(sbi->s_es->s_first_meta_bg);
3200
3201         if (!ext4_has_feature_meta_bg(sb) || nr < first_meta_bg)
3202                 return logical_sb_block + nr + 1;
3203         bg = sbi->s_desc_per_block * nr;
3204         if (ext4_bg_has_super(sb, bg))
3205                 has_super = 1;
3206
3207         /*
3208          * If we have a meta_bg fs with 1k blocks, group 0's GDT is at
3209          * block 2, not 1.  If s_first_data_block == 0 (bigalloc is enabled
3210          * on modern mke2fs or blksize > 1k on older mke2fs) then we must
3211          * compensate.
3212          */
3213         if (sb->s_blocksize == 1024 && nr == 0 &&
3214             le32_to_cpu(sbi->s_es->s_first_data_block) == 0)
3215                 has_super++;
3216
3217         return (has_super + ext4_group_first_block_no(sb, bg));
3218 }
3219
3220 /**
3221  * ext4_get_stripe_size: Get the stripe size.
3222  * @sbi: In memory super block info
3223  *
3224  * If we have specified it via mount option, then
3225  * use the mount option value. If the value specified at mount time is
3226  * greater than the blocks per group use the super block value.
3227  * If the super block value is greater than blocks per group return 0.
3228  * Allocator needs it be less than blocks per group.
3229  *
3230  */
3231 static unsigned long ext4_get_stripe_size(struct ext4_sb_info *sbi)
3232 {
3233         unsigned long stride = le16_to_cpu(sbi->s_es->s_raid_stride);
3234         unsigned long stripe_width =
3235                         le32_to_cpu(sbi->s_es->s_raid_stripe_width);
3236         int ret;
3237
3238         if (sbi->s_stripe && sbi->s_stripe <= sbi->s_blocks_per_group)
3239                 ret = sbi->s_stripe;
3240         else if (stripe_width && stripe_width <= sbi->s_blocks_per_group)
3241                 ret = stripe_width;
3242         else if (stride && stride <= sbi->s_blocks_per_group)
3243                 ret = stride;
3244         else
3245                 ret = 0;
3246
3247         /*
3248          * If the stripe width is 1, this makes no sense and
3249          * we set it to 0 to turn off stripe handling code.
3250          */
3251         if (ret <= 1)
3252                 ret = 0;
3253
3254         return ret;
3255 }
3256
3257 /*
3258  * Check whether this filesystem can be mounted based on
3259  * the features present and the RDONLY/RDWR mount requested.
3260  * Returns 1 if this filesystem can be mounted as requested,
3261  * 0 if it cannot be.
3262  */
3263 static int ext4_feature_set_ok(struct super_block *sb, int readonly)
3264 {
3265         if (ext4_has_unknown_ext4_incompat_features(sb)) {
3266                 ext4_msg(sb, KERN_ERR,
3267                         "Couldn't mount because of "
3268                         "unsupported optional features (%x)",
3269                         (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_incompat) &
3270                         ~EXT4_FEATURE_INCOMPAT_SUPP));
3271                 return 0;
3272         }
3273
3274 #ifndef CONFIG_UNICODE
3275         if (ext4_has_feature_casefold(sb)) {
3276                 ext4_msg(sb, KERN_ERR,
3277                          "Filesystem with casefold feature cannot be "
3278                          "mounted without CONFIG_UNICODE");
3279                 return 0;
3280         }
3281 #endif
3282
3283         if (readonly)
3284                 return 1;
3285
3286         if (ext4_has_feature_readonly(sb)) {
3287                 ext4_msg(sb, KERN_INFO, "filesystem is read-only");
3288                 sb->s_flags |= SB_RDONLY;
3289                 return 1;
3290         }
3291
3292         /* Check that feature set is OK for a read-write mount */
3293         if (ext4_has_unknown_ext4_ro_compat_features(sb)) {
3294                 ext4_msg(sb, KERN_ERR, "couldn't mount RDWR because of "
3295                          "unsupported optional features (%x)",
3296                          (le32_to_cpu(EXT4_SB(sb)->s_es->s_feature_ro_compat) &
3297                                 ~EXT4_FEATURE_RO_COMPAT_SUPP));
3298                 return 0;
3299         }
3300         if (ext4_has_feature_bigalloc(sb) && !ext4_has_feature_extents(sb)) {
3301                 ext4_msg(sb, KERN_ERR,
3302                          "Can't support bigalloc feature without "
3303                          "extents feature\n");
3304                 return 0;
3305         }
3306
3307 #if !IS_ENABLED(CONFIG_QUOTA) || !IS_ENABLED(CONFIG_QFMT_V2)
3308         if (!readonly && (ext4_has_feature_quota(sb) ||
3309                           ext4_has_feature_project(sb))) {
3310                 ext4_msg(sb, KERN_ERR,
3311                          "The kernel was not built with CONFIG_QUOTA and CONFIG_QFMT_V2");
3312                 return 0;
3313         }
3314 #endif  /* CONFIG_QUOTA */
3315         return 1;
3316 }
3317
3318 /*
3319  * This function is called once a day if we have errors logged
3320  * on the file system
3321  */
3322 static void print_daily_error_info(struct timer_list *t)
3323 {
3324         struct ext4_sb_info *sbi = from_timer(sbi, t, s_err_report);
3325         struct super_block *sb = sbi->s_sb;
3326         struct ext4_super_block *es = sbi->s_es;
3327
3328         if (es->s_error_count)
3329                 /* fsck newer than v1.41.13 is needed to clean this condition. */
3330                 ext4_msg(sb, KERN_NOTICE, "error count since last fsck: %u",
3331                          le32_to_cpu(es->s_error_count));
3332         if (es->s_first_error_time) {
3333                 printk(KERN_NOTICE "EXT4-fs (%s): initial error at time %llu: %.*s:%d",
3334                        sb->s_id,
3335                        ext4_get_tstamp(es, s_first_error_time),
3336                        (int) sizeof(es->s_first_error_func),
3337                        es->s_first_error_func,
3338                        le32_to_cpu(es->s_first_error_line));
3339                 if (es->s_first_error_ino)
3340                         printk(KERN_CONT ": inode %u",
3341                                le32_to_cpu(es->s_first_error_ino));
3342                 if (es->s_first_error_block)
3343                         printk(KERN_CONT ": block %llu", (unsigned long long)
3344                                le64_to_cpu(es->s_first_error_block));
3345                 printk(KERN_CONT "\n");
3346         }
3347         if (es->s_last_error_time) {
3348                 printk(KERN_NOTICE "EXT4-fs (%s): last error at time %llu: %.*s:%d",
3349                        sb->s_id,
3350                        ext4_get_tstamp(es, s_last_error_time),
3351                        (int) sizeof(es->s_last_error_func),
3352                        es->s_last_error_func,
3353                        le32_to_cpu(es->s_last_error_line));
3354                 if (es->s_last_error_ino)
3355                         printk(KERN_CONT ": inode %u",
3356                                le32_to_cpu(es->s_last_error_ino));
3357                 if (es->s_last_error_block)
3358                         printk(KERN_CONT ": block %llu", (unsigned long long)
3359                                le64_to_cpu(es->s_last_error_block));
3360                 printk(KERN_CONT "\n");
3361         }
3362         mod_timer(&sbi->s_err_report, jiffies + 24*60*60*HZ);  /* Once a day */
3363 }
3364
3365 /* Find next suitable group and run ext4_init_inode_table */
3366 static int ext4_run_li_request(struct ext4_li_request *elr)
3367 {
3368         struct ext4_group_desc *gdp = NULL;
3369         struct super_block *sb = elr->lr_super;
3370         ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
3371         ext4_group_t group = elr->lr_next_group;
3372         unsigned long timeout = 0;
3373         unsigned int prefetch_ios = 0;
3374         int ret = 0;
3375
3376         if (elr->lr_mode == EXT4_LI_MODE_PREFETCH_BBITMAP) {
3377                 elr->lr_next_group = ext4_mb_prefetch(sb, group,
3378                                 EXT4_SB(sb)->s_mb_prefetch, &prefetch_ios);
3379                 if (prefetch_ios)
3380                         ext4_mb_prefetch_fini(sb, elr->lr_next_group,
3381                                               prefetch_ios);
3382                 trace_ext4_prefetch_bitmaps(sb, group, elr->lr_next_group,
3383                                             prefetch_ios);
3384                 if (group >= elr->lr_next_group) {
3385                         ret = 1;
3386                         if (elr->lr_first_not_zeroed != ngroups &&
3387                             !sb_rdonly(sb) && test_opt(sb, INIT_INODE_TABLE)) {
3388                                 elr->lr_next_group = elr->lr_first_not_zeroed;
3389                                 elr->lr_mode = EXT4_LI_MODE_ITABLE;
3390                                 ret = 0;
3391                         }
3392                 }
3393                 return ret;
3394         }
3395
3396         for (; group < ngroups; group++) {
3397                 gdp = ext4_get_group_desc(sb, group, NULL);
3398                 if (!gdp) {
3399                         ret = 1;
3400                         break;
3401                 }
3402
3403                 if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3404                         break;
3405         }
3406
3407         if (group >= ngroups)
3408                 ret = 1;
3409
3410         if (!ret) {
3411                 timeout = jiffies;
3412                 ret = ext4_init_inode_table(sb, group,
3413                                             elr->lr_timeout ? 0 : 1);
3414                 trace_ext4_lazy_itable_init(sb, group);
3415                 if (elr->lr_timeout == 0) {
3416                         timeout = (jiffies - timeout) *
3417                                 EXT4_SB(elr->lr_super)->s_li_wait_mult;
3418                         elr->lr_timeout = timeout;
3419                 }
3420                 elr->lr_next_sched = jiffies + elr->lr_timeout;
3421                 elr->lr_next_group = group + 1;
3422         }
3423         return ret;
3424 }
3425
3426 /*
3427  * Remove lr_request from the list_request and free the
3428  * request structure. Should be called with li_list_mtx held
3429  */
3430 static void ext4_remove_li_request(struct ext4_li_request *elr)
3431 {
3432         if (!elr)
3433                 return;
3434
3435         list_del(&elr->lr_request);
3436         EXT4_SB(elr->lr_super)->s_li_request = NULL;
3437         kfree(elr);
3438 }
3439
3440 static void ext4_unregister_li_request(struct super_block *sb)
3441 {
3442         mutex_lock(&ext4_li_mtx);
3443         if (!ext4_li_info) {
3444                 mutex_unlock(&ext4_li_mtx);
3445                 return;
3446         }
3447
3448         mutex_lock(&ext4_li_info->li_list_mtx);
3449         ext4_remove_li_request(EXT4_SB(sb)->s_li_request);
3450         mutex_unlock(&ext4_li_info->li_list_mtx);
3451         mutex_unlock(&ext4_li_mtx);
3452 }
3453
3454 static struct task_struct *ext4_lazyinit_task;
3455
3456 /*
3457  * This is the function where ext4lazyinit thread lives. It walks
3458  * through the request list searching for next scheduled filesystem.
3459  * When such a fs is found, run the lazy initialization request
3460  * (ext4_rn_li_request) and keep track of the time spend in this
3461  * function. Based on that time we compute next schedule time of
3462  * the request. When walking through the list is complete, compute
3463  * next waking time and put itself into sleep.
3464  */
3465 static int ext4_lazyinit_thread(void *arg)
3466 {
3467         struct ext4_lazy_init *eli = (struct ext4_lazy_init *)arg;
3468         struct list_head *pos, *n;
3469         struct ext4_li_request *elr;
3470         unsigned long next_wakeup, cur;
3471
3472         BUG_ON(NULL == eli);
3473
3474 cont_thread:
3475         while (true) {
3476                 next_wakeup = MAX_JIFFY_OFFSET;
3477
3478                 mutex_lock(&eli->li_list_mtx);
3479                 if (list_empty(&eli->li_request_list)) {
3480                         mutex_unlock(&eli->li_list_mtx);
3481                         goto exit_thread;
3482                 }
3483                 list_for_each_safe(pos, n, &eli->li_request_list) {
3484                         int err = 0;
3485                         int progress = 0;
3486                         elr = list_entry(pos, struct ext4_li_request,
3487                                          lr_request);
3488
3489                         if (time_before(jiffies, elr->lr_next_sched)) {
3490                                 if (time_before(elr->lr_next_sched, next_wakeup))
3491                                         next_wakeup = elr->lr_next_sched;
3492                                 continue;
3493                         }
3494                         if (down_read_trylock(&elr->lr_super->s_umount)) {
3495                                 if (sb_start_write_trylock(elr->lr_super)) {
3496                                         progress = 1;
3497                                         /*
3498                                          * We hold sb->s_umount, sb can not
3499                                          * be removed from the list, it is
3500                                          * now safe to drop li_list_mtx
3501                                          */
3502                                         mutex_unlock(&eli->li_list_mtx);
3503                                         err = ext4_run_li_request(elr);
3504                                         sb_end_write(elr->lr_super);
3505                                         mutex_lock(&eli->li_list_mtx);
3506                                         n = pos->next;
3507                                 }
3508                                 up_read((&elr->lr_super->s_umount));
3509                         }
3510                         /* error, remove the lazy_init job */
3511                         if (err) {
3512                                 ext4_remove_li_request(elr);
3513                                 continue;
3514                         }
3515                         if (!progress) {
3516                                 elr->lr_next_sched = jiffies +
3517                                         (prandom_u32()
3518                                          % (EXT4_DEF_LI_MAX_START_DELAY * HZ));
3519                         }
3520                         if (time_before(elr->lr_next_sched, next_wakeup))
3521                                 next_wakeup = elr->lr_next_sched;
3522                 }
3523                 mutex_unlock(&eli->li_list_mtx);
3524
3525                 try_to_freeze();
3526
3527                 cur = jiffies;
3528                 if ((time_after_eq(cur, next_wakeup)) ||
3529                     (MAX_JIFFY_OFFSET == next_wakeup)) {
3530                         cond_resched();
3531                         continue;
3532                 }
3533
3534                 schedule_timeout_interruptible(next_wakeup - cur);
3535
3536                 if (kthread_should_stop()) {
3537                         ext4_clear_request_list();
3538                         goto exit_thread;
3539                 }
3540         }
3541
3542 exit_thread:
3543         /*
3544          * It looks like the request list is empty, but we need
3545          * to check it under the li_list_mtx lock, to prevent any
3546          * additions into it, and of course we should lock ext4_li_mtx
3547          * to atomically free the list and ext4_li_info, because at
3548          * this point another ext4 filesystem could be registering
3549          * new one.
3550          */
3551         mutex_lock(&ext4_li_mtx);
3552         mutex_lock(&eli->li_list_mtx);
3553         if (!list_empty(&eli->li_request_list)) {
3554                 mutex_unlock(&eli->li_list_mtx);
3555                 mutex_unlock(&ext4_li_mtx);
3556                 goto cont_thread;
3557         }
3558         mutex_unlock(&eli->li_list_mtx);
3559         kfree(ext4_li_info);
3560         ext4_li_info = NULL;
3561         mutex_unlock(&ext4_li_mtx);
3562
3563         return 0;
3564 }
3565
3566 static void ext4_clear_request_list(void)
3567 {
3568         struct list_head *pos, *n;
3569         struct ext4_li_request *elr;
3570
3571         mutex_lock(&ext4_li_info->li_list_mtx);
3572         list_for_each_safe(pos, n, &ext4_li_info->li_request_list) {
3573                 elr = list_entry(pos, struct ext4_li_request,
3574                                  lr_request);
3575                 ext4_remove_li_request(elr);
3576         }
3577         mutex_unlock(&ext4_li_info->li_list_mtx);
3578 }
3579
3580 static int ext4_run_lazyinit_thread(void)
3581 {
3582         ext4_lazyinit_task = kthread_run(ext4_lazyinit_thread,
3583                                          ext4_li_info, "ext4lazyinit");
3584         if (IS_ERR(ext4_lazyinit_task)) {
3585                 int err = PTR_ERR(ext4_lazyinit_task);
3586                 ext4_clear_request_list();
3587                 kfree(ext4_li_info);
3588                 ext4_li_info = NULL;
3589                 printk(KERN_CRIT "EXT4-fs: error %d creating inode table "
3590                                  "initialization thread\n",
3591                                  err);
3592                 return err;
3593         }
3594         ext4_li_info->li_state |= EXT4_LAZYINIT_RUNNING;
3595         return 0;
3596 }
3597
3598 /*
3599  * Check whether it make sense to run itable init. thread or not.
3600  * If there is at least one uninitialized inode table, return
3601  * corresponding group number, else the loop goes through all
3602  * groups and return total number of groups.
3603  */
3604 static ext4_group_t ext4_has_uninit_itable(struct super_block *sb)
3605 {
3606         ext4_group_t group, ngroups = EXT4_SB(sb)->s_groups_count;
3607         struct ext4_group_desc *gdp = NULL;
3608
3609         if (!ext4_has_group_desc_csum(sb))
3610                 return ngroups;
3611
3612         for (group = 0; group < ngroups; group++) {
3613                 gdp = ext4_get_group_desc(sb, group, NULL);
3614                 if (!gdp)
3615                         continue;
3616
3617                 if (!(gdp->bg_flags & cpu_to_le16(EXT4_BG_INODE_ZEROED)))
3618                         break;
3619         }
3620
3621         return group;
3622 }
3623
3624 static int ext4_li_info_new(void)
3625 {
3626         struct ext4_lazy_init *eli = NULL;
3627
3628         eli = kzalloc(sizeof(*eli), GFP_KERNEL);
3629         if (!eli)
3630                 return -ENOMEM;
3631
3632         INIT_LIST_HEAD(&eli->li_request_list);
3633         mutex_init(&eli->li_list_mtx);
3634
3635         eli->li_state |= EXT4_LAZYINIT_QUIT;
3636
3637         ext4_li_info = eli;
3638
3639         return 0;
3640 }
3641
3642 static struct ext4_li_request *ext4_li_request_new(struct super_block *sb,
3643                                             ext4_group_t start)
3644 {
3645         struct ext4_li_request *elr;
3646
3647         elr = kzalloc(sizeof(*elr), GFP_KERNEL);
3648         if (!elr)
3649                 return NULL;
3650
3651         elr->lr_super = sb;
3652         elr->lr_first_not_zeroed = start;
3653         if (test_opt(sb, PREFETCH_BLOCK_BITMAPS))
3654                 elr->lr_mode = EXT4_LI_MODE_PREFETCH_BBITMAP;
3655         else {
3656                 elr->lr_mode = EXT4_LI_MODE_ITABLE;
3657                 elr->lr_next_group = start;
3658         }
3659
3660         /*
3661          * Randomize first schedule time of the request to
3662          * spread the inode table initialization requests
3663          * better.
3664          */
3665         elr->lr_next_sched = jiffies + (prandom_u32() %
3666                                 (EXT4_DEF_LI_MAX_START_DELAY * HZ));
3667         return elr;
3668 }
3669
3670 int ext4_register_li_request(struct super_block *sb,
3671                              ext4_group_t first_not_zeroed)
3672 {
3673         struct ext4_sb_info *sbi = EXT4_SB(sb);
3674         struct ext4_li_request *elr = NULL;
3675         ext4_group_t ngroups = sbi->s_groups_count;
3676         int ret = 0;
3677
3678         mutex_lock(&ext4_li_mtx);
3679         if (sbi->s_li_request != NULL) {
3680                 /*
3681                  * Reset timeout so it can be computed again, because
3682                  * s_li_wait_mult might have changed.
3683                  */
3684                 sbi->s_li_request->lr_timeout = 0;
3685                 goto out;
3686         }
3687
3688         if (!test_opt(sb, PREFETCH_BLOCK_BITMAPS) &&
3689             (first_not_zeroed == ngroups || sb_rdonly(sb) ||
3690              !test_opt(sb, INIT_INODE_TABLE)))
3691                 goto out;
3692
3693         elr = ext4_li_request_new(sb, first_not_zeroed);
3694         if (!elr) {
3695                 ret = -ENOMEM;
3696                 goto out;
3697         }
3698
3699         if (NULL == ext4_li_info) {
3700                 ret = ext4_li_info_new();
3701                 if (ret)
3702                         goto out;
3703         }
3704
3705         mutex_lock(&ext4_li_info->li_list_mtx);
3706         list_add(&elr->lr_request, &ext4_li_info->li_request_list);
3707         mutex_unlock(&ext4_li_info->li_list_mtx);
3708
3709         sbi->s_li_request = elr;
3710         /*
3711          * set elr to NULL here since it has been inserted to
3712          * the request_list and the removal and free of it is
3713          * handled by ext4_clear_request_list from now on.
3714          */
3715         elr = NULL;
3716
3717         if (!(ext4_li_info->li_state & EXT4_LAZYINIT_RUNNING)) {
3718                 ret = ext4_run_lazyinit_thread();
3719                 if (ret)
3720                         goto out;
3721         }
3722 out:
3723         mutex_unlock(&ext4_li_mtx);
3724         if (ret)
3725                 kfree(elr);
3726         return ret;
3727 }
3728
3729 /*
3730  * We do not need to lock anything since this is called on
3731  * module unload.
3732  */
3733 static void ext4_destroy_lazyinit_thread(void)
3734 {
3735         /*
3736          * If thread exited earlier
3737          * there's nothing to be done.
3738          */
3739         if (!ext4_li_info || !ext4_lazyinit_task)
3740                 return;
3741
3742         kthread_stop(ext4_lazyinit_task);
3743 }
3744
3745 static int set_journal_csum_feature_set(struct super_block *sb)
3746 {
3747         int ret = 1;
3748         int compat, incompat;
3749         struct ext4_sb_info *sbi = EXT4_SB(sb);
3750
3751         if (ext4_has_metadata_csum(sb)) {
3752                 /* journal checksum v3 */
3753                 compat = 0;
3754                 incompat = JBD2_FEATURE_INCOMPAT_CSUM_V3;
3755         } else {
3756                 /* journal checksum v1 */
3757                 compat = JBD2_FEATURE_COMPAT_CHECKSUM;
3758                 incompat = 0;
3759         }
3760
3761         jbd2_journal_clear_features(sbi->s_journal,
3762                         JBD2_FEATURE_COMPAT_CHECKSUM, 0,
3763                         JBD2_FEATURE_INCOMPAT_CSUM_V3 |
3764                         JBD2_FEATURE_INCOMPAT_CSUM_V2);
3765         if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
3766                 ret = jbd2_journal_set_features(sbi->s_journal,
3767                                 compat, 0,
3768                                 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT |
3769                                 incompat);
3770         } else if (test_opt(sb, JOURNAL_CHECKSUM)) {
3771                 ret = jbd2_journal_set_features(sbi->s_journal,
3772                                 compat, 0,
3773                                 incompat);
3774                 jbd2_journal_clear_features(sbi->s_journal, 0, 0,
3775                                 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
3776         } else {
3777                 jbd2_journal_clear_features(sbi->s_journal, 0, 0,
3778                                 JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT);
3779         }
3780
3781         return ret;
3782 }
3783
3784 /*
3785  * Note: calculating the overhead so we can be compatible with
3786  * historical BSD practice is quite difficult in the face of
3787  * clusters/bigalloc.  This is because multiple metadata blocks from
3788  * different block group can end up in the same allocation cluster.
3789  * Calculating the exact overhead in the face of clustered allocation
3790  * requires either O(all block bitmaps) in memory or O(number of block
3791  * groups**2) in time.  We will still calculate the superblock for
3792  * older file systems --- and if we come across with a bigalloc file
3793  * system with zero in s_overhead_clusters the estimate will be close to
3794  * correct especially for very large cluster sizes --- but for newer
3795  * file systems, it's better to calculate this figure once at mkfs
3796  * time, and store it in the superblock.  If the superblock value is
3797  * present (even for non-bigalloc file systems), we will use it.
3798  */
3799 static int count_overhead(struct super_block *sb, ext4_group_t grp,
3800                           char *buf)
3801 {
3802         struct ext4_sb_info     *sbi = EXT4_SB(sb);
3803         struct ext4_group_desc  *gdp;
3804         ext4_fsblk_t            first_block, last_block, b;
3805         ext4_group_t            i, ngroups = ext4_get_groups_count(sb);
3806         int                     s, j, count = 0;
3807
3808         if (!ext4_has_feature_bigalloc(sb))
3809                 return (ext4_bg_has_super(sb, grp) + ext4_bg_num_gdb(sb, grp) +
3810                         sbi->s_itb_per_group + 2);
3811
3812         first_block = le32_to_cpu(sbi->s_es->s_first_data_block) +
3813                 (grp * EXT4_BLOCKS_PER_GROUP(sb));
3814         last_block = first_block + EXT4_BLOCKS_PER_GROUP(sb) - 1;
3815         for (i = 0; i < ngroups; i++) {
3816                 gdp = ext4_get_group_desc(sb, i, NULL);
3817                 b = ext4_block_bitmap(sb, gdp);
3818                 if (b >= first_block && b <= last_block) {
3819                         ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf);
3820                         count++;
3821                 }
3822                 b = ext4_inode_bitmap(sb, gdp);
3823                 if (b >= first_block && b <= last_block) {
3824                         ext4_set_bit(EXT4_B2C(sbi, b - first_block), buf);
3825                         count++;
3826                 }
3827                 b = ext4_inode_table(sb, gdp);
3828                 if (b >= first_block && b + sbi->s_itb_per_group <= last_block)
3829                         for (j = 0; j < sbi->s_itb_per_group; j++, b++) {
3830                                 int c = EXT4_B2C(sbi, b - first_block);
3831                                 ext4_set_bit(c, buf);
3832                                 count++;
3833                         }
3834                 if (i != grp)
3835                         continue;
3836                 s = 0;
3837                 if (ext4_bg_has_super(sb, grp)) {
3838                         ext4_set_bit(s++, buf);
3839                         count++;
3840                 }
3841                 j = ext4_bg_num_gdb(sb, grp);
3842                 if (s + j > EXT4_BLOCKS_PER_GROUP(sb)) {
3843                         ext4_error(sb, "Invalid number of block group "
3844                                    "descriptor blocks: %d", j);
3845                         j = EXT4_BLOCKS_PER_GROUP(sb) - s;
3846                 }
3847                 count += j;
3848                 for (; j > 0; j--)
3849                         ext4_set_bit(EXT4_B2C(sbi, s++), buf);
3850         }
3851         if (!count)
3852                 return 0;
3853         return EXT4_CLUSTERS_PER_GROUP(sb) -
3854                 ext4_count_free(buf, EXT4_CLUSTERS_PER_GROUP(sb) / 8);
3855 }
3856
3857 /*
3858  * Compute the overhead and stash it in sbi->s_overhead
3859  */
3860 int ext4_calculate_overhead(struct super_block *sb)
3861 {
3862         struct ext4_sb_info *sbi = EXT4_SB(sb);
3863         struct ext4_super_block *es = sbi->s_es;
3864         struct inode *j_inode;
3865         unsigned int j_blocks, j_inum = le32_to_cpu(es->s_journal_inum);
3866         ext4_group_t i, ngroups = ext4_get_groups_count(sb);
3867         ext4_fsblk_t overhead = 0;
3868         char *buf = (char *) get_zeroed_page(GFP_NOFS);
3869
3870         if (!buf)
3871                 return -ENOMEM;
3872
3873         /*
3874          * Compute the overhead (FS structures).  This is constant
3875          * for a given filesystem unless the number of block groups
3876          * changes so we cache the previous value until it does.
3877          */
3878
3879         /*
3880          * All of the blocks before first_data_block are overhead
3881          */
3882         overhead = EXT4_B2C(sbi, le32_to_cpu(es->s_first_data_block));
3883
3884         /*
3885          * Add the overhead found in each block group
3886          */
3887         for (i = 0; i < ngroups; i++) {
3888                 int blks;
3889
3890                 blks = count_overhead(sb, i, buf);
3891                 overhead += blks;
3892                 if (blks)
3893                         memset(buf, 0, PAGE_SIZE);
3894                 cond_resched();
3895         }
3896
3897         /*
3898          * Add the internal journal blocks whether the journal has been
3899          * loaded or not
3900          */
3901         if (sbi->s_journal && !sbi->s_journal_bdev)
3902                 overhead += EXT4_NUM_B2C(sbi, sbi->s_journal->j_total_len);
3903         else if (ext4_has_feature_journal(sb) && !sbi->s_journal && j_inum) {
3904                 /* j_inum for internal journal is non-zero */
3905                 j_inode = ext4_get_journal_inode(sb, j_inum);
3906                 if (j_inode) {
3907                         j_blocks = j_inode->i_size >> sb->s_blocksize_bits;
3908                         overhead += EXT4_NUM_B2C(sbi, j_blocks);
3909                         iput(j_inode);
3910                 } else {
3911                         ext4_msg(sb, KERN_ERR, "can't get journal size");
3912                 }
3913         }
3914         sbi->s_overhead = overhead;
3915         smp_wmb();
3916         free_page((unsigned long) buf);
3917         return 0;
3918 }
3919
3920 static void ext4_set_resv_clusters(struct super_block *sb)
3921 {
3922         ext4_fsblk_t resv_clusters;
3923         struct ext4_sb_info *sbi = EXT4_SB(sb);
3924
3925         /*
3926          * There's no need to reserve anything when we aren't using extents.
3927          * The space estimates are exact, there are no unwritten extents,
3928          * hole punching doesn't need new metadata... This is needed especially
3929          * to keep ext2/3 backward compatibility.
3930          */
3931         if (!ext4_has_feature_extents(sb))
3932                 return;
3933         /*
3934          * By default we reserve 2% or 4096 clusters, whichever is smaller.
3935          * This should cover the situations where we can not afford to run
3936          * out of space like for example punch hole, or converting
3937          * unwritten extents in delalloc path. In most cases such
3938          * allocation would require 1, or 2 blocks, higher numbers are
3939          * very rare.
3940          */
3941         resv_clusters = (ext4_blocks_count(sbi->s_es) >>
3942                          sbi->s_cluster_bits);
3943
3944         do_div(resv_clusters, 50);
3945         resv_clusters = min_t(ext4_fsblk_t, resv_clusters, 4096);
3946
3947         atomic64_set(&sbi->s_resv_clusters, resv_clusters);
3948 }
3949
3950 static const char *ext4_quota_mode(struct super_block *sb)
3951 {
3952 #ifdef CONFIG_QUOTA
3953         if (!ext4_quota_capable(sb))
3954                 return "none";
3955
3956         if (EXT4_SB(sb)->s_journal && ext4_is_quota_journalled(sb))
3957                 return "journalled";
3958         else
3959                 return "writeback";
3960 #else
3961         return "disabled";
3962 #endif
3963 }
3964
3965 static int ext4_fill_super(struct super_block *sb, void *data, int silent)
3966 {
3967         struct dax_device *dax_dev = fs_dax_get_by_bdev(sb->s_bdev);
3968         char *orig_data = kstrdup(data, GFP_KERNEL);
3969         struct buffer_head *bh, **group_desc;
3970         struct ext4_super_block *es = NULL;
3971         struct ext4_sb_info *sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
3972         struct flex_groups **flex_groups;
3973         ext4_fsblk_t block;
3974         ext4_fsblk_t sb_block = get_sb_block(&data);
3975         ext4_fsblk_t logical_sb_block;
3976         unsigned long offset = 0;
3977         unsigned long journal_devnum = 0;
3978         unsigned long def_mount_opts;
3979         struct inode *root;
3980         const char *descr;
3981         int ret = -ENOMEM;
3982         int blocksize, clustersize;
3983         unsigned int db_count;
3984         unsigned int i;
3985         int needs_recovery, has_huge_files;
3986         __u64 blocks_count;
3987         int err = 0;
3988         unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
3989         ext4_group_t first_not_zeroed;
3990
3991         if ((data && !orig_data) || !sbi)
3992                 goto out_free_base;
3993
3994         sbi->s_daxdev = dax_dev;
3995         sbi->s_blockgroup_lock =
3996                 kzalloc(sizeof(struct blockgroup_lock), GFP_KERNEL);
3997         if (!sbi->s_blockgroup_lock)
3998                 goto out_free_base;
3999
4000         sb->s_fs_info = sbi;
4001         sbi->s_sb = sb;
4002         sbi->s_inode_readahead_blks = EXT4_DEF_INODE_READAHEAD_BLKS;
4003         sbi->s_sb_block = sb_block;
4004         if (sb->s_bdev->bd_part)
4005                 sbi->s_sectors_written_start =
4006                         part_stat_read(sb->s_bdev->bd_part, sectors[STAT_WRITE]);
4007
4008         /* Cleanup superblock name */
4009         strreplace(sb->s_id, '/', '!');
4010
4011         /* -EINVAL is default */
4012         ret = -EINVAL;
4013         blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE);
4014         if (!blocksize) {
4015                 ext4_msg(sb, KERN_ERR, "unable to set blocksize");
4016                 goto out_fail;
4017         }
4018
4019         /*
4020          * The ext4 superblock will not be buffer aligned for other than 1kB
4021          * block sizes.  We need to calculate the offset from buffer start.
4022          */
4023         if (blocksize != EXT4_MIN_BLOCK_SIZE) {
4024                 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
4025                 offset = do_div(logical_sb_block, blocksize);
4026         } else {
4027                 logical_sb_block = sb_block;
4028         }
4029
4030         bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
4031         if (IS_ERR(bh)) {
4032                 ext4_msg(sb, KERN_ERR, "unable to read superblock");
4033                 ret = PTR_ERR(bh);
4034                 goto out_fail;
4035         }
4036         /*
4037          * Note: s_es must be initialized as soon as possible because
4038          *       some ext4 macro-instructions depend on its value
4039          */
4040         es = (struct ext4_super_block *) (bh->b_data + offset);
4041         sbi->s_es = es;
4042         sb->s_magic = le16_to_cpu(es->s_magic);
4043         if (sb->s_magic != EXT4_SUPER_MAGIC)
4044                 goto cantfind_ext4;
4045         sbi->s_kbytes_written = le64_to_cpu(es->s_kbytes_written);
4046
4047         /* Warn if metadata_csum and gdt_csum are both set. */
4048         if (ext4_has_feature_metadata_csum(sb) &&
4049             ext4_has_feature_gdt_csum(sb))
4050                 ext4_warning(sb, "metadata_csum and uninit_bg are "
4051                              "redundant flags; please run fsck.");
4052
4053         /* Check for a known checksum algorithm */
4054         if (!ext4_verify_csum_type(sb, es)) {
4055                 ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
4056                          "unknown checksum algorithm.");
4057                 silent = 1;
4058                 goto cantfind_ext4;
4059         }
4060
4061         /* Load the checksum driver */
4062         sbi->s_chksum_driver = crypto_alloc_shash("crc32c", 0, 0);
4063         if (IS_ERR(sbi->s_chksum_driver)) {
4064                 ext4_msg(sb, KERN_ERR, "Cannot load crc32c driver.");
4065                 ret = PTR_ERR(sbi->s_chksum_driver);
4066                 sbi->s_chksum_driver = NULL;
4067                 goto failed_mount;
4068         }
4069
4070         /* Check superblock checksum */
4071         if (!ext4_superblock_csum_verify(sb, es)) {
4072                 ext4_msg(sb, KERN_ERR, "VFS: Found ext4 filesystem with "
4073                          "invalid superblock checksum.  Run e2fsck?");
4074                 silent = 1;
4075                 ret = -EFSBADCRC;
4076                 goto cantfind_ext4;
4077         }
4078
4079         /* Precompute checksum seed for all metadata */
4080         if (ext4_has_feature_csum_seed(sb))
4081                 sbi->s_csum_seed = le32_to_cpu(es->s_checksum_seed);
4082         else if (ext4_has_metadata_csum(sb) || ext4_has_feature_ea_inode(sb))
4083                 sbi->s_csum_seed = ext4_chksum(sbi, ~0, es->s_uuid,
4084                                                sizeof(es->s_uuid));
4085
4086         /* Set defaults before we parse the mount options */
4087         def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
4088         set_opt(sb, INIT_INODE_TABLE);
4089         if (def_mount_opts & EXT4_DEFM_DEBUG)
4090                 set_opt(sb, DEBUG);
4091         if (def_mount_opts & EXT4_DEFM_BSDGROUPS)
4092                 set_opt(sb, GRPID);
4093         if (def_mount_opts & EXT4_DEFM_UID16)
4094                 set_opt(sb, NO_UID32);
4095         /* xattr user namespace & acls are now defaulted on */
4096         set_opt(sb, XATTR_USER);
4097 #ifdef CONFIG_EXT4_FS_POSIX_ACL
4098         set_opt(sb, POSIX_ACL);
4099 #endif
4100         if (ext4_has_feature_fast_commit(sb))
4101                 set_opt2(sb, JOURNAL_FAST_COMMIT);
4102         /* don't forget to enable journal_csum when metadata_csum is enabled. */
4103         if (ext4_has_metadata_csum(sb))
4104                 set_opt(sb, JOURNAL_CHECKSUM);
4105
4106         if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
4107                 set_opt(sb, JOURNAL_DATA);
4108         else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
4109                 set_opt(sb, ORDERED_DATA);
4110         else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_WBACK)
4111                 set_opt(sb, WRITEBACK_DATA);
4112
4113         if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_PANIC)
4114                 set_opt(sb, ERRORS_PANIC);
4115         else if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_CONTINUE)
4116                 set_opt(sb, ERRORS_CONT);
4117         else
4118                 set_opt(sb, ERRORS_RO);
4119         /* block_validity enabled by default; disable with noblock_validity */
4120         set_opt(sb, BLOCK_VALIDITY);
4121         if (def_mount_opts & EXT4_DEFM_DISCARD)
4122                 set_opt(sb, DISCARD);
4123
4124         sbi->s_resuid = make_kuid(&init_user_ns, le16_to_cpu(es->s_def_resuid));
4125         sbi->s_resgid = make_kgid(&init_user_ns, le16_to_cpu(es->s_def_resgid));
4126         sbi->s_commit_interval = JBD2_DEFAULT_MAX_COMMIT_AGE * HZ;
4127         sbi->s_min_batch_time = EXT4_DEF_MIN_BATCH_TIME;
4128         sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
4129
4130         if ((def_mount_opts & EXT4_DEFM_NOBARRIER) == 0)
4131                 set_opt(sb, BARRIER);
4132
4133         /*
4134          * enable delayed allocation by default
4135          * Use -o nodelalloc to turn it off
4136          */
4137         if (!IS_EXT3_SB(sb) && !IS_EXT2_SB(sb) &&
4138             ((def_mount_opts & EXT4_DEFM_NODELALLOC) == 0))
4139                 set_opt(sb, DELALLOC);
4140
4141         /*
4142          * set default s_li_wait_mult for lazyinit, for the case there is
4143          * no mount option specified.
4144          */
4145         sbi->s_li_wait_mult = EXT4_DEF_LI_WAIT_MULT;
4146
4147         if (le32_to_cpu(es->s_log_block_size) >
4148             (EXT4_MAX_BLOCK_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
4149                 ext4_msg(sb, KERN_ERR,
4150                          "Invalid log block size: %u",
4151                          le32_to_cpu(es->s_log_block_size));
4152                 goto failed_mount;
4153         }
4154         if (le32_to_cpu(es->s_log_cluster_size) >
4155             (EXT4_MAX_CLUSTER_LOG_SIZE - EXT4_MIN_BLOCK_LOG_SIZE)) {
4156                 ext4_msg(sb, KERN_ERR,
4157                          "Invalid log cluster size: %u",
4158                          le32_to_cpu(es->s_log_cluster_size));
4159                 goto failed_mount;
4160         }
4161
4162         blocksize = EXT4_MIN_BLOCK_SIZE << le32_to_cpu(es->s_log_block_size);
4163
4164         if (blocksize == PAGE_SIZE)
4165                 set_opt(sb, DIOREAD_NOLOCK);
4166
4167         if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV) {
4168                 sbi->s_inode_size = EXT4_GOOD_OLD_INODE_SIZE;
4169                 sbi->s_first_ino = EXT4_GOOD_OLD_FIRST_INO;
4170         } else {
4171                 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
4172                 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
4173                 if (sbi->s_first_ino < EXT4_GOOD_OLD_FIRST_INO) {
4174                         ext4_msg(sb, KERN_ERR, "invalid first ino: %u",
4175                                  sbi->s_first_ino);
4176                         goto failed_mount;
4177                 }
4178                 if ((sbi->s_inode_size < EXT4_GOOD_OLD_INODE_SIZE) ||
4179                     (!is_power_of_2(sbi->s_inode_size)) ||
4180                     (sbi->s_inode_size > blocksize)) {
4181                         ext4_msg(sb, KERN_ERR,
4182                                "unsupported inode size: %d",
4183                                sbi->s_inode_size);
4184                         ext4_msg(sb, KERN_ERR, "blocksize: %d", blocksize);
4185                         goto failed_mount;
4186                 }
4187                 /*
4188                  * i_atime_extra is the last extra field available for
4189                  * [acm]times in struct ext4_inode. Checking for that
4190                  * field should suffice to ensure we have extra space
4191                  * for all three.
4192                  */
4193                 if (sbi->s_inode_size >= offsetof(struct ext4_inode, i_atime_extra) +
4194                         sizeof(((struct ext4_inode *)0)->i_atime_extra)) {
4195                         sb->s_time_gran = 1;
4196                         sb->s_time_max = EXT4_EXTRA_TIMESTAMP_MAX;
4197                 } else {
4198                         sb->s_time_gran = NSEC_PER_SEC;
4199                         sb->s_time_max = EXT4_NON_EXTRA_TIMESTAMP_MAX;
4200                 }
4201                 sb->s_time_min = EXT4_TIMESTAMP_MIN;
4202         }
4203         if (sbi->s_inode_size > EXT4_GOOD_OLD_INODE_SIZE) {
4204                 sbi->s_want_extra_isize = sizeof(struct ext4_inode) -
4205                         EXT4_GOOD_OLD_INODE_SIZE;
4206                 if (ext4_has_feature_extra_isize(sb)) {
4207                         unsigned v, max = (sbi->s_inode_size -
4208                                            EXT4_GOOD_OLD_INODE_SIZE);
4209
4210                         v = le16_to_cpu(es->s_want_extra_isize);
4211                         if (v > max) {
4212                                 ext4_msg(sb, KERN_ERR,
4213                                          "bad s_want_extra_isize: %d", v);
4214                                 goto failed_mount;
4215                         }
4216                         if (sbi->s_want_extra_isize < v)
4217                                 sbi->s_want_extra_isize = v;
4218
4219                         v = le16_to_cpu(es->s_min_extra_isize);
4220                         if (v > max) {
4221                                 ext4_msg(sb, KERN_ERR,
4222                                          "bad s_min_extra_isize: %d", v);
4223                                 goto failed_mount;
4224                         }
4225                         if (sbi->s_want_extra_isize < v)
4226                                 sbi->s_want_extra_isize = v;
4227                 }
4228         }
4229
4230         if (sbi->s_es->s_mount_opts[0]) {
4231                 char *s_mount_opts = kstrndup(sbi->s_es->s_mount_opts,
4232                                               sizeof(sbi->s_es->s_mount_opts),
4233                                               GFP_KERNEL);
4234                 if (!s_mount_opts)
4235                         goto failed_mount;
4236                 if (!parse_options(s_mount_opts, sb, &journal_devnum,
4237                                    &journal_ioprio, 0)) {
4238                         ext4_msg(sb, KERN_WARNING,
4239                                  "failed to parse options in superblock: %s",
4240                                  s_mount_opts);
4241                 }
4242                 kfree(s_mount_opts);
4243         }
4244         sbi->s_def_mount_opt = sbi->s_mount_opt;
4245         if (!parse_options((char *) data, sb, &journal_devnum,
4246                            &journal_ioprio, 0))
4247                 goto failed_mount;
4248
4249 #ifdef CONFIG_UNICODE
4250         if (ext4_has_feature_casefold(sb) && !sb->s_encoding) {
4251                 const struct ext4_sb_encodings *encoding_info;
4252                 struct unicode_map *encoding;
4253                 __u16 encoding_flags;
4254
4255                 if (ext4_has_feature_encrypt(sb)) {
4256                         ext4_msg(sb, KERN_ERR,
4257                                  "Can't mount with encoding and encryption");
4258                         goto failed_mount;
4259                 }
4260
4261                 if (ext4_sb_read_encoding(es, &encoding_info,
4262                                           &encoding_flags)) {
4263                         ext4_msg(sb, KERN_ERR,
4264                                  "Encoding requested by superblock is unknown");
4265                         goto failed_mount;
4266                 }
4267
4268                 encoding = utf8_load(encoding_info->version);
4269                 if (IS_ERR(encoding)) {
4270                         ext4_msg(sb, KERN_ERR,
4271                                  "can't mount with superblock charset: %s-%s "
4272                                  "not supported by the kernel. flags: 0x%x.",
4273                                  encoding_info->name, encoding_info->version,
4274                                  encoding_flags);
4275                         goto failed_mount;
4276                 }
4277                 ext4_msg(sb, KERN_INFO,"Using encoding defined by superblock: "
4278                          "%s-%s with flags 0x%hx", encoding_info->name,
4279                          encoding_info->version?:"\b", encoding_flags);
4280
4281                 sb->s_encoding = encoding;
4282                 sb->s_encoding_flags = encoding_flags;
4283         }
4284 #endif
4285
4286         if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
4287                 printk_once(KERN_WARNING "EXT4-fs: Warning: mounting with data=journal disables delayed allocation, dioread_nolock, O_DIRECT and fast_commit support!\n");
4288                 /* can't mount with both data=journal and dioread_nolock. */
4289                 clear_opt(sb, DIOREAD_NOLOCK);
4290                 clear_opt2(sb, JOURNAL_FAST_COMMIT);
4291                 if (test_opt2(sb, EXPLICIT_DELALLOC)) {
4292                         ext4_msg(sb, KERN_ERR, "can't mount with "
4293                                  "both data=journal and delalloc");
4294                         goto failed_mount;
4295                 }
4296                 if (test_opt(sb, DAX_ALWAYS)) {
4297                         ext4_msg(sb, KERN_ERR, "can't mount with "
4298                                  "both data=journal and dax");
4299                         goto failed_mount;
4300                 }
4301                 if (ext4_has_feature_encrypt(sb)) {
4302                         ext4_msg(sb, KERN_WARNING,
4303                                  "encrypted files will use data=ordered "
4304                                  "instead of data journaling mode");
4305                 }
4306                 if (test_opt(sb, DELALLOC))
4307                         clear_opt(sb, DELALLOC);
4308         } else {
4309                 sb->s_iflags |= SB_I_CGROUPWB;
4310         }
4311
4312         sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
4313                 (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
4314
4315         if (le32_to_cpu(es->s_rev_level) == EXT4_GOOD_OLD_REV &&
4316             (ext4_has_compat_features(sb) ||
4317              ext4_has_ro_compat_features(sb) ||
4318              ext4_has_incompat_features(sb)))
4319                 ext4_msg(sb, KERN_WARNING,
4320                        "feature flags set on rev 0 fs, "
4321                        "running e2fsck is recommended");
4322
4323         if (es->s_creator_os == cpu_to_le32(EXT4_OS_HURD)) {
4324                 set_opt2(sb, HURD_COMPAT);
4325                 if (ext4_has_feature_64bit(sb)) {
4326                         ext4_msg(sb, KERN_ERR,
4327                                  "The Hurd can't support 64-bit file systems");
4328                         goto failed_mount;
4329                 }
4330
4331                 /*
4332                  * ea_inode feature uses l_i_version field which is not
4333                  * available in HURD_COMPAT mode.
4334                  */
4335                 if (ext4_has_feature_ea_inode(sb)) {
4336                         ext4_msg(sb, KERN_ERR,
4337                                  "ea_inode feature is not supported for Hurd");
4338                         goto failed_mount;
4339                 }
4340         }
4341
4342         if (IS_EXT2_SB(sb)) {
4343                 if (ext2_feature_set_ok(sb))
4344                         ext4_msg(sb, KERN_INFO, "mounting ext2 file system "
4345                                  "using the ext4 subsystem");
4346                 else {
4347                         /*
4348                          * If we're probing be silent, if this looks like
4349                          * it's actually an ext[34] filesystem.
4350                          */
4351                         if (silent && ext4_feature_set_ok(sb, sb_rdonly(sb)))
4352                                 goto failed_mount;
4353                         ext4_msg(sb, KERN_ERR, "couldn't mount as ext2 due "
4354                                  "to feature incompatibilities");
4355                         goto failed_mount;
4356                 }
4357         }
4358
4359         if (IS_EXT3_SB(sb)) {
4360                 if (ext3_feature_set_ok(sb))
4361                         ext4_msg(sb, KERN_INFO, "mounting ext3 file system "
4362                                  "using the ext4 subsystem");
4363                 else {
4364                         /*
4365                          * If we're probing be silent, if this looks like
4366                          * it's actually an ext4 filesystem.
4367                          */
4368                         if (silent && ext4_feature_set_ok(sb, sb_rdonly(sb)))
4369                                 goto failed_mount;
4370                         ext4_msg(sb, KERN_ERR, "couldn't mount as ext3 due "
4371                                  "to feature incompatibilities");
4372                         goto failed_mount;
4373                 }
4374         }
4375
4376         /*
4377          * Check feature flags regardless of the revision level, since we
4378          * previously didn't change the revision level when setting the flags,
4379          * so there is a chance incompat flags are set on a rev 0 filesystem.
4380          */
4381         if (!ext4_feature_set_ok(sb, (sb_rdonly(sb))))
4382                 goto failed_mount;
4383
4384         if (le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks) > (blocksize / 4)) {
4385                 ext4_msg(sb, KERN_ERR,
4386                          "Number of reserved GDT blocks insanely large: %d",
4387                          le16_to_cpu(sbi->s_es->s_reserved_gdt_blocks));
4388                 goto failed_mount;
4389         }
4390
4391         if (bdev_dax_supported(sb->s_bdev, blocksize))
4392                 set_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags);
4393
4394         if (sbi->s_mount_opt & EXT4_MOUNT_DAX_ALWAYS) {
4395                 if (ext4_has_feature_inline_data(sb)) {
4396                         ext4_msg(sb, KERN_ERR, "Cannot use DAX on a filesystem"
4397                                         " that may contain inline data");
4398                         goto failed_mount;
4399                 }
4400                 if (!test_bit(EXT4_FLAGS_BDEV_IS_DAX, &sbi->s_ext4_flags)) {
4401                         ext4_msg(sb, KERN_ERR,
4402                                 "DAX unsupported by block device.");
4403                         goto failed_mount;
4404                 }
4405         }
4406
4407         if (ext4_has_feature_encrypt(sb) && es->s_encryption_level) {
4408                 ext4_msg(sb, KERN_ERR, "Unsupported encryption level %d",
4409                          es->s_encryption_level);
4410                 goto failed_mount;
4411         }
4412
4413         if (sb->s_blocksize != blocksize) {
4414                 /* Validate the filesystem blocksize */
4415                 if (!sb_set_blocksize(sb, blocksize)) {
4416                         ext4_msg(sb, KERN_ERR, "bad block size %d",
4417                                         blocksize);
4418                         goto failed_mount;
4419                 }
4420
4421                 brelse(bh);
4422                 logical_sb_block = sb_block * EXT4_MIN_BLOCK_SIZE;
4423                 offset = do_div(logical_sb_block, blocksize);
4424                 bh = ext4_sb_bread_unmovable(sb, logical_sb_block);
4425                 if (IS_ERR(bh)) {
4426                         ext4_msg(sb, KERN_ERR,
4427                                "Can't read superblock on 2nd try");
4428                         ret = PTR_ERR(bh);
4429                         bh = NULL;
4430                         goto failed_mount;
4431                 }
4432                 es = (struct ext4_super_block *)(bh->b_data + offset);
4433                 sbi->s_es = es;
4434                 if (es->s_magic != cpu_to_le16(EXT4_SUPER_MAGIC)) {
4435                         ext4_msg(sb, KERN_ERR,
4436                                "Magic mismatch, very weird!");
4437                         goto failed_mount;
4438                 }
4439         }
4440
4441         has_huge_files = ext4_has_feature_huge_file(sb);
4442         sbi->s_bitmap_maxbytes = ext4_max_bitmap_size(sb->s_blocksize_bits,
4443                                                       has_huge_files);
4444         sb->s_maxbytes = ext4_max_size(sb->s_blocksize_bits, has_huge_files);
4445
4446         sbi->s_desc_size = le16_to_cpu(es->s_desc_size);
4447         if (ext4_has_feature_64bit(sb)) {
4448                 if (sbi->s_desc_size < EXT4_MIN_DESC_SIZE_64BIT ||
4449                     sbi->s_desc_size > EXT4_MAX_DESC_SIZE ||
4450                     !is_power_of_2(sbi->s_desc_size)) {
4451                         ext4_msg(sb, KERN_ERR,
4452                                "unsupported descriptor size %lu",
4453                                sbi->s_desc_size);
4454                         goto failed_mount;
4455                 }
4456         } else
4457                 sbi->s_desc_size = EXT4_MIN_DESC_SIZE;
4458
4459         sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
4460         sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
4461
4462         sbi->s_inodes_per_block = blocksize / EXT4_INODE_SIZE(sb);
4463         if (sbi->s_inodes_per_block == 0)
4464                 goto cantfind_ext4;
4465         if (sbi->s_inodes_per_group < sbi->s_inodes_per_block ||
4466             sbi->s_inodes_per_group > blocksize * 8) {
4467                 ext4_msg(sb, KERN_ERR, "invalid inodes per group: %lu\n",
4468                          sbi->s_inodes_per_group);
4469                 goto failed_mount;
4470         }
4471         sbi->s_itb_per_group = sbi->s_inodes_per_group /
4472                                         sbi->s_inodes_per_block;
4473         sbi->s_desc_per_block = blocksize / EXT4_DESC_SIZE(sb);
4474         sbi->s_sbh = bh;
4475         sbi->s_mount_state = le16_to_cpu(es->s_state);
4476         sbi->s_addr_per_block_bits = ilog2(EXT4_ADDR_PER_BLOCK(sb));
4477         sbi->s_desc_per_block_bits = ilog2(EXT4_DESC_PER_BLOCK(sb));
4478
4479         for (i = 0; i < 4; i++)
4480                 sbi->s_hash_seed[i] = le32_to_cpu(es->s_hash_seed[i]);
4481         sbi->s_def_hash_version = es->s_def_hash_version;
4482         if (ext4_has_feature_dir_index(sb)) {
4483                 i = le32_to_cpu(es->s_flags);
4484                 if (i & EXT2_FLAGS_UNSIGNED_HASH)
4485                         sbi->s_hash_unsigned = 3;
4486                 else if ((i & EXT2_FLAGS_SIGNED_HASH) == 0) {
4487 #ifdef __CHAR_UNSIGNED__
4488                         if (!sb_rdonly(sb))
4489                                 es->s_flags |=
4490                                         cpu_to_le32(EXT2_FLAGS_UNSIGNED_HASH);
4491                         sbi->s_hash_unsigned = 3;
4492 #else
4493                         if (!sb_rdonly(sb))
4494                                 es->s_flags |=
4495                                         cpu_to_le32(EXT2_FLAGS_SIGNED_HASH);
4496 #endif
4497                 }
4498         }
4499
4500         /* Handle clustersize */
4501         clustersize = BLOCK_SIZE << le32_to_cpu(es->s_log_cluster_size);
4502         if (ext4_has_feature_bigalloc(sb)) {
4503                 if (clustersize < blocksize) {
4504                         ext4_msg(sb, KERN_ERR,
4505                                  "cluster size (%d) smaller than "
4506                                  "block size (%d)", clustersize, blocksize);
4507                         goto failed_mount;
4508                 }
4509                 sbi->s_cluster_bits = le32_to_cpu(es->s_log_cluster_size) -
4510                         le32_to_cpu(es->s_log_block_size);
4511                 sbi->s_clusters_per_group =
4512                         le32_to_cpu(es->s_clusters_per_group);
4513                 if (sbi->s_clusters_per_group > blocksize * 8) {
4514                         ext4_msg(sb, KERN_ERR,
4515                                  "#clusters per group too big: %lu",
4516                                  sbi->s_clusters_per_group);
4517                         goto failed_mount;
4518                 }
4519                 if (sbi->s_blocks_per_group !=
4520                     (sbi->s_clusters_per_group * (clustersize / blocksize))) {
4521                         ext4_msg(sb, KERN_ERR, "blocks per group (%lu) and "
4522                                  "clusters per group (%lu) inconsistent",
4523                                  sbi->s_blocks_per_group,
4524                                  sbi->s_clusters_per_group);
4525                         goto failed_mount;
4526                 }
4527         } else {
4528                 if (clustersize != blocksize) {
4529                         ext4_msg(sb, KERN_ERR,
4530                                  "fragment/cluster size (%d) != "
4531                                  "block size (%d)", clustersize, blocksize);
4532                         goto failed_mount;
4533                 }
4534                 if (sbi->s_blocks_per_group > blocksize * 8) {
4535                         ext4_msg(sb, KERN_ERR,
4536                                  "#blocks per group too big: %lu",
4537                                  sbi->s_blocks_per_group);
4538                         goto failed_mount;
4539                 }
4540                 sbi->s_clusters_per_group = sbi->s_blocks_per_group;
4541                 sbi->s_cluster_bits = 0;
4542         }
4543         sbi->s_cluster_ratio = clustersize / blocksize;
4544
4545         /* Do we have standard group size of clustersize * 8 blocks ? */
4546         if (sbi->s_blocks_per_group == clustersize << 3)
4547                 set_opt2(sb, STD_GROUP_SIZE);
4548
4549         /*
4550          * Test whether we have more sectors than will fit in sector_t,
4551          * and whether the max offset is addressable by the page cache.
4552          */
4553         err = generic_check_addressable(sb->s_blocksize_bits,
4554                                         ext4_blocks_count(es));
4555         if (err) {
4556                 ext4_msg(sb, KERN_ERR, "filesystem"
4557                          " too large to mount safely on this system");
4558                 goto failed_mount;
4559         }
4560
4561         if (EXT4_BLOCKS_PER_GROUP(sb) == 0)
4562                 goto cantfind_ext4;
4563
4564         /* check blocks count against device size */
4565         blocks_count = sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits;
4566         if (blocks_count && ext4_blocks_count(es) > blocks_count) {
4567                 ext4_msg(sb, KERN_WARNING, "bad geometry: block count %llu "
4568                        "exceeds size of device (%llu blocks)",
4569                        ext4_blocks_count(es), blocks_count);
4570                 goto failed_mount;
4571         }
4572
4573         /*
4574          * It makes no sense for the first data block to be beyond the end
4575          * of the filesystem.
4576          */
4577         if (le32_to_cpu(es->s_first_data_block) >= ext4_blocks_count(es)) {
4578                 ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
4579                          "block %u is beyond end of filesystem (%llu)",
4580                          le32_to_cpu(es->s_first_data_block),
4581                          ext4_blocks_count(es));
4582                 goto failed_mount;
4583         }
4584         if ((es->s_first_data_block == 0) && (es->s_log_block_size == 0) &&
4585             (sbi->s_cluster_ratio == 1)) {
4586                 ext4_msg(sb, KERN_WARNING, "bad geometry: first data "
4587                          "block is 0 with a 1k block and cluster size");
4588                 goto failed_mount;
4589         }
4590
4591         blocks_count = (ext4_blocks_count(es) -
4592                         le32_to_cpu(es->s_first_data_block) +
4593                         EXT4_BLOCKS_PER_GROUP(sb) - 1);
4594         do_div(blocks_count, EXT4_BLOCKS_PER_GROUP(sb));
4595         if (blocks_count > ((uint64_t)1<<32) - EXT4_DESC_PER_BLOCK(sb)) {
4596                 ext4_msg(sb, KERN_WARNING, "groups count too large: %llu "
4597                        "(block count %llu, first data block %u, "
4598                        "blocks per group %lu)", blocks_count,
4599                        ext4_blocks_count(es),
4600                        le32_to_cpu(es->s_first_data_block),
4601                        EXT4_BLOCKS_PER_GROUP(sb));
4602                 goto failed_mount;
4603         }
4604         sbi->s_groups_count = blocks_count;
4605         sbi->s_blockfile_groups = min_t(ext4_group_t, sbi->s_groups_count,
4606                         (EXT4_MAX_BLOCK_FILE_PHYS / EXT4_BLOCKS_PER_GROUP(sb)));
4607         if (((u64)sbi->s_groups_count * sbi->s_inodes_per_group) !=
4608             le32_to_cpu(es->s_inodes_count)) {
4609                 ext4_msg(sb, KERN_ERR, "inodes count not valid: %u vs %llu",
4610                          le32_to_cpu(es->s_inodes_count),
4611                          ((u64)sbi->s_groups_count * sbi->s_inodes_per_group));
4612                 ret = -EINVAL;
4613                 goto failed_mount;
4614         }
4615         db_count = (sbi->s_groups_count + EXT4_DESC_PER_BLOCK(sb) - 1) /
4616                    EXT4_DESC_PER_BLOCK(sb);
4617         if (ext4_has_feature_meta_bg(sb)) {
4618                 if (le32_to_cpu(es->s_first_meta_bg) > db_count) {
4619                         ext4_msg(sb, KERN_WARNING,
4620                                  "first meta block group too large: %u "
4621                                  "(group descriptor block count %u)",
4622                                  le32_to_cpu(es->s_first_meta_bg), db_count);
4623                         goto failed_mount;
4624                 }
4625         }
4626         rcu_assign_pointer(sbi->s_group_desc,
4627                            kvmalloc_array(db_count,
4628                                           sizeof(struct buffer_head *),
4629                                           GFP_KERNEL));
4630         if (sbi->s_group_desc == NULL) {
4631                 ext4_msg(sb, KERN_ERR, "not enough memory");
4632                 ret = -ENOMEM;
4633                 goto failed_mount;
4634         }
4635
4636         bgl_lock_init(sbi->s_blockgroup_lock);
4637
4638         /* Pre-read the descriptors into the buffer cache */
4639         for (i = 0; i < db_count; i++) {
4640                 block = descriptor_loc(sb, logical_sb_block, i);
4641                 ext4_sb_breadahead_unmovable(sb, block);
4642         }
4643
4644         for (i = 0; i < db_count; i++) {
4645                 struct buffer_head *bh;
4646
4647                 block = descriptor_loc(sb, logical_sb_block, i);
4648                 bh = ext4_sb_bread_unmovable(sb, block);
4649                 if (IS_ERR(bh)) {
4650                         ext4_msg(sb, KERN_ERR,
4651                                "can't read group descriptor %d", i);
4652                         db_count = i;
4653                         ret = PTR_ERR(bh);
4654                         goto failed_mount2;
4655                 }
4656                 rcu_read_lock();
4657                 rcu_dereference(sbi->s_group_desc)[i] = bh;
4658                 rcu_read_unlock();
4659         }
4660         sbi->s_gdb_count = db_count;
4661         if (!ext4_check_descriptors(sb, logical_sb_block, &first_not_zeroed)) {
4662                 ext4_msg(sb, KERN_ERR, "group descriptors corrupted!");
4663                 ret = -EFSCORRUPTED;
4664                 goto failed_mount2;
4665         }
4666
4667         timer_setup(&sbi->s_err_report, print_daily_error_info, 0);
4668         spin_lock_init(&sbi->s_error_lock);
4669         INIT_WORK(&sbi->s_error_work, flush_stashed_error_work);
4670
4671         /* Register extent status tree shrinker */
4672         if (ext4_es_register_shrinker(sbi))
4673                 goto failed_mount3;
4674
4675         sbi->s_stripe = ext4_get_stripe_size(sbi);
4676         sbi->s_extent_max_zeroout_kb = 32;
4677
4678         /*
4679          * set up enough so that it can read an inode
4680          */
4681         sb->s_op = &ext4_sops;
4682         sb->s_export_op = &ext4_export_ops;
4683         sb->s_xattr = ext4_xattr_handlers;
4684 #ifdef CONFIG_FS_ENCRYPTION
4685         sb->s_cop = &ext4_cryptops;
4686 #endif
4687 #ifdef CONFIG_FS_VERITY
4688         sb->s_vop = &ext4_verityops;
4689 #endif
4690 #ifdef CONFIG_QUOTA
4691         sb->dq_op = &ext4_quota_operations;
4692         if (ext4_has_feature_quota(sb))
4693                 sb->s_qcop = &dquot_quotactl_sysfile_ops;
4694         else
4695                 sb->s_qcop = &ext4_qctl_operations;
4696         sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
4697 #endif
4698         memcpy(&sb->s_uuid, es->s_uuid, sizeof(es->s_uuid));
4699
4700         INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
4701         mutex_init(&sbi->s_orphan_lock);
4702
4703         /* Initialize fast commit stuff */
4704         atomic_set(&sbi->s_fc_subtid, 0);
4705         atomic_set(&sbi->s_fc_ineligible_updates, 0);
4706         INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_MAIN]);
4707         INIT_LIST_HEAD(&sbi->s_fc_q[FC_Q_STAGING]);
4708         INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_MAIN]);
4709         INIT_LIST_HEAD(&sbi->s_fc_dentry_q[FC_Q_STAGING]);
4710         sbi->s_fc_bytes = 0;
4711         ext4_clear_mount_flag(sb, EXT4_MF_FC_INELIGIBLE);
4712         ext4_clear_mount_flag(sb, EXT4_MF_FC_COMMITTING);
4713         spin_lock_init(&sbi->s_fc_lock);
4714         memset(&sbi->s_fc_stats, 0, sizeof(sbi->s_fc_stats));
4715         sbi->s_fc_replay_state.fc_regions = NULL;
4716         sbi->s_fc_replay_state.fc_regions_size = 0;
4717         sbi->s_fc_replay_state.fc_regions_used = 0;
4718         sbi->s_fc_replay_state.fc_regions_valid = 0;
4719         sbi->s_fc_replay_state.fc_modified_inodes = NULL;
4720         sbi->s_fc_replay_state.fc_modified_inodes_size = 0;
4721         sbi->s_fc_replay_state.fc_modified_inodes_used = 0;
4722
4723         sb->s_root = NULL;
4724
4725         needs_recovery = (es->s_last_orphan != 0 ||
4726                           ext4_has_feature_journal_needs_recovery(sb));
4727
4728         if (ext4_has_feature_mmp(sb) && !sb_rdonly(sb))
4729                 if (ext4_multi_mount_protect(sb, le64_to_cpu(es->s_mmp_block)))
4730                         goto failed_mount3a;
4731
4732         /*
4733          * The first inode we look at is the journal inode.  Don't try
4734          * root first: it may be modified in the journal!
4735          */
4736         if (!test_opt(sb, NOLOAD) && ext4_has_feature_journal(sb)) {
4737                 err = ext4_load_journal(sb, es, journal_devnum);
4738                 if (err)
4739                         goto failed_mount3a;
4740         } else if (test_opt(sb, NOLOAD) && !sb_rdonly(sb) &&
4741                    ext4_has_feature_journal_needs_recovery(sb)) {
4742                 ext4_msg(sb, KERN_ERR, "required journal recovery "
4743                        "suppressed and not mounted read-only");
4744                 goto failed_mount_wq;
4745         } else {
4746                 /* Nojournal mode, all journal mount options are illegal */
4747                 if (test_opt2(sb, EXPLICIT_JOURNAL_CHECKSUM)) {
4748                         ext4_msg(sb, KERN_ERR, "can't mount with "
4749                                  "journal_checksum, fs mounted w/o journal");
4750                         goto failed_mount_wq;
4751                 }
4752                 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
4753                         ext4_msg(sb, KERN_ERR, "can't mount with "
4754                                  "journal_async_commit, fs mounted w/o journal");
4755                         goto failed_mount_wq;
4756                 }
4757                 if (sbi->s_commit_interval != JBD2_DEFAULT_MAX_COMMIT_AGE*HZ) {
4758                         ext4_msg(sb, KERN_ERR, "can't mount with "
4759                                  "commit=%lu, fs mounted w/o journal",
4760                                  sbi->s_commit_interval / HZ);
4761                         goto failed_mount_wq;
4762                 }
4763                 if (EXT4_MOUNT_DATA_FLAGS &
4764                     (sbi->s_mount_opt ^ sbi->s_def_mount_opt)) {
4765                         ext4_msg(sb, KERN_ERR, "can't mount with "
4766                                  "data=, fs mounted w/o journal");
4767                         goto failed_mount_wq;
4768                 }
4769                 sbi->s_def_mount_opt &= ~EXT4_MOUNT_JOURNAL_CHECKSUM;
4770                 clear_opt(sb, JOURNAL_CHECKSUM);
4771                 clear_opt(sb, DATA_FLAGS);
4772                 clear_opt2(sb, JOURNAL_FAST_COMMIT);
4773                 sbi->s_journal = NULL;
4774                 needs_recovery = 0;
4775                 goto no_journal;
4776         }
4777
4778         if (ext4_has_feature_64bit(sb) &&
4779             !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
4780                                        JBD2_FEATURE_INCOMPAT_64BIT)) {
4781                 ext4_msg(sb, KERN_ERR, "Failed to set 64-bit journal feature");
4782                 goto failed_mount_wq;
4783         }
4784
4785         if (!set_journal_csum_feature_set(sb)) {
4786                 ext4_msg(sb, KERN_ERR, "Failed to set journal checksum "
4787                          "feature set");
4788                 goto failed_mount_wq;
4789         }
4790
4791         if (test_opt2(sb, JOURNAL_FAST_COMMIT) &&
4792                 !jbd2_journal_set_features(EXT4_SB(sb)->s_journal, 0, 0,
4793                                           JBD2_FEATURE_INCOMPAT_FAST_COMMIT)) {
4794                 ext4_msg(sb, KERN_ERR,
4795                         "Failed to set fast commit journal feature");
4796                 goto failed_mount_wq;
4797         }
4798
4799         /* We have now updated the journal if required, so we can
4800          * validate the data journaling mode. */
4801         switch (test_opt(sb, DATA_FLAGS)) {
4802         case 0:
4803                 /* No mode set, assume a default based on the journal
4804                  * capabilities: ORDERED_DATA if the journal can
4805                  * cope, else JOURNAL_DATA
4806                  */
4807                 if (jbd2_journal_check_available_features
4808                     (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
4809                         set_opt(sb, ORDERED_DATA);
4810                         sbi->s_def_mount_opt |= EXT4_MOUNT_ORDERED_DATA;
4811                 } else {
4812                         set_opt(sb, JOURNAL_DATA);
4813                         sbi->s_def_mount_opt |= EXT4_MOUNT_JOURNAL_DATA;
4814                 }
4815                 break;
4816
4817         case EXT4_MOUNT_ORDERED_DATA:
4818         case EXT4_MOUNT_WRITEBACK_DATA:
4819                 if (!jbd2_journal_check_available_features
4820                     (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE)) {
4821                         ext4_msg(sb, KERN_ERR, "Journal does not support "
4822                                "requested data journaling mode");
4823                         goto failed_mount_wq;
4824                 }
4825                 break;
4826         default:
4827                 break;
4828         }
4829
4830         if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA &&
4831             test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
4832                 ext4_msg(sb, KERN_ERR, "can't mount with "
4833                         "journal_async_commit in data=ordered mode");
4834                 goto failed_mount_wq;
4835         }
4836
4837         set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
4838
4839         sbi->s_journal->j_commit_callback = ext4_journal_commit_callback;
4840         sbi->s_journal->j_submit_inode_data_buffers =
4841                 ext4_journal_submit_inode_data_buffers;
4842         sbi->s_journal->j_finish_inode_data_buffers =
4843                 ext4_journal_finish_inode_data_buffers;
4844
4845 no_journal:
4846         if (!test_opt(sb, NO_MBCACHE)) {
4847                 sbi->s_ea_block_cache = ext4_xattr_create_cache();
4848                 if (!sbi->s_ea_block_cache) {
4849                         ext4_msg(sb, KERN_ERR,
4850                                  "Failed to create ea_block_cache");
4851                         goto failed_mount_wq;
4852                 }
4853
4854                 if (ext4_has_feature_ea_inode(sb)) {
4855                         sbi->s_ea_inode_cache = ext4_xattr_create_cache();
4856                         if (!sbi->s_ea_inode_cache) {
4857                                 ext4_msg(sb, KERN_ERR,
4858                                          "Failed to create ea_inode_cache");
4859                                 goto failed_mount_wq;
4860                         }
4861                 }
4862         }
4863
4864         if (ext4_has_feature_verity(sb) && blocksize != PAGE_SIZE) {
4865                 ext4_msg(sb, KERN_ERR, "Unsupported blocksize for fs-verity");
4866                 goto failed_mount_wq;
4867         }
4868
4869         if (DUMMY_ENCRYPTION_ENABLED(sbi) && !sb_rdonly(sb) &&
4870             !ext4_has_feature_encrypt(sb)) {
4871                 ext4_set_feature_encrypt(sb);
4872                 ext4_commit_super(sb, 1);
4873         }
4874
4875         /*
4876          * Get the # of file system overhead blocks from the
4877          * superblock if present.
4878          */
4879         if (es->s_overhead_clusters)
4880                 sbi->s_overhead = le32_to_cpu(es->s_overhead_clusters);
4881         else {
4882                 err = ext4_calculate_overhead(sb);
4883                 if (err)
4884                         goto failed_mount_wq;
4885         }
4886
4887         /*
4888          * The maximum number of concurrent works can be high and
4889          * concurrency isn't really necessary.  Limit it to 1.
4890          */
4891         EXT4_SB(sb)->rsv_conversion_wq =
4892                 alloc_workqueue("ext4-rsv-conversion", WQ_MEM_RECLAIM | WQ_UNBOUND, 1);
4893         if (!EXT4_SB(sb)->rsv_conversion_wq) {
4894                 printk(KERN_ERR "EXT4-fs: failed to create workqueue\n");
4895                 ret = -ENOMEM;
4896                 goto failed_mount4;
4897         }
4898
4899         /*
4900          * The jbd2_journal_load will have done any necessary log recovery,
4901          * so we can safely mount the rest of the filesystem now.
4902          */
4903
4904         root = ext4_iget(sb, EXT4_ROOT_INO, EXT4_IGET_SPECIAL);
4905         if (IS_ERR(root)) {
4906                 ext4_msg(sb, KERN_ERR, "get root inode failed");
4907                 ret = PTR_ERR(root);
4908                 root = NULL;
4909                 goto failed_mount4;
4910         }
4911         if (!S_ISDIR(root->i_mode) || !root->i_blocks || !root->i_size) {
4912                 ext4_msg(sb, KERN_ERR, "corrupt root inode, run e2fsck");
4913                 iput(root);
4914                 goto failed_mount4;
4915         }
4916
4917 #ifdef CONFIG_UNICODE
4918         if (sb->s_encoding)
4919                 sb->s_d_op = &ext4_dentry_ops;
4920 #endif
4921
4922         sb->s_root = d_make_root(root);
4923         if (!sb->s_root) {
4924                 ext4_msg(sb, KERN_ERR, "get root dentry failed");
4925                 ret = -ENOMEM;
4926                 goto failed_mount4;
4927         }
4928
4929         ret = ext4_setup_super(sb, es, sb_rdonly(sb));
4930         if (ret == -EROFS) {
4931                 sb->s_flags |= SB_RDONLY;
4932                 ret = 0;
4933         } else if (ret)
4934                 goto failed_mount4a;
4935
4936         ext4_set_resv_clusters(sb);
4937
4938         if (test_opt(sb, BLOCK_VALIDITY)) {
4939                 err = ext4_setup_system_zone(sb);
4940                 if (err) {
4941                         ext4_msg(sb, KERN_ERR, "failed to initialize system "
4942                                  "zone (%d)", err);
4943                         goto failed_mount4a;
4944                 }
4945         }
4946         ext4_fc_replay_cleanup(sb);
4947
4948         ext4_ext_init(sb);
4949         err = ext4_mb_init(sb);
4950         if (err) {
4951                 ext4_msg(sb, KERN_ERR, "failed to initialize mballoc (%d)",
4952                          err);
4953                 goto failed_mount5;
4954         }
4955
4956         block = ext4_count_free_clusters(sb);
4957         ext4_free_blocks_count_set(sbi->s_es,
4958                                    EXT4_C2B(sbi, block));
4959         err = percpu_counter_init(&sbi->s_freeclusters_counter, block,
4960                                   GFP_KERNEL);
4961         if (!err) {
4962                 unsigned long freei = ext4_count_free_inodes(sb);
4963                 sbi->s_es->s_free_inodes_count = cpu_to_le32(freei);
4964                 err = percpu_counter_init(&sbi->s_freeinodes_counter, freei,
4965                                           GFP_KERNEL);
4966         }
4967         if (!err)
4968                 err = percpu_counter_init(&sbi->s_dirs_counter,
4969                                           ext4_count_dirs(sb), GFP_KERNEL);
4970         if (!err)
4971                 err = percpu_counter_init(&sbi->s_dirtyclusters_counter, 0,
4972                                           GFP_KERNEL);
4973         if (!err)
4974                 err = percpu_init_rwsem(&sbi->s_writepages_rwsem);
4975
4976         if (err) {
4977                 ext4_msg(sb, KERN_ERR, "insufficient memory");
4978                 goto failed_mount6;
4979         }
4980
4981         if (ext4_has_feature_flex_bg(sb))
4982                 if (!ext4_fill_flex_info(sb)) {
4983                         ext4_msg(sb, KERN_ERR,
4984                                "unable to initialize "
4985                                "flex_bg meta info!");
4986                         goto failed_mount6;
4987                 }
4988
4989         err = ext4_register_li_request(sb, first_not_zeroed);
4990         if (err)
4991                 goto failed_mount6;
4992
4993         err = ext4_register_sysfs(sb);
4994         if (err)
4995                 goto failed_mount7;
4996
4997 #ifdef CONFIG_QUOTA
4998         /* Enable quota usage during mount. */
4999         if (ext4_has_feature_quota(sb) && !sb_rdonly(sb)) {
5000                 err = ext4_enable_quotas(sb);
5001                 if (err)
5002                         goto failed_mount8;
5003         }
5004 #endif  /* CONFIG_QUOTA */
5005
5006         /*
5007          * Save the original bdev mapping's wb_err value which could be
5008          * used to detect the metadata async write error.
5009          */
5010         spin_lock_init(&sbi->s_bdev_wb_lock);
5011         errseq_check_and_advance(&sb->s_bdev->bd_inode->i_mapping->wb_err,
5012                                  &sbi->s_bdev_wb_err);
5013         sb->s_bdev->bd_super = sb;
5014         EXT4_SB(sb)->s_mount_state |= EXT4_ORPHAN_FS;
5015         ext4_orphan_cleanup(sb, es);
5016         EXT4_SB(sb)->s_mount_state &= ~EXT4_ORPHAN_FS;
5017         if (needs_recovery) {
5018                 ext4_msg(sb, KERN_INFO, "recovery complete");
5019                 err = ext4_mark_recovery_complete(sb, es);
5020                 if (err)
5021                         goto failed_mount8;
5022         }
5023         if (EXT4_SB(sb)->s_journal) {
5024                 if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)
5025                         descr = " journalled data mode";
5026                 else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA)
5027                         descr = " ordered data mode";
5028                 else
5029                         descr = " writeback data mode";
5030         } else
5031                 descr = "out journal";
5032
5033         if (test_opt(sb, DISCARD)) {
5034                 struct request_queue *q = bdev_get_queue(sb->s_bdev);
5035                 if (!blk_queue_discard(q))
5036                         ext4_msg(sb, KERN_WARNING,
5037                                  "mounting with \"discard\" option, but "
5038                                  "the device does not support discard");
5039         }
5040
5041         if (___ratelimit(&ext4_mount_msg_ratelimit, "EXT4-fs mount"))
5042                 ext4_msg(sb, KERN_INFO, "mounted filesystem with%s. "
5043                          "Opts: %.*s%s%s. Quota mode: %s.", descr,
5044                          (int) sizeof(sbi->s_es->s_mount_opts),
5045                          sbi->s_es->s_mount_opts,
5046                          *sbi->s_es->s_mount_opts ? "; " : "", orig_data,
5047                          ext4_quota_mode(sb));
5048
5049         if (es->s_error_count)
5050                 mod_timer(&sbi->s_err_report, jiffies + 300*HZ); /* 5 minutes */
5051
5052         /* Enable message ratelimiting. Default is 10 messages per 5 secs. */
5053         ratelimit_state_init(&sbi->s_err_ratelimit_state, 5 * HZ, 10);
5054         ratelimit_state_init(&sbi->s_warning_ratelimit_state, 5 * HZ, 10);
5055         ratelimit_state_init(&sbi->s_msg_ratelimit_state, 5 * HZ, 10);
5056         atomic_set(&sbi->s_warning_count, 0);
5057         atomic_set(&sbi->s_msg_count, 0);
5058
5059         kfree(orig_data);
5060         return 0;
5061
5062 cantfind_ext4:
5063         if (!silent)
5064                 ext4_msg(sb, KERN_ERR, "VFS: Can't find ext4 filesystem");
5065         goto failed_mount;
5066
5067 failed_mount8:
5068         ext4_unregister_sysfs(sb);
5069         kobject_put(&sbi->s_kobj);
5070 failed_mount7:
5071         ext4_unregister_li_request(sb);
5072 failed_mount6:
5073         ext4_mb_release(sb);
5074         rcu_read_lock();
5075         flex_groups = rcu_dereference(sbi->s_flex_groups);
5076         if (flex_groups) {
5077                 for (i = 0; i < sbi->s_flex_groups_allocated; i++)
5078                         kvfree(flex_groups[i]);
5079                 kvfree(flex_groups);
5080         }
5081         rcu_read_unlock();
5082         percpu_counter_destroy(&sbi->s_freeclusters_counter);
5083         percpu_counter_destroy(&sbi->s_freeinodes_counter);
5084         percpu_counter_destroy(&sbi->s_dirs_counter);
5085         percpu_counter_destroy(&sbi->s_dirtyclusters_counter);
5086         percpu_free_rwsem(&sbi->s_writepages_rwsem);
5087 failed_mount5:
5088         ext4_ext_release(sb);
5089         ext4_release_system_zone(sb);
5090 failed_mount4a:
5091         dput(sb->s_root);
5092         sb->s_root = NULL;
5093 failed_mount4:
5094         ext4_msg(sb, KERN_ERR, "mount failed");
5095         if (EXT4_SB(sb)->rsv_conversion_wq)
5096                 destroy_workqueue(EXT4_SB(sb)->rsv_conversion_wq);
5097 failed_mount_wq:
5098         ext4_xattr_destroy_cache(sbi->s_ea_inode_cache);
5099         sbi->s_ea_inode_cache = NULL;
5100
5101         ext4_xattr_destroy_cache(sbi->s_ea_block_cache);
5102         sbi->s_ea_block_cache = NULL;
5103
5104         if (sbi->s_journal) {
5105                 jbd2_journal_destroy(sbi->s_journal);
5106                 sbi->s_journal = NULL;
5107         }
5108 failed_mount3a:
5109         ext4_es_unregister_shrinker(sbi);
5110 failed_mount3:
5111         del_timer_sync(&sbi->s_err_report);
5112         flush_work(&sbi->s_error_work);
5113         if (sbi->s_mmp_tsk)
5114                 kthread_stop(sbi->s_mmp_tsk);
5115 failed_mount2:
5116         rcu_read_lock();
5117         group_desc = rcu_dereference(sbi->s_group_desc);
5118         for (i = 0; i < db_count; i++)
5119                 brelse(group_desc[i]);
5120         kvfree(group_desc);
5121         rcu_read_unlock();
5122 failed_mount:
5123         if (sbi->s_chksum_driver)
5124                 crypto_free_shash(sbi->s_chksum_driver);
5125
5126 #ifdef CONFIG_UNICODE
5127         utf8_unload(sb->s_encoding);
5128 #endif
5129
5130 #ifdef CONFIG_QUOTA
5131         for (i = 0; i < EXT4_MAXQUOTAS; i++)
5132                 kfree(get_qf_name(sb, sbi, i));
5133 #endif
5134         fscrypt_free_dummy_policy(&sbi->s_dummy_enc_policy);
5135         ext4_blkdev_remove(sbi);
5136         brelse(bh);
5137 out_fail:
5138         sb->s_fs_info = NULL;
5139         kfree(sbi->s_blockgroup_lock);
5140 out_free_base:
5141         kfree(sbi);
5142         kfree(orig_data);
5143         fs_put_dax(dax_dev);
5144         return err ? err : ret;
5145 }
5146
5147 /*
5148  * Setup any per-fs journal parameters now.  We'll do this both on
5149  * initial mount, once the journal has been initialised but before we've
5150  * done any recovery; and again on any subsequent remount.
5151  */
5152 static void ext4_init_journal_params(struct super_block *sb, journal_t *journal)
5153 {
5154         struct ext4_sb_info *sbi = EXT4_SB(sb);
5155
5156         journal->j_commit_interval = sbi->s_commit_interval;
5157         journal->j_min_batch_time = sbi->s_min_batch_time;
5158         journal->j_max_batch_time = sbi->s_max_batch_time;
5159         ext4_fc_init(sb, journal);
5160
5161         write_lock(&journal->j_state_lock);
5162         if (test_opt(sb, BARRIER))
5163                 journal->j_flags |= JBD2_BARRIER;
5164         else
5165                 journal->j_flags &= ~JBD2_BARRIER;
5166         if (test_opt(sb, DATA_ERR_ABORT))
5167                 journal->j_flags |= JBD2_ABORT_ON_SYNCDATA_ERR;
5168         else
5169                 journal->j_flags &= ~JBD2_ABORT_ON_SYNCDATA_ERR;
5170         write_unlock(&journal->j_state_lock);
5171 }
5172
5173 static struct inode *ext4_get_journal_inode(struct super_block *sb,
5174                                              unsigned int journal_inum)
5175 {
5176         struct inode *journal_inode;
5177
5178         /*
5179          * Test for the existence of a valid inode on disk.  Bad things
5180          * happen if we iget() an unused inode, as the subsequent iput()
5181          * will try to delete it.
5182          */
5183         journal_inode = ext4_iget(sb, journal_inum, EXT4_IGET_SPECIAL);
5184         if (IS_ERR(journal_inode)) {
5185                 ext4_msg(sb, KERN_ERR, "no journal found");
5186                 return NULL;
5187         }
5188         if (!journal_inode->i_nlink) {
5189                 make_bad_inode(journal_inode);
5190                 iput(journal_inode);
5191                 ext4_msg(sb, KERN_ERR, "journal inode is deleted");
5192                 return NULL;
5193         }
5194
5195         jbd_debug(2, "Journal inode found at %p: %lld bytes\n",
5196                   journal_inode, journal_inode->i_size);
5197         if (!S_ISREG(journal_inode->i_mode)) {
5198                 ext4_msg(sb, KERN_ERR, "invalid journal inode");
5199                 iput(journal_inode);
5200                 return NULL;
5201         }
5202         return journal_inode;
5203 }
5204
5205 static journal_t *ext4_get_journal(struct super_block *sb,
5206                                    unsigned int journal_inum)
5207 {
5208         struct inode *journal_inode;
5209         journal_t *journal;
5210
5211         if (WARN_ON_ONCE(!ext4_has_feature_journal(sb)))
5212                 return NULL;
5213
5214         journal_inode = ext4_get_journal_inode(sb, journal_inum);
5215         if (!journal_inode)
5216                 return NULL;
5217
5218         journal = jbd2_journal_init_inode(journal_inode);
5219         if (!journal) {
5220                 ext4_msg(sb, KERN_ERR, "Could not load journal inode");
5221                 iput(journal_inode);
5222                 return NULL;
5223         }
5224         journal->j_private = sb;
5225         ext4_init_journal_params(sb, journal);
5226         return journal;
5227 }
5228
5229 static journal_t *ext4_get_dev_journal(struct super_block *sb,
5230                                        dev_t j_dev)
5231 {
5232         struct buffer_head *bh;
5233         journal_t *journal;
5234         ext4_fsblk_t start;
5235         ext4_fsblk_t len;
5236         int hblock, blocksize;
5237         ext4_fsblk_t sb_block;
5238         unsigned long offset;
5239         struct ext4_super_block *es;
5240         struct block_device *bdev;
5241
5242         if (WARN_ON_ONCE(!ext4_has_feature_journal(sb)))
5243                 return NULL;
5244
5245         bdev = ext4_blkdev_get(j_dev, sb);
5246         if (bdev == NULL)
5247                 return NULL;
5248
5249         blocksize = sb->s_blocksize;
5250         hblock = bdev_logical_block_size(bdev);
5251         if (blocksize < hblock) {
5252                 ext4_msg(sb, KERN_ERR,
5253                         "blocksize too small for journal device");
5254                 goto out_bdev;
5255         }
5256
5257         sb_block = EXT4_MIN_BLOCK_SIZE / blocksize;
5258         offset = EXT4_MIN_BLOCK_SIZE % blocksize;
5259         set_blocksize(bdev, blocksize);
5260         if (!(bh = __bread(bdev, sb_block, blocksize))) {
5261                 ext4_msg(sb, KERN_ERR, "couldn't read superblock of "
5262                        "external journal");
5263                 goto out_bdev;
5264         }
5265
5266         es = (struct ext4_super_block *) (bh->b_data + offset);
5267         if ((le16_to_cpu(es->s_magic) != EXT4_SUPER_MAGIC) ||
5268             !(le32_to_cpu(es->s_feature_incompat) &
5269               EXT4_FEATURE_INCOMPAT_JOURNAL_DEV)) {
5270                 ext4_msg(sb, KERN_ERR, "external journal has "
5271                                         "bad superblock");
5272                 brelse(bh);
5273                 goto out_bdev;
5274         }
5275
5276         if ((le32_to_cpu(es->s_feature_ro_compat) &
5277              EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
5278             es->s_checksum != ext4_superblock_csum(sb, es)) {
5279                 ext4_msg(sb, KERN_ERR, "external journal has "
5280                                        "corrupt superblock");
5281                 brelse(bh);
5282                 goto out_bdev;
5283         }
5284
5285         if (memcmp(EXT4_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
5286                 ext4_msg(sb, KERN_ERR, "journal UUID does not match");
5287                 brelse(bh);
5288                 goto out_bdev;
5289         }
5290
5291         len = ext4_blocks_count(es);
5292         start = sb_block + 1;
5293         brelse(bh);     /* we're done with the superblock */
5294
5295         journal = jbd2_journal_init_dev(bdev, sb->s_bdev,
5296                                         start, len, blocksize);
5297         if (!journal) {
5298                 ext4_msg(sb, KERN_ERR, "failed to create device journal");
5299                 goto out_bdev;
5300         }
5301         journal->j_private = sb;
5302         if (ext4_read_bh_lock(journal->j_sb_buffer, REQ_META | REQ_PRIO, true)) {
5303                 ext4_msg(sb, KERN_ERR, "I/O error on journal device");
5304                 goto out_journal;
5305         }
5306         if (be32_to_cpu(journal->j_superblock->s_nr_users) != 1) {
5307                 ext4_msg(sb, KERN_ERR, "External journal has more than one "
5308                                         "user (unsupported) - %d",
5309                         be32_to_cpu(journal->j_superblock->s_nr_users));
5310                 goto out_journal;
5311         }
5312         EXT4_SB(sb)->s_journal_bdev = bdev;
5313         ext4_init_journal_params(sb, journal);
5314         return journal;
5315
5316 out_journal:
5317         jbd2_journal_destroy(journal);
5318 out_bdev:
5319         ext4_blkdev_put(bdev);
5320         return NULL;
5321 }
5322
5323 static int ext4_load_journal(struct super_block *sb,
5324                              struct ext4_super_block *es,
5325                              unsigned long journal_devnum)
5326 {
5327         journal_t *journal;
5328         unsigned int journal_inum = le32_to_cpu(es->s_journal_inum);
5329         dev_t journal_dev;
5330         int err = 0;
5331         int really_read_only;
5332         int journal_dev_ro;
5333
5334         if (WARN_ON_ONCE(!ext4_has_feature_journal(sb)))
5335                 return -EFSCORRUPTED;
5336
5337         if (journal_devnum &&
5338             journal_devnum != le32_to_cpu(es->s_journal_dev)) {
5339                 ext4_msg(sb, KERN_INFO, "external journal device major/minor "
5340                         "numbers have changed");
5341                 journal_dev = new_decode_dev(journal_devnum);
5342         } else
5343                 journal_dev = new_decode_dev(le32_to_cpu(es->s_journal_dev));
5344
5345         if (journal_inum && journal_dev) {
5346                 ext4_msg(sb, KERN_ERR,
5347                          "filesystem has both journal inode and journal device!");
5348                 return -EINVAL;
5349         }
5350
5351         if (journal_inum) {
5352                 journal = ext4_get_journal(sb, journal_inum);
5353                 if (!journal)
5354                         return -EINVAL;
5355         } else {
5356                 journal = ext4_get_dev_journal(sb, journal_dev);
5357                 if (!journal)
5358                         return -EINVAL;
5359         }
5360
5361         journal_dev_ro = bdev_read_only(journal->j_dev);
5362         really_read_only = bdev_read_only(sb->s_bdev) | journal_dev_ro;
5363
5364         if (journal_dev_ro && !sb_rdonly(sb)) {
5365                 ext4_msg(sb, KERN_ERR,
5366                          "journal device read-only, try mounting with '-o ro'");
5367                 err = -EROFS;
5368                 goto err_out;
5369         }
5370
5371         /*
5372          * Are we loading a blank journal or performing recovery after a
5373          * crash?  For recovery, we need to check in advance whether we
5374          * can get read-write access to the device.
5375          */
5376         if (ext4_has_feature_journal_needs_recovery(sb)) {
5377                 if (sb_rdonly(sb)) {
5378                         ext4_msg(sb, KERN_INFO, "INFO: recovery "
5379                                         "required on readonly filesystem");
5380                         if (really_read_only) {
5381                                 ext4_msg(sb, KERN_ERR, "write access "
5382                                         "unavailable, cannot proceed "
5383                                         "(try mounting with noload)");
5384                                 err = -EROFS;
5385                                 goto err_out;
5386                         }
5387                         ext4_msg(sb, KERN_INFO, "write access will "
5388                                "be enabled during recovery");
5389                 }
5390         }
5391
5392         if (!(journal->j_flags & JBD2_BARRIER))
5393                 ext4_msg(sb, KERN_INFO, "barriers disabled");
5394
5395         if (!ext4_has_feature_journal_needs_recovery(sb))
5396                 err = jbd2_journal_wipe(journal, !really_read_only);
5397         if (!err) {
5398                 char *save = kmalloc(EXT4_S_ERR_LEN, GFP_KERNEL);
5399                 if (save)
5400                         memcpy(save, ((char *) es) +
5401                                EXT4_S_ERR_START, EXT4_S_ERR_LEN);
5402                 err = jbd2_journal_load(journal);
5403                 if (save)
5404                         memcpy(((char *) es) + EXT4_S_ERR_START,
5405                                save, EXT4_S_ERR_LEN);
5406                 kfree(save);
5407         }
5408
5409         if (err) {
5410                 ext4_msg(sb, KERN_ERR, "error loading journal");
5411                 goto err_out;
5412         }
5413
5414         EXT4_SB(sb)->s_journal = journal;
5415         err = ext4_clear_journal_err(sb, es);
5416         if (err) {
5417                 EXT4_SB(sb)->s_journal = NULL;
5418                 jbd2_journal_destroy(journal);
5419                 return err;
5420         }
5421
5422         if (!really_read_only && journal_devnum &&
5423             journal_devnum != le32_to_cpu(es->s_journal_dev)) {
5424                 es->s_journal_dev = cpu_to_le32(journal_devnum);
5425
5426                 /* Make sure we flush the recovery flag to disk. */
5427                 ext4_commit_super(sb, 1);
5428         }
5429
5430         return 0;
5431
5432 err_out:
5433         jbd2_journal_destroy(journal);
5434         return err;
5435 }
5436
5437 static int ext4_commit_super(struct super_block *sb, int sync)
5438 {
5439         struct ext4_sb_info *sbi = EXT4_SB(sb);
5440         struct ext4_super_block *es = EXT4_SB(sb)->s_es;
5441         struct buffer_head *sbh = EXT4_SB(sb)->s_sbh;
5442         int error = 0;
5443
5444         if (!sbh || block_device_ejected(sb))
5445                 return error;
5446
5447         /*
5448          * If the file system is mounted read-only, don't update the
5449          * superblock write time.  This avoids updating the superblock
5450          * write time when we are mounting the root file system
5451          * read/only but we need to replay the journal; at that point,
5452          * for people who are east of GMT and who make their clock
5453          * tick in localtime for Windows bug-for-bug compatibility,
5454          * the clock is set in the future, and this will cause e2fsck
5455          * to complain and force a full file system check.
5456          */
5457         if (!(sb->s_flags & SB_RDONLY))
5458                 ext4_update_tstamp(es, s_wtime);
5459         if (sb->s_bdev->bd_part)
5460                 es->s_kbytes_written =
5461                         cpu_to_le64(EXT4_SB(sb)->s_kbytes_written +
5462                             ((part_stat_read(sb->s_bdev->bd_part,
5463                                              sectors[STAT_WRITE]) -
5464                               EXT4_SB(sb)->s_sectors_written_start) >> 1));
5465         else
5466                 es->s_kbytes_written =
5467                         cpu_to_le64(EXT4_SB(sb)->s_kbytes_written);
5468         if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeclusters_counter))
5469                 ext4_free_blocks_count_set(es,
5470                         EXT4_C2B(EXT4_SB(sb), percpu_counter_sum_positive(
5471                                 &EXT4_SB(sb)->s_freeclusters_counter)));
5472         if (percpu_counter_initialized(&EXT4_SB(sb)->s_freeinodes_counter))
5473                 es->s_free_inodes_count =
5474                         cpu_to_le32(percpu_counter_sum_positive(
5475                                 &EXT4_SB(sb)->s_freeinodes_counter));
5476         /* Copy error information to the on-disk superblock */
5477         spin_lock(&sbi->s_error_lock);
5478         if (sbi->s_add_error_count > 0) {
5479                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
5480                 if (!es->s_first_error_time && !es->s_first_error_time_hi) {
5481                         __ext4_update_tstamp(&es->s_first_error_time,
5482                                              &es->s_first_error_time_hi,
5483                                              sbi->s_first_error_time);
5484                         strncpy(es->s_first_error_func, sbi->s_first_error_func,
5485                                 sizeof(es->s_first_error_func));
5486                         es->s_first_error_line =
5487                                 cpu_to_le32(sbi->s_first_error_line);
5488                         es->s_first_error_ino =
5489                                 cpu_to_le32(sbi->s_first_error_ino);
5490                         es->s_first_error_block =
5491                                 cpu_to_le64(sbi->s_first_error_block);
5492                         es->s_first_error_errcode =
5493                                 ext4_errno_to_code(sbi->s_first_error_code);
5494                 }
5495                 __ext4_update_tstamp(&es->s_last_error_time,
5496                                      &es->s_last_error_time_hi,
5497                                      sbi->s_last_error_time);
5498                 strncpy(es->s_last_error_func, sbi->s_last_error_func,
5499                         sizeof(es->s_last_error_func));
5500                 es->s_last_error_line = cpu_to_le32(sbi->s_last_error_line);
5501                 es->s_last_error_ino = cpu_to_le32(sbi->s_last_error_ino);
5502                 es->s_last_error_block = cpu_to_le64(sbi->s_last_error_block);
5503                 es->s_last_error_errcode =
5504                                 ext4_errno_to_code(sbi->s_last_error_code);
5505                 /*
5506                  * Start the daily error reporting function if it hasn't been
5507                  * started already
5508                  */
5509                 if (!es->s_error_count)
5510                         mod_timer(&sbi->s_err_report, jiffies + 24*60*60*HZ);
5511                 le32_add_cpu(&es->s_error_count, sbi->s_add_error_count);
5512                 sbi->s_add_error_count = 0;
5513         }
5514         spin_unlock(&sbi->s_error_lock);
5515
5516         BUFFER_TRACE(sbh, "marking dirty");
5517         ext4_superblock_csum_set(sb);
5518         if (sync)
5519                 lock_buffer(sbh);
5520         if (buffer_write_io_error(sbh) || !buffer_uptodate(sbh)) {
5521                 /*
5522                  * Oh, dear.  A previous attempt to write the
5523                  * superblock failed.  This could happen because the
5524                  * USB device was yanked out.  Or it could happen to
5525                  * be a transient write error and maybe the block will
5526                  * be remapped.  Nothing we can do but to retry the
5527                  * write and hope for the best.
5528                  */
5529                 ext4_msg(sb, KERN_ERR, "previous I/O error to "
5530                        "superblock detected");
5531                 clear_buffer_write_io_error(sbh);
5532                 set_buffer_uptodate(sbh);
5533         }
5534         mark_buffer_dirty(sbh);
5535         if (sync) {
5536                 unlock_buffer(sbh);
5537                 error = __sync_dirty_buffer(sbh,
5538                         REQ_SYNC | (test_opt(sb, BARRIER) ? REQ_FUA : 0));
5539                 if (buffer_write_io_error(sbh)) {
5540                         ext4_msg(sb, KERN_ERR, "I/O error while writing "
5541                                "superblock");
5542                         clear_buffer_write_io_error(sbh);
5543                         set_buffer_uptodate(sbh);
5544                 }
5545         }
5546         return error;
5547 }
5548
5549 /*
5550  * Have we just finished recovery?  If so, and if we are mounting (or
5551  * remounting) the filesystem readonly, then we will end up with a
5552  * consistent fs on disk.  Record that fact.
5553  */
5554 static int ext4_mark_recovery_complete(struct super_block *sb,
5555                                        struct ext4_super_block *es)
5556 {
5557         int err;
5558         journal_t *journal = EXT4_SB(sb)->s_journal;
5559
5560         if (!ext4_has_feature_journal(sb)) {
5561                 if (journal != NULL) {
5562                         ext4_error(sb, "Journal got removed while the fs was "
5563                                    "mounted!");
5564                         return -EFSCORRUPTED;
5565                 }
5566                 return 0;
5567         }
5568         jbd2_journal_lock_updates(journal);
5569         err = jbd2_journal_flush(journal);
5570         if (err < 0)
5571                 goto out;
5572
5573         if (ext4_has_feature_journal_needs_recovery(sb) && sb_rdonly(sb)) {
5574                 ext4_clear_feature_journal_needs_recovery(sb);
5575                 ext4_commit_super(sb, 1);
5576         }
5577 out:
5578         jbd2_journal_unlock_updates(journal);
5579         return err;
5580 }
5581
5582 /*
5583  * If we are mounting (or read-write remounting) a filesystem whose journal
5584  * has recorded an error from a previous lifetime, move that error to the
5585  * main filesystem now.
5586  */
5587 static int ext4_clear_journal_err(struct super_block *sb,
5588                                    struct ext4_super_block *es)
5589 {
5590         journal_t *journal;
5591         int j_errno;
5592         const char *errstr;
5593
5594         if (!ext4_has_feature_journal(sb)) {
5595                 ext4_error(sb, "Journal got removed while the fs was mounted!");
5596                 return -EFSCORRUPTED;
5597         }
5598
5599         journal = EXT4_SB(sb)->s_journal;
5600
5601         /*
5602          * Now check for any error status which may have been recorded in the
5603          * journal by a prior ext4_error() or ext4_abort()
5604          */
5605
5606         j_errno = jbd2_journal_errno(journal);
5607         if (j_errno) {
5608                 char nbuf[16];
5609
5610                 errstr = ext4_decode_error(sb, j_errno, nbuf);
5611                 ext4_warning(sb, "Filesystem error recorded "
5612                              "from previous mount: %s", errstr);
5613                 ext4_warning(sb, "Marking fs in need of filesystem check.");
5614
5615                 EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
5616                 es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
5617                 ext4_commit_super(sb, 1);
5618
5619                 jbd2_journal_clear_err(journal);
5620                 jbd2_journal_update_sb_errno(journal);
5621         }
5622         return 0;
5623 }
5624
5625 /*
5626  * Force the running and committing transactions to commit,
5627  * and wait on the commit.
5628  */
5629 int ext4_force_commit(struct super_block *sb)
5630 {
5631         journal_t *journal;
5632
5633         if (sb_rdonly(sb))
5634                 return 0;
5635
5636         journal = EXT4_SB(sb)->s_journal;
5637         return ext4_journal_force_commit(journal);
5638 }
5639
5640 static int ext4_sync_fs(struct super_block *sb, int wait)
5641 {
5642         int ret = 0;
5643         tid_t target;
5644         bool needs_barrier = false;
5645         struct ext4_sb_info *sbi = EXT4_SB(sb);
5646
5647         if (unlikely(ext4_forced_shutdown(sbi)))
5648                 return 0;
5649
5650         trace_ext4_sync_fs(sb, wait);
5651         flush_workqueue(sbi->rsv_conversion_wq);
5652         /*
5653          * Writeback quota in non-journalled quota case - journalled quota has
5654          * no dirty dquots
5655          */
5656         dquot_writeback_dquots(sb, -1);
5657         /*
5658          * Data writeback is possible w/o journal transaction, so barrier must
5659          * being sent at the end of the function. But we can skip it if
5660          * transaction_commit will do it for us.
5661          */
5662         if (sbi->s_journal) {
5663                 target = jbd2_get_latest_transaction(sbi->s_journal);
5664                 if (wait && sbi->s_journal->j_flags & JBD2_BARRIER &&
5665                     !jbd2_trans_will_send_data_barrier(sbi->s_journal, target))
5666                         needs_barrier = true;
5667
5668                 if (jbd2_journal_start_commit(sbi->s_journal, &target)) {
5669                         if (wait)
5670                                 ret = jbd2_log_wait_commit(sbi->s_journal,
5671                                                            target);
5672                 }
5673         } else if (wait && test_opt(sb, BARRIER))
5674                 needs_barrier = true;
5675         if (needs_barrier) {
5676                 int err;
5677                 err = blkdev_issue_flush(sb->s_bdev, GFP_KERNEL);
5678                 if (!ret)
5679                         ret = err;
5680         }
5681
5682         return ret;
5683 }
5684
5685 /*
5686  * LVM calls this function before a (read-only) snapshot is created.  This
5687  * gives us a chance to flush the journal completely and mark the fs clean.
5688  *
5689  * Note that only this function cannot bring a filesystem to be in a clean
5690  * state independently. It relies on upper layer to stop all data & metadata
5691  * modifications.
5692  */
5693 static int ext4_freeze(struct super_block *sb)
5694 {
5695         int error = 0;
5696         journal_t *journal;
5697
5698         if (sb_rdonly(sb))
5699                 return 0;
5700
5701         journal = EXT4_SB(sb)->s_journal;
5702
5703         if (journal) {
5704                 /* Now we set up the journal barrier. */
5705                 jbd2_journal_lock_updates(journal);
5706
5707                 /*
5708                  * Don't clear the needs_recovery flag if we failed to
5709                  * flush the journal.
5710                  */
5711                 error = jbd2_journal_flush(journal);
5712                 if (error < 0)
5713                         goto out;
5714
5715                 /* Journal blocked and flushed, clear needs_recovery flag. */
5716                 ext4_clear_feature_journal_needs_recovery(sb);
5717         }
5718
5719         error = ext4_commit_super(sb, 1);
5720 out:
5721         if (journal)
5722                 /* we rely on upper layer to stop further updates */
5723                 jbd2_journal_unlock_updates(journal);
5724         return error;
5725 }
5726
5727 /*
5728  * Called by LVM after the snapshot is done.  We need to reset the RECOVER
5729  * flag here, even though the filesystem is not technically dirty yet.
5730  */
5731 static int ext4_unfreeze(struct super_block *sb)
5732 {
5733         if (sb_rdonly(sb) || ext4_forced_shutdown(EXT4_SB(sb)))
5734                 return 0;
5735
5736         if (EXT4_SB(sb)->s_journal) {
5737                 /* Reset the needs_recovery flag before the fs is unlocked. */
5738                 ext4_set_feature_journal_needs_recovery(sb);
5739         }
5740
5741         ext4_commit_super(sb, 1);
5742         return 0;
5743 }
5744
5745 /*
5746  * Structure to save mount options for ext4_remount's benefit
5747  */
5748 struct ext4_mount_options {
5749         unsigned long s_mount_opt;
5750         unsigned long s_mount_opt2;
5751         kuid_t s_resuid;
5752         kgid_t s_resgid;
5753         unsigned long s_commit_interval;
5754         u32 s_min_batch_time, s_max_batch_time;
5755 #ifdef CONFIG_QUOTA
5756         int s_jquota_fmt;
5757         char *s_qf_names[EXT4_MAXQUOTAS];
5758 #endif
5759 };
5760
5761 static int ext4_remount(struct super_block *sb, int *flags, char *data)
5762 {
5763         struct ext4_super_block *es;
5764         struct ext4_sb_info *sbi = EXT4_SB(sb);
5765         unsigned long old_sb_flags, vfs_flags;
5766         struct ext4_mount_options old_opts;
5767         int enable_quota = 0;
5768         ext4_group_t g;
5769         unsigned int journal_ioprio = DEFAULT_JOURNAL_IOPRIO;
5770         int err = 0;
5771 #ifdef CONFIG_QUOTA
5772         int i, j;
5773         char *to_free[EXT4_MAXQUOTAS];
5774 #endif
5775         char *orig_data = kstrdup(data, GFP_KERNEL);
5776
5777         if (data && !orig_data)
5778                 return -ENOMEM;
5779
5780         /* Store the original options */
5781         old_sb_flags = sb->s_flags;
5782         old_opts.s_mount_opt = sbi->s_mount_opt;
5783         old_opts.s_mount_opt2 = sbi->s_mount_opt2;
5784         old_opts.s_resuid = sbi->s_resuid;
5785         old_opts.s_resgid = sbi->s_resgid;
5786         old_opts.s_commit_interval = sbi->s_commit_interval;
5787         old_opts.s_min_batch_time = sbi->s_min_batch_time;
5788         old_opts.s_max_batch_time = sbi->s_max_batch_time;
5789 #ifdef CONFIG_QUOTA
5790         old_opts.s_jquota_fmt = sbi->s_jquota_fmt;
5791         for (i = 0; i < EXT4_MAXQUOTAS; i++)
5792                 if (sbi->s_qf_names[i]) {
5793                         char *qf_name = get_qf_name(sb, sbi, i);
5794
5795                         old_opts.s_qf_names[i] = kstrdup(qf_name, GFP_KERNEL);
5796                         if (!old_opts.s_qf_names[i]) {
5797                                 for (j = 0; j < i; j++)
5798                                         kfree(old_opts.s_qf_names[j]);
5799                                 kfree(orig_data);
5800                                 return -ENOMEM;
5801                         }
5802                 } else
5803                         old_opts.s_qf_names[i] = NULL;
5804 #endif
5805         if (sbi->s_journal && sbi->s_journal->j_task->io_context)
5806                 journal_ioprio = sbi->s_journal->j_task->io_context->ioprio;
5807
5808         /*
5809          * Some options can be enabled by ext4 and/or by VFS mount flag
5810          * either way we need to make sure it matches in both *flags and
5811          * s_flags. Copy those selected flags from *flags to s_flags
5812          */
5813         vfs_flags = SB_LAZYTIME | SB_I_VERSION;
5814         sb->s_flags = (sb->s_flags & ~vfs_flags) | (*flags & vfs_flags);
5815
5816         if (!parse_options(data, sb, NULL, &journal_ioprio, 1)) {
5817                 err = -EINVAL;
5818                 goto restore_opts;
5819         }
5820
5821         if ((old_opts.s_mount_opt & EXT4_MOUNT_JOURNAL_CHECKSUM) ^
5822             test_opt(sb, JOURNAL_CHECKSUM)) {
5823                 ext4_msg(sb, KERN_ERR, "changing journal_checksum "
5824                          "during remount not supported; ignoring");
5825                 sbi->s_mount_opt ^= EXT4_MOUNT_JOURNAL_CHECKSUM;
5826         }
5827
5828         if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
5829                 if (test_opt2(sb, EXPLICIT_DELALLOC)) {
5830                         ext4_msg(sb, KERN_ERR, "can't mount with "
5831                                  "both data=journal and delalloc");
5832                         err = -EINVAL;
5833                         goto restore_opts;
5834                 }
5835                 if (test_opt(sb, DIOREAD_NOLOCK)) {
5836                         ext4_msg(sb, KERN_ERR, "can't mount with "
5837                                  "both data=journal and dioread_nolock");
5838                         err = -EINVAL;
5839                         goto restore_opts;
5840                 }
5841         } else if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_ORDERED_DATA) {
5842                 if (test_opt(sb, JOURNAL_ASYNC_COMMIT)) {
5843                         ext4_msg(sb, KERN_ERR, "can't mount with "
5844                                 "journal_async_commit in data=ordered mode");
5845                         err = -EINVAL;
5846                         goto restore_opts;
5847                 }
5848         }
5849
5850         if ((sbi->s_mount_opt ^ old_opts.s_mount_opt) & EXT4_MOUNT_NO_MBCACHE) {
5851                 ext4_msg(sb, KERN_ERR, "can't enable nombcache during remount");
5852                 err = -EINVAL;
5853                 goto restore_opts;
5854         }
5855
5856         if (ext4_test_mount_flag(sb, EXT4_MF_FS_ABORTED))
5857                 ext4_abort(sb, EXT4_ERR_ESHUTDOWN, "Abort forced by user");
5858
5859         sb->s_flags = (sb->s_flags & ~SB_POSIXACL) |
5860                 (test_opt(sb, POSIX_ACL) ? SB_POSIXACL : 0);
5861
5862         es = sbi->s_es;
5863
5864         if (sbi->s_journal) {
5865                 ext4_init_journal_params(sb, sbi->s_journal);
5866                 set_task_ioprio(sbi->s_journal->j_task, journal_ioprio);
5867         }
5868
5869         /* Flush outstanding errors before changing fs state */
5870         flush_work(&sbi->s_error_work);
5871
5872         if ((bool)(*flags & SB_RDONLY) != sb_rdonly(sb)) {
5873                 if (ext4_test_mount_flag(sb, EXT4_MF_FS_ABORTED)) {
5874                         err = -EROFS;
5875                         goto restore_opts;
5876                 }
5877
5878                 if (*flags & SB_RDONLY) {
5879                         err = sync_filesystem(sb);
5880                         if (err < 0)
5881                                 goto restore_opts;
5882                         err = dquot_suspend(sb, -1);
5883                         if (err < 0)
5884                                 goto restore_opts;
5885
5886                         /*
5887                          * First of all, the unconditional stuff we have to do
5888                          * to disable replay of the journal when we next remount
5889                          */
5890                         sb->s_flags |= SB_RDONLY;
5891
5892                         /*
5893                          * OK, test if we are remounting a valid rw partition
5894                          * readonly, and if so set the rdonly flag and then
5895                          * mark the partition as valid again.
5896                          */
5897                         if (!(es->s_state & cpu_to_le16(EXT4_VALID_FS)) &&
5898                             (sbi->s_mount_state & EXT4_VALID_FS))
5899                                 es->s_state = cpu_to_le16(sbi->s_mount_state);
5900
5901                         if (sbi->s_journal) {
5902                                 /*
5903                                  * We let remount-ro finish even if marking fs
5904                                  * as clean failed...
5905                                  */
5906                                 ext4_mark_recovery_complete(sb, es);
5907                         }
5908                         if (sbi->s_mmp_tsk)
5909                                 kthread_stop(sbi->s_mmp_tsk);
5910                 } else {
5911                         /* Make sure we can mount this feature set readwrite */
5912                         if (ext4_has_feature_readonly(sb) ||
5913                             !ext4_feature_set_ok(sb, 0)) {
5914                                 err = -EROFS;
5915                                 goto restore_opts;
5916                         }
5917                         /*
5918                          * Make sure the group descriptor checksums
5919                          * are sane.  If they aren't, refuse to remount r/w.
5920                          */
5921                         for (g = 0; g < sbi->s_groups_count; g++) {
5922                                 struct ext4_group_desc *gdp =
5923                                         ext4_get_group_desc(sb, g, NULL);
5924
5925                                 if (!ext4_group_desc_csum_verify(sb, g, gdp)) {
5926                                         ext4_msg(sb, KERN_ERR,
5927                "ext4_remount: Checksum for group %u failed (%u!=%u)",
5928                 g, le16_to_cpu(ext4_group_desc_csum(sb, g, gdp)),
5929                                                le16_to_cpu(gdp->bg_checksum));
5930                                         err = -EFSBADCRC;
5931                                         goto restore_opts;
5932                                 }
5933                         }
5934
5935                         /*
5936                          * If we have an unprocessed orphan list hanging
5937                          * around from a previously readonly bdev mount,
5938                          * require a full umount/remount for now.
5939                          */
5940                         if (es->s_last_orphan) {
5941                                 ext4_msg(sb, KERN_WARNING, "Couldn't "
5942                                        "remount RDWR because of unprocessed "
5943                                        "orphan inode list.  Please "
5944                                        "umount/remount instead");
5945                                 err = -EINVAL;
5946                                 goto restore_opts;
5947                         }
5948
5949                         /*
5950                          * Mounting a RDONLY partition read-write, so reread
5951                          * and store the current valid flag.  (It may have
5952                          * been changed by e2fsck since we originally mounted
5953                          * the partition.)
5954                          */
5955                         if (sbi->s_journal) {
5956                                 err = ext4_clear_journal_err(sb, es);
5957                                 if (err)
5958                                         goto restore_opts;
5959                         }
5960                         sbi->s_mount_state = le16_to_cpu(es->s_state);
5961
5962                         err = ext4_setup_super(sb, es, 0);
5963                         if (err)
5964                                 goto restore_opts;
5965
5966                         sb->s_flags &= ~SB_RDONLY;
5967                         if (ext4_has_feature_mmp(sb))
5968                                 if (ext4_multi_mount_protect(sb,
5969                                                 le64_to_cpu(es->s_mmp_block))) {
5970                                         err = -EROFS;
5971                                         goto restore_opts;
5972                                 }
5973                         enable_quota = 1;
5974                 }
5975         }
5976
5977         /*
5978          * Reinitialize lazy itable initialization thread based on
5979          * current settings
5980          */
5981         if (sb_rdonly(sb) || !test_opt(sb, INIT_INODE_TABLE))
5982                 ext4_unregister_li_request(sb);
5983         else {
5984                 ext4_group_t first_not_zeroed;
5985                 first_not_zeroed = ext4_has_uninit_itable(sb);
5986                 ext4_register_li_request(sb, first_not_zeroed);
5987         }
5988
5989         /*
5990          * Handle creation of system zone data early because it can fail.
5991          * Releasing of existing data is done when we are sure remount will
5992          * succeed.
5993          */
5994         if (test_opt(sb, BLOCK_VALIDITY) && !sbi->s_system_blks) {
5995                 err = ext4_setup_system_zone(sb);
5996                 if (err)
5997                         goto restore_opts;
5998         }
5999
6000         if (sbi->s_journal == NULL && !(old_sb_flags & SB_RDONLY)) {
6001                 err = ext4_commit_super(sb, 1);
6002                 if (err)
6003                         goto restore_opts;
6004         }
6005
6006 #ifdef CONFIG_QUOTA
6007         /* Release old quota file names */
6008         for (i = 0; i < EXT4_MAXQUOTAS; i++)
6009                 kfree(old_opts.s_qf_names[i]);
6010         if (enable_quota) {
6011                 if (sb_any_quota_suspended(sb))
6012                         dquot_resume(sb, -1);
6013                 else if (ext4_has_feature_quota(sb)) {
6014                         err = ext4_enable_quotas(sb);
6015                         if (err)
6016                                 goto restore_opts;
6017                 }
6018         }
6019 #endif
6020         if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
6021                 ext4_release_system_zone(sb);
6022
6023         /*
6024          * Some options can be enabled by ext4 and/or by VFS mount flag
6025          * either way we need to make sure it matches in both *flags and
6026          * s_flags. Copy those selected flags from s_flags to *flags
6027          */
6028         *flags = (*flags & ~vfs_flags) | (sb->s_flags & vfs_flags);
6029
6030         ext4_msg(sb, KERN_INFO, "re-mounted. Opts: %s. Quota mode: %s.",
6031                  orig_data, ext4_quota_mode(sb));
6032         kfree(orig_data);
6033         return 0;
6034
6035 restore_opts:
6036         sb->s_flags = old_sb_flags;
6037         sbi->s_mount_opt = old_opts.s_mount_opt;
6038         sbi->s_mount_opt2 = old_opts.s_mount_opt2;
6039         sbi->s_resuid = old_opts.s_resuid;
6040         sbi->s_resgid = old_opts.s_resgid;
6041         sbi->s_commit_interval = old_opts.s_commit_interval;
6042         sbi->s_min_batch_time = old_opts.s_min_batch_time;
6043         sbi->s_max_batch_time = old_opts.s_max_batch_time;
6044         if (!test_opt(sb, BLOCK_VALIDITY) && sbi->s_system_blks)
6045                 ext4_release_system_zone(sb);
6046 #ifdef CONFIG_QUOTA
6047         sbi->s_jquota_fmt = old_opts.s_jquota_fmt;
6048         for (i = 0; i < EXT4_MAXQUOTAS; i++) {
6049                 to_free[i] = get_qf_name(sb, sbi, i);
6050                 rcu_assign_pointer(sbi->s_qf_names[i], old_opts.s_qf_names[i]);
6051         }
6052         synchronize_rcu();
6053         for (i = 0; i < EXT4_MAXQUOTAS; i++)
6054                 kfree(to_free[i]);
6055 #endif
6056         kfree(orig_data);
6057         return err;
6058 }
6059
6060 #ifdef CONFIG_QUOTA
6061 static int ext4_statfs_project(struct super_block *sb,
6062                                kprojid_t projid, struct kstatfs *buf)
6063 {
6064         struct kqid qid;
6065         struct dquot *dquot;
6066         u64 limit;
6067         u64 curblock;
6068
6069         qid = make_kqid_projid(projid);
6070         dquot = dqget(sb, qid);
6071         if (IS_ERR(dquot))
6072                 return PTR_ERR(dquot);
6073         spin_lock(&dquot->dq_dqb_lock);
6074
6075         limit = min_not_zero(dquot->dq_dqb.dqb_bsoftlimit,
6076                              dquot->dq_dqb.dqb_bhardlimit);
6077         limit >>= sb->s_blocksize_bits;
6078
6079         if (limit && buf->f_blocks > limit) {
6080                 curblock = (dquot->dq_dqb.dqb_curspace +
6081                             dquot->dq_dqb.dqb_rsvspace) >> sb->s_blocksize_bits;
6082                 buf->f_blocks = limit;
6083                 buf->f_bfree = buf->f_bavail =
6084                         (buf->f_blocks > curblock) ?
6085                          (buf->f_blocks - curblock) : 0;
6086         }
6087
6088         limit = min_not_zero(dquot->dq_dqb.dqb_isoftlimit,
6089                              dquot->dq_dqb.dqb_ihardlimit);
6090         if (limit && buf->f_files > limit) {
6091                 buf->f_files = limit;
6092                 buf->f_ffree =
6093                         (buf->f_files > dquot->dq_dqb.dqb_curinodes) ?
6094                          (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;
6095         }
6096
6097         spin_unlock(&dquot->dq_dqb_lock);
6098         dqput(dquot);
6099         return 0;
6100 }
6101 #endif
6102
6103 static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf)
6104 {
6105         struct super_block *sb = dentry->d_sb;
6106         struct ext4_sb_info *sbi = EXT4_SB(sb);
6107         struct ext4_super_block *es = sbi->s_es;
6108         ext4_fsblk_t overhead = 0, resv_blocks;
6109         u64 fsid;
6110         s64 bfree;
6111         resv_blocks = EXT4_C2B(sbi, atomic64_read(&sbi->s_resv_clusters));
6112
6113         if (!test_opt(sb, MINIX_DF))
6114                 overhead = sbi->s_overhead;
6115
6116         buf->f_type = EXT4_SUPER_MAGIC;
6117         buf->f_bsize = sb->s_blocksize;
6118         buf->f_blocks = ext4_blocks_count(es) - EXT4_C2B(sbi, overhead);
6119         bfree = percpu_counter_sum_positive(&sbi->s_freeclusters_counter) -
6120                 percpu_counter_sum_positive(&sbi->s_dirtyclusters_counter);
6121         /* prevent underflow in case that few free space is available */
6122         buf->f_bfree = EXT4_C2B(sbi, max_t(s64, bfree, 0));
6123         buf->f_bavail = buf->f_bfree -
6124                         (ext4_r_blocks_count(es) + resv_blocks);
6125         if (buf->f_bfree < (ext4_r_blocks_count(es) + resv_blocks))
6126                 buf->f_bavail = 0;
6127         buf->f_files = le32_to_cpu(es->s_inodes_count);
6128         buf->f_ffree = percpu_counter_sum_positive(&sbi->s_freeinodes_counter);
6129         buf->f_namelen = EXT4_NAME_LEN;
6130         fsid = le64_to_cpup((void *)es->s_uuid) ^
6131                le64_to_cpup((void *)es->s_uuid + sizeof(u64));
6132         buf->f_fsid = u64_to_fsid(fsid);
6133
6134 #ifdef CONFIG_QUOTA
6135         if (ext4_test_inode_flag(dentry->d_inode, EXT4_INODE_PROJINHERIT) &&
6136             sb_has_quota_limits_enabled(sb, PRJQUOTA))
6137                 ext4_statfs_project(sb, EXT4_I(dentry->d_inode)->i_projid, buf);
6138 #endif
6139         return 0;
6140 }
6141
6142
6143 #ifdef CONFIG_QUOTA
6144
6145 /*
6146  * Helper functions so that transaction is started before we acquire dqio_sem
6147  * to keep correct lock ordering of transaction > dqio_sem
6148  */
6149 static inline struct inode *dquot_to_inode(struct dquot *dquot)
6150 {
6151         return sb_dqopt(dquot->dq_sb)->files[dquot->dq_id.type];
6152 }
6153
6154 static int ext4_write_dquot(struct dquot *dquot)
6155 {
6156         int ret, err;
6157         handle_t *handle;
6158         struct inode *inode;
6159
6160         inode = dquot_to_inode(dquot);
6161         handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
6162                                     EXT4_QUOTA_TRANS_BLOCKS(dquot->dq_sb));
6163         if (IS_ERR(handle))
6164                 return PTR_ERR(handle);
6165         ret = dquot_commit(dquot);
6166         err = ext4_journal_stop(handle);
6167         if (!ret)
6168                 ret = err;
6169         return ret;
6170 }
6171
6172 static int ext4_acquire_dquot(struct dquot *dquot)
6173 {
6174         int ret, err;
6175         handle_t *handle;
6176
6177         handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
6178                                     EXT4_QUOTA_INIT_BLOCKS(dquot->dq_sb));
6179         if (IS_ERR(handle))
6180                 return PTR_ERR(handle);
6181         ret = dquot_acquire(dquot);
6182         err = ext4_journal_stop(handle);
6183         if (!ret)
6184                 ret = err;
6185         return ret;
6186 }
6187
6188 static int ext4_release_dquot(struct dquot *dquot)
6189 {
6190         int ret, err;
6191         handle_t *handle;
6192
6193         handle = ext4_journal_start(dquot_to_inode(dquot), EXT4_HT_QUOTA,
6194                                     EXT4_QUOTA_DEL_BLOCKS(dquot->dq_sb));
6195         if (IS_ERR(handle)) {
6196                 /* Release dquot anyway to avoid endless cycle in dqput() */
6197                 dquot_release(dquot);
6198                 return PTR_ERR(handle);
6199         }
6200         ret = dquot_release(dquot);
6201         err = ext4_journal_stop(handle);
6202         if (!ret)
6203                 ret = err;
6204         return ret;
6205 }
6206
6207 static int ext4_mark_dquot_dirty(struct dquot *dquot)
6208 {
6209         struct super_block *sb = dquot->dq_sb;
6210
6211         if (ext4_is_quota_journalled(sb)) {
6212                 dquot_mark_dquot_dirty(dquot);
6213                 return ext4_write_dquot(dquot);
6214         } else {
6215                 return dquot_mark_dquot_dirty(dquot);
6216         }
6217 }
6218
6219 static int ext4_write_info(struct super_block *sb, int type)
6220 {
6221         int ret, err;
6222         handle_t *handle;
6223
6224         /* Data block + inode block */
6225         handle = ext4_journal_start(d_inode(sb->s_root), EXT4_HT_QUOTA, 2);
6226         if (IS_ERR(handle))
6227                 return PTR_ERR(handle);
6228         ret = dquot_commit_info(sb, type);
6229         err = ext4_journal_stop(handle);
6230         if (!ret)
6231                 ret = err;
6232         return ret;
6233 }
6234
6235 /*
6236  * Turn on quotas during mount time - we need to find
6237  * the quota file and such...
6238  */
6239 static int ext4_quota_on_mount(struct super_block *sb, int type)
6240 {
6241         return dquot_quota_on_mount(sb, get_qf_name(sb, EXT4_SB(sb), type),
6242                                         EXT4_SB(sb)->s_jquota_fmt, type);
6243 }
6244
6245 static void lockdep_set_quota_inode(struct inode *inode, int subclass)
6246 {
6247         struct ext4_inode_info *ei = EXT4_I(inode);
6248
6249         /* The first argument of lockdep_set_subclass has to be
6250          * *exactly* the same as the argument to init_rwsem() --- in
6251          * this case, in init_once() --- or lockdep gets unhappy
6252          * because the name of the lock is set using the
6253          * stringification of the argument to init_rwsem().
6254          */
6255         (void) ei;      /* shut up clang warning if !CONFIG_LOCKDEP */
6256         lockdep_set_subclass(&ei->i_data_sem, subclass);
6257 }
6258
6259 /*
6260  * Standard function to be called on quota_on
6261  */
6262 static int ext4_quota_on(struct super_block *sb, int type, int format_id,
6263                          const struct path *path)
6264 {
6265         int err;
6266
6267         if (!test_opt(sb, QUOTA))
6268                 return -EINVAL;
6269
6270         /* Quotafile not on the same filesystem? */
6271         if (path->dentry->d_sb != sb)
6272                 return -EXDEV;
6273
6274         /* Quota already enabled for this file? */
6275         if (IS_NOQUOTA(d_inode(path->dentry)))
6276                 return -EBUSY;
6277
6278         /* Journaling quota? */
6279         if (EXT4_SB(sb)->s_qf_names[type]) {
6280                 /* Quotafile not in fs root? */
6281                 if (path->dentry->d_parent != sb->s_root)
6282                         ext4_msg(sb, KERN_WARNING,
6283                                 "Quota file not on filesystem root. "
6284                                 "Journaled quota will not work");
6285                 sb_dqopt(sb)->flags |= DQUOT_NOLIST_DIRTY;
6286         } else {
6287                 /*
6288                  * Clear the flag just in case mount options changed since
6289                  * last time.
6290                  */
6291                 sb_dqopt(sb)->flags &= ~DQUOT_NOLIST_DIRTY;
6292         }
6293
6294         /*
6295          * When we journal data on quota file, we have to flush journal to see
6296          * all updates to the file when we bypass pagecache...
6297          */
6298         if (EXT4_SB(sb)->s_journal &&
6299             ext4_should_journal_data(d_inode(path->dentry))) {
6300                 /*
6301                  * We don't need to lock updates but journal_flush() could
6302                  * otherwise be livelocked...
6303                  */
6304                 jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
6305                 err = jbd2_journal_flush(EXT4_SB(sb)->s_journal);
6306                 jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
6307                 if (err)
6308                         return err;
6309         }
6310
6311         lockdep_set_quota_inode(path->dentry->d_inode, I_DATA_SEM_QUOTA);
6312         err = dquot_quota_on(sb, type, format_id, path);
6313         if (err) {
6314                 lockdep_set_quota_inode(path->dentry->d_inode,
6315                                              I_DATA_SEM_NORMAL);
6316         } else {
6317                 struct inode *inode = d_inode(path->dentry);
6318                 handle_t *handle;
6319
6320                 /*
6321                  * Set inode flags to prevent userspace from messing with quota
6322                  * files. If this fails, we return success anyway since quotas
6323                  * are already enabled and this is not a hard failure.
6324                  */
6325                 inode_lock(inode);
6326                 handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
6327                 if (IS_ERR(handle))
6328                         goto unlock_inode;
6329                 EXT4_I(inode)->i_flags |= EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL;
6330                 inode_set_flags(inode, S_NOATIME | S_IMMUTABLE,
6331                                 S_NOATIME | S_IMMUTABLE);
6332                 err = ext4_mark_inode_dirty(handle, inode);
6333                 ext4_journal_stop(handle);
6334         unlock_inode:
6335                 inode_unlock(inode);
6336         }
6337         return err;
6338 }
6339
6340 static int ext4_quota_enable(struct super_block *sb, int type, int format_id,
6341                              unsigned int flags)
6342 {
6343         int err;
6344         struct inode *qf_inode;
6345         unsigned long qf_inums[EXT4_MAXQUOTAS] = {
6346                 le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
6347                 le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum),
6348                 le32_to_cpu(EXT4_SB(sb)->s_es->s_prj_quota_inum)
6349         };
6350
6351         BUG_ON(!ext4_has_feature_quota(sb));
6352
6353         if (!qf_inums[type])
6354                 return -EPERM;
6355
6356         qf_inode = ext4_iget(sb, qf_inums[type], EXT4_IGET_SPECIAL);
6357         if (IS_ERR(qf_inode)) {
6358                 ext4_error(sb, "Bad quota inode # %lu", qf_inums[type]);
6359                 return PTR_ERR(qf_inode);
6360         }
6361
6362         /* Don't account quota for quota files to avoid recursion */
6363         qf_inode->i_flags |= S_NOQUOTA;
6364         lockdep_set_quota_inode(qf_inode, I_DATA_SEM_QUOTA);
6365         err = dquot_load_quota_inode(qf_inode, type, format_id, flags);
6366         if (err)
6367                 lockdep_set_quota_inode(qf_inode, I_DATA_SEM_NORMAL);
6368         iput(qf_inode);
6369
6370         return err;
6371 }
6372
6373 /* Enable usage tracking for all quota types. */
6374 static int ext4_enable_quotas(struct super_block *sb)
6375 {
6376         int type, err = 0;
6377         unsigned long qf_inums[EXT4_MAXQUOTAS] = {
6378                 le32_to_cpu(EXT4_SB(sb)->s_es->s_usr_quota_inum),
6379                 le32_to_cpu(EXT4_SB(sb)->s_es->s_grp_quota_inum),
6380                 le32_to_cpu(EXT4_SB(sb)->s_es->s_prj_quota_inum)
6381         };
6382         bool quota_mopt[EXT4_MAXQUOTAS] = {
6383                 test_opt(sb, USRQUOTA),
6384                 test_opt(sb, GRPQUOTA),
6385                 test_opt(sb, PRJQUOTA),
6386         };
6387
6388         sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE | DQUOT_NOLIST_DIRTY;
6389         for (type = 0; type < EXT4_MAXQUOTAS; type++) {
6390                 if (qf_inums[type]) {
6391                         err = ext4_quota_enable(sb, type, QFMT_VFS_V1,
6392                                 DQUOT_USAGE_ENABLED |
6393                                 (quota_mopt[type] ? DQUOT_LIMITS_ENABLED : 0));
6394                         if (err) {
6395                                 ext4_warning(sb,
6396                                         "Failed to enable quota tracking "
6397                                         "(type=%d, err=%d). Please run "
6398                                         "e2fsck to fix.", type, err);
6399                                 for (type--; type >= 0; type--)
6400                                         dquot_quota_off(sb, type);
6401
6402                                 return err;
6403                         }
6404                 }
6405         }
6406         return 0;
6407 }
6408
6409 static int ext4_quota_off(struct super_block *sb, int type)
6410 {
6411         struct inode *inode = sb_dqopt(sb)->files[type];
6412         handle_t *handle;
6413         int err;
6414
6415         /* Force all delayed allocation blocks to be allocated.
6416          * Caller already holds s_umount sem */
6417         if (test_opt(sb, DELALLOC))
6418                 sync_filesystem(sb);
6419
6420         if (!inode || !igrab(inode))
6421                 goto out;
6422
6423         err = dquot_quota_off(sb, type);
6424         if (err || ext4_has_feature_quota(sb))
6425                 goto out_put;
6426
6427         inode_lock(inode);
6428         /*
6429          * Update modification times of quota files when userspace can
6430          * start looking at them. If we fail, we return success anyway since
6431          * this is not a hard failure and quotas are already disabled.
6432          */
6433         handle = ext4_journal_start(inode, EXT4_HT_QUOTA, 1);
6434         if (IS_ERR(handle)) {
6435                 err = PTR_ERR(handle);
6436                 goto out_unlock;
6437         }
6438         EXT4_I(inode)->i_flags &= ~(EXT4_NOATIME_FL | EXT4_IMMUTABLE_FL);
6439         inode_set_flags(inode, 0, S_NOATIME | S_IMMUTABLE);
6440         inode->i_mtime = inode->i_ctime = current_time(inode);
6441         err = ext4_mark_inode_dirty(handle, inode);
6442         ext4_journal_stop(handle);
6443 out_unlock:
6444         inode_unlock(inode);
6445 out_put:
6446         lockdep_set_quota_inode(inode, I_DATA_SEM_NORMAL);
6447         iput(inode);
6448         return err;
6449 out:
6450         return dquot_quota_off(sb, type);
6451 }
6452
6453 /* Read data from quotafile - avoid pagecache and such because we cannot afford
6454  * acquiring the locks... As quota files are never truncated and quota code
6455  * itself serializes the operations (and no one else should touch the files)
6456  * we don't have to be afraid of races */
6457 static ssize_t ext4_quota_read(struct super_block *sb, int type, char *data,
6458                                size_t len, loff_t off)
6459 {
6460         struct inode *inode = sb_dqopt(sb)->files[type];
6461         ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
6462         int offset = off & (sb->s_blocksize - 1);
6463         int tocopy;
6464         size_t toread;
6465         struct buffer_head *bh;
6466         loff_t i_size = i_size_read(inode);
6467
6468         if (off > i_size)
6469                 return 0;
6470         if (off+len > i_size)
6471                 len = i_size-off;
6472         toread = len;
6473         while (toread > 0) {
6474                 tocopy = sb->s_blocksize - offset < toread ?
6475                                 sb->s_blocksize - offset : toread;
6476                 bh = ext4_bread(NULL, inode, blk, 0);
6477                 if (IS_ERR(bh))
6478                         return PTR_ERR(bh);
6479                 if (!bh)        /* A hole? */
6480                         memset(data, 0, tocopy);
6481                 else
6482                         memcpy(data, bh->b_data+offset, tocopy);
6483                 brelse(bh);
6484                 offset = 0;
6485                 toread -= tocopy;
6486                 data += tocopy;
6487                 blk++;
6488         }
6489         return len;
6490 }
6491
6492 /* Write to quotafile (we know the transaction is already started and has
6493  * enough credits) */
6494 static ssize_t ext4_quota_write(struct super_block *sb, int type,
6495                                 const char *data, size_t len, loff_t off)
6496 {
6497         struct inode *inode = sb_dqopt(sb)->files[type];
6498         ext4_lblk_t blk = off >> EXT4_BLOCK_SIZE_BITS(sb);
6499         int err = 0, err2 = 0, offset = off & (sb->s_blocksize - 1);
6500         int retries = 0;
6501         struct buffer_head *bh;
6502         handle_t *handle = journal_current_handle();
6503
6504         if (EXT4_SB(sb)->s_journal && !handle) {
6505                 ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
6506                         " cancelled because transaction is not started",
6507                         (unsigned long long)off, (unsigned long long)len);
6508                 return -EIO;
6509         }
6510         /*
6511          * Since we account only one data block in transaction credits,
6512          * then it is impossible to cross a block boundary.
6513          */
6514         if (sb->s_blocksize - offset < len) {
6515                 ext4_msg(sb, KERN_WARNING, "Quota write (off=%llu, len=%llu)"
6516                         " cancelled because not block aligned",
6517                         (unsigned long long)off, (unsigned long long)len);
6518                 return -EIO;
6519         }
6520
6521         do {
6522                 bh = ext4_bread(handle, inode, blk,
6523                                 EXT4_GET_BLOCKS_CREATE |
6524                                 EXT4_GET_BLOCKS_METADATA_NOFAIL);
6525         } while (PTR_ERR(bh) == -ENOSPC &&
6526                  ext4_should_retry_alloc(inode->i_sb, &retries));
6527         if (IS_ERR(bh))
6528                 return PTR_ERR(bh);
6529         if (!bh)
6530                 goto out;
6531         BUFFER_TRACE(bh, "get write access");
6532         err = ext4_journal_get_write_access(handle, bh);
6533         if (err) {
6534                 brelse(bh);
6535                 return err;
6536         }
6537         lock_buffer(bh);
6538         memcpy(bh->b_data+offset, data, len);
6539         flush_dcache_page(bh->b_page);
6540         unlock_buffer(bh);
6541         err = ext4_handle_dirty_metadata(handle, NULL, bh);
6542         brelse(bh);
6543 out:
6544         if (inode->i_size < off + len) {
6545                 i_size_write(inode, off + len);
6546                 EXT4_I(inode)->i_disksize = inode->i_size;
6547                 err2 = ext4_mark_inode_dirty(handle, inode);
6548                 if (unlikely(err2 && !err))
6549                         err = err2;
6550         }
6551         return err ? err : len;
6552 }
6553 #endif
6554
6555 static struct dentry *ext4_mount(struct file_system_type *fs_type, int flags,
6556                        const char *dev_name, void *data)
6557 {
6558         return mount_bdev(fs_type, flags, dev_name, data, ext4_fill_super);
6559 }
6560
6561 #if !defined(CONFIG_EXT2_FS) && !defined(CONFIG_EXT2_FS_MODULE) && defined(CONFIG_EXT4_USE_FOR_EXT2)
6562 static inline void register_as_ext2(void)
6563 {
6564         int err = register_filesystem(&ext2_fs_type);
6565         if (err)
6566                 printk(KERN_WARNING
6567                        "EXT4-fs: Unable to register as ext2 (%d)\n", err);
6568 }
6569
6570 static inline void unregister_as_ext2(void)
6571 {
6572         unregister_filesystem(&ext2_fs_type);
6573 }
6574
6575 static inline int ext2_feature_set_ok(struct super_block *sb)
6576 {
6577         if (ext4_has_unknown_ext2_incompat_features(sb))
6578                 return 0;
6579         if (sb_rdonly(sb))
6580                 return 1;
6581         if (ext4_has_unknown_ext2_ro_compat_features(sb))
6582                 return 0;
6583         return 1;
6584 }
6585 #else
6586 static inline void register_as_ext2(void) { }
6587 static inline void unregister_as_ext2(void) { }
6588 static inline int ext2_feature_set_ok(struct super_block *sb) { return 0; }
6589 #endif
6590
6591 static inline void register_as_ext3(void)
6592 {
6593         int err = register_filesystem(&ext3_fs_type);
6594         if (err)
6595                 printk(KERN_WARNING
6596                        "EXT4-fs: Unable to register as ext3 (%d)\n", err);
6597 }
6598
6599 static inline void unregister_as_ext3(void)
6600 {
6601         unregister_filesystem(&ext3_fs_type);
6602 }
6603
6604 static inline int ext3_feature_set_ok(struct super_block *sb)
6605 {
6606         if (ext4_has_unknown_ext3_incompat_features(sb))
6607                 return 0;
6608         if (!ext4_has_feature_journal(sb))
6609                 return 0;
6610         if (sb_rdonly(sb))
6611                 return 1;
6612         if (ext4_has_unknown_ext3_ro_compat_features(sb))
6613                 return 0;
6614         return 1;
6615 }
6616
6617 static struct file_system_type ext4_fs_type = {
6618         .owner          = THIS_MODULE,
6619         .name           = "ext4",
6620         .mount          = ext4_mount,
6621         .kill_sb        = kill_block_super,
6622         .fs_flags       = FS_REQUIRES_DEV,
6623 };
6624 MODULE_ALIAS_FS("ext4");
6625
6626 /* Shared across all ext4 file systems */
6627 wait_queue_head_t ext4__ioend_wq[EXT4_WQ_HASH_SZ];
6628
6629 static int __init ext4_init_fs(void)
6630 {
6631         int i, err;
6632
6633         ratelimit_state_init(&ext4_mount_msg_ratelimit, 30 * HZ, 64);
6634         ext4_li_info = NULL;
6635         mutex_init(&ext4_li_mtx);
6636
6637         /* Build-time check for flags consistency */
6638         ext4_check_flag_values();
6639
6640         for (i = 0; i < EXT4_WQ_HASH_SZ; i++)
6641                 init_waitqueue_head(&ext4__ioend_wq[i]);
6642
6643         err = ext4_init_es();
6644         if (err)
6645                 return err;
6646
6647         err = ext4_init_pending();
6648         if (err)
6649                 goto out7;
6650
6651         err = ext4_init_post_read_processing();
6652         if (err)
6653                 goto out6;
6654
6655         err = ext4_init_pageio();
6656         if (err)
6657                 goto out5;
6658
6659         err = ext4_init_system_zone();
6660         if (err)
6661                 goto out4;
6662
6663         err = ext4_init_sysfs();
6664         if (err)
6665                 goto out3;
6666
6667         err = ext4_init_mballoc();
6668         if (err)
6669                 goto out2;
6670         err = init_inodecache();
6671         if (err)
6672                 goto out1;
6673
6674         err = ext4_fc_init_dentry_cache();
6675         if (err)
6676                 goto out05;
6677
6678         register_as_ext3();
6679         register_as_ext2();
6680         err = register_filesystem(&ext4_fs_type);
6681         if (err)
6682                 goto out;
6683
6684         return 0;
6685 out:
6686         unregister_as_ext2();
6687         unregister_as_ext3();
6688 out05:
6689         destroy_inodecache();
6690 out1:
6691         ext4_exit_mballoc();
6692 out2:
6693         ext4_exit_sysfs();
6694 out3:
6695         ext4_exit_system_zone();
6696 out4:
6697         ext4_exit_pageio();
6698 out5:
6699         ext4_exit_post_read_processing();
6700 out6:
6701         ext4_exit_pending();
6702 out7:
6703         ext4_exit_es();
6704
6705         return err;
6706 }
6707
6708 static void __exit ext4_exit_fs(void)
6709 {
6710         ext4_destroy_lazyinit_thread();
6711         unregister_as_ext2();
6712         unregister_as_ext3();
6713         unregister_filesystem(&ext4_fs_type);
6714         destroy_inodecache();
6715         ext4_exit_mballoc();
6716         ext4_exit_sysfs();
6717         ext4_exit_system_zone();
6718         ext4_exit_pageio();
6719         ext4_exit_post_read_processing();
6720         ext4_exit_es();
6721         ext4_exit_pending();
6722 }
6723
6724 MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
6725 MODULE_DESCRIPTION("Fourth Extended Filesystem");
6726 MODULE_LICENSE("GPL");
6727 MODULE_SOFTDEP("pre: crc32c");
6728 module_init(ext4_init_fs)
6729 module_exit(ext4_exit_fs)