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

Merge branch 'quota_scaling' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs 

Pull quota scaling updates from Jan Kara:
 "This contains changes to make the quota subsystem more scalable.

  Reportedly it improves number of files created per second on ext4
  filesystem on fast storage by about a factor of 2x"

* 'quota_scaling' of git://git.kernel.org/pub/scm/linux/kernel/git/jack/linux-fs: (28 commits)
  quota: Add lock annotations to struct members
  quota: Reduce contention on dq_data_lock
  fs: Provide __inode_get_bytes()
  quota: Inline dquot_[re]claim_reserved_space() into callsite
  quota: Inline inode_{incr,decr}_space() into callsites
  quota: Inline functions into their callsites
  ext4: Disable dirty list tracking of dquots when journalling quotas
  quota: Allow disabling tracking of dirty dquots in a list
  quota: Remove dq_wait_unused from dquot
  quota: Move locking into clear_dquot_dirty()
  quota: Do not dirty bad dquots
  quota: Fix possible corruption of dqi_flags
  quota: Propagate ->quota_read errors from v2_read_file_info()
  quota: Fix error codes in v2_read_file_info()
  quota: Push dqio_sem down to ->read_file_info()
  quota: Push dqio_sem down to ->write_file_info()
  quota: Push dqio_sem down to ->get_next_id()
  quota: Push dqio_sem down to ->release_dqblk()
  quota: Remove locking for writing to the old quota format
  quota: Do not acquire dqio_sem for dquot overwrites in v2 format
  ...
parents 460352c2 6c83fd51

fs/ext4/super.c

+14 −12
Original line number Diff line number Diff line
@@ -5215,7 +5215,7 @@ static int ext4_statfs_project(struct super_block *sb, 
	dquot = dqget(sb, qid);

	if (IS_ERR(dquot))

		return PTR_ERR(dquot);

	spin_lock(&dq_data_lock);

	spin_lock(&dquot->dq_dqb_lock);



	limit = (dquot->dq_dqb.dqb_bsoftlimit ?

		 dquot->dq_dqb.dqb_bsoftlimit :
@@ -5238,7 +5238,7 @@ static int ext4_statfs_project(struct super_block *sb, 
			 (buf->f_files - dquot->dq_dqb.dqb_curinodes) : 0;

	}



	spin_unlock(&dq_data_lock);

	spin_unlock(&dquot->dq_dqb_lock);

	dqput(dquot);

	return 0;

}
@@ -5284,18 +5284,13 @@ static int ext4_statfs(struct dentry *dentry, struct kstatfs *buf) 
	return 0;

}



/* Helper function for writing quotas on sync - we need to start transaction

 * before quota file is locked for write. Otherwise the are possible deadlocks:

 * Process 1                         Process 2

 * ext4_create()                     quota_sync()

 *   jbd2_journal_start()                  write_dquot()

 *   dquot_initialize()                         down(dqio_mutex)

 *     down(dqio_mutex)                    jbd2_journal_start()

 *

 */



#ifdef CONFIG_QUOTA



/*

 * Helper functions so that transaction is started before we acquire dqio_sem

 * to keep correct lock ordering of transaction > dqio_sem

 */

static inline struct inode *dquot_to_inode(struct dquot *dquot)

{

	return sb_dqopt(dquot->dq_sb)->files[dquot->dq_id.type];
@@ -5430,6 +5425,13 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id, 
			ext4_msg(sb, KERN_WARNING,

				"Quota file not on filesystem root. "

				"Journaled quota will not work");

		sb_dqopt(sb)->flags |= DQUOT_NOLIST_DIRTY;

	} else {

		/*

		 * Clear the flag just in case mount options changed since

		 * last time.

		 */

		sb_dqopt(sb)->flags &= ~DQUOT_NOLIST_DIRTY;

	}



	/*
@@ -5526,7 +5528,7 @@ static int ext4_enable_quotas(struct super_block *sb) 
		test_opt(sb, PRJQUOTA),

	};



	sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE;

	sb_dqopt(sb)->flags |= DQUOT_QUOTA_SYS_FILE | DQUOT_NOLIST_DIRTY;

	for (type = 0; type < EXT4_MAXQUOTAS; type++) {

		if (qf_inums[type]) {

			err = ext4_quota_enable(sb, type, QFMT_VFS_V1,

fs/ocfs2/quota_global.c

+20 −16
Original line number Diff line number Diff line
@@ -33,7 +33,7 @@ 
 * Locking of quotas with OCFS2 is rather complex. Here are rules that

 * should be obeyed by all the functions:

 * - any write of quota structure (either to local or global file) is protected

 *   by dqio_mutex or dquot->dq_lock.

 *   by dqio_sem or dquot->dq_lock.

 * - any modification of global quota file holds inode cluster lock, i_mutex,

 *   and ip_alloc_sem of the global quota file (achieved by

 *   ocfs2_lock_global_qf). It also has to hold qinfo_lock.
@@ -42,9 +42,9 @@ 
 *

 * A rough sketch of locking dependencies (lf = local file, gf = global file):

 * Normal filesystem operation:

 *   start_trans -> dqio_mutex -> write to lf

 *   start_trans -> dqio_sem -> write to lf

 * Syncing of local and global file:

 *   ocfs2_lock_global_qf -> start_trans -> dqio_mutex -> qinfo_lock ->

 *   ocfs2_lock_global_qf -> start_trans -> dqio_sem -> qinfo_lock ->

 *     write to gf

 *						       -> write to lf

 * Acquire dquot for the first time:
@@ -60,7 +60,7 @@ 
 * Recovery:

 *   inode cluster lock of recovered lf

 *     -> read bitmaps -> ip_alloc_sem of lf

 *     -> ocfs2_lock_global_qf -> start_trans -> dqio_mutex -> qinfo_lock ->

 *     -> ocfs2_lock_global_qf -> start_trans -> dqio_sem -> qinfo_lock ->

 *        write to gf

 */
@@ -443,13 +443,17 @@ static int __ocfs2_global_write_info(struct super_block *sb, int type) 
int ocfs2_global_write_info(struct super_block *sb, int type)

{

	int err;

	struct ocfs2_mem_dqinfo *info = sb_dqinfo(sb, type)->dqi_priv;

	struct quota_info *dqopt = sb_dqopt(sb);

	struct ocfs2_mem_dqinfo *info = dqopt->info[type].dqi_priv;



	down_write(&dqopt->dqio_sem);

	err = ocfs2_qinfo_lock(info, 1);

	if (err < 0)

		return err;

		goto out_sem;

	err = __ocfs2_global_write_info(sb, type);

	ocfs2_qinfo_unlock(info, 1);

out_sem:

	up_write(&dqopt->dqio_sem);

	return err;

}
@@ -500,7 +504,7 @@ int __ocfs2_sync_dquot(struct dquot *dquot, int freeing) 
	/* Update space and inode usage. Get also other information from

	 * global quota file so that we don't overwrite any changes there.

	 * We are */

	spin_lock(&dq_data_lock);

	spin_lock(&dquot->dq_dqb_lock);

	spacechange = dquot->dq_dqb.dqb_curspace -

					OCFS2_DQUOT(dquot)->dq_origspace;

	inodechange = dquot->dq_dqb.dqb_curinodes -
@@ -556,7 +560,7 @@ int __ocfs2_sync_dquot(struct dquot *dquot, int freeing) 
	__clear_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);

	OCFS2_DQUOT(dquot)->dq_origspace = dquot->dq_dqb.dqb_curspace;

	OCFS2_DQUOT(dquot)->dq_originodes = dquot->dq_dqb.dqb_curinodes;

	spin_unlock(&dq_data_lock);

	spin_unlock(&dquot->dq_dqb_lock);

	err = ocfs2_qinfo_lock(info, freeing);

	if (err < 0) {

		mlog(ML_ERROR, "Failed to lock quota info, losing quota write"
@@ -611,7 +615,7 @@ static int ocfs2_sync_dquot_helper(struct dquot *dquot, unsigned long type) 
		mlog_errno(status);

		goto out_ilock;

	}

	mutex_lock(&sb_dqopt(sb)->dqio_mutex);

	down_write(&sb_dqopt(sb)->dqio_sem);

	status = ocfs2_sync_dquot(dquot);

	if (status < 0)

		mlog_errno(status);
@@ -619,7 +623,7 @@ static int ocfs2_sync_dquot_helper(struct dquot *dquot, unsigned long type) 
	status = ocfs2_local_write_dquot(dquot);

	if (status < 0)

		mlog_errno(status);

	mutex_unlock(&sb_dqopt(sb)->dqio_mutex);

	up_write(&sb_dqopt(sb)->dqio_sem);

	ocfs2_commit_trans(osb, handle);

out_ilock:

	ocfs2_unlock_global_qf(oinfo, 1);
@@ -666,9 +670,9 @@ static int ocfs2_write_dquot(struct dquot *dquot) 
		mlog_errno(status);

		goto out;

	}

	mutex_lock(&sb_dqopt(dquot->dq_sb)->dqio_mutex);

	down_write(&sb_dqopt(dquot->dq_sb)->dqio_sem);

	status = ocfs2_local_write_dquot(dquot);

	mutex_unlock(&sb_dqopt(dquot->dq_sb)->dqio_mutex);

	up_write(&sb_dqopt(dquot->dq_sb)->dqio_sem);

	ocfs2_commit_trans(osb, handle);

out:

	return status;
@@ -920,10 +924,10 @@ static int ocfs2_mark_dquot_dirty(struct dquot *dquot) 


	/* In case user set some limits, sync dquot immediately to global

	 * quota file so that information propagates quicker */

	spin_lock(&dq_data_lock);

	spin_lock(&dquot->dq_dqb_lock);

	if (dquot->dq_flags & mask)

		sync = 1;

	spin_unlock(&dq_data_lock);

	spin_unlock(&dquot->dq_dqb_lock);

	/* This is a slight hack but we can't afford getting global quota

	 * lock if we already have a transaction started. */

	if (!sync || journal_current_handle()) {
@@ -939,7 +943,7 @@ static int ocfs2_mark_dquot_dirty(struct dquot *dquot) 
		mlog_errno(status);

		goto out_ilock;

	}

	mutex_lock(&sb_dqopt(sb)->dqio_mutex);

	down_write(&sb_dqopt(sb)->dqio_sem);

	status = ocfs2_sync_dquot(dquot);

	if (status < 0) {

		mlog_errno(status);
@@ -948,7 +952,7 @@ static int ocfs2_mark_dquot_dirty(struct dquot *dquot) 
	/* Now write updated local dquot structure */

	status = ocfs2_local_write_dquot(dquot);

out_dlock:

	mutex_unlock(&sb_dqopt(sb)->dqio_mutex);

	up_write(&sb_dqopt(sb)->dqio_sem);

	ocfs2_commit_trans(osb, handle);

out_ilock:

	ocfs2_unlock_global_qf(oinfo, 1);

fs/ocfs2/quota_local.c

+6 −11
Original line number Diff line number Diff line
@@ -520,8 +520,8 @@ static int ocfs2_recover_local_quota_file(struct inode *lqinode, 
				mlog_errno(status);

				goto out_drop_lock;

			}

			mutex_lock(&sb_dqopt(sb)->dqio_mutex);

			spin_lock(&dq_data_lock);

			down_write(&sb_dqopt(sb)->dqio_sem);

			spin_lock(&dquot->dq_dqb_lock);

			/* Add usage from quota entry into quota changes

			 * of our node. Auxiliary variables are important

			 * due to signedness */
@@ -529,7 +529,7 @@ static int ocfs2_recover_local_quota_file(struct inode *lqinode, 
			inodechange = le64_to_cpu(dqblk->dqb_inodemod);

			dquot->dq_dqb.dqb_curspace += spacechange;

			dquot->dq_dqb.dqb_curinodes += inodechange;

			spin_unlock(&dq_data_lock);

			spin_unlock(&dquot->dq_dqb_lock);

			/* We want to drop reference held by the crashed

			 * node. Since we have our own reference we know

			 * global structure actually won't be freed. */
@@ -553,7 +553,7 @@ static int ocfs2_recover_local_quota_file(struct inode *lqinode, 
			unlock_buffer(qbh);

			ocfs2_journal_dirty(handle, qbh);

out_commit:

			mutex_unlock(&sb_dqopt(sb)->dqio_mutex);

			up_write(&sb_dqopt(sb)->dqio_sem);

			ocfs2_commit_trans(OCFS2_SB(sb), handle);

out_drop_lock:

			ocfs2_unlock_global_qf(oinfo, 1);
@@ -691,9 +691,6 @@ static int ocfs2_local_read_info(struct super_block *sb, int type) 
	struct ocfs2_quota_recovery *rec;

	int locked = 0;



	/* We don't need the lock and we have to acquire quota file locks

	 * which will later depend on this lock */

	mutex_unlock(&sb_dqopt(sb)->dqio_mutex);

	info->dqi_max_spc_limit = 0x7fffffffffffffffLL;

	info->dqi_max_ino_limit = 0x7fffffffffffffffLL;

	oinfo = kmalloc(sizeof(struct ocfs2_mem_dqinfo), GFP_NOFS);
@@ -772,7 +769,6 @@ static int ocfs2_local_read_info(struct super_block *sb, int type) 
		goto out_err;

	}



	mutex_lock(&sb_dqopt(sb)->dqio_mutex);

	return 0;

out_err:

	if (oinfo) {
@@ -786,7 +782,6 @@ out_err: 
		kfree(oinfo);

	}

	brelse(bh);

	mutex_lock(&sb_dqopt(sb)->dqio_mutex);

	return -1;

}
@@ -882,12 +877,12 @@ static void olq_set_dquot(struct buffer_head *bh, void *private) 


	dqblk->dqb_id = cpu_to_le64(from_kqid(&init_user_ns,

					      od->dq_dquot.dq_id));

	spin_lock(&dq_data_lock);

	spin_lock(&od->dq_dquot.dq_dqb_lock);

	dqblk->dqb_spacemod = cpu_to_le64(od->dq_dquot.dq_dqb.dqb_curspace -

					  od->dq_origspace);

	dqblk->dqb_inodemod = cpu_to_le64(od->dq_dquot.dq_dqb.dqb_curinodes -

					  od->dq_originodes);

	spin_unlock(&dq_data_lock);

	spin_unlock(&od->dq_dquot.dq_dqb_lock);

	trace_olq_set_dquot(

		(unsigned long long)le64_to_cpu(dqblk->dqb_spacemod),

		(unsigned long long)le64_to_cpu(dqblk->dqb_inodemod),

fs/quota/dquot.c

+259 −245

File changed.

Preview size limit exceeded, changes collapsed.

fs/quota/quota_tree.c

+5 −5
Original line number Diff line number Diff line
@@ -379,7 +379,7 @@ int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) 
	if (!ddquot)

		return -ENOMEM;



	/* dq_off is guarded by dqio_mutex */

	/* dq_off is guarded by dqio_sem */

	if (!dquot->dq_off) {

		ret = dq_insert_tree(info, dquot);

		if (ret < 0) {
@@ -389,9 +389,9 @@ int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) 
			return ret;

		}

	}

	spin_lock(&dq_data_lock);

	spin_lock(&dquot->dq_dqb_lock);

	info->dqi_ops->mem2disk_dqblk(ddquot, dquot);

	spin_unlock(&dq_data_lock);

	spin_unlock(&dquot->dq_dqb_lock);

	ret = sb->s_op->quota_write(sb, type, ddquot, info->dqi_entry_size,

				    dquot->dq_off);

	if (ret != info->dqi_entry_size) {
@@ -649,14 +649,14 @@ int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot) 
		kfree(ddquot);

		goto out;

	}

	spin_lock(&dq_data_lock);

	spin_lock(&dquot->dq_dqb_lock);

	info->dqi_ops->disk2mem_dqblk(dquot, ddquot);

	if (!dquot->dq_dqb.dqb_bhardlimit &&

	    !dquot->dq_dqb.dqb_bsoftlimit &&

	    !dquot->dq_dqb.dqb_ihardlimit &&

	    !dquot->dq_dqb.dqb_isoftlimit)

		set_bit(DQ_FAKE_B, &dquot->dq_flags);

	spin_unlock(&dq_data_lock);

	spin_unlock(&dquot->dq_dqb_lock);

	kfree(ddquot);

out:

	dqstats_inc(DQST_READS);

CRA Git | Maintained and supported by SUSTech CRA and CCSE