From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Tue, 11 Jan 2011 22:37:31 +0000 (-0800)
Subject: Merge branch 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4
X-Git-Tag: v2.6.38-rc1~409
X-Git-Url: https://git.openpandora.org/cgi-bin/gitweb.cgi?p=pandora-kernel.git;a=commitdiff_plain;h=e9688f6acad8cb1f2e8d7abb2de06a6a5c9cbcf2;hp=-c

Merge branch 'for_linus' of git://git./linux/kernel/git/tytso/ext4

* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4: (44 commits)
  ext4: fix trimming starting with block 0 with small blocksize
  ext4: revert buggy trim overflow patch
  ext4: don't pass entire map to check_eofblocks_fl
  ext4: fix memory leak in ext4_free_branches
  ext4: remove ext4_mb_return_to_preallocation()
  ext4: flush the i_completed_io_list during ext4_truncate
  ext4: add error checking to calls to ext4_handle_dirty_metadata()
  ext4: fix trimming of a single group
  ext4: fix uninitialized variable in ext4_register_li_request
  ext4: dynamically allocate the jbd2_inode in ext4_inode_info as necessary
  ext4: drop i_state_flags on architectures with 64-bit longs
  ext4: reorder ext4_inode_info structure elements to remove unneeded padding
  ext4: drop ec_type from the ext4_ext_cache structure
  ext4: use ext4_lblk_t instead of sector_t for logical blocks
  ext4: replace i_delalloc_reserved_flag with EXT4_STATE_DELALLOC_RESERVED
  ext4: fix 32bit overflow in ext4_ext_find_goal()
  ext4: add more error checks to ext4_mkdir()
  ext4: ext4_ext_migrate should use NULL not 0
  ext4: Use ext4_error_file() to print the pathname to the corrupted inode
  ext4: use IS_ERR() to check for errors in ext4_error_file
  ...
---

e9688f6acad8cb1f2e8d7abb2de06a6a5c9cbcf2
diff --combined fs/ext4/resize.c
index 981c8477adab,7faf47dde7fb..3ecc6e45d2f9
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@@ -220,7 -220,11 +220,11 @@@ static int setup_new_group_blocks(struc
  		memcpy(gdb->b_data, sbi->s_group_desc[i]->b_data, gdb->b_size);
  		set_buffer_uptodate(gdb);
  		unlock_buffer(gdb);
- 		ext4_handle_dirty_metadata(handle, NULL, gdb);
+ 		err = ext4_handle_dirty_metadata(handle, NULL, gdb);
+ 		if (unlikely(err)) {
+ 			brelse(gdb);
+ 			goto exit_bh;
+ 		}
  		ext4_set_bit(bit, bh->b_data);
  		brelse(gdb);
  	}
@@@ -232,8 -236,6 +236,8 @@@
  			       GFP_NOFS);
  	if (err)
  		goto exit_bh;
 +	for (i = 0, bit = gdblocks + 1; i < reserved_gdb; i++, bit++)
 +		ext4_set_bit(bit, bh->b_data);
  
  	ext4_debug("mark block bitmap %#04llx (+%llu)\n", input->block_bitmap,
  		   input->block_bitmap - start);
@@@ -249,16 -251,17 +253,20 @@@
  	err = sb_issue_zeroout(sb, block, sbi->s_itb_per_group, GFP_NOFS);
  	if (err)
  		goto exit_bh;
 +	for (i = 0, bit = input->inode_table - start;
 +	     i < sbi->s_itb_per_group; i++, bit++)
 +		ext4_set_bit(bit, bh->b_data);
  
  	if ((err = extend_or_restart_transaction(handle, 2, bh)))
  		goto exit_bh;
  
  	ext4_mark_bitmap_end(input->blocks_count, sb->s_blocksize * 8,
  			     bh->b_data);
- 	ext4_handle_dirty_metadata(handle, NULL, bh);
+ 	err = ext4_handle_dirty_metadata(handle, NULL, bh);
+ 	if (unlikely(err)) {
+ 		ext4_std_error(sb, err);
+ 		goto exit_bh;
+ 	}
  	brelse(bh);
  	/* Mark unused entries in inode bitmap used */
  	ext4_debug("clear inode bitmap %#04llx (+%llu)\n",
@@@ -270,7 -273,9 +278,9 @@@
  
  	ext4_mark_bitmap_end(EXT4_INODES_PER_GROUP(sb), sb->s_blocksize * 8,
  			     bh->b_data);
- 	ext4_handle_dirty_metadata(handle, NULL, bh);
+ 	err = ext4_handle_dirty_metadata(handle, NULL, bh);
+ 	if (unlikely(err))
+ 		ext4_std_error(sb, err);
  exit_bh:
  	brelse(bh);
  
@@@ -422,17 -427,21 +432,21 @@@ static int add_new_gdb(handle_t *handle
  		goto exit_dind;
  	}
  
- 	if ((err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh)))
+ 	err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
+ 	if (unlikely(err))
  		goto exit_dind;
  
- 	if ((err = ext4_journal_get_write_access(handle, *primary)))
+ 	err = ext4_journal_get_write_access(handle, *primary);
+ 	if (unlikely(err))
  		goto exit_sbh;
  
- 	if ((err = ext4_journal_get_write_access(handle, dind)))
- 		goto exit_primary;
+ 	err = ext4_journal_get_write_access(handle, dind);
+ 	if (unlikely(err))
+ 		ext4_std_error(sb, err);
  
  	/* ext4_reserve_inode_write() gets a reference on the iloc */
- 	if ((err = ext4_reserve_inode_write(handle, inode, &iloc)))
+ 	err = ext4_reserve_inode_write(handle, inode, &iloc);
+ 	if (unlikely(err))
  		goto exit_dindj;
  
  	n_group_desc = kmalloc((gdb_num + 1) * sizeof(struct buffer_head *),
@@@ -454,12 -463,20 +468,20 @@@
  	 * reserved inode, and will become GDT blocks (primary and backup).
  	 */
  	data[gdb_num % EXT4_ADDR_PER_BLOCK(sb)] = 0;
- 	ext4_handle_dirty_metadata(handle, NULL, dind);
- 	brelse(dind);
+ 	err = ext4_handle_dirty_metadata(handle, NULL, dind);
+ 	if (unlikely(err)) {
+ 		ext4_std_error(sb, err);
+ 		goto exit_inode;
+ 	}
  	inode->i_blocks -= (gdbackups + 1) * sb->s_blocksize >> 9;
  	ext4_mark_iloc_dirty(handle, inode, &iloc);
  	memset((*primary)->b_data, 0, sb->s_blocksize);
- 	ext4_handle_dirty_metadata(handle, NULL, *primary);
+ 	err = ext4_handle_dirty_metadata(handle, NULL, *primary);
+ 	if (unlikely(err)) {
+ 		ext4_std_error(sb, err);
+ 		goto exit_inode;
+ 	}
+ 	brelse(dind);
  
  	o_group_desc = EXT4_SB(sb)->s_group_desc;
  	memcpy(n_group_desc, o_group_desc,
@@@ -470,19 -487,19 +492,19 @@@
  	kfree(o_group_desc);
  
  	le16_add_cpu(&es->s_reserved_gdt_blocks, -1);
- 	ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);
+ 	err = ext4_handle_dirty_metadata(handle, NULL, EXT4_SB(sb)->s_sbh);
+ 	if (err)
+ 		ext4_std_error(sb, err);
  
- 	return 0;
+ 	return err;
  
  exit_inode:
  	/* ext4_journal_release_buffer(handle, iloc.bh); */
  	brelse(iloc.bh);
  exit_dindj:
  	/* ext4_journal_release_buffer(handle, dind); */
- exit_primary:
- 	/* ext4_journal_release_buffer(handle, *primary); */
  exit_sbh:
- 	/* ext4_journal_release_buffer(handle, *primary); */
+ 	/* ext4_journal_release_buffer(handle, EXT4_SB(sb)->s_sbh); */
  exit_dind:
  	brelse(dind);
  exit_bh:
@@@ -665,7 -682,9 +687,9 @@@ static void update_backups(struct super
  			memset(bh->b_data + size, 0, rest);
  		set_buffer_uptodate(bh);
  		unlock_buffer(bh);
- 		ext4_handle_dirty_metadata(handle, NULL, bh);
+ 		err = ext4_handle_dirty_metadata(handle, NULL, bh);
+ 		if (unlikely(err))
+ 			ext4_std_error(sb, err);
  		brelse(bh);
  	}
  	if ((err2 = ext4_journal_stop(handle)) && !err)
@@@ -883,7 -902,11 +907,11 @@@ int ext4_group_add(struct super_block *
  	/* Update the global fs size fields */
  	sbi->s_groups_count++;
  
- 	ext4_handle_dirty_metadata(handle, NULL, primary);
+ 	err = ext4_handle_dirty_metadata(handle, NULL, primary);
+ 	if (unlikely(err)) {
+ 		ext4_std_error(sb, err);
+ 		goto exit_journal;
+ 	}
  
  	/* Update the reserved block counts only once the new group is
  	 * active. */
diff --combined fs/ext4/super.c
index cd37f9d5e447,757cb24c0256..29c80f6d8b27
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@@ -388,13 -388,14 +388,14 @@@ static void ext4_handle_error(struct su
  void __ext4_error(struct super_block *sb, const char *function,
  		  unsigned int line, const char *fmt, ...)
  {
+ 	struct va_format vaf;
  	va_list args;
  
  	va_start(args, fmt);
- 	printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: comm %s: ",
- 	       sb->s_id, function, line, current->comm);
- 	vprintk(fmt, args);
- 	printk("\n");
+ 	vaf.fmt = fmt;
+ 	vaf.va = &args;
+ 	printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: comm %s: %pV\n",
+ 	       sb->s_id, function, line, current->comm, &vaf);
  	va_end(args);
  
  	ext4_handle_error(sb);
@@@ -405,28 -406,31 +406,31 @@@ void ext4_error_inode(struct inode *ino
  		      const char *fmt, ...)
  {
  	va_list args;
+ 	struct va_format vaf;
  	struct ext4_super_block *es = EXT4_SB(inode->i_sb)->s_es;
  
  	es->s_last_error_ino = cpu_to_le32(inode->i_ino);
  	es->s_last_error_block = cpu_to_le64(block);
  	save_error_info(inode->i_sb, function, line);
  	va_start(args, fmt);
+ 	vaf.fmt = fmt;
+ 	vaf.va = &args;
  	printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: inode #%lu: ",
  	       inode->i_sb->s_id, function, line, inode->i_ino);
  	if (block)
- 		printk("block %llu: ", block);
- 	printk("comm %s: ", current->comm);
- 	vprintk(fmt, args);
- 	printk("\n");
+ 		printk(KERN_CONT "block %llu: ", block);
+ 	printk(KERN_CONT "comm %s: %pV\n", current->comm, &vaf);
  	va_end(args);
  
  	ext4_handle_error(inode->i_sb);
  }
  
  void ext4_error_file(struct file *file, const char *function,
- 		     unsigned int line, const char *fmt, ...)
+ 		     unsigned int line, ext4_fsblk_t block,
+ 		     const char *fmt, ...)
  {
  	va_list args;
+ 	struct va_format vaf;
  	struct ext4_super_block *es;
  	struct inode *inode = file->f_dentry->d_inode;
  	char pathname[80], *path;
@@@ -434,17 -438,18 +438,18 @@@
  	es = EXT4_SB(inode->i_sb)->s_es;
  	es->s_last_error_ino = cpu_to_le32(inode->i_ino);
  	save_error_info(inode->i_sb, function, line);
- 	va_start(args, fmt);
  	path = d_path(&(file->f_path), pathname, sizeof(pathname));
- 	if (!path)
+ 	if (IS_ERR(path))
  		path = "(unknown)";
  	printk(KERN_CRIT
- 	       "EXT4-fs error (device %s): %s:%d: inode #%lu "
- 	       "(comm %s path %s): ",
- 	       inode->i_sb->s_id, function, line, inode->i_ino,
- 	       current->comm, path);
- 	vprintk(fmt, args);
- 	printk("\n");
+ 	       "EXT4-fs error (device %s): %s:%d: inode #%lu: ",
+ 	       inode->i_sb->s_id, function, line, inode->i_ino);
+ 	if (block)
+ 		printk(KERN_CONT "block %llu: ", block);
+ 	va_start(args, fmt);
+ 	vaf.fmt = fmt;
+ 	vaf.va = &args;
+ 	printk(KERN_CONT "comm %s: path %s: %pV\n", current->comm, path, &vaf);
  	va_end(args);
  
  	ext4_handle_error(inode->i_sb);
@@@ -543,28 -548,29 +548,29 @@@ void __ext4_abort(struct super_block *s
  		panic("EXT4-fs panic from previous error\n");
  }
  
- void ext4_msg (struct super_block * sb, const char *prefix,
- 		   const char *fmt, ...)
+ void ext4_msg(struct super_block *sb, const char *prefix, const char *fmt, ...)
  {
+ 	struct va_format vaf;
  	va_list args;
  
  	va_start(args, fmt);
- 	printk("%sEXT4-fs (%s): ", prefix, sb->s_id);
- 	vprintk(fmt, args);
- 	printk("\n");
+ 	vaf.fmt = fmt;
+ 	vaf.va = &args;
+ 	printk("%sEXT4-fs (%s): %pV\n", prefix, sb->s_id, &vaf);
  	va_end(args);
  }
  
  void __ext4_warning(struct super_block *sb, const char *function,
  		    unsigned int line, const char *fmt, ...)
  {
+ 	struct va_format vaf;
  	va_list args;
  
  	va_start(args, fmt);
- 	printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: ",
- 	       sb->s_id, function, line);
- 	vprintk(fmt, args);
- 	printk("\n");
+ 	vaf.fmt = fmt;
+ 	vaf.va = &args;
+ 	printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: %pV\n",
+ 	       sb->s_id, function, line, &vaf);
  	va_end(args);
  }
  
@@@ -575,21 -581,25 +581,25 @@@ void __ext4_grp_locked_error(const cha
  __releases(bitlock)
  __acquires(bitlock)
  {
+ 	struct va_format vaf;
  	va_list args;
  	struct ext4_super_block *es = EXT4_SB(sb)->s_es;
  
  	es->s_last_error_ino = cpu_to_le32(ino);
  	es->s_last_error_block = cpu_to_le64(block);
  	__save_error_info(sb, function, line);
+ 
  	va_start(args, fmt);
+ 
+ 	vaf.fmt = fmt;
+ 	vaf.va = &args;
  	printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u",
  	       sb->s_id, function, line, grp);
  	if (ino)
- 		printk("inode %lu: ", ino);
+ 		printk(KERN_CONT "inode %lu: ", ino);
  	if (block)
- 		printk("block %llu:", (unsigned long long) block);
- 	vprintk(fmt, args);
- 	printk("\n");
+ 		printk(KERN_CONT "block %llu:", (unsigned long long) block);
+ 	printk(KERN_CONT "%pV\n", &vaf);
  	va_end(args);
  
  	if (test_opt(sb, ERRORS_CONT)) {
@@@ -808,21 -818,15 +818,15 @@@ static struct inode *ext4_alloc_inode(s
  	memset(&ei->i_cached_extent, 0, sizeof(struct ext4_ext_cache));
  	INIT_LIST_HEAD(&ei->i_prealloc_list);
  	spin_lock_init(&ei->i_prealloc_lock);
- 	/*
- 	 * Note:  We can be called before EXT4_SB(sb)->s_journal is set,
- 	 * therefore it can be null here.  Don't check it, just initialize
- 	 * jinode.
- 	 */
- 	jbd2_journal_init_jbd_inode(&ei->jinode, &ei->vfs_inode);
  	ei->i_reserved_data_blocks = 0;
  	ei->i_reserved_meta_blocks = 0;
  	ei->i_allocated_meta_blocks = 0;
  	ei->i_da_metadata_calc_len = 0;
- 	ei->i_delalloc_reserved_flag = 0;
  	spin_lock_init(&(ei->i_block_reservation_lock));
  #ifdef CONFIG_QUOTA
  	ei->i_reserved_quota = 0;
  #endif
+ 	ei->jinode = NULL;
  	INIT_LIST_HEAD(&ei->i_completed_io_list);
  	spin_lock_init(&ei->i_completed_io_lock);
  	ei->cur_aio_dio = NULL;
@@@ -841,13 -845,6 +845,13 @@@ static int ext4_drop_inode(struct inod
  	return drop;
  }
  
 +static void ext4_i_callback(struct rcu_head *head)
 +{
 +	struct inode *inode = container_of(head, struct inode, i_rcu);
 +	INIT_LIST_HEAD(&inode->i_dentry);
 +	kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
 +}
 +
  static void ext4_destroy_inode(struct inode *inode)
  {
  	ext4_ioend_wait(inode);
@@@ -860,7 -857,7 +864,7 @@@
  				true);
  		dump_stack();
  	}
 -	kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
 +	call_rcu(&inode->i_rcu, ext4_i_callback);
  }
  
  static void init_once(void *foo)
@@@ -898,9 -895,12 +902,12 @@@ void ext4_clear_inode(struct inode *ino
  	end_writeback(inode);
  	dquot_drop(inode);
  	ext4_discard_preallocations(inode);
- 	if (EXT4_JOURNAL(inode))
- 		jbd2_journal_release_jbd_inode(EXT4_SB(inode->i_sb)->s_journal,
- 				       &EXT4_I(inode)->jinode);
+ 	if (EXT4_I(inode)->jinode) {
+ 		jbd2_journal_release_jbd_inode(EXT4_JOURNAL(inode),
+ 					       EXT4_I(inode)->jinode);
+ 		jbd2_free_inode(EXT4_I(inode)->jinode);
+ 		EXT4_I(inode)->jinode = NULL;
+ 	}
  }
  
  static inline void ext4_show_quota_options(struct seq_file *seq,
@@@ -1393,7 -1393,7 +1400,7 @@@ static int set_qf_name(struct super_blo
  		sbi->s_qf_names[qtype] = NULL;
  		return 0;
  	}
- 	set_opt(sbi->s_mount_opt, QUOTA);
+ 	set_opt(sb, QUOTA);
  	return 1;
  }
  
@@@ -1448,21 -1448,21 +1455,21 @@@ static int parse_options(char *options
  		switch (token) {
  		case Opt_bsd_df:
  			ext4_msg(sb, KERN_WARNING, deprecated_msg, p, "2.6.38");
- 			clear_opt(sbi->s_mount_opt, MINIX_DF);
+ 			clear_opt(sb, MINIX_DF);
  			break;
  		case Opt_minix_df:
  			ext4_msg(sb, KERN_WARNING, deprecated_msg, p, "2.6.38");
- 			set_opt(sbi->s_mount_opt, MINIX_DF);
+ 			set_opt(sb, MINIX_DF);
  
  			break;
  		case Opt_grpid:
  			ext4_msg(sb, KERN_WARNING, deprecated_msg, p, "2.6.38");
- 			set_opt(sbi->s_mount_opt, GRPID);
+ 			set_opt(sb, GRPID);
  
  			break;
  		case Opt_nogrpid:
  			ext4_msg(sb, KERN_WARNING, deprecated_msg, p, "2.6.38");
- 			clear_opt(sbi->s_mount_opt, GRPID);
+ 			clear_opt(sb, GRPID);
  
  			break;
  		case Opt_resuid:
@@@ -1480,38 -1480,38 +1487,38 @@@
  			/* *sb_block = match_int(&args[0]); */
  			break;
  		case Opt_err_panic:
- 			clear_opt(sbi->s_mount_opt, ERRORS_CONT);
- 			clear_opt(sbi->s_mount_opt, ERRORS_RO);
- 			set_opt(sbi->s_mount_opt, ERRORS_PANIC);
+ 			clear_opt(sb, ERRORS_CONT);
+ 			clear_opt(sb, ERRORS_RO);
+ 			set_opt(sb, ERRORS_PANIC);
  			break;
  		case Opt_err_ro:
- 			clear_opt(sbi->s_mount_opt, ERRORS_CONT);
- 			clear_opt(sbi->s_mount_opt, ERRORS_PANIC);
- 			set_opt(sbi->s_mount_opt, ERRORS_RO);
+ 			clear_opt(sb, ERRORS_CONT);
+ 			clear_opt(sb, ERRORS_PANIC);
+ 			set_opt(sb, ERRORS_RO);
  			break;
  		case Opt_err_cont:
- 			clear_opt(sbi->s_mount_opt, ERRORS_RO);
- 			clear_opt(sbi->s_mount_opt, ERRORS_PANIC);
- 			set_opt(sbi->s_mount_opt, ERRORS_CONT);
+ 			clear_opt(sb, ERRORS_RO);
+ 			clear_opt(sb, ERRORS_PANIC);
+ 			set_opt(sb, ERRORS_CONT);
  			break;
  		case Opt_nouid32:
- 			set_opt(sbi->s_mount_opt, NO_UID32);
+ 			set_opt(sb, NO_UID32);
  			break;
  		case Opt_debug:
- 			set_opt(sbi->s_mount_opt, DEBUG);
+ 			set_opt(sb, DEBUG);
  			break;
  		case Opt_oldalloc:
- 			set_opt(sbi->s_mount_opt, OLDALLOC);
+ 			set_opt(sb, OLDALLOC);
  			break;
  		case Opt_orlov:
- 			clear_opt(sbi->s_mount_opt, OLDALLOC);
+ 			clear_opt(sb, OLDALLOC);
  			break;
  #ifdef CONFIG_EXT4_FS_XATTR
  		case Opt_user_xattr:
- 			set_opt(sbi->s_mount_opt, XATTR_USER);
+ 			set_opt(sb, XATTR_USER);
  			break;
  		case Opt_nouser_xattr:
- 			clear_opt(sbi->s_mount_opt, XATTR_USER);
+ 			clear_opt(sb, XATTR_USER);
  			break;
  #else
  		case Opt_user_xattr:
@@@ -1521,10 -1521,10 +1528,10 @@@
  #endif
  #ifdef CONFIG_EXT4_FS_POSIX_ACL
  		case Opt_acl:
- 			set_opt(sbi->s_mount_opt, POSIX_ACL);
+ 			set_opt(sb, POSIX_ACL);
  			break;
  		case Opt_noacl:
- 			clear_opt(sbi->s_mount_opt, POSIX_ACL);
+ 			clear_opt(sb, POSIX_ACL);
  			break;
  #else
  		case Opt_acl:
@@@ -1543,7 -1543,7 +1550,7 @@@
  					 "Cannot specify journal on remount");
  				return 0;
  			}
- 			set_opt(sbi->s_mount_opt, UPDATE_JOURNAL);
+ 			set_opt(sb, UPDATE_JOURNAL);
  			break;
  		case Opt_journal_dev:
  			if (is_remount) {
@@@ -1556,14 -1556,14 +1563,14 @@@
  			*journal_devnum = option;
  			break;
  		case Opt_journal_checksum:
- 			set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
+ 			set_opt(sb, JOURNAL_CHECKSUM);
  			break;
  		case Opt_journal_async_commit:
- 			set_opt(sbi->s_mount_opt, JOURNAL_ASYNC_COMMIT);
- 			set_opt(sbi->s_mount_opt, JOURNAL_CHECKSUM);
+ 			set_opt(sb, JOURNAL_ASYNC_COMMIT);
+ 			set_opt(sb, JOURNAL_CHECKSUM);
  			break;
  		case Opt_noload:
- 			set_opt(sbi->s_mount_opt, NOLOAD);
+ 			set_opt(sb, NOLOAD);
  			break;
  		case Opt_commit:
  			if (match_int(&args[0], &option))
@@@ -1606,15 -1606,15 +1613,15 @@@
  					return 0;
  				}
  			} else {
- 				clear_opt(sbi->s_mount_opt, DATA_FLAGS);
+ 				clear_opt(sb, DATA_FLAGS);
  				sbi->s_mount_opt |= data_opt;
  			}
  			break;
  		case Opt_data_err_abort:
- 			set_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
+ 			set_opt(sb, DATA_ERR_ABORT);
  			break;
  		case Opt_data_err_ignore:
- 			clear_opt(sbi->s_mount_opt, DATA_ERR_ABORT);
+ 			clear_opt(sb, DATA_ERR_ABORT);
  			break;
  #ifdef CONFIG_QUOTA
  		case Opt_usrjquota:
@@@ -1654,12 -1654,12 +1661,12 @@@ set_qf_format
  			break;
  		case Opt_quota:
  		case Opt_usrquota:
- 			set_opt(sbi->s_mount_opt, QUOTA);
- 			set_opt(sbi->s_mount_opt, USRQUOTA);
+ 			set_opt(sb, QUOTA);
+ 			set_opt(sb, USRQUOTA);
  			break;
  		case Opt_grpquota:
- 			set_opt(sbi->s_mount_opt, QUOTA);
- 			set_opt(sbi->s_mount_opt, GRPQUOTA);
+ 			set_opt(sb, QUOTA);
+ 			set_opt(sb, GRPQUOTA);
  			break;
  		case Opt_noquota:
  			if (sb_any_quota_loaded(sb)) {
@@@ -1667,9 -1667,9 +1674,9 @@@
  					"options when quota turned on");
  				return 0;
  			}
- 			clear_opt(sbi->s_mount_opt, QUOTA);
- 			clear_opt(sbi->s_mount_opt, USRQUOTA);
- 			clear_opt(sbi->s_mount_opt, GRPQUOTA);
+ 			clear_opt(sb, QUOTA);
+ 			clear_opt(sb, USRQUOTA);
+ 			clear_opt(sb, GRPQUOTA);
  			break;
  #else
  		case Opt_quota:
@@@ -1695,7 -1695,7 +1702,7 @@@
  			sbi->s_mount_flags |= EXT4_MF_FS_ABORTED;
  			break;
  		case Opt_nobarrier:
- 			clear_opt(sbi->s_mount_opt, BARRIER);
+ 			clear_opt(sb, BARRIER);
  			break;
  		case Opt_barrier:
  			if (args[0].from) {
@@@ -1704,9 -1704,9 +1711,9 @@@
  			} else
  				option = 1;	/* No argument, default to 1 */
  			if (option)
- 				set_opt(sbi->s_mount_opt, BARRIER);
+ 				set_opt(sb, BARRIER);
  			else
- 				clear_opt(sbi->s_mount_opt, BARRIER);
+ 				clear_opt(sb, BARRIER);
  			break;
  		case Opt_ignore:
  			break;
@@@ -1730,17 -1730,17 +1737,17 @@@
  				 "Ignoring deprecated bh option");
  			break;
  		case Opt_i_version:
- 			set_opt(sbi->s_mount_opt, I_VERSION);
+ 			set_opt(sb, I_VERSION);
  			sb->s_flags |= MS_I_VERSION;
  			break;
  		case Opt_nodelalloc:
- 			clear_opt(sbi->s_mount_opt, DELALLOC);
+ 			clear_opt(sb, DELALLOC);
  			break;
  		case Opt_mblk_io_submit:
- 			set_opt(sbi->s_mount_opt, MBLK_IO_SUBMIT);
+ 			set_opt(sb, MBLK_IO_SUBMIT);
  			break;
  		case Opt_nomblk_io_submit:
- 			clear_opt(sbi->s_mount_opt, MBLK_IO_SUBMIT);
+ 			clear_opt(sb, MBLK_IO_SUBMIT);
  			break;
  		case Opt_stripe:
  			if (match_int(&args[0], &option))
@@@ -1750,13 -1750,13 +1757,13 @@@
  			sbi->s_stripe = option;
  			break;
  		case Opt_delalloc:
- 			set_opt(sbi->s_mount_opt, DELALLOC);
+ 			set_opt(sb, DELALLOC);
  			break;
  		case Opt_block_validity:
- 			set_opt(sbi->s_mount_opt, BLOCK_VALIDITY);
+ 			set_opt(sb, BLOCK_VALIDITY);
  			break;
  		case Opt_noblock_validity:
- 			clear_opt(sbi->s_mount_opt, BLOCK_VALIDITY);
+ 			clear_opt(sb, BLOCK_VALIDITY);
  			break;
  		case Opt_inode_readahead_blks:
  			if (match_int(&args[0], &option))
@@@ -1780,7 -1780,7 +1787,7 @@@
  							    option);
  			break;
  		case Opt_noauto_da_alloc:
- 			set_opt(sbi->s_mount_opt,NO_AUTO_DA_ALLOC);
+ 			set_opt(sb, NO_AUTO_DA_ALLOC);
  			break;
  		case Opt_auto_da_alloc:
  			if (args[0].from) {
@@@ -1789,24 -1789,24 +1796,24 @@@
  			} else
  				option = 1;	/* No argument, default to 1 */
  			if (option)
- 				clear_opt(sbi->s_mount_opt, NO_AUTO_DA_ALLOC);
+ 				clear_opt(sb, NO_AUTO_DA_ALLOC);
  			else
- 				set_opt(sbi->s_mount_opt,NO_AUTO_DA_ALLOC);
+ 				set_opt(sb,NO_AUTO_DA_ALLOC);
  			break;
  		case Opt_discard:
- 			set_opt(sbi->s_mount_opt, DISCARD);
+ 			set_opt(sb, DISCARD);
  			break;
  		case Opt_nodiscard:
- 			clear_opt(sbi->s_mount_opt, DISCARD);
+ 			clear_opt(sb, DISCARD);
  			break;
  		case Opt_dioread_nolock:
- 			set_opt(sbi->s_mount_opt, DIOREAD_NOLOCK);
+ 			set_opt(sb, DIOREAD_NOLOCK);
  			break;
  		case Opt_dioread_lock:
- 			clear_opt(sbi->s_mount_opt, DIOREAD_NOLOCK);
+ 			clear_opt(sb, DIOREAD_NOLOCK);
  			break;
  		case Opt_init_inode_table:
- 			set_opt(sbi->s_mount_opt, INIT_INODE_TABLE);
+ 			set_opt(sb, INIT_INODE_TABLE);
  			if (args[0].from) {
  				if (match_int(&args[0], &option))
  					return 0;
@@@ -1817,7 -1817,7 +1824,7 @@@
  			sbi->s_li_wait_mult = option;
  			break;
  		case Opt_noinit_inode_table:
- 			clear_opt(sbi->s_mount_opt, INIT_INODE_TABLE);
+ 			clear_opt(sb, INIT_INODE_TABLE);
  			break;
  		default:
  			ext4_msg(sb, KERN_ERR,
@@@ -1829,10 -1829,10 +1836,10 @@@
  #ifdef CONFIG_QUOTA
  	if (sbi->s_qf_names[USRQUOTA] || sbi->s_qf_names[GRPQUOTA]) {
  		if (test_opt(sb, USRQUOTA) && sbi->s_qf_names[USRQUOTA])
- 			clear_opt(sbi->s_mount_opt, USRQUOTA);
+ 			clear_opt(sb, USRQUOTA);
  
  		if (test_opt(sb, GRPQUOTA) && sbi->s_qf_names[GRPQUOTA])
- 			clear_opt(sbi->s_mount_opt, GRPQUOTA);
+ 			clear_opt(sb, GRPQUOTA);
  
  		if (test_opt(sb, GRPQUOTA) || test_opt(sb, USRQUOTA)) {
  			ext4_msg(sb, KERN_ERR, "old and new quota "
@@@ -1902,12 -1902,12 +1909,12 @@@ static int ext4_setup_super(struct supe
  	ext4_commit_super(sb, 1);
  	if (test_opt(sb, DEBUG))
  		printk(KERN_INFO "[EXT4 FS bs=%lu, gc=%u, "
- 				"bpg=%lu, ipg=%lu, mo=%04x]\n",
+ 				"bpg=%lu, ipg=%lu, mo=%04x, mo2=%04x]\n",
  			sb->s_blocksize,
  			sbi->s_groups_count,
  			EXT4_BLOCKS_PER_GROUP(sb),
  			EXT4_INODES_PER_GROUP(sb),
- 			sbi->s_mount_opt);
+ 			sbi->s_mount_opt, sbi->s_mount_opt2);
  
  	return res;
  }
@@@ -1937,14 -1937,13 +1944,13 @@@ static int ext4_fill_flex_info(struct s
  	size = flex_group_count * sizeof(struct flex_groups);
  	sbi->s_flex_groups = kzalloc(size, GFP_KERNEL);
  	if (sbi->s_flex_groups == NULL) {
- 		sbi->s_flex_groups = vmalloc(size);
- 		if (sbi->s_flex_groups)
- 			memset(sbi->s_flex_groups, 0, size);
- 	}
- 	if (sbi->s_flex_groups == NULL) {
- 		ext4_msg(sb, KERN_ERR, "not enough memory for "
- 				"%u flex groups", flex_group_count);
- 		goto failed;
+ 		sbi->s_flex_groups = vzalloc(size);
+ 		if (sbi->s_flex_groups == NULL) {
+ 			ext4_msg(sb, KERN_ERR,
+ 				 "not enough memory for %u flex groups",
+ 				 flex_group_count);
+ 			goto failed;
+ 		}
  	}
  
  	for (i = 0; i < sbi->s_groups_count; i++) {
@@@ -2923,7 -2922,7 +2929,7 @@@ static int ext4_register_li_request(str
  	struct ext4_sb_info *sbi = EXT4_SB(sb);
  	struct ext4_li_request *elr;
  	ext4_group_t ngroups = EXT4_SB(sb)->s_groups_count;
- 	int ret;
+ 	int ret = 0;
  
  	if (sbi->s_li_request != NULL)
  		return 0;
@@@ -3078,41 -3077,41 +3084,41 @@@ static int ext4_fill_super(struct super
  
  	/* Set defaults before we parse the mount options */
  	def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
- 	set_opt(sbi->s_mount_opt, INIT_INODE_TABLE);
+ 	set_opt(sb, INIT_INODE_TABLE);
  	if (def_mount_opts & EXT4_DEFM_DEBUG)
- 		set_opt(sbi->s_mount_opt, DEBUG);
+ 		set_opt(sb, DEBUG);
  	if (def_mount_opts & EXT4_DEFM_BSDGROUPS) {
  		ext4_msg(sb, KERN_WARNING, deprecated_msg, "bsdgroups",
  			"2.6.38");
- 		set_opt(sbi->s_mount_opt, GRPID);
+ 		set_opt(sb, GRPID);
  	}
  	if (def_mount_opts & EXT4_DEFM_UID16)
- 		set_opt(sbi->s_mount_opt, NO_UID32);
+ 		set_opt(sb, NO_UID32);
  #ifdef CONFIG_EXT4_FS_XATTR
  	if (def_mount_opts & EXT4_DEFM_XATTR_USER)
- 		set_opt(sbi->s_mount_opt, XATTR_USER);
+ 		set_opt(sb, XATTR_USER);
  #endif
  #ifdef CONFIG_EXT4_FS_POSIX_ACL
  	if (def_mount_opts & EXT4_DEFM_ACL)
- 		set_opt(sbi->s_mount_opt, POSIX_ACL);
+ 		set_opt(sb, POSIX_ACL);
  #endif
  	if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_DATA)
- 		set_opt(sbi->s_mount_opt, JOURNAL_DATA);
+ 		set_opt(sb, JOURNAL_DATA);
  	else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_ORDERED)
- 		set_opt(sbi->s_mount_opt, ORDERED_DATA);
+ 		set_opt(sb, ORDERED_DATA);
  	else if ((def_mount_opts & EXT4_DEFM_JMODE) == EXT4_DEFM_JMODE_WBACK)
- 		set_opt(sbi->s_mount_opt, WRITEBACK_DATA);
+ 		set_opt(sb, WRITEBACK_DATA);
  
  	if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_PANIC)
- 		set_opt(sbi->s_mount_opt, ERRORS_PANIC);
+ 		set_opt(sb, ERRORS_PANIC);
  	else if (le16_to_cpu(sbi->s_es->s_errors) == EXT4_ERRORS_CONTINUE)
- 		set_opt(sbi->s_mount_opt, ERRORS_CONT);
+ 		set_opt(sb, ERRORS_CONT);
  	else
- 		set_opt(sbi->s_mount_opt, ERRORS_RO);
+ 		set_opt(sb, ERRORS_RO);
  	if (def_mount_opts & EXT4_DEFM_BLOCK_VALIDITY)
- 		set_opt(sbi->s_mount_opt, BLOCK_VALIDITY);
+ 		set_opt(sb, BLOCK_VALIDITY);
  	if (def_mount_opts & EXT4_DEFM_DISCARD)
- 		set_opt(sbi->s_mount_opt, DISCARD);
+ 		set_opt(sb, DISCARD);
  
  	sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
  	sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
@@@ -3121,7 -3120,7 +3127,7 @@@
  	sbi->s_max_batch_time = EXT4_DEF_MAX_BATCH_TIME;
  
  	if ((def_mount_opts & EXT4_DEFM_NOBARRIER) == 0)
- 		set_opt(sbi->s_mount_opt, BARRIER);
+ 		set_opt(sb, BARRIER);
  
  	/*
  	 * enable delayed allocation by default
@@@ -3129,7 -3128,7 +3135,7 @@@
  	 */
  	if (!IS_EXT3_SB(sb) &&
  	    ((def_mount_opts & EXT4_DEFM_NODELALLOC) == 0))
- 		set_opt(sbi->s_mount_opt, DELALLOC);
+ 		set_opt(sb, DELALLOC);
  
  	if (!parse_options((char *) sbi->s_es->s_mount_opts, sb,
  			   &journal_devnum, &journal_ioprio, NULL, 0)) {
@@@ -3432,8 -3431,8 +3438,8 @@@
  		       "suppressed and not mounted read-only");
  		goto failed_mount_wq;
  	} else {
- 		clear_opt(sbi->s_mount_opt, DATA_FLAGS);
- 		set_opt(sbi->s_mount_opt, WRITEBACK_DATA);
+ 		clear_opt(sb, DATA_FLAGS);
+ 		set_opt(sb, WRITEBACK_DATA);
  		sbi->s_journal = NULL;
  		needs_recovery = 0;
  		goto no_journal;
@@@ -3471,9 -3470,9 +3477,9 @@@
  		 */
  		if (jbd2_journal_check_available_features
  		    (sbi->s_journal, 0, 0, JBD2_FEATURE_INCOMPAT_REVOKE))
- 			set_opt(sbi->s_mount_opt, ORDERED_DATA);
+ 			set_opt(sb, ORDERED_DATA);
  		else
- 			set_opt(sbi->s_mount_opt, JOURNAL_DATA);
+ 			set_opt(sb, JOURNAL_DATA);
  		break;
  
  	case EXT4_MOUNT_ORDERED_DATA:
@@@ -3563,18 -3562,18 +3569,18 @@@ no_journal
  	    (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA)) {
  		ext4_msg(sb, KERN_WARNING, "Ignoring delalloc option - "
  			 "requested data journaling mode");
- 		clear_opt(sbi->s_mount_opt, DELALLOC);
+ 		clear_opt(sb, DELALLOC);
  	}
  	if (test_opt(sb, DIOREAD_NOLOCK)) {
  		if (test_opt(sb, DATA_FLAGS) == EXT4_MOUNT_JOURNAL_DATA) {
  			ext4_msg(sb, KERN_WARNING, "Ignoring dioread_nolock "
  				"option - requested data journaling mode");
- 			clear_opt(sbi->s_mount_opt, DIOREAD_NOLOCK);
+ 			clear_opt(sb, DIOREAD_NOLOCK);
  		}
  		if (sb->s_blocksize < PAGE_SIZE) {
  			ext4_msg(sb, KERN_WARNING, "Ignoring dioread_nolock "
  				"option - block size is too small");
- 			clear_opt(sbi->s_mount_opt, DIOREAD_NOLOCK);
+ 			clear_opt(sb, DIOREAD_NOLOCK);
  		}
  	}
  
@@@ -4173,6 -4172,22 +4179,22 @@@ static int ext4_unfreeze(struct super_b
  	return 0;
  }
  
+ /*
+  * Structure to save mount options for ext4_remount's benefit
+  */
+ struct ext4_mount_options {
+ 	unsigned long s_mount_opt;
+ 	unsigned long s_mount_opt2;
+ 	uid_t s_resuid;
+ 	gid_t s_resgid;
+ 	unsigned long s_commit_interval;
+ 	u32 s_min_batch_time, s_max_batch_time;
+ #ifdef CONFIG_QUOTA
+ 	int s_jquota_fmt;
+ 	char *s_qf_names[MAXQUOTAS];
+ #endif
+ };
+ 
  static int ext4_remount(struct super_block *sb, int *flags, char *data)
  {
  	struct ext4_super_block *es;
@@@ -4193,6 -4208,7 +4215,7 @@@
  	lock_super(sb);
  	old_sb_flags = sb->s_flags;
  	old_opts.s_mount_opt = sbi->s_mount_opt;
+ 	old_opts.s_mount_opt2 = sbi->s_mount_opt2;
  	old_opts.s_resuid = sbi->s_resuid;
  	old_opts.s_resgid = sbi->s_resgid;
  	old_opts.s_commit_interval = sbi->s_commit_interval;
@@@ -4346,6 -4362,7 +4369,7 @@@
  restore_opts:
  	sb->s_flags = old_sb_flags;
  	sbi->s_mount_opt = old_opts.s_mount_opt;
+ 	sbi->s_mount_opt2 = old_opts.s_mount_opt2;
  	sbi->s_resuid = old_opts.s_resuid;
  	sbi->s_resgid = old_opts.s_resgid;
  	sbi->s_commit_interval = old_opts.s_commit_interval;