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