Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ac0e9c30 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

* 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tytso/ext4:
  jbd2: update transaction t_state to T_COMMIT fix
  ext4: Retry block allocation if new blocks are allocated from system zone.
  ext4: mballoc fix mb_normalize_request algorithm for 1KB block size filesystems
  ext4: fix typos in messages and comments (journalled -> journaled)
  ext4: fix synchronization of quota files in journal=data mode
  ext4: Fix mount messages when quota disabled
  ext4: correct mount option parsing to detect when quota options can be changed
parents a76bfd0d 02c471cb

fs/ext4/balloc.c

+11 −6
Original line number Diff line number Diff line
@@ -287,11 +287,11 @@ read_block_bitmap(struct super_block *sb, ext4_group_t block_group) 
			    (int)block_group, (unsigned long long)bitmap_blk);

		return NULL;

	}

	if (!ext4_valid_block_bitmap(sb, desc, block_group, bh)) {

		put_bh(bh);

		return NULL;

	}



	ext4_valid_block_bitmap(sb, desc, block_group, bh);

	/*

	 * file system mounted not to panic on error,

	 * continue with corrupt bitmap

	 */

	return bh;

}

/*
@@ -1770,7 +1770,12 @@ allocated: 
			    "Allocating block in system zone - "

			    "blocks from %llu, length %lu",

			     ret_block, num);

		goto out;

		/*

		 * claim_block marked the blocks we allocated

		 * as in use. So we may want to selectively

		 * mark some of the blocks as free

		 */

		goto retry_alloc;

	}



	performed_allocation = 1;

fs/ext4/mballoc.c

+45 −21
Original line number Diff line number Diff line
@@ -2736,7 +2736,7 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac, 
	struct ext4_sb_info *sbi;

	struct super_block *sb;

	ext4_fsblk_t block;

	int err;

	int err, len;



	BUG_ON(ac->ac_status != AC_STATUS_FOUND);

	BUG_ON(ac->ac_b_ex.fe_len <= 0);
@@ -2770,14 +2770,27 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac, 
		+ ac->ac_b_ex.fe_start

		+ le32_to_cpu(es->s_first_data_block);



	if (block == ext4_block_bitmap(sb, gdp) ||

			block == ext4_inode_bitmap(sb, gdp) ||

	len = ac->ac_b_ex.fe_len;

	if (in_range(ext4_block_bitmap(sb, gdp), block, len) ||

	    in_range(ext4_inode_bitmap(sb, gdp), block, len) ||

	    in_range(block, ext4_inode_table(sb, gdp),

		     EXT4_SB(sb)->s_itb_per_group) ||

	    in_range(block + len - 1, ext4_inode_table(sb, gdp),

		     EXT4_SB(sb)->s_itb_per_group)) {



		ext4_error(sb, __func__,

			   "Allocating block in system zone - block = %llu",

			   block);

		/* File system mounted not to panic on error

		 * Fix the bitmap and repeat the block allocation

		 * We leak some of the blocks here.

		 */

		mb_set_bits(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group),

				bitmap_bh->b_data, ac->ac_b_ex.fe_start,

				ac->ac_b_ex.fe_len);

		err = ext4_journal_dirty_metadata(handle, bitmap_bh);

		if (!err)

			err = -EAGAIN;

		goto out_err;

	}

#ifdef AGGRESSIVE_CHECK

	{
@@ -2880,12 +2893,11 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac, 
	if (size < i_size_read(ac->ac_inode))

		size = i_size_read(ac->ac_inode);



	/* max available blocks in a free group */

	max = EXT4_BLOCKS_PER_GROUP(ac->ac_sb) - 1 - 1 -

				EXT4_SB(ac->ac_sb)->s_itb_per_group;

	/* max size of free chunks */

	max = 2 << bsbits;



#define NRL_CHECK_SIZE(req, size, max,bits)	\

		(req <= (size) || max <= ((size) >> bits))

#define NRL_CHECK_SIZE(req, size, max, chunk_size)	\

		(req <= (size) || max <= (chunk_size))



	/* first, try to predict filesize */

	/* XXX: should this table be tunable? */
@@ -2904,16 +2916,16 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac, 
		size = 512 * 1024;

	} else if (size <= 1024 * 1024) {

		size = 1024 * 1024;

	} else if (NRL_CHECK_SIZE(size, 4 * 1024 * 1024, max, bsbits)) {

	} else if (NRL_CHECK_SIZE(size, 4 * 1024 * 1024, max, 2 * 1024)) {

		start_off = ((loff_t)ac->ac_o_ex.fe_logical >>

						(20 - bsbits)) << 20;

		size = 1024 * 1024;

	} else if (NRL_CHECK_SIZE(size, 8 * 1024 * 1024, max, bsbits)) {

						(21 - bsbits)) << 21;

		size = 2 * 1024 * 1024;

	} else if (NRL_CHECK_SIZE(size, 8 * 1024 * 1024, max, 4 * 1024)) {

		start_off = ((loff_t)ac->ac_o_ex.fe_logical >>

							(22 - bsbits)) << 22;

		size = 4 * 1024 * 1024;

	} else if (NRL_CHECK_SIZE(ac->ac_o_ex.fe_len,

					(8<<20)>>bsbits, max, bsbits)) {

					(8<<20)>>bsbits, max, 8 * 1024)) {

		start_off = ((loff_t)ac->ac_o_ex.fe_logical >>

							(23 - bsbits)) << 23;

		size = 8 * 1024 * 1024;
@@ -4033,7 +4045,6 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle, 


		ac->ac_op = EXT4_MB_HISTORY_ALLOC;

		ext4_mb_normalize_request(ac, ar);



repeat:

		/* allocate space in core */

		ext4_mb_regular_allocator(ac);
@@ -4047,10 +4058,21 @@ repeat: 
	}



	if (likely(ac->ac_status == AC_STATUS_FOUND)) {

		ext4_mb_mark_diskspace_used(ac, handle);

		*errp = 0;

		*errp = ext4_mb_mark_diskspace_used(ac, handle);

		if (*errp ==  -EAGAIN) {

			ac->ac_b_ex.fe_group = 0;

			ac->ac_b_ex.fe_start = 0;

			ac->ac_b_ex.fe_len = 0;

			ac->ac_status = AC_STATUS_CONTINUE;

			goto repeat;

		} else if (*errp) {

			ac->ac_b_ex.fe_len = 0;

			ar->len = 0;

			ext4_mb_show_ac(ac);

		} else {

			block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);

			ar->len = ac->ac_b_ex.fe_len;

		}

	} else {

		freed  = ext4_mb_discard_preallocations(sb, ac->ac_o_ex.fe_len);

		if (freed)
@@ -4237,6 +4259,8 @@ do_more: 
		ext4_error(sb, __func__,

			   "Freeing blocks in system zone - "

			   "Block = %lu, count = %lu", block, count);

		/* err = 0. ext4_std_error should be a no op */

		goto error_return;

	}



	BUFFER_TRACE(bitmap_bh, "getting write access");

fs/ext4/super.c

+58 −22
Original line number Diff line number Diff line
@@ -979,7 +979,7 @@ static int parse_options (char *options, struct super_block *sb, 
	int data_opt = 0;

	int option;

#ifdef CONFIG_QUOTA

	int qtype;

	int qtype, qfmt;

	char *qname;

#endif
@@ -1162,9 +1162,11 @@ static int parse_options (char *options, struct super_block *sb, 
		case Opt_grpjquota:

			qtype = GRPQUOTA;

set_qf_name:

			if (sb_any_quota_enabled(sb)) {

			if ((sb_any_quota_enabled(sb) ||

			     sb_any_quota_suspended(sb)) &&

			    !sbi->s_qf_names[qtype]) {

				printk(KERN_ERR

					"EXT4-fs: Cannot change journalled "

					"EXT4-fs: Cannot change journaled "

					"quota options when quota turned on.\n");

				return 0;

			}
@@ -1200,9 +1202,11 @@ set_qf_name: 
		case Opt_offgrpjquota:

			qtype = GRPQUOTA;

clear_qf_name:

			if (sb_any_quota_enabled(sb)) {

			if ((sb_any_quota_enabled(sb) ||

			     sb_any_quota_suspended(sb)) &&

			    sbi->s_qf_names[qtype]) {

				printk(KERN_ERR "EXT4-fs: Cannot change "

					"journalled quota options when "

					"journaled quota options when "

					"quota turned on.\n");

				return 0;

			}
@@ -1213,10 +1217,20 @@ clear_qf_name: 
			sbi->s_qf_names[qtype] = NULL;

			break;

		case Opt_jqfmt_vfsold:

			sbi->s_jquota_fmt = QFMT_VFS_OLD;

			break;

			qfmt = QFMT_VFS_OLD;

			goto set_qf_format;

		case Opt_jqfmt_vfsv0:

			sbi->s_jquota_fmt = QFMT_VFS_V0;

			qfmt = QFMT_VFS_V0;

set_qf_format:

			if ((sb_any_quota_enabled(sb) ||

			     sb_any_quota_suspended(sb)) &&

			    sbi->s_jquota_fmt != qfmt) {

				printk(KERN_ERR "EXT4-fs: Cannot change "

					"journaled quota options when "

					"quota turned on.\n");

				return 0;

			}

			sbi->s_jquota_fmt = qfmt;

			break;

		case Opt_quota:

		case Opt_usrquota:
@@ -1241,6 +1255,9 @@ clear_qf_name: 
		case Opt_quota:

		case Opt_usrquota:

		case Opt_grpquota:

			printk(KERN_ERR

				"EXT4-fs: quota options not supported.\n");

			break;

		case Opt_usrjquota:

		case Opt_grpjquota:

		case Opt_offusrjquota:
@@ -1248,7 +1265,7 @@ clear_qf_name: 
		case Opt_jqfmt_vfsold:

		case Opt_jqfmt_vfsv0:

			printk(KERN_ERR

				"EXT4-fs: journalled quota options not "

				"EXT4-fs: journaled quota options not "

				"supported.\n");

			break;

		case Opt_noquota:
@@ -1333,14 +1350,14 @@ clear_qf_name: 
		}



		if (!sbi->s_jquota_fmt) {

			printk(KERN_ERR "EXT4-fs: journalled quota format "

			printk(KERN_ERR "EXT4-fs: journaled quota format "

					"not specified.\n");

			return 0;

		}

	} else {

		if (sbi->s_jquota_fmt) {

			printk(KERN_ERR "EXT4-fs: journalled quota format "

					"specified with no journalling "

			printk(KERN_ERR "EXT4-fs: journaled quota format "

					"specified with no journaling "

					"enabled.\n");

			return 0;

		}
@@ -1581,7 +1598,7 @@ static void ext4_orphan_cleanup (struct super_block * sb, 
			int ret = ext4_quota_on_mount(sb, i);

			if (ret < 0)

				printk(KERN_ERR

					"EXT4-fs: Cannot turn on journalled "

					"EXT4-fs: Cannot turn on journaled "

					"quota: error %d\n", ret);

		}

	}
@@ -3106,7 +3123,7 @@ static int ext4_release_dquot(struct dquot *dquot) 


static int ext4_mark_dquot_dirty(struct dquot *dquot)

{

	/* Are we journalling quotas? */

	/* Are we journaling quotas? */

	if (EXT4_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||

	    EXT4_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {

		dquot_mark_dquot_dirty(dquot);
@@ -3153,23 +3170,42 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id, 


	if (!test_opt(sb, QUOTA))

		return -EINVAL;

	/* Not journalling quota? */

	if ((!EXT4_SB(sb)->s_qf_names[USRQUOTA] &&

	    !EXT4_SB(sb)->s_qf_names[GRPQUOTA]) || remount)

	/* When remounting, no checks are needed and in fact, path is NULL */

	if (remount)

		return vfs_quota_on(sb, type, format_id, path, remount);



	err = path_lookup(path, LOOKUP_FOLLOW, &nd);

	if (err)

		return err;



	/* Quotafile not on the same filesystem? */

	if (nd.path.mnt->mnt_sb != sb) {

		path_put(&nd.path);

		return -EXDEV;

	}

	/* Journaling quota? */

	if (EXT4_SB(sb)->s_qf_names[type]) {

		/* Quotafile not of fs root? */

		if (nd.path.dentry->d_parent->d_inode != sb->s_root->d_inode)

			printk(KERN_WARNING

				"EXT4-fs: Quota file not on filesystem root. "

			"Journalled quota will not work.\n");

				"Journaled quota will not work.\n");

 	}



	/*

	 * When we journal data on quota file, we have to flush journal to see

	 * all updates to the file when we bypass pagecache...

	 */

	if (ext4_should_journal_data(nd.path.dentry->d_inode)) {

		/*

		 * We don't need to lock updates but journal_flush() could

		 * otherwise be livelocked...

		 */

		jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);

		jbd2_journal_flush(EXT4_SB(sb)->s_journal);

		jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);

	}



	path_put(&nd.path);

	return vfs_quota_on(sb, type, format_id, path, remount);

}

fs/jbd2/commit.c

+2 −0
Original line number Diff line number Diff line
@@ -560,7 +560,9 @@ void jbd2_journal_commit_transaction(journal_t *journal) 
	 * transaction!  Now comes the tricky part: we need to write out

	 * metadata.  Loop over the transaction's entire buffer list:

	 */

	spin_lock(&journal->j_state_lock);

	commit_transaction->t_state = T_COMMIT;

	spin_unlock(&journal->j_state_lock);



	stats.u.run.rs_logging = jiffies;

	stats.u.run.rs_flushing = jbd2_time_diff(stats.u.run.rs_flushing,