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