From: Dmitry <dmonakhov@openvz.org>
To: linux-fsdevel@vger.kernel.org
Cc: jack@suse.cz, hch@infradead.org
Subject: Re: [PATCH 10/19] quota: make per-sb dq_data_lock
Date: Tue, 26 Oct 2010 21:38:09 +0400 [thread overview]
Message-ID: <87bp6gq2gu.fsf@dmon-lap.sw.ru> (raw)
In-Reply-To: <1287768904-27810-11-git-send-email-dmonakhov@openvz.org>
On Fri, 22 Oct 2010 21:34:55 +0400, Dmitry Monakhov <dmonakhov@openvz.org> wrote:
> From: Dmitry Monakhov <dmonakhov@gmail.com>
>
> Currently dq_data_lock is global, which is bad for scalability.
> In fact different super_blocks have no shared quota data.
> So we may simply convert global the lock to per-sb locks.
>
> Signed-off-by: Dmitry Monakhov <dmonakhov@openvz.org>
> ---
> fs/ocfs2/quota_global.c | 20 ++++++++--------
> fs/ocfs2/quota_local.c | 13 ++++++-----
> fs/quota/dquot.c | 54 ++++++++++++++++++++++++----------------------
> fs/quota/quota_tree.c | 8 +++---
> fs/quota/quota_v2.c | 4 +-
> include/linux/quota.h | 3 +-
> 6 files changed, 52 insertions(+), 50 deletions(-)
>
> diff --git a/fs/ocfs2/quota_global.c b/fs/ocfs2/quota_global.c
> index b464947..3e7fda8 100644
> --- a/fs/ocfs2/quota_global.c
> +++ b/fs/ocfs2/quota_global.c
> @@ -300,12 +300,12 @@ int ocfs2_lock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex)
> status = ocfs2_inode_lock(oinfo->dqi_gqinode, &bh, ex);
> if (status < 0)
> return status;
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(oinfo->dqi_gqinode->i_sb)->dq_data_lock);
> if (!oinfo->dqi_gqi_count++)
> oinfo->dqi_gqi_bh = bh;
> else
> WARN_ON(bh != oinfo->dqi_gqi_bh);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(oinfo->dqi_gqinode->i_sb)->dq_data_lock);
> if (ex) {
> mutex_lock(&oinfo->dqi_gqinode->i_mutex);
> down_write(&OCFS2_I(oinfo->dqi_gqinode)->ip_alloc_sem);
> @@ -325,10 +325,10 @@ void ocfs2_unlock_global_qf(struct ocfs2_mem_dqinfo *oinfo, int ex)
> }
> ocfs2_inode_unlock(oinfo->dqi_gqinode, ex);
> brelse(oinfo->dqi_gqi_bh);
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(oinfo->dqi_gqinode->i_sb)->dq_data_lock);
> if (!--oinfo->dqi_gqi_count)
> oinfo->dqi_gqi_bh = NULL;
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(oinfo->dqi_gqinode->i_sb)->dq_data_lock);
> }
>
> /* Read information header from global quota file */
> @@ -421,11 +421,11 @@ static int __ocfs2_global_write_info(struct super_block *sb, int type)
> struct ocfs2_global_disk_dqinfo dinfo;
> ssize_t size;
>
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(sb)->dq_data_lock);
> info->dqi_flags &= ~DQF_INFO_DIRTY;
> dinfo.dqi_bgrace = cpu_to_le32(info->dqi_bgrace);
> dinfo.dqi_igrace = cpu_to_le32(info->dqi_igrace);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(sb)->dq_data_lock);
> dinfo.dqi_syncms = cpu_to_le32(oinfo->dqi_syncms);
> dinfo.dqi_blocks = cpu_to_le32(oinfo->dqi_gi.dqi_blocks);
> dinfo.dqi_free_blk = cpu_to_le32(oinfo->dqi_gi.dqi_free_blk);
> @@ -502,7 +502,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(&dqopts(sb)->dq_data_lock);
> spacechange = dquot->dq_dqb.dqb_curspace -
> OCFS2_DQUOT(dquot)->dq_origspace;
> inodechange = dquot->dq_dqb.dqb_curinodes -
> @@ -556,7 +556,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(&dqopts(sb)->dq_data_lock);
> err = ocfs2_qinfo_lock(info, freeing);
> if (err < 0) {
> mlog(ML_ERROR, "Failed to lock quota info, loosing quota write"
> @@ -835,10 +835,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(&dqopts(sb)->dq_data_lock);
> if (dquot->dq_flags & mask)
> sync = 1;
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(sb)->dq_data_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()) {
> diff --git a/fs/ocfs2/quota_local.c b/fs/ocfs2/quota_local.c
> index 7c30ba3..2d2e981 100644
> --- a/fs/ocfs2/quota_local.c
> +++ b/fs/ocfs2/quota_local.c
> @@ -288,14 +288,15 @@ static void olq_update_info(struct buffer_head *bh, void *private)
> struct mem_dqinfo *info = private;
> struct ocfs2_mem_dqinfo *oinfo = info->dqi_priv;
> struct ocfs2_local_disk_dqinfo *ldinfo;
> + struct quota_info *dqopt = dqopts(oinfo->dqi_gqinode->i_sb);
>
> ldinfo = (struct ocfs2_local_disk_dqinfo *)(bh->b_data +
> OCFS2_LOCAL_INFO_OFF);
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopt->dq_data_lock);
> ldinfo->dqi_flags = cpu_to_le32(info->dqi_flags & DQF_MASK);
> ldinfo->dqi_chunks = cpu_to_le32(oinfo->dqi_chunks);
> ldinfo->dqi_blocks = cpu_to_le32(oinfo->dqi_blocks);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopt->dq_data_lock);
> }
>
> static int ocfs2_add_recovery_chunk(struct super_block *sb,
> @@ -523,7 +524,7 @@ static int ocfs2_recover_local_quota_file(struct inode *lqinode,
> goto out_drop_lock;
> }
> mutex_lock(&dqopts(sb)->dqio_mutex);
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(sb)->dq_data_lock);
> /* Add usage from quota entry into quota changes
> * of our node. Auxiliary variables are important
> * due to signedness */
> @@ -531,7 +532,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(&dqopts(sb)->dq_data_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. */
> @@ -876,12 +877,12 @@ static void olq_set_dquot(struct buffer_head *bh, void *private)
> + ol_dqblk_block_offset(sb, od->dq_local_off));
>
> dqblk->dqb_id = cpu_to_le64(od->dq_dquot.dq_id);
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(sb)->dq_data_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(&dqopts(sb)->dq_data_lock);
> mlog(0, "Writing local dquot %u space %lld inodes %lld\n",
> od->dq_dquot.dq_id, (long long)le64_to_cpu(dqblk->dqb_spacemod),
> (long long)le64_to_cpu(dqblk->dqb_inodemod));
> diff --git a/fs/quota/dquot.c b/fs/quota/dquot.c
> index fdaa386..6c68172 100644
> --- a/fs/quota/dquot.c
> +++ b/fs/quota/dquot.c
> @@ -128,8 +128,6 @@
> */
>
> static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_fmt_lock);
> -__cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
> -EXPORT_SYMBOL(dq_data_lock);
>
> void __quota_error(struct super_block *sb, const char *func,
> const char *fmt, ...)
> @@ -1417,8 +1415,11 @@ static void __dquot_initialize(struct inode *inode, int type)
> * did a write before quota was turned on
> */
> rsv = inode_get_rsv_space(inode);
> - if (unlikely(rsv))
> - dquot_resv_space(inode->i_dquot[cnt], rsv);
> + if (unlikely(rsv)) {
> + spin_lock(&got[cnt]->dq_lock);
> + dquot_resv_space(got[cnt], rsv);
> + spin_unlock(&got[cnt]->dq_lock);
> + }
Ohhh, sorry. got[cnt] is already NULL at this moment,
Off course this hank should look like follows
+ if (unlikely(rsv)) {
+ spin_lock(&inode->i_dquot[cnt]->dq_lock);
+ dquot_resv_space(inode->i_dquot[cnt], rsv);
+ spin_unlock(&inode->i_dquot[cnt]->dq_lock);
> }
> }
> out_err:
> @@ -1574,14 +1575,14 @@ int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
> for (cnt = 0; cnt < MAXQUOTAS; cnt++)
> warntype[cnt] = QUOTA_NL_NOWARN;
>
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(inode->i_sb)->dq_data_lock);
> for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
> if (!inode->i_dquot[cnt])
> continue;
> ret = check_bdq(inode->i_dquot[cnt], number, !warn,
> warntype+cnt);
> if (ret && !nofail) {
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(inode->i_sb)->dq_data_lock);
> goto out_flush_warn;
> }
> }
> @@ -1594,7 +1595,7 @@ int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
> dquot_incr_space(inode->i_dquot[cnt], number);
> }
> inode_incr_space(inode, number, reserve);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(inode->i_sb)->dq_data_lock);
>
> if (reserve)
> goto out_flush_warn;
> @@ -1622,7 +1623,7 @@ int dquot_alloc_inode(const struct inode *inode)
> for (cnt = 0; cnt < MAXQUOTAS; cnt++)
> warntype[cnt] = QUOTA_NL_NOWARN;
> down_read(&dqctl(inode->i_sb)->dqptr_sem);
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(inode->i_sb)->dq_data_lock);
> for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
> if (!inode->i_dquot[cnt])
> continue;
> @@ -1638,7 +1639,7 @@ int dquot_alloc_inode(const struct inode *inode)
> }
>
> warn_put_all:
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(inode->i_sb)->dq_data_lock);
> if (ret == 0)
> mark_all_dquot_dirty(inode->i_dquot);
> flush_warnings(inode->i_dquot, warntype);
> @@ -1660,7 +1661,7 @@ int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
> }
>
> down_read(&dqctl(inode->i_sb)->dqptr_sem);
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(inode->i_sb)->dq_data_lock);
> /* Claim reserved quotas to allocated quotas */
> for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
> if (inode->i_dquot[cnt])
> @@ -1669,7 +1670,7 @@ int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
> }
> /* Update inode bytes */
> inode_claim_rsv_space(inode, number);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(inode->i_sb)->dq_data_lock);
> mark_all_dquot_dirty(inode->i_dquot);
> up_read(&dqctl(inode->i_sb)->dqptr_sem);
> return 0;
> @@ -1693,7 +1694,7 @@ void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
> }
>
> down_read(&dqctl(inode->i_sb)->dqptr_sem);
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(inode->i_sb)->dq_data_lock);
> for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
> if (!inode->i_dquot[cnt])
> continue;
> @@ -1704,7 +1705,7 @@ void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
> dquot_decr_space(inode->i_dquot[cnt], number);
> }
> inode_decr_space(inode, number, reserve);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(inode->i_sb)->dq_data_lock);
>
> if (reserve)
> goto out_unlock;
> @@ -1729,14 +1730,14 @@ void dquot_free_inode(const struct inode *inode)
> return;
>
> down_read(&dqctl(inode->i_sb)->dqptr_sem);
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(inode->i_sb)->dq_data_lock);
> for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
> if (!inode->i_dquot[cnt])
> continue;
> warntype[cnt] = info_idq_free(inode->i_dquot[cnt], 1);
> dquot_decr_inodes(inode->i_dquot[cnt], 1);
> }
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(inode->i_sb)->dq_data_lock);
> mark_all_dquot_dirty(inode->i_dquot);
> flush_warnings(inode->i_dquot, warntype);
> up_read(&dqctl(inode->i_sb)->dqptr_sem);
> @@ -1775,7 +1776,7 @@ int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
> up_write(&dqctl(inode->i_sb)->dqptr_sem);
> return 0;
> }
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(inode->i_sb)->dq_data_lock);
> cur_space = inode_get_bytes(inode);
> rsv_space = inode_get_rsv_space(inode);
> space = cur_space + rsv_space;
> @@ -1823,7 +1824,7 @@ int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
>
> inode->i_dquot[cnt] = transfer_to[cnt];
> }
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(inode->i_sb)->dq_data_lock);
> up_write(&dqctl(inode->i_sb)->dqptr_sem);
>
> mark_all_dquot_dirty(transfer_from);
> @@ -1837,7 +1838,7 @@ int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
> transfer_to[cnt] = transfer_from[cnt];
> return 0;
> over_quota:
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(inode->i_sb)->dq_data_lock);
> up_write(&dqctl(inode->i_sb)->dqptr_sem);
> flush_warnings(transfer_to, warntype_to);
> return ret;
> @@ -1958,6 +1959,7 @@ static int alloc_quota_info(struct quota_ctl_info *dqctl) {
>
> mutex_init(&dqopt->dqio_mutex);
> spin_lock_init(&dqopt->dq_state_lock);
> + spin_lock_init(&dqopt->dq_data_lock);
> spin_lock_init(&dqopt->dq_list_lock);
> INIT_LIST_HEAD(&dqopt->dq_inuse_list);
> INIT_LIST_HEAD(&dqopt->dq_free_list);
> @@ -2415,7 +2417,7 @@ static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
> FS_USER_QUOTA : FS_GROUP_QUOTA;
> di->d_id = dquot->dq_id;
>
> - spin_lock(&dq_data_lock);
> + spin_lock(&sb_dqopts(dquot)->dq_data_lock);
> di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit);
> di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit);
> di->d_ino_hardlimit = dm->dqb_ihardlimit;
> @@ -2424,7 +2426,7 @@ static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
> di->d_icount = dm->dqb_curinodes;
> di->d_btimer = dm->dqb_btime;
> di->d_itimer = dm->dqb_itime;
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&sb_dqopts(dquot)->dq_data_lock);
> }
>
> int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
> @@ -2467,7 +2469,7 @@ static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
> (di->d_ino_hardlimit > dqi->dqi_maxilimit)))
> return -ERANGE;
>
> - spin_lock(&dq_data_lock);
> + spin_lock(&sb_dqopts(dquot)->dq_data_lock);
> if (di->d_fieldmask & FS_DQ_BCOUNT) {
> dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace;
> check_blim = 1;
> @@ -2533,7 +2535,7 @@ static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
> clear_bit(DQ_FAKE_B, &dquot->dq_flags);
> else
> set_bit(DQ_FAKE_B, &dquot->dq_flags);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&sb_dqopts(dquot)->dq_data_lock);
> mark_dquot_dirty(dquot);
>
> return 0;
> @@ -2568,12 +2570,12 @@ int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
> return -ESRCH;
> }
> mi = dqopts(sb)->info + type;
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(sb)->dq_data_lock);
> ii->dqi_bgrace = mi->dqi_bgrace;
> ii->dqi_igrace = mi->dqi_igrace;
> ii->dqi_flags = mi->dqi_flags & DQF_MASK;
> ii->dqi_valid = IIF_ALL;
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(sb)->dq_data_lock);
> mutex_unlock(&dqctl(sb)->dqonoff_mutex);
> return 0;
> }
> @@ -2591,7 +2593,7 @@ int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
> goto out;
> }
> mi = dqopts(sb)->info + type;
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(sb)->dq_data_lock);
> if (ii->dqi_valid & IIF_BGRACE)
> mi->dqi_bgrace = ii->dqi_bgrace;
> if (ii->dqi_valid & IIF_IGRACE)
> @@ -2599,7 +2601,7 @@ int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
> if (ii->dqi_valid & IIF_FLAGS)
> mi->dqi_flags = (mi->dqi_flags & ~DQF_MASK) |
> (ii->dqi_flags & DQF_MASK);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(sb)->dq_data_lock);
> mark_info_dirty(sb, type);
> /* Force write to disk */
> dqctl(sb)->dq_op->write_info(sb, type);
> diff --git a/fs/quota/quota_tree.c b/fs/quota/quota_tree.c
> index 21a4a6a..a089c70 100644
> --- a/fs/quota/quota_tree.c
> +++ b/fs/quota/quota_tree.c
> @@ -375,9 +375,9 @@ int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
> return ret;
> }
> }
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(sb)->dq_data_lock);
> info->dqi_ops->mem2disk_dqblk(ddquot, dquot);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(sb)->dq_data_lock);
> ret = sb->s_op->quota_write(sb, type, ddquot, info->dqi_entry_size,
> dquot->dq_off);
> if (ret != info->dqi_entry_size) {
> @@ -631,14 +631,14 @@ int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot)
> kfree(ddquot);
> goto out;
> }
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(sb)->dq_data_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(&dqopts(sb)->dq_data_lock);
> kfree(ddquot);
> out:
> dqstats_inc(DQST_READS);
> diff --git a/fs/quota/quota_v2.c b/fs/quota/quota_v2.c
> index 65444d2..e4ef8de 100644
> --- a/fs/quota/quota_v2.c
> +++ b/fs/quota/quota_v2.c
> @@ -153,12 +153,12 @@ static int v2_write_file_info(struct super_block *sb, int type)
> struct qtree_mem_dqinfo *qinfo = info->dqi_priv;
> ssize_t size;
>
> - spin_lock(&dq_data_lock);
> + spin_lock(&dqopts(sb)->dq_data_lock);
> info->dqi_flags &= ~DQF_INFO_DIRTY;
> dinfo.dqi_bgrace = cpu_to_le32(info->dqi_bgrace);
> dinfo.dqi_igrace = cpu_to_le32(info->dqi_igrace);
> dinfo.dqi_flags = cpu_to_le32(info->dqi_flags & DQF_MASK);
> - spin_unlock(&dq_data_lock);
> + spin_unlock(&dqopts(sb)->dq_data_lock);
> dinfo.dqi_blocks = cpu_to_le32(qinfo->dqi_blocks);
> dinfo.dqi_free_blk = cpu_to_le32(qinfo->dqi_free_blk);
> dinfo.dqi_free_entry = cpu_to_le32(qinfo->dqi_free_entry);
> diff --git a/include/linux/quota.h b/include/linux/quota.h
> index 754aedb..6b04001 100644
> --- a/include/linux/quota.h
> +++ b/include/linux/quota.h
> @@ -186,8 +186,6 @@ enum {
> typedef __kernel_uid32_t qid_t; /* Type in which we store ids in memory */
> typedef long long qsize_t; /* Type in which we store sizes */
>
> -extern spinlock_t dq_data_lock;
> -
> /* Maximal numbers of writes for quota operation (insert/delete/update)
> * (over VFS all formats) */
> #define DQUOT_INIT_ALLOC max(V1_INIT_ALLOC, V2_INIT_ALLOC)
> @@ -413,6 +411,7 @@ struct quota_info {
> struct mutex dqio_mutex; /* lock device while I/O in progress */
> struct mem_dqinfo info[MAXQUOTAS]; /* Information for each quota type */
> spinlock_t dq_state_lock; /* serialize quota state changes*/
> + spinlock_t dq_data_lock; /* protect in memory data */
> spinlock_t dq_list_lock; /* protect lists and hash*/
> struct list_head dq_inuse_list; /* list of inused dquotas */
> struct list_head dq_free_list; /* list of free dquotas */
> --
> 1.6.5.2
>
next prev parent reply other threads:[~2010-10-26 17:38 UTC|newest]
Thread overview: 24+ messages / expand[flat|nested] mbox.gz Atom feed top
2010-10-22 17:34 [PATCH 00/19] quota: RFC SMP improvements for generic quota V2 Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 01/19] quota: protect getfmt call with dqonoff_mutex lock Dmitry Monakhov
2010-10-28 14:27 ` Christoph Hellwig
2010-10-22 17:34 ` [PATCH 02/19] quota: Wrap common expression to helper function Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 03/19] quota: mode quota internals from sb to quota_info Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 04/19] quota: Convert dq_state_lock to per-sb dq_state_lock Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 05/19] quota: add quota format lock Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 06/19] quota: make dquot lists per-sb Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 07/19] quota: make per-sb hash array Dmitry Monakhov
2010-10-27 19:31 ` Al Viro
2010-10-28 10:58 ` Dmitry
2010-10-22 17:34 ` [PATCH 08/19] quota: remove global dq_list_lock Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 09/19] quota: rename dq_lock Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 10/19] quota: make per-sb dq_data_lock Dmitry Monakhov
2010-10-26 17:38 ` Dmitry [this message]
2010-10-22 17:34 ` [PATCH 11/19] quota: protect dquot mem info with object's lock Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 12/19] quota: drop dq_data_lock where possible Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 13/19] quota: relax dq_data_lock dq_lock locking consistency Dmitry Monakhov
2010-10-22 17:34 ` [PATCH 14/19] quota: protect dqget() from parallels quotaoff via RCU Dmitry Monakhov
2010-10-22 17:35 ` [PATCH 15/19] quota: remove dq_state_lock Dmitry Monakhov
2010-10-22 17:35 ` [PATCH 16/19] fs: add unlocked helpers Dmitry Monakhov
2010-10-22 17:35 ` [PATCH 17/19] quota: Some stylistic cleanup for dquot interface Dmitry Monakhov
2010-10-22 17:35 ` [PATCH 18/19] quota: remove dqptr_sem Dmitry Monakhov
2010-10-22 17:35 ` [PATCH 19/19] quota: redesign dquot reference counting Dmitry Monakhov
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=87bp6gq2gu.fsf@dmon-lap.sw.ru \
--to=dmonakhov@openvz.org \
--cc=hch@infradead.org \
--cc=jack@suse.cz \
--cc=linux-fsdevel@vger.kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.