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