2019-05-31 08:09:56 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2006-01-16 16:50:04 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
2007-12-12 00:51:25 +00:00
|
|
|
* Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
|
2006-01-16 16:50:04 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Quota change tags are associated with each transaction that allocates or
|
|
|
|
* deallocates space. Those changes are accumulated locally to each node (in a
|
|
|
|
* per-node file) and then are periodically synced to the quota file. This
|
|
|
|
* avoids the bottleneck of constantly touching the quota file, but introduces
|
|
|
|
* fuzziness in the current usage value of IDs that are being used on different
|
|
|
|
* nodes in the cluster simultaneously. So, it is possible for a user on
|
|
|
|
* multiple nodes to overrun their quota, but that overrun is controlable.
|
2009-09-15 19:42:56 +00:00
|
|
|
* Since quota tags are part of transactions, there is no need for a quota check
|
2006-01-16 16:50:04 +00:00
|
|
|
* program to be run on node crashes or anything like that.
|
|
|
|
*
|
|
|
|
* There are couple of knobs that let the administrator manage the quota
|
|
|
|
* fuzziness. "quota_quantum" sets the maximum time a quota change can be
|
|
|
|
* sitting on one node before being synced to the quota file. (The default is
|
|
|
|
* 60 seconds.) Another knob, "quota_scale" controls how quickly the frequency
|
|
|
|
* of quota file syncs increases as the user moves closer to their limit. The
|
|
|
|
* more frequent the syncs, the more accurate the quota enforcement, but that
|
|
|
|
* means that there is more contention between the nodes for the quota file.
|
|
|
|
* The default value is one. This sets the maximum theoretical quota overrun
|
|
|
|
* (with infinite node with infinite bandwidth) to twice the user's limit. (In
|
|
|
|
* practice, the maximum overrun you see should be much less.) A "quota_scale"
|
|
|
|
* number greater than one makes quota syncs more frequent and reduces the
|
|
|
|
* maximum overrun. Numbers less than one (but greater than zero) make quota
|
|
|
|
* syncs less frequent.
|
|
|
|
*
|
|
|
|
* GFS quotas also use per-ID Lock Value Blocks (LVBs) to cache the contents of
|
|
|
|
* the quota file, so it is not being constantly read.
|
|
|
|
*/
|
|
|
|
|
2014-03-06 20:10:45 +00:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/slab.h>
|
2011-05-25 00:12:27 +00:00
|
|
|
#include <linux/mm.h>
|
2006-01-16 16:50:04 +00:00
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/completion.h>
|
|
|
|
#include <linux/buffer_head.h>
|
|
|
|
#include <linux/sort.h>
|
2006-02-08 11:50:51 +00:00
|
|
|
#include <linux/fs.h>
|
2006-10-02 15:38:25 +00:00
|
|
|
#include <linux/bio.h>
|
2006-02-27 22:23:27 +00:00
|
|
|
#include <linux/gfs2_ondisk.h>
|
2008-11-17 14:25:37 +00:00
|
|
|
#include <linux/kthread.h>
|
|
|
|
#include <linux/freezer.h>
|
2009-09-28 11:49:15 +00:00
|
|
|
#include <linux/quota.h>
|
2009-09-11 14:57:27 +00:00
|
|
|
#include <linux/dqblk_xfs.h>
|
2013-11-01 18:52:06 +00:00
|
|
|
#include <linux/lockref.h>
|
2013-11-04 10:15:08 +00:00
|
|
|
#include <linux/list_lru.h>
|
2013-12-12 10:47:59 +00:00
|
|
|
#include <linux/rcupdate.h>
|
|
|
|
#include <linux/rculist_bl.h>
|
|
|
|
#include <linux/bit_spinlock.h>
|
|
|
|
#include <linux/jhash.h>
|
2014-01-15 12:57:25 +00:00
|
|
|
#include <linux/vmalloc.h>
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
#include "gfs2.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "incore.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
#include "bmap.h"
|
|
|
|
#include "glock.h"
|
|
|
|
#include "glops.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "meta_io.h"
|
|
|
|
#include "quota.h"
|
|
|
|
#include "rgrp.h"
|
|
|
|
#include "super.h"
|
|
|
|
#include "trans.h"
|
2006-02-08 11:50:51 +00:00
|
|
|
#include "inode.h"
|
2006-02-27 22:23:27 +00:00
|
|
|
#include "util.h"
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
#define GFS2_QD_HASH_SHIFT 12
|
2016-08-02 17:05:27 +00:00
|
|
|
#define GFS2_QD_HASH_SIZE BIT(GFS2_QD_HASH_SHIFT)
|
2013-12-12 10:47:59 +00:00
|
|
|
#define GFS2_QD_HASH_MASK (GFS2_QD_HASH_SIZE - 1)
|
|
|
|
|
gfs2: Add quota_change type
Function do_qc has two main uses: (1) to re-sync the local quota changes
(qd) to the master quotas, and (2) normal quota changes. In the case of
normal quota changes, the change can be positive or negative, as the
quota usage goes up and down.
Before this patch function do_qc was distinguishing one from another by
whether the resulting value is or isn't zero: In the case of a re-sync
(called do_sync) the quota value is moved from the temporary value to a
master value, so the amount is added to one and subtracted from the
other. The problem is that since the values can be positive or negative
we can occasionally run into situations where we are not doing a re-sync
but the quota change just happens to cancel out the previous value.
In the case of a re-sync extra references and locks are taken, and so
do_qc needs to release them. In the case of a normal quota change, no
extra references and locks are taken, so it must not try to release
them.
The problem is: if the quota change is not a re-sync but the value just
happens to cancel out the original quota change, the resulting zero
value fools do_qc into thinking this is a re-sync and therefore it must
release the extra references. This results in problems, mainly having to
do with slot reference numbers going smaller than zero.
This patch introduces new constants, QC_SYNC and QC_CHANGE so do_qc can
really tell the difference. For QC_SYNC calls it must release the extra
references acquired by gfs2_quota_unlock's call to qd_check_sync. For
QC_CHANGE calls it does not have extra references to put.
Note that this allows quota changes back to a value of zero, and so I
removed an assert warning related to that.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2023-06-28 14:54:41 +00:00
|
|
|
#define QC_CHANGE 0
|
|
|
|
#define QC_SYNC 1
|
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
/* Lock order: qd_lock -> bucket lock -> qd->lockref.lock -> lru lock */
|
2013-12-13 11:46:28 +00:00
|
|
|
/* -> sd_bitmap_lock */
|
2013-11-01 18:52:08 +00:00
|
|
|
static DEFINE_SPINLOCK(qd_lock);
|
2013-11-04 10:15:08 +00:00
|
|
|
struct list_lru gfs2_qd_lru;
|
2009-01-07 22:03:37 +00:00
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
static struct hlist_bl_head qd_hash_table[GFS2_QD_HASH_SIZE];
|
|
|
|
|
|
|
|
static unsigned int gfs2_qd_hash(const struct gfs2_sbd *sdp,
|
|
|
|
const struct kqid qid)
|
|
|
|
{
|
|
|
|
unsigned int h;
|
|
|
|
|
|
|
|
h = jhash(&sdp, sizeof(struct gfs2_sbd *), 0);
|
|
|
|
h = jhash(&qid, sizeof(struct kqid), h);
|
|
|
|
|
|
|
|
return h & GFS2_QD_HASH_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void spin_lock_bucket(unsigned int hash)
|
|
|
|
{
|
|
|
|
hlist_bl_lock(&qd_hash_table[hash]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void spin_unlock_bucket(unsigned int hash)
|
|
|
|
{
|
|
|
|
hlist_bl_unlock(&qd_hash_table[hash]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void gfs2_qd_dealloc(struct rcu_head *rcu)
|
|
|
|
{
|
|
|
|
struct gfs2_quota_data *qd = container_of(rcu, struct gfs2_quota_data, qd_rcu);
|
2023-08-23 15:15:47 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
kmem_cache_free(gfs2_quotad_cachep, qd);
|
2023-08-23 15:15:47 +00:00
|
|
|
if (atomic_dec_and_test(&sdp->sd_quota_count))
|
|
|
|
wake_up(&sdp->sd_kill_wait);
|
2013-12-12 10:47:59 +00:00
|
|
|
}
|
|
|
|
|
2023-08-22 12:18:21 +00:00
|
|
|
static void gfs2_qd_dispose(struct gfs2_quota_data *qd)
|
2009-01-07 22:03:37 +00:00
|
|
|
{
|
2023-08-22 12:18:21 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2013-11-04 10:15:08 +00:00
|
|
|
|
2023-08-22 12:18:21 +00:00
|
|
|
spin_lock(&qd_lock);
|
|
|
|
list_del(&qd->qd_list);
|
|
|
|
spin_unlock(&qd_lock);
|
2009-01-07 22:03:37 +00:00
|
|
|
|
2023-08-22 12:18:21 +00:00
|
|
|
spin_lock_bucket(qd->qd_hash);
|
|
|
|
hlist_bl_del_rcu(&qd->qd_hlist);
|
|
|
|
spin_unlock_bucket(qd->qd_hash);
|
2013-12-12 10:47:59 +00:00
|
|
|
|
2023-12-20 16:16:29 +00:00
|
|
|
if (!gfs2_withdrawing_or_withdrawn(sdp)) {
|
2009-01-07 22:03:37 +00:00
|
|
|
gfs2_assert_warn(sdp, !qd->qd_change);
|
2023-06-16 18:22:04 +00:00
|
|
|
gfs2_assert_warn(sdp, !qd->qd_slot_ref);
|
2009-01-07 22:03:37 +00:00
|
|
|
gfs2_assert_warn(sdp, !qd->qd_bh_count);
|
2023-08-24 13:08:55 +00:00
|
|
|
}
|
2009-01-07 22:03:37 +00:00
|
|
|
|
2023-08-22 12:18:21 +00:00
|
|
|
gfs2_glock_put(qd->qd_gl);
|
|
|
|
call_rcu(&qd->qd_rcu, gfs2_qd_dealloc);
|
|
|
|
}
|
2009-01-07 22:03:37 +00:00
|
|
|
|
2023-08-22 12:18:21 +00:00
|
|
|
static void gfs2_qd_list_dispose(struct list_head *list)
|
|
|
|
{
|
|
|
|
struct gfs2_quota_data *qd;
|
2009-01-07 22:03:37 +00:00
|
|
|
|
2023-08-22 12:18:21 +00:00
|
|
|
while (!list_empty(list)) {
|
|
|
|
qd = list_first_entry(list, struct gfs2_quota_data, qd_lru);
|
|
|
|
list_del(&qd->qd_lru);
|
2009-01-07 22:03:37 +00:00
|
|
|
|
2023-08-22 12:18:21 +00:00
|
|
|
gfs2_qd_dispose(qd);
|
2009-01-07 22:03:37 +00:00
|
|
|
}
|
2013-11-04 10:15:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-02-12 22:59:35 +00:00
|
|
|
static enum lru_status gfs2_qd_isolate(struct list_head *item,
|
|
|
|
struct list_lru_one *lru, spinlock_t *lru_lock, void *arg)
|
2013-11-04 10:15:08 +00:00
|
|
|
{
|
|
|
|
struct list_head *dispose = arg;
|
2023-08-22 20:59:27 +00:00
|
|
|
struct gfs2_quota_data *qd =
|
|
|
|
list_entry(item, struct gfs2_quota_data, qd_lru);
|
|
|
|
enum lru_status status;
|
2013-11-04 10:15:08 +00:00
|
|
|
|
|
|
|
if (!spin_trylock(&qd->qd_lockref.lock))
|
|
|
|
return LRU_SKIP;
|
|
|
|
|
2023-08-22 20:59:27 +00:00
|
|
|
status = LRU_SKIP;
|
2013-11-04 10:15:08 +00:00
|
|
|
if (qd->qd_lockref.count == 0) {
|
|
|
|
lockref_mark_dead(&qd->qd_lockref);
|
2015-02-12 22:59:35 +00:00
|
|
|
list_lru_isolate_move(lru, &qd->qd_lru, dispose);
|
2023-08-22 20:59:27 +00:00
|
|
|
status = LRU_REMOVED;
|
2013-11-04 10:15:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock(&qd->qd_lockref.lock);
|
2023-08-22 20:59:27 +00:00
|
|
|
return status;
|
2013-11-04 10:15:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned long gfs2_qd_shrink_scan(struct shrinker *shrink,
|
|
|
|
struct shrink_control *sc)
|
|
|
|
{
|
|
|
|
LIST_HEAD(dispose);
|
|
|
|
unsigned long freed;
|
|
|
|
|
|
|
|
if (!(sc->gfp_mask & __GFP_FS))
|
|
|
|
return SHRINK_STOP;
|
|
|
|
|
list_lru: introduce list_lru_shrink_{count,walk}
Kmem accounting of memcg is unusable now, because it lacks slab shrinker
support. That means when we hit the limit we will get ENOMEM w/o any
chance to recover. What we should do then is to call shrink_slab, which
would reclaim old inode/dentry caches from this cgroup. This is what
this patch set is intended to do.
Basically, it does two things. First, it introduces the notion of
per-memcg slab shrinker. A shrinker that wants to reclaim objects per
cgroup should mark itself as SHRINKER_MEMCG_AWARE. Then it will be
passed the memory cgroup to scan from in shrink_control->memcg. For
such shrinkers shrink_slab iterates over the whole cgroup subtree under
the target cgroup and calls the shrinker for each kmem-active memory
cgroup.
Secondly, this patch set makes the list_lru structure per-memcg. It's
done transparently to list_lru users - everything they have to do is to
tell list_lru_init that they want memcg-aware list_lru. Then the
list_lru will automatically distribute objects among per-memcg lists
basing on which cgroup the object is accounted to. This way to make FS
shrinkers (icache, dcache) memcg-aware we only need to make them use
memcg-aware list_lru, and this is what this patch set does.
As before, this patch set only enables per-memcg kmem reclaim when the
pressure goes from memory.limit, not from memory.kmem.limit. Handling
memory.kmem.limit is going to be tricky due to GFP_NOFS allocations, and
it is still unclear whether we will have this knob in the unified
hierarchy.
This patch (of 9):
NUMA aware slab shrinkers use the list_lru structure to distribute
objects coming from different NUMA nodes to different lists. Whenever
such a shrinker needs to count or scan objects from a particular node,
it issues commands like this:
count = list_lru_count_node(lru, sc->nid);
freed = list_lru_walk_node(lru, sc->nid, isolate_func,
isolate_arg, &sc->nr_to_scan);
where sc is an instance of the shrink_control structure passed to it
from vmscan.
To simplify this, let's add special list_lru functions to be used by
shrinkers, list_lru_shrink_count() and list_lru_shrink_walk(), which
consolidate the nid and nr_to_scan arguments in the shrink_control
structure.
This will also allow us to avoid patching shrinkers that use list_lru
when we make shrink_slab() per-memcg - all we will have to do is extend
the shrink_control structure to include the target memcg and make
list_lru_shrink_{count,walk} handle this appropriately.
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Suggested-by: Dave Chinner <david@fromorbit.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Greg Thelen <gthelen@google.com>
Cc: Glauber Costa <glommer@gmail.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Christoph Lameter <cl@linux.com>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: David Rientjes <rientjes@google.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Tejun Heo <tj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-02-12 22:58:47 +00:00
|
|
|
freed = list_lru_shrink_walk(&gfs2_qd_lru, sc,
|
|
|
|
gfs2_qd_isolate, &dispose);
|
2013-11-04 10:15:08 +00:00
|
|
|
|
2023-08-22 12:18:21 +00:00
|
|
|
gfs2_qd_list_dispose(&dispose);
|
2013-11-04 10:15:08 +00:00
|
|
|
|
2013-08-28 00:18:09 +00:00
|
|
|
return freed;
|
|
|
|
}
|
2009-01-07 22:03:37 +00:00
|
|
|
|
2013-11-04 10:15:08 +00:00
|
|
|
static unsigned long gfs2_qd_shrink_count(struct shrinker *shrink,
|
|
|
|
struct shrink_control *sc)
|
2013-08-28 00:18:09 +00:00
|
|
|
{
|
list_lru: introduce list_lru_shrink_{count,walk}
Kmem accounting of memcg is unusable now, because it lacks slab shrinker
support. That means when we hit the limit we will get ENOMEM w/o any
chance to recover. What we should do then is to call shrink_slab, which
would reclaim old inode/dentry caches from this cgroup. This is what
this patch set is intended to do.
Basically, it does two things. First, it introduces the notion of
per-memcg slab shrinker. A shrinker that wants to reclaim objects per
cgroup should mark itself as SHRINKER_MEMCG_AWARE. Then it will be
passed the memory cgroup to scan from in shrink_control->memcg. For
such shrinkers shrink_slab iterates over the whole cgroup subtree under
the target cgroup and calls the shrinker for each kmem-active memory
cgroup.
Secondly, this patch set makes the list_lru structure per-memcg. It's
done transparently to list_lru users - everything they have to do is to
tell list_lru_init that they want memcg-aware list_lru. Then the
list_lru will automatically distribute objects among per-memcg lists
basing on which cgroup the object is accounted to. This way to make FS
shrinkers (icache, dcache) memcg-aware we only need to make them use
memcg-aware list_lru, and this is what this patch set does.
As before, this patch set only enables per-memcg kmem reclaim when the
pressure goes from memory.limit, not from memory.kmem.limit. Handling
memory.kmem.limit is going to be tricky due to GFP_NOFS allocations, and
it is still unclear whether we will have this knob in the unified
hierarchy.
This patch (of 9):
NUMA aware slab shrinkers use the list_lru structure to distribute
objects coming from different NUMA nodes to different lists. Whenever
such a shrinker needs to count or scan objects from a particular node,
it issues commands like this:
count = list_lru_count_node(lru, sc->nid);
freed = list_lru_walk_node(lru, sc->nid, isolate_func,
isolate_arg, &sc->nr_to_scan);
where sc is an instance of the shrink_control structure passed to it
from vmscan.
To simplify this, let's add special list_lru functions to be used by
shrinkers, list_lru_shrink_count() and list_lru_shrink_walk(), which
consolidate the nid and nr_to_scan arguments in the shrink_control
structure.
This will also allow us to avoid patching shrinkers that use list_lru
when we make shrink_slab() per-memcg - all we will have to do is extend
the shrink_control structure to include the target memcg and make
list_lru_shrink_{count,walk} handle this appropriately.
Signed-off-by: Vladimir Davydov <vdavydov@parallels.com>
Suggested-by: Dave Chinner <david@fromorbit.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@suse.cz>
Cc: Greg Thelen <gthelen@google.com>
Cc: Glauber Costa <glommer@gmail.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Christoph Lameter <cl@linux.com>
Cc: Pekka Enberg <penberg@kernel.org>
Cc: David Rientjes <rientjes@google.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Tejun Heo <tj@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2015-02-12 22:58:47 +00:00
|
|
|
return vfs_pressure_ratio(list_lru_shrink_count(&gfs2_qd_lru, sc));
|
2009-01-07 22:03:37 +00:00
|
|
|
}
|
|
|
|
|
2023-09-11 09:44:08 +00:00
|
|
|
static struct shrinker *gfs2_qd_shrinker;
|
2013-11-04 10:15:08 +00:00
|
|
|
|
2023-09-11 09:44:08 +00:00
|
|
|
int __init gfs2_qd_shrinker_init(void)
|
|
|
|
{
|
|
|
|
gfs2_qd_shrinker = shrinker_alloc(SHRINKER_NUMA_AWARE, "gfs2-qd");
|
|
|
|
if (!gfs2_qd_shrinker)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
gfs2_qd_shrinker->count_objects = gfs2_qd_shrink_count;
|
|
|
|
gfs2_qd_shrinker->scan_objects = gfs2_qd_shrink_scan;
|
|
|
|
|
|
|
|
shrinker_register(gfs2_qd_shrinker);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void gfs2_qd_shrinker_exit(void)
|
|
|
|
{
|
|
|
|
shrinker_free(gfs2_qd_shrinker);
|
|
|
|
}
|
2013-11-04 10:15:08 +00:00
|
|
|
|
2013-02-01 02:33:38 +00:00
|
|
|
static u64 qd2index(struct gfs2_quota_data *qd)
|
|
|
|
{
|
2013-02-01 03:52:08 +00:00
|
|
|
struct kqid qid = qd->qd_id;
|
|
|
|
return (2 * (u64)from_kqid(&init_user_ns, qid)) +
|
2013-05-10 15:59:18 +00:00
|
|
|
((qid.type == USRQUOTA) ? 0 : 1);
|
2013-02-01 02:33:38 +00:00
|
|
|
}
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
static u64 qd2offset(struct gfs2_quota_data *qd)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2023-06-26 15:55:52 +00:00
|
|
|
return qd2index(qd) * sizeof(struct gfs2_quota);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
static struct gfs2_quota_data *qd_alloc(unsigned hash, struct gfs2_sbd *sdp, struct kqid qid)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
|
|
|
struct gfs2_quota_data *qd;
|
|
|
|
int error;
|
|
|
|
|
2008-11-17 14:25:37 +00:00
|
|
|
qd = kmem_cache_zalloc(gfs2_quotad_cachep, GFP_NOFS);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!qd)
|
2013-12-12 10:47:59 +00:00
|
|
|
return NULL;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
qd->qd_sbd = sdp;
|
2023-08-24 12:52:29 +00:00
|
|
|
qd->qd_lockref.count = 0;
|
2013-11-01 18:52:06 +00:00
|
|
|
spin_lock_init(&qd->qd_lockref.lock);
|
2013-02-01 03:52:08 +00:00
|
|
|
qd->qd_id = qid;
|
2006-01-16 16:50:04 +00:00
|
|
|
qd->qd_slot = -1;
|
2013-11-04 10:15:08 +00:00
|
|
|
INIT_LIST_HEAD(&qd->qd_lru);
|
2013-12-12 10:47:59 +00:00
|
|
|
qd->qd_hash = hash;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-02-01 02:33:38 +00:00
|
|
|
error = gfs2_glock_get(sdp, qd2index(qd),
|
2006-01-16 16:50:04 +00:00
|
|
|
&gfs2_quota_glops, CREATE, &qd->qd_gl);
|
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
return qd;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
fail:
|
2008-11-17 14:25:37 +00:00
|
|
|
kmem_cache_free(gfs2_quotad_cachep, qd);
|
2013-12-12 10:47:59 +00:00
|
|
|
return NULL;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
static struct gfs2_quota_data *gfs2_qd_search_bucket(unsigned int hash,
|
|
|
|
const struct gfs2_sbd *sdp,
|
|
|
|
struct kqid qid)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2013-12-12 10:47:59 +00:00
|
|
|
struct gfs2_quota_data *qd;
|
|
|
|
struct hlist_bl_node *h;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
hlist_bl_for_each_entry_rcu(qd, h, &qd_hash_table[hash], qd_hlist) {
|
|
|
|
if (!qid_eq(qd->qd_id, qid))
|
|
|
|
continue;
|
|
|
|
if (qd->qd_sbd != sdp)
|
|
|
|
continue;
|
|
|
|
if (lockref_get_not_dead(&qd->qd_lockref)) {
|
list_lru: allow explicit memcg and NUMA node selection
Patch series "workload-specific and memory pressure-driven zswap
writeback", v8.
There are currently several issues with zswap writeback:
1. There is only a single global LRU for zswap, making it impossible to
perform worload-specific shrinking - an memcg under memory pressure
cannot determine which pages in the pool it owns, and often ends up
writing pages from other memcgs. This issue has been previously
observed in practice and mitigated by simply disabling
memcg-initiated shrinking:
https://lore.kernel.org/all/20230530232435.3097106-1-nphamcs@gmail.com/T/#u
But this solution leaves a lot to be desired, as we still do not
have an avenue for an memcg to free up its own memory locked up in
the zswap pool.
2. We only shrink the zswap pool when the user-defined limit is hit.
This means that if we set the limit too high, cold data that are
unlikely to be used again will reside in the pool, wasting precious
memory. It is hard to predict how much zswap space will be needed
ahead of time, as this depends on the workload (specifically, on
factors such as memory access patterns and compressibility of the
memory pages).
This patch series solves these issues by separating the global zswap LRU
into per-memcg and per-NUMA LRUs, and performs workload-specific (i.e
memcg- and NUMA-aware) zswap writeback under memory pressure. The new
shrinker does not have any parameter that must be tuned by the user, and
can be opted in or out on a per-memcg basis.
As a proof of concept, we ran the following synthetic benchmark: build the
linux kernel in a memory-limited cgroup, and allocate some cold data in
tmpfs to see if the shrinker could write them out and improved the overall
performance. Depending on the amount of cold data generated, we observe
from 14% to 35% reduction in kernel CPU time used in the kernel builds.
This patch (of 6):
The interface of list_lru is based on the assumption that the list node
and the data it represents belong to the same allocated on the correct
node/memcg. While this assumption is valid for existing slab objects LRU
such as dentries and inodes, it is undocumented, and rather inflexible for
certain potential list_lru users (such as the upcoming zswap shrinker and
the THP shrinker). It has caused us a lot of issues during our
development.
This patch changes list_lru interface so that the caller must explicitly
specify numa node and memcg when adding and removing objects. The old
list_lru_add() and list_lru_del() are renamed to list_lru_add_obj() and
list_lru_del_obj(), respectively.
It also extends the list_lru API with a new function, list_lru_putback,
which undoes a previous list_lru_isolate call. Unlike list_lru_add, it
does not increment the LRU node count (as list_lru_isolate does not
decrement the node count). list_lru_putback also allows for explicit
memcg and NUMA node selection.
Link: https://lkml.kernel.org/r/20231130194023.4102148-1-nphamcs@gmail.com
Link: https://lkml.kernel.org/r/20231130194023.4102148-2-nphamcs@gmail.com
Signed-off-by: Nhat Pham <nphamcs@gmail.com>
Suggested-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Tested-by: Bagas Sanjaya <bagasdotme@gmail.com>
Cc: Chris Li <chrisl@kernel.org>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Domenico Cerasuolo <cerasuolodomenico@gmail.com>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Muchun Song <muchun.song@linux.dev>
Cc: Roman Gushchin <roman.gushchin@linux.dev>
Cc: Seth Jennings <sjenning@redhat.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Vitaly Wool <vitaly.wool@konsulko.com>
Cc: Yosry Ahmed <yosryahmed@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
2023-11-30 19:40:18 +00:00
|
|
|
list_lru_del_obj(&gfs2_qd_lru, &qd->qd_lru);
|
2013-12-12 10:47:59 +00:00
|
|
|
return qd;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
2013-12-12 10:47:59 +00:00
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
static int qd_get(struct gfs2_sbd *sdp, struct kqid qid,
|
|
|
|
struct gfs2_quota_data **qdp)
|
|
|
|
{
|
|
|
|
struct gfs2_quota_data *qd, *new_qd;
|
|
|
|
unsigned int hash = gfs2_qd_hash(sdp, qid);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
rcu_read_lock();
|
|
|
|
*qdp = qd = gfs2_qd_search_bucket(hash, sdp, qid);
|
|
|
|
rcu_read_unlock();
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
if (qd)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
new_qd = qd_alloc(hash, sdp, qid);
|
|
|
|
if (!new_qd)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
spin_lock(&qd_lock);
|
|
|
|
spin_lock_bucket(hash);
|
|
|
|
*qdp = qd = gfs2_qd_search_bucket(hash, sdp, qid);
|
|
|
|
if (qd == NULL) {
|
2023-08-24 12:52:29 +00:00
|
|
|
new_qd->qd_lockref.count++;
|
2013-12-12 10:47:59 +00:00
|
|
|
*qdp = new_qd;
|
|
|
|
list_add(&new_qd->qd_list, &sdp->sd_quota_list);
|
|
|
|
hlist_bl_add_head_rcu(&new_qd->qd_hlist, &qd_hash_table[hash]);
|
|
|
|
atomic_inc(&sdp->sd_quota_count);
|
|
|
|
}
|
|
|
|
spin_unlock_bucket(hash);
|
|
|
|
spin_unlock(&qd_lock);
|
|
|
|
|
|
|
|
if (qd) {
|
|
|
|
gfs2_glock_put(new_qd->qd_gl);
|
|
|
|
kmem_cache_free(gfs2_quotad_cachep, new_qd);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
2013-12-12 10:47:59 +00:00
|
|
|
|
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
static void qd_hold(struct gfs2_quota_data *qd)
|
|
|
|
{
|
2023-06-16 15:46:50 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2013-11-01 18:52:06 +00:00
|
|
|
gfs2_assert(sdp, !__lockref_is_dead(&qd->qd_lockref));
|
|
|
|
lockref_get(&qd->qd_lockref);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void qd_put(struct gfs2_quota_data *qd)
|
|
|
|
{
|
2023-08-23 15:15:47 +00:00
|
|
|
struct gfs2_sbd *sdp;
|
|
|
|
|
2013-11-04 10:15:08 +00:00
|
|
|
if (lockref_put_or_lock(&qd->qd_lockref))
|
|
|
|
return;
|
2013-11-01 18:52:06 +00:00
|
|
|
|
2023-08-23 15:15:47 +00:00
|
|
|
BUG_ON(__lockref_is_dead(&qd->qd_lockref));
|
|
|
|
sdp = qd->qd_sbd;
|
|
|
|
if (unlikely(!test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags))) {
|
|
|
|
lockref_mark_dead(&qd->qd_lockref);
|
|
|
|
spin_unlock(&qd->qd_lockref.lock);
|
|
|
|
|
|
|
|
gfs2_qd_dispose(qd);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-04 10:15:08 +00:00
|
|
|
qd->qd_lockref.count = 0;
|
list_lru: allow explicit memcg and NUMA node selection
Patch series "workload-specific and memory pressure-driven zswap
writeback", v8.
There are currently several issues with zswap writeback:
1. There is only a single global LRU for zswap, making it impossible to
perform worload-specific shrinking - an memcg under memory pressure
cannot determine which pages in the pool it owns, and often ends up
writing pages from other memcgs. This issue has been previously
observed in practice and mitigated by simply disabling
memcg-initiated shrinking:
https://lore.kernel.org/all/20230530232435.3097106-1-nphamcs@gmail.com/T/#u
But this solution leaves a lot to be desired, as we still do not
have an avenue for an memcg to free up its own memory locked up in
the zswap pool.
2. We only shrink the zswap pool when the user-defined limit is hit.
This means that if we set the limit too high, cold data that are
unlikely to be used again will reside in the pool, wasting precious
memory. It is hard to predict how much zswap space will be needed
ahead of time, as this depends on the workload (specifically, on
factors such as memory access patterns and compressibility of the
memory pages).
This patch series solves these issues by separating the global zswap LRU
into per-memcg and per-NUMA LRUs, and performs workload-specific (i.e
memcg- and NUMA-aware) zswap writeback under memory pressure. The new
shrinker does not have any parameter that must be tuned by the user, and
can be opted in or out on a per-memcg basis.
As a proof of concept, we ran the following synthetic benchmark: build the
linux kernel in a memory-limited cgroup, and allocate some cold data in
tmpfs to see if the shrinker could write them out and improved the overall
performance. Depending on the amount of cold data generated, we observe
from 14% to 35% reduction in kernel CPU time used in the kernel builds.
This patch (of 6):
The interface of list_lru is based on the assumption that the list node
and the data it represents belong to the same allocated on the correct
node/memcg. While this assumption is valid for existing slab objects LRU
such as dentries and inodes, it is undocumented, and rather inflexible for
certain potential list_lru users (such as the upcoming zswap shrinker and
the THP shrinker). It has caused us a lot of issues during our
development.
This patch changes list_lru interface so that the caller must explicitly
specify numa node and memcg when adding and removing objects. The old
list_lru_add() and list_lru_del() are renamed to list_lru_add_obj() and
list_lru_del_obj(), respectively.
It also extends the list_lru API with a new function, list_lru_putback,
which undoes a previous list_lru_isolate call. Unlike list_lru_add, it
does not increment the LRU node count (as list_lru_isolate does not
decrement the node count). list_lru_putback also allows for explicit
memcg and NUMA node selection.
Link: https://lkml.kernel.org/r/20231130194023.4102148-1-nphamcs@gmail.com
Link: https://lkml.kernel.org/r/20231130194023.4102148-2-nphamcs@gmail.com
Signed-off-by: Nhat Pham <nphamcs@gmail.com>
Suggested-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Tested-by: Bagas Sanjaya <bagasdotme@gmail.com>
Cc: Chris Li <chrisl@kernel.org>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Domenico Cerasuolo <cerasuolodomenico@gmail.com>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Muchun Song <muchun.song@linux.dev>
Cc: Roman Gushchin <roman.gushchin@linux.dev>
Cc: Seth Jennings <sjenning@redhat.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Vitaly Wool <vitaly.wool@konsulko.com>
Cc: Yosry Ahmed <yosryahmed@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
2023-11-30 19:40:18 +00:00
|
|
|
list_lru_add_obj(&gfs2_qd_lru, &qd->qd_lru);
|
2013-11-04 10:15:08 +00:00
|
|
|
spin_unlock(&qd->qd_lockref.lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int slot_get(struct gfs2_quota_data *qd)
|
|
|
|
{
|
2013-12-12 17:29:32 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
|
|
|
unsigned int bit;
|
|
|
|
int error = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-13 11:46:28 +00:00
|
|
|
spin_lock(&sdp->sd_bitmap_lock);
|
2023-06-16 18:22:04 +00:00
|
|
|
if (qd->qd_slot_ref == 0) {
|
2023-06-28 12:40:30 +00:00
|
|
|
bit = find_first_zero_bit(sdp->sd_quota_bitmap,
|
|
|
|
sdp->sd_quota_slots);
|
|
|
|
if (bit >= sdp->sd_quota_slots) {
|
|
|
|
error = -ENOSPC;
|
|
|
|
goto out;
|
|
|
|
}
|
2013-12-12 17:29:32 +00:00
|
|
|
set_bit(bit, sdp->sd_quota_bitmap);
|
|
|
|
qd->qd_slot = bit;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
2023-06-16 18:22:04 +00:00
|
|
|
qd->qd_slot_ref++;
|
2023-06-28 12:40:30 +00:00
|
|
|
out:
|
2013-12-13 11:46:28 +00:00
|
|
|
spin_unlock(&sdp->sd_bitmap_lock);
|
2013-12-12 17:29:32 +00:00
|
|
|
return error;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void slot_hold(struct gfs2_quota_data *qd)
|
|
|
|
{
|
2013-12-12 17:29:32 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-13 11:46:28 +00:00
|
|
|
spin_lock(&sdp->sd_bitmap_lock);
|
2023-06-16 18:22:04 +00:00
|
|
|
gfs2_assert(sdp, qd->qd_slot_ref);
|
|
|
|
qd->qd_slot_ref++;
|
2013-12-13 11:46:28 +00:00
|
|
|
spin_unlock(&sdp->sd_bitmap_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void slot_put(struct gfs2_quota_data *qd)
|
|
|
|
{
|
2013-12-12 17:29:32 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-13 11:46:28 +00:00
|
|
|
spin_lock(&sdp->sd_bitmap_lock);
|
2023-06-16 18:22:04 +00:00
|
|
|
gfs2_assert(sdp, qd->qd_slot_ref);
|
|
|
|
if (!--qd->qd_slot_ref) {
|
2013-12-12 17:29:32 +00:00
|
|
|
BUG_ON(!test_and_clear_bit(qd->qd_slot, sdp->sd_quota_bitmap));
|
2006-01-16 16:50:04 +00:00
|
|
|
qd->qd_slot = -1;
|
|
|
|
}
|
2013-12-13 11:46:28 +00:00
|
|
|
spin_unlock(&sdp->sd_bitmap_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int bh_get(struct gfs2_quota_data *qd)
|
|
|
|
{
|
2023-06-16 15:46:50 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2022-02-11 15:50:36 +00:00
|
|
|
struct inode *inode = sdp->sd_qc_inode;
|
|
|
|
struct gfs2_inode *ip = GFS2_I(inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
unsigned int block, offset;
|
|
|
|
struct buffer_head *bh;
|
2022-02-11 15:50:36 +00:00
|
|
|
struct iomap iomap = { };
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_lock(&sdp->sd_quota_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (qd->qd_bh_count++) {
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_unlock(&sdp->sd_quota_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
block = qd->qd_slot / sdp->sd_qc_per_block;
|
2007-12-12 00:51:25 +00:00
|
|
|
offset = qd->qd_slot % sdp->sd_qc_per_block;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2022-02-11 15:50:36 +00:00
|
|
|
error = gfs2_iomap_get(inode,
|
|
|
|
(loff_t)block << inode->i_blkbits,
|
|
|
|
i_blocksize(inode), &iomap);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
2022-02-11 15:50:36 +00:00
|
|
|
error = -ENOENT;
|
|
|
|
if (iomap.type != IOMAP_MAPPED)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
error = gfs2_meta_read(ip->i_gl, iomap.addr >> inode->i_blkbits,
|
|
|
|
DIO_WAIT, 0, &bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
error = -EIO;
|
|
|
|
if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC))
|
|
|
|
goto fail_brelse;
|
|
|
|
|
|
|
|
qd->qd_bh = bh;
|
|
|
|
qd->qd_bh_qc = (struct gfs2_quota_change *)
|
|
|
|
(bh->b_data + sizeof(struct gfs2_meta_header) +
|
|
|
|
offset * sizeof(struct gfs2_quota_change));
|
|
|
|
|
2007-02-20 05:03:29 +00:00
|
|
|
mutex_unlock(&sdp->sd_quota_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_brelse:
|
2006-01-16 16:50:04 +00:00
|
|
|
brelse(bh);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail:
|
2006-01-16 16:50:04 +00:00
|
|
|
qd->qd_bh_count--;
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_unlock(&sdp->sd_quota_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bh_put(struct gfs2_quota_data *qd)
|
|
|
|
{
|
2023-06-16 15:46:50 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_lock(&sdp->sd_quota_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_assert(sdp, qd->qd_bh_count);
|
|
|
|
if (!--qd->qd_bh_count) {
|
|
|
|
brelse(qd->qd_bh);
|
|
|
|
qd->qd_bh = NULL;
|
|
|
|
qd->qd_bh_qc = NULL;
|
|
|
|
}
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_unlock(&sdp->sd_quota_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2013-10-04 10:14:46 +00:00
|
|
|
static int qd_check_sync(struct gfs2_sbd *sdp, struct gfs2_quota_data *qd,
|
|
|
|
u64 *sync_gen)
|
|
|
|
{
|
|
|
|
if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
|
|
|
|
!test_bit(QDF_CHANGE, &qd->qd_flags) ||
|
|
|
|
(sync_gen && (qd->qd_sync_gen >= *sync_gen)))
|
|
|
|
return 0;
|
|
|
|
|
gfs2: ignore negated quota changes
When lots of quota changes are made, there may be cases in which an
inode's quota information is increased and then decreased, such as when
blocks are added to a file, then deleted from it. If the timing is
right, function do_qc can add pending quota changes to a transaction,
then later, another call to do_qc can negate those changes, resulting
in a net gain of 0. The quota_change information is recorded in the qc
buffer (and qd element of the inode as well). The buffer is added to the
transaction by the first call to do_qc, but a subsequent call changes
the value from non-zero back to zero. At that point it's too late to
remove the buffer_head from the transaction. Later, when the quota sync
code is called, the zero-change qd element is discovered and flagged as
an assert warning. If the fs is mounted with errors=panic, the kernel
will panic.
This is usually seen when files are truncated and the quota changes are
negated by punch_hole/truncate which uses gfs2_quota_hold and
gfs2_quota_unhold rather than block allocations that use gfs2_quota_lock
and gfs2_quota_unlock which automatically do quota sync.
This patch solves the problem by adding a check to qd_check_sync such
that net-zero quota changes already added to the transaction are no
longer deemed necessary to be synced, and skipped.
In this case references are taken for the qd and the slot from do_qc
so those need to be put. The normal sequence of events for a normal
non-zero quota change is as follows:
gfs2_quota_change
do_qc
qd_hold
slot_hold
Later, when the changes are to be synced:
gfs2_quota_sync
qd_fish
qd_check_sync
gets qd ref via lockref_get_not_dead
do_sync
do_qc(QC_SYNC)
qd_put
lockref_put_or_lock
qd_unlock
qd_put
lockref_put_or_lock
In the net-zero change case, we add a check to qd_check_sync so it puts
the qd and slot references acquired in gfs2_quota_change and skip the
unneeded sync.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2023-09-21 13:46:43 +00:00
|
|
|
/*
|
|
|
|
* If qd_change is 0 it means a pending quota change was negated.
|
|
|
|
* We should not sync it, but we still have a qd reference and slot
|
|
|
|
* reference taken by gfs2_quota_change -> do_qc that need to be put.
|
|
|
|
*/
|
|
|
|
if (!qd->qd_change && test_and_clear_bit(QDF_CHANGE, &qd->qd_flags)) {
|
|
|
|
slot_put(qd);
|
|
|
|
qd_put(qd);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-04 10:15:08 +00:00
|
|
|
if (!lockref_get_not_dead(&qd->qd_lockref))
|
|
|
|
return 0;
|
2013-10-04 10:14:46 +00:00
|
|
|
|
2013-11-04 10:15:08 +00:00
|
|
|
list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
|
2013-10-04 10:14:46 +00:00
|
|
|
set_bit(QDF_LOCKED, &qd->qd_flags);
|
|
|
|
qd->qd_change_sync = qd->qd_change;
|
2013-12-13 11:46:28 +00:00
|
|
|
slot_hold(qd);
|
2013-10-04 10:14:46 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2023-06-23 13:07:55 +00:00
|
|
|
static int qd_bh_get_or_undo(struct gfs2_sbd *sdp, struct gfs2_quota_data *qd)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
|
|
|
error = bh_get(qd);
|
|
|
|
if (!error)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
clear_bit(QDF_LOCKED, &qd->qd_flags);
|
|
|
|
slot_put(qd);
|
|
|
|
qd_put(qd);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
static int qd_fish(struct gfs2_sbd *sdp, struct gfs2_quota_data **qdp)
|
|
|
|
{
|
2022-03-31 22:38:57 +00:00
|
|
|
struct gfs2_quota_data *qd = NULL, *iter;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
*qdp = NULL;
|
|
|
|
|
2017-07-17 07:45:34 +00:00
|
|
|
if (sb_rdonly(sdp->sd_vfs))
|
2006-01-16 16:50:04 +00:00
|
|
|
return 0;
|
|
|
|
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_lock(&qd_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2022-03-31 22:38:57 +00:00
|
|
|
list_for_each_entry(iter, &sdp->sd_quota_list, qd_list) {
|
|
|
|
if (qd_check_sync(sdp, iter, &sdp->sd_quota_sync_gen)) {
|
|
|
|
qd = iter;
|
2013-10-04 10:14:46 +00:00
|
|
|
break;
|
2022-03-31 22:38:57 +00:00
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_unlock(&qd_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (qd) {
|
2023-06-23 13:07:55 +00:00
|
|
|
error = qd_bh_get_or_undo(sdp, qd);
|
|
|
|
if (error)
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
2023-06-23 13:07:55 +00:00
|
|
|
*qdp = qd;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2023-06-16 17:36:51 +00:00
|
|
|
static void qdsb_put(struct gfs2_quota_data *qd)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
|
|
|
bh_put(qd);
|
|
|
|
slot_put(qd);
|
|
|
|
qd_put(qd);
|
|
|
|
}
|
|
|
|
|
2023-06-16 17:36:51 +00:00
|
|
|
static void qd_unlock(struct gfs2_quota_data *qd)
|
|
|
|
{
|
|
|
|
gfs2_assert_warn(qd->qd_sbd, test_bit(QDF_LOCKED, &qd->qd_flags));
|
|
|
|
clear_bit(QDF_LOCKED, &qd->qd_flags);
|
|
|
|
qdsb_put(qd);
|
|
|
|
}
|
|
|
|
|
2013-02-01 03:35:56 +00:00
|
|
|
static int qdsb_get(struct gfs2_sbd *sdp, struct kqid qid,
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_quota_data **qdp)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2013-02-01 03:52:08 +00:00
|
|
|
error = qd_get(sdp, qid, qdp);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
error = slot_get(*qdp);
|
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
error = bh_get(*qdp);
|
|
|
|
if (error)
|
|
|
|
goto fail_slot;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_slot:
|
2006-01-16 16:50:04 +00:00
|
|
|
slot_put(*qdp);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail:
|
2006-01-16 16:50:04 +00:00
|
|
|
qd_put(*qdp);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
/**
|
2020-02-27 18:47:53 +00:00
|
|
|
* gfs2_qa_get - make sure we have a quota allocations data structure,
|
|
|
|
* if necessary
|
2015-10-26 15:40:28 +00:00
|
|
|
* @ip: the inode for this reservation
|
|
|
|
*/
|
2020-02-27 18:47:53 +00:00
|
|
|
int gfs2_qa_get(struct gfs2_inode *ip)
|
2015-10-26 15:40:28 +00:00
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2022-02-11 15:50:08 +00:00
|
|
|
struct inode *inode = &ip->i_inode;
|
2015-10-26 15:40:28 +00:00
|
|
|
|
|
|
|
if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
|
|
|
|
return 0;
|
|
|
|
|
2022-02-11 15:50:08 +00:00
|
|
|
spin_lock(&inode->i_lock);
|
2015-10-26 15:40:28 +00:00
|
|
|
if (ip->i_qadata == NULL) {
|
2022-02-11 15:50:08 +00:00
|
|
|
struct gfs2_qadata *tmp;
|
|
|
|
|
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
tmp = kmem_cache_zalloc(gfs2_qadata_cachep, GFP_NOFS);
|
|
|
|
if (!tmp)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
|
|
|
if (ip->i_qadata == NULL)
|
|
|
|
ip->i_qadata = tmp;
|
|
|
|
else
|
|
|
|
kmem_cache_free(gfs2_qadata_cachep, tmp);
|
2015-10-26 15:40:28 +00:00
|
|
|
}
|
2020-02-27 18:47:53 +00:00
|
|
|
ip->i_qadata->qa_ref++;
|
2022-02-11 15:50:08 +00:00
|
|
|
spin_unlock(&inode->i_lock);
|
|
|
|
return 0;
|
2015-10-26 15:40:28 +00:00
|
|
|
}
|
|
|
|
|
2020-02-27 18:47:53 +00:00
|
|
|
void gfs2_qa_put(struct gfs2_inode *ip)
|
2015-10-26 15:40:28 +00:00
|
|
|
{
|
2022-02-11 15:50:08 +00:00
|
|
|
struct inode *inode = &ip->i_inode;
|
|
|
|
|
|
|
|
spin_lock(&inode->i_lock);
|
2020-02-27 18:47:53 +00:00
|
|
|
if (ip->i_qadata && --ip->i_qadata->qa_ref == 0) {
|
2015-10-26 15:40:28 +00:00
|
|
|
kmem_cache_free(gfs2_qadata_cachep, ip->i_qadata);
|
|
|
|
ip->i_qadata = NULL;
|
|
|
|
}
|
2022-02-11 15:50:08 +00:00
|
|
|
spin_unlock(&inode->i_lock);
|
2015-10-26 15:40:28 +00:00
|
|
|
}
|
|
|
|
|
2013-02-01 04:27:54 +00:00
|
|
|
int gfs2_quota_hold(struct gfs2_inode *ip, kuid_t uid, kgid_t gid)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2012-05-18 13:28:23 +00:00
|
|
|
struct gfs2_quota_data **qd;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
|
|
|
|
return 0;
|
|
|
|
|
2020-02-27 18:47:53 +00:00
|
|
|
error = gfs2_qa_get(ip);
|
|
|
|
if (error)
|
|
|
|
return error;
|
2012-05-18 13:28:23 +00:00
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
qd = ip->i_qadata->qa_qd;
|
2012-05-18 13:28:23 +00:00
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
if (gfs2_assert_warn(sdp, !ip->i_qadata->qa_qd_num) ||
|
2020-02-27 18:47:53 +00:00
|
|
|
gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags))) {
|
|
|
|
error = -EIO;
|
2023-05-15 16:37:57 +00:00
|
|
|
gfs2_qa_put(ip);
|
2020-02-27 18:47:53 +00:00
|
|
|
goto out;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-02-01 03:35:56 +00:00
|
|
|
error = qdsb_get(sdp, make_kqid_uid(ip->i_inode.i_uid), qd);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
2020-02-27 18:47:53 +00:00
|
|
|
goto out_unhold;
|
2015-10-26 15:40:28 +00:00
|
|
|
ip->i_qadata->qa_qd_num++;
|
2006-01-16 16:50:04 +00:00
|
|
|
qd++;
|
|
|
|
|
2013-02-01 03:35:56 +00:00
|
|
|
error = qdsb_get(sdp, make_kqid_gid(ip->i_inode.i_gid), qd);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
2020-02-27 18:47:53 +00:00
|
|
|
goto out_unhold;
|
2015-10-26 15:40:28 +00:00
|
|
|
ip->i_qadata->qa_qd_num++;
|
2006-01-16 16:50:04 +00:00
|
|
|
qd++;
|
|
|
|
|
2013-02-01 05:56:13 +00:00
|
|
|
if (!uid_eq(uid, NO_UID_QUOTA_CHANGE) &&
|
|
|
|
!uid_eq(uid, ip->i_inode.i_uid)) {
|
2013-02-01 03:35:56 +00:00
|
|
|
error = qdsb_get(sdp, make_kqid_uid(uid), qd);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
2020-02-27 18:47:53 +00:00
|
|
|
goto out_unhold;
|
2015-10-26 15:40:28 +00:00
|
|
|
ip->i_qadata->qa_qd_num++;
|
2006-01-16 16:50:04 +00:00
|
|
|
qd++;
|
|
|
|
}
|
|
|
|
|
2013-02-01 05:56:13 +00:00
|
|
|
if (!gid_eq(gid, NO_GID_QUOTA_CHANGE) &&
|
|
|
|
!gid_eq(gid, ip->i_inode.i_gid)) {
|
2013-02-01 03:35:56 +00:00
|
|
|
error = qdsb_get(sdp, make_kqid_gid(gid), qd);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
2020-02-27 18:47:53 +00:00
|
|
|
goto out_unhold;
|
2015-10-26 15:40:28 +00:00
|
|
|
ip->i_qadata->qa_qd_num++;
|
2006-01-16 16:50:04 +00:00
|
|
|
qd++;
|
|
|
|
}
|
|
|
|
|
2020-02-27 18:47:53 +00:00
|
|
|
out_unhold:
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
gfs2_quota_unhold(ip);
|
2020-02-27 18:47:53 +00:00
|
|
|
out:
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
void gfs2_quota_unhold(struct gfs2_inode *ip)
|
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2015-07-24 14:45:43 +00:00
|
|
|
u32 x;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
if (ip->i_qadata == NULL)
|
2012-05-18 13:28:23 +00:00
|
|
|
return;
|
2020-02-27 18:47:53 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags));
|
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
|
|
|
|
qdsb_put(ip->i_qadata->qa_qd[x]);
|
|
|
|
ip->i_qadata->qa_qd[x] = NULL;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
2015-10-26 15:40:28 +00:00
|
|
|
ip->i_qadata->qa_qd_num = 0;
|
2020-02-27 18:47:53 +00:00
|
|
|
gfs2_qa_put(ip);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int sort_qd(const void *a, const void *b)
|
|
|
|
{
|
2006-09-05 19:17:12 +00:00
|
|
|
const struct gfs2_quota_data *qd_a = *(const struct gfs2_quota_data **)a;
|
|
|
|
const struct gfs2_quota_data *qd_b = *(const struct gfs2_quota_data **)b;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-02-01 03:52:08 +00:00
|
|
|
if (qid_lt(qd_a->qd_id, qd_b->qd_id))
|
2006-09-05 19:17:12 +00:00
|
|
|
return -1;
|
2013-02-01 03:52:08 +00:00
|
|
|
if (qid_lt(qd_b->qd_id, qd_a->qd_id))
|
2006-09-05 19:17:12 +00:00
|
|
|
return 1;
|
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
gfs2: Add quota_change type
Function do_qc has two main uses: (1) to re-sync the local quota changes
(qd) to the master quotas, and (2) normal quota changes. In the case of
normal quota changes, the change can be positive or negative, as the
quota usage goes up and down.
Before this patch function do_qc was distinguishing one from another by
whether the resulting value is or isn't zero: In the case of a re-sync
(called do_sync) the quota value is moved from the temporary value to a
master value, so the amount is added to one and subtracted from the
other. The problem is that since the values can be positive or negative
we can occasionally run into situations where we are not doing a re-sync
but the quota change just happens to cancel out the previous value.
In the case of a re-sync extra references and locks are taken, and so
do_qc needs to release them. In the case of a normal quota change, no
extra references and locks are taken, so it must not try to release
them.
The problem is: if the quota change is not a re-sync but the value just
happens to cancel out the original quota change, the resulting zero
value fools do_qc into thinking this is a re-sync and therefore it must
release the extra references. This results in problems, mainly having to
do with slot reference numbers going smaller than zero.
This patch introduces new constants, QC_SYNC and QC_CHANGE so do_qc can
really tell the difference. For QC_SYNC calls it must release the extra
references acquired by gfs2_quota_unlock's call to qd_check_sync. For
QC_CHANGE calls it does not have extra references to put.
Note that this allows quota changes back to a value of zero, and so I
removed an assert warning related to that.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2023-06-28 14:54:41 +00:00
|
|
|
static void do_qc(struct gfs2_quota_data *qd, s64 change, int qc_type)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2023-06-16 15:46:50 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_quota_change *qc = qd->qd_bh_qc;
|
2006-09-04 16:49:07 +00:00
|
|
|
s64 x;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_lock(&sdp->sd_quota_mutex);
|
2012-12-14 12:36:02 +00:00
|
|
|
gfs2_trans_add_meta(ip->i_gl, qd->qd_bh);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (!test_bit(QDF_CHANGE, &qd->qd_flags)) {
|
|
|
|
qc->qc_change = 0;
|
|
|
|
qc->qc_flags = 0;
|
2013-02-01 03:52:08 +00:00
|
|
|
if (qd->qd_id.type == USRQUOTA)
|
2006-01-16 16:50:04 +00:00
|
|
|
qc->qc_flags = cpu_to_be32(GFS2_QCF_USER);
|
2013-02-01 03:52:08 +00:00
|
|
|
qc->qc_id = cpu_to_be32(from_kqid(&init_user_ns, qd->qd_id));
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-10-14 14:46:30 +00:00
|
|
|
x = be64_to_cpu(qc->qc_change) + change;
|
2006-01-16 16:50:04 +00:00
|
|
|
qc->qc_change = cpu_to_be64(x);
|
|
|
|
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_lock(&qd_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
qd->qd_change = x;
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_unlock(&qd_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
gfs2: Add quota_change type
Function do_qc has two main uses: (1) to re-sync the local quota changes
(qd) to the master quotas, and (2) normal quota changes. In the case of
normal quota changes, the change can be positive or negative, as the
quota usage goes up and down.
Before this patch function do_qc was distinguishing one from another by
whether the resulting value is or isn't zero: In the case of a re-sync
(called do_sync) the quota value is moved from the temporary value to a
master value, so the amount is added to one and subtracted from the
other. The problem is that since the values can be positive or negative
we can occasionally run into situations where we are not doing a re-sync
but the quota change just happens to cancel out the previous value.
In the case of a re-sync extra references and locks are taken, and so
do_qc needs to release them. In the case of a normal quota change, no
extra references and locks are taken, so it must not try to release
them.
The problem is: if the quota change is not a re-sync but the value just
happens to cancel out the original quota change, the resulting zero
value fools do_qc into thinking this is a re-sync and therefore it must
release the extra references. This results in problems, mainly having to
do with slot reference numbers going smaller than zero.
This patch introduces new constants, QC_SYNC and QC_CHANGE so do_qc can
really tell the difference. For QC_SYNC calls it must release the extra
references acquired by gfs2_quota_unlock's call to qd_check_sync. For
QC_CHANGE calls it does not have extra references to put.
Note that this allows quota changes back to a value of zero, and so I
removed an assert warning related to that.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2023-06-28 14:54:41 +00:00
|
|
|
if (qc_type == QC_CHANGE) {
|
|
|
|
if (!test_and_set_bit(QDF_CHANGE, &qd->qd_flags)) {
|
|
|
|
qd_hold(qd);
|
|
|
|
slot_hold(qd);
|
|
|
|
}
|
|
|
|
} else {
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_assert_warn(sdp, test_bit(QDF_CHANGE, &qd->qd_flags));
|
|
|
|
clear_bit(QDF_CHANGE, &qd->qd_flags);
|
|
|
|
qc->qc_flags = 0;
|
|
|
|
qc->qc_id = 0;
|
|
|
|
slot_put(qd);
|
|
|
|
qd_put(qd);
|
|
|
|
}
|
2006-09-25 13:26:04 +00:00
|
|
|
|
2015-06-02 16:03:04 +00:00
|
|
|
if (change < 0) /* Reset quiet flag if we freed some blocks */
|
|
|
|
clear_bit(QDF_QMSG_QUIET, &qd->qd_flags);
|
2006-02-21 12:51:39 +00:00
|
|
|
mutex_unlock(&sdp->sd_quota_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2023-05-31 15:39:42 +00:00
|
|
|
static int gfs2_write_buf_to_page(struct gfs2_sbd *sdp, unsigned long index,
|
2015-06-02 16:02:24 +00:00
|
|
|
unsigned off, void *buf, unsigned bytes)
|
|
|
|
{
|
2023-05-31 15:39:42 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
|
2015-06-02 16:02:24 +00:00
|
|
|
struct inode *inode = &ip->i_inode;
|
|
|
|
struct address_space *mapping = inode->i_mapping;
|
2023-10-16 20:10:56 +00:00
|
|
|
struct folio *folio;
|
2015-06-02 16:02:24 +00:00
|
|
|
struct buffer_head *bh;
|
|
|
|
u64 blk;
|
|
|
|
unsigned bsize = sdp->sd_sb.sb_bsize, bnum = 0, boff = 0;
|
|
|
|
unsigned to_write = bytes, pg_off = off;
|
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
blk = index << (PAGE_SHIFT - sdp->sd_sb.sb_bsize_shift);
|
2015-06-02 16:02:24 +00:00
|
|
|
boff = off % bsize;
|
|
|
|
|
2023-10-16 20:10:56 +00:00
|
|
|
folio = filemap_grab_folio(mapping, index);
|
|
|
|
if (IS_ERR(folio))
|
|
|
|
return PTR_ERR(folio);
|
|
|
|
bh = folio_buffers(folio);
|
|
|
|
if (!bh)
|
2023-10-16 20:11:14 +00:00
|
|
|
bh = create_empty_buffers(folio, bsize, 0);
|
2015-06-02 16:02:24 +00:00
|
|
|
|
2023-10-16 20:10:56 +00:00
|
|
|
for (;;) {
|
|
|
|
/* Find the beginning block within the folio */
|
2015-06-02 16:02:24 +00:00
|
|
|
if (pg_off >= ((bnum * bsize) + bsize)) {
|
|
|
|
bh = bh->b_this_page;
|
|
|
|
bnum++;
|
|
|
|
blk++;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!buffer_mapped(bh)) {
|
|
|
|
gfs2_block_map(inode, blk, bh, 1);
|
|
|
|
if (!buffer_mapped(bh))
|
|
|
|
goto unlock_out;
|
|
|
|
/* If it's a newly allocated disk block, zero it */
|
|
|
|
if (buffer_new(bh))
|
2023-10-16 20:10:56 +00:00
|
|
|
folio_zero_range(folio, bnum * bsize,
|
|
|
|
bh->b_size);
|
2015-06-02 16:02:24 +00:00
|
|
|
}
|
2023-10-16 20:10:56 +00:00
|
|
|
if (folio_test_uptodate(folio))
|
2015-06-02 16:02:24 +00:00
|
|
|
set_buffer_uptodate(bh);
|
2022-09-01 13:34:55 +00:00
|
|
|
if (bh_read(bh, REQ_META | REQ_PRIO) < 0)
|
|
|
|
goto unlock_out;
|
2023-05-31 15:08:49 +00:00
|
|
|
gfs2_trans_add_data(ip->i_gl, bh);
|
2015-06-02 16:02:24 +00:00
|
|
|
|
|
|
|
/* If we need to write to the next block as well */
|
|
|
|
if (to_write > (bsize - boff)) {
|
|
|
|
pg_off += (bsize - boff);
|
|
|
|
to_write -= (bsize - boff);
|
|
|
|
boff = pg_off % bsize;
|
|
|
|
continue;
|
|
|
|
}
|
2023-05-31 15:47:17 +00:00
|
|
|
break;
|
2015-06-02 16:02:24 +00:00
|
|
|
}
|
|
|
|
|
2023-10-16 20:10:56 +00:00
|
|
|
/* Write to the folio, now that we have setup the buffer(s) */
|
|
|
|
memcpy_to_folio(folio, off, buf, bytes);
|
|
|
|
flush_dcache_folio(folio);
|
|
|
|
folio_unlock(folio);
|
|
|
|
folio_put(folio);
|
2015-06-02 16:02:24 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
unlock_out:
|
2023-10-16 20:10:56 +00:00
|
|
|
folio_unlock(folio);
|
|
|
|
folio_put(folio);
|
2015-06-02 16:02:24 +00:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2023-05-31 15:31:33 +00:00
|
|
|
static int gfs2_write_disk_quota(struct gfs2_sbd *sdp, struct gfs2_quota *qp,
|
2015-06-02 16:02:24 +00:00
|
|
|
loff_t loc)
|
|
|
|
{
|
|
|
|
unsigned long pg_beg;
|
|
|
|
unsigned pg_off, nbytes, overflow = 0;
|
2023-05-31 16:41:16 +00:00
|
|
|
int error;
|
2015-06-02 16:02:24 +00:00
|
|
|
void *ptr;
|
|
|
|
|
|
|
|
nbytes = sizeof(struct gfs2_quota);
|
|
|
|
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
pg_beg = loc >> PAGE_SHIFT;
|
2019-09-02 16:31:06 +00:00
|
|
|
pg_off = offset_in_page(loc);
|
2015-06-02 16:02:24 +00:00
|
|
|
|
|
|
|
/* If the quota straddles a page boundary, split the write in two */
|
2023-05-31 16:41:16 +00:00
|
|
|
if ((pg_off + nbytes) > PAGE_SIZE)
|
mm, fs: get rid of PAGE_CACHE_* and page_cache_{get,release} macros
PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} macros were introduced *long* time
ago with promise that one day it will be possible to implement page
cache with bigger chunks than PAGE_SIZE.
This promise never materialized. And unlikely will.
We have many places where PAGE_CACHE_SIZE assumed to be equal to
PAGE_SIZE. And it's constant source of confusion on whether
PAGE_CACHE_* or PAGE_* constant should be used in a particular case,
especially on the border between fs and mm.
Global switching to PAGE_CACHE_SIZE != PAGE_SIZE would cause to much
breakage to be doable.
Let's stop pretending that pages in page cache are special. They are
not.
The changes are pretty straight-forward:
- <foo> << (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- <foo> >> (PAGE_CACHE_SHIFT - PAGE_SHIFT) -> <foo>;
- PAGE_CACHE_{SIZE,SHIFT,MASK,ALIGN} -> PAGE_{SIZE,SHIFT,MASK,ALIGN};
- page_cache_get() -> get_page();
- page_cache_release() -> put_page();
This patch contains automated changes generated with coccinelle using
script below. For some reason, coccinelle doesn't patch header files.
I've called spatch for them manually.
The only adjustment after coccinelle is revert of changes to
PAGE_CAHCE_ALIGN definition: we are going to drop it later.
There are few places in the code where coccinelle didn't reach. I'll
fix them manually in a separate patch. Comments and documentation also
will be addressed with the separate patch.
virtual patch
@@
expression E;
@@
- E << (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
expression E;
@@
- E >> (PAGE_CACHE_SHIFT - PAGE_SHIFT)
+ E
@@
@@
- PAGE_CACHE_SHIFT
+ PAGE_SHIFT
@@
@@
- PAGE_CACHE_SIZE
+ PAGE_SIZE
@@
@@
- PAGE_CACHE_MASK
+ PAGE_MASK
@@
expression E;
@@
- PAGE_CACHE_ALIGN(E)
+ PAGE_ALIGN(E)
@@
expression E;
@@
- page_cache_get(E)
+ get_page(E)
@@
expression E;
@@
- page_cache_release(E)
+ put_page(E)
Signed-off-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2016-04-01 12:29:47 +00:00
|
|
|
overflow = (pg_off + nbytes) - PAGE_SIZE;
|
2015-06-02 16:02:24 +00:00
|
|
|
|
|
|
|
ptr = qp;
|
2023-05-31 15:39:42 +00:00
|
|
|
error = gfs2_write_buf_to_page(sdp, pg_beg, pg_off, ptr,
|
2015-06-02 16:02:24 +00:00
|
|
|
nbytes - overflow);
|
|
|
|
/* If there's an overflow, write the remaining bytes to the next page */
|
2023-05-31 16:41:16 +00:00
|
|
|
if (!error && overflow)
|
2023-05-31 15:39:42 +00:00
|
|
|
error = gfs2_write_buf_to_page(sdp, pg_beg + 1, 0,
|
2015-06-02 16:02:24 +00:00
|
|
|
ptr + nbytes - overflow,
|
|
|
|
overflow);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-02-08 11:50:51 +00:00
|
|
|
/**
|
2009-09-15 19:42:56 +00:00
|
|
|
* gfs2_adjust_quota - adjust record of current block usage
|
2023-05-31 15:25:29 +00:00
|
|
|
* @sdp: The superblock
|
2009-09-15 19:42:56 +00:00
|
|
|
* @loc: Offset of the entry in the quota file
|
2009-09-23 12:50:49 +00:00
|
|
|
* @change: The amount of usage change to record
|
2009-09-15 19:42:56 +00:00
|
|
|
* @qd: The quota data
|
2009-09-23 12:50:49 +00:00
|
|
|
* @fdq: The updated limits to record
|
2006-02-08 11:50:51 +00:00
|
|
|
*
|
|
|
|
* This function was mostly borrowed from gfs2_block_truncate_page which was
|
|
|
|
* in turn mostly borrowed from ext3
|
2009-09-15 19:42:56 +00:00
|
|
|
*
|
|
|
|
* Returns: 0 or -ve on error
|
2006-02-08 11:50:51 +00:00
|
|
|
*/
|
2009-09-15 19:42:56 +00:00
|
|
|
|
2023-05-31 15:25:29 +00:00
|
|
|
static int gfs2_adjust_quota(struct gfs2_sbd *sdp, loff_t loc,
|
2009-09-23 12:50:49 +00:00
|
|
|
s64 change, struct gfs2_quota_data *qd,
|
2014-10-09 14:03:13 +00:00
|
|
|
struct qc_dqblk *fdq)
|
2006-02-08 11:50:51 +00:00
|
|
|
{
|
2023-05-31 15:25:29 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
|
2006-06-14 19:32:57 +00:00
|
|
|
struct inode *inode = &ip->i_inode;
|
2013-06-02 23:53:40 +00:00
|
|
|
struct gfs2_quota q;
|
2015-06-02 16:02:24 +00:00
|
|
|
int err;
|
2009-09-23 12:50:49 +00:00
|
|
|
u64 size;
|
2006-02-08 11:50:51 +00:00
|
|
|
|
2011-09-19 09:25:49 +00:00
|
|
|
if (gfs2_is_stuffed(ip)) {
|
2021-06-17 19:36:50 +00:00
|
|
|
err = gfs2_unstuff_dinode(ip);
|
2011-09-19 09:25:49 +00:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
}
|
2010-05-07 21:50:18 +00:00
|
|
|
|
|
|
|
memset(&q, 0, sizeof(struct gfs2_quota));
|
2012-04-16 15:40:55 +00:00
|
|
|
err = gfs2_internal_read(ip, (char *)&q, &loc, sizeof(q));
|
2010-05-07 21:50:18 +00:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2015-06-02 16:02:24 +00:00
|
|
|
loc -= sizeof(q); /* gfs2_internal_read would've advanced the loc ptr */
|
2013-06-02 23:53:40 +00:00
|
|
|
be64_add_cpu(&q.qu_value, change);
|
2015-06-08 16:20:50 +00:00
|
|
|
if (((s64)be64_to_cpu(q.qu_value)) < 0)
|
2015-06-02 16:02:24 +00:00
|
|
|
q.qu_value = 0; /* Never go negative on quota usage */
|
2013-06-02 23:53:40 +00:00
|
|
|
qd->qd_qb.qb_value = q.qu_value;
|
2010-05-07 21:50:18 +00:00
|
|
|
if (fdq) {
|
2014-10-09 14:03:13 +00:00
|
|
|
if (fdq->d_fieldmask & QC_SPC_SOFT) {
|
|
|
|
q.qu_warn = cpu_to_be64(fdq->d_spc_softlimit >> sdp->sd_sb.sb_bsize_shift);
|
2013-06-02 23:53:40 +00:00
|
|
|
qd->qd_qb.qb_warn = q.qu_warn;
|
2010-05-07 21:50:18 +00:00
|
|
|
}
|
2014-10-09 14:03:13 +00:00
|
|
|
if (fdq->d_fieldmask & QC_SPC_HARD) {
|
|
|
|
q.qu_limit = cpu_to_be64(fdq->d_spc_hardlimit >> sdp->sd_sb.sb_bsize_shift);
|
2013-06-02 23:53:40 +00:00
|
|
|
qd->qd_qb.qb_limit = q.qu_limit;
|
2010-05-07 21:50:18 +00:00
|
|
|
}
|
2014-10-09 14:03:13 +00:00
|
|
|
if (fdq->d_fieldmask & QC_SPACE) {
|
|
|
|
q.qu_value = cpu_to_be64(fdq->d_space >> sdp->sd_sb.sb_bsize_shift);
|
2013-06-02 23:53:40 +00:00
|
|
|
qd->qd_qb.qb_value = q.qu_value;
|
2010-11-18 16:26:46 +00:00
|
|
|
}
|
2010-05-07 21:50:18 +00:00
|
|
|
}
|
|
|
|
|
2023-05-31 15:31:33 +00:00
|
|
|
err = gfs2_write_disk_quota(sdp, &q, loc);
|
2015-06-02 16:02:24 +00:00
|
|
|
if (!err) {
|
|
|
|
size = loc + sizeof(struct gfs2_quota);
|
|
|
|
if (size > inode->i_size)
|
|
|
|
i_size_write(inode, size);
|
2023-10-04 18:52:25 +00:00
|
|
|
inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
|
2015-06-02 16:02:24 +00:00
|
|
|
mark_inode_dirty(inode);
|
|
|
|
set_bit(QDF_REFRESH, &qd->qd_flags);
|
2010-05-07 21:50:18 +00:00
|
|
|
}
|
2009-09-23 12:50:49 +00:00
|
|
|
|
2006-02-08 11:50:51 +00:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
|
|
|
|
{
|
2023-06-16 15:46:50 +00:00
|
|
|
struct gfs2_sbd *sdp = (*qda)->qd_sbd;
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
|
2023-10-20 20:02:04 +00:00
|
|
|
struct gfs2_alloc_parms ap = {};
|
2006-01-16 16:50:04 +00:00
|
|
|
unsigned int data_blocks, ind_blocks;
|
|
|
|
struct gfs2_holder *ghs, i_gh;
|
|
|
|
unsigned int qx, x;
|
|
|
|
struct gfs2_quota_data *qd;
|
2012-07-30 13:53:19 +00:00
|
|
|
unsigned reserved;
|
2006-01-30 18:34:10 +00:00
|
|
|
loff_t offset;
|
2008-03-06 23:43:52 +00:00
|
|
|
unsigned int nalloc = 0, blocks;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
|
|
|
gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
|
|
|
|
&data_blocks, &ind_blocks);
|
|
|
|
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-12 20:55:00 +00:00
|
|
|
ghs = kmalloc_array(num_qd, sizeof(struct gfs2_holder), GFP_NOFS);
|
2023-06-22 17:36:59 +00:00
|
|
|
if (!ghs)
|
|
|
|
return -ENOMEM;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
sort(qda, num_qd, sizeof(struct gfs2_quota_data *), sort_qd, NULL);
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_lock(&ip->i_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
for (qx = 0; qx < num_qd; qx++) {
|
2009-09-15 19:42:56 +00:00
|
|
|
error = gfs2_glock_nq_init(qda[qx]->qd_gl, LM_ST_EXCLUSIVE,
|
2006-01-16 16:50:04 +00:00
|
|
|
GL_NOCACHE, &ghs[qx]);
|
|
|
|
if (error)
|
2020-02-27 18:47:53 +00:00
|
|
|
goto out_dq;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
|
|
|
|
if (error)
|
2020-02-27 18:47:53 +00:00
|
|
|
goto out_dq;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
for (x = 0; x < num_qd; x++) {
|
|
|
|
offset = qd2offset(qda[x]);
|
2010-06-24 23:21:20 +00:00
|
|
|
if (gfs2_write_alloc_required(ip, offset,
|
|
|
|
sizeof(struct gfs2_quota)))
|
2006-01-16 16:50:04 +00:00
|
|
|
nalloc++;
|
|
|
|
}
|
|
|
|
|
2008-03-06 23:43:52 +00:00
|
|
|
/*
|
|
|
|
* 1 blk for unstuffing inode if stuffed. We add this extra
|
|
|
|
* block to the reservation unconditionally. If the inode
|
|
|
|
* doesn't need unstuffing, the block will be released to the
|
|
|
|
* rgrp since it won't be allocated during the transaction
|
|
|
|
*/
|
2010-05-07 21:50:18 +00:00
|
|
|
/* +3 in the end for unstuffing block, inode size update block
|
|
|
|
* and another block in case quota straddles page boundary and
|
|
|
|
* two blocks need to be updated instead of 1 */
|
|
|
|
blocks = num_qd * data_blocks + RES_DINODE + num_qd + 3;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2012-07-30 13:53:19 +00:00
|
|
|
reserved = 1 + (nalloc * (data_blocks + ind_blocks));
|
2013-10-02 10:13:25 +00:00
|
|
|
ap.target = reserved;
|
|
|
|
error = gfs2_inplace_reserve(ip, &ap);
|
2008-03-06 23:43:52 +00:00
|
|
|
if (error)
|
|
|
|
goto out_alloc;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2008-03-06 23:43:52 +00:00
|
|
|
if (nalloc)
|
2012-07-30 13:53:19 +00:00
|
|
|
blocks += gfs2_rg_blocks(ip, reserved) + nalloc * ind_blocks + RES_STATFS;
|
2008-03-06 23:43:52 +00:00
|
|
|
|
|
|
|
error = gfs2_trans_begin(sdp, blocks, 0);
|
|
|
|
if (error)
|
|
|
|
goto out_ipres;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
for (x = 0; x < num_qd; x++) {
|
|
|
|
qd = qda[x];
|
|
|
|
offset = qd2offset(qd);
|
2023-05-31 15:25:29 +00:00
|
|
|
error = gfs2_adjust_quota(sdp, offset, qd->qd_change_sync, qd,
|
|
|
|
NULL);
|
2006-02-08 11:50:51 +00:00
|
|
|
if (error)
|
2006-01-16 16:50:04 +00:00
|
|
|
goto out_end_trans;
|
|
|
|
|
gfs2: Add quota_change type
Function do_qc has two main uses: (1) to re-sync the local quota changes
(qd) to the master quotas, and (2) normal quota changes. In the case of
normal quota changes, the change can be positive or negative, as the
quota usage goes up and down.
Before this patch function do_qc was distinguishing one from another by
whether the resulting value is or isn't zero: In the case of a re-sync
(called do_sync) the quota value is moved from the temporary value to a
master value, so the amount is added to one and subtracted from the
other. The problem is that since the values can be positive or negative
we can occasionally run into situations where we are not doing a re-sync
but the quota change just happens to cancel out the previous value.
In the case of a re-sync extra references and locks are taken, and so
do_qc needs to release them. In the case of a normal quota change, no
extra references and locks are taken, so it must not try to release
them.
The problem is: if the quota change is not a re-sync but the value just
happens to cancel out the original quota change, the resulting zero
value fools do_qc into thinking this is a re-sync and therefore it must
release the extra references. This results in problems, mainly having to
do with slot reference numbers going smaller than zero.
This patch introduces new constants, QC_SYNC and QC_CHANGE so do_qc can
really tell the difference. For QC_SYNC calls it must release the extra
references acquired by gfs2_quota_unlock's call to qd_check_sync. For
QC_CHANGE calls it does not have extra references to put.
Note that this allows quota changes back to a value of zero, and so I
removed an assert warning related to that.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2023-06-28 14:54:41 +00:00
|
|
|
do_qc(qd, -qd->qd_change_sync, QC_SYNC);
|
2011-03-08 15:40:42 +00:00
|
|
|
set_bit(QDF_REFRESH, &qd->qd_flags);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
out_end_trans:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_trans_end(sdp);
|
2006-09-04 16:04:26 +00:00
|
|
|
out_ipres:
|
2008-03-06 23:43:52 +00:00
|
|
|
gfs2_inplace_release(ip);
|
2006-09-04 16:04:26 +00:00
|
|
|
out_alloc:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
2020-02-27 18:47:53 +00:00
|
|
|
out_dq:
|
2006-01-16 16:50:04 +00:00
|
|
|
while (qx--)
|
|
|
|
gfs2_glock_dq_uninit(&ghs[qx]);
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_unlock(&ip->i_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
kfree(ghs);
|
2018-01-16 23:01:33 +00:00
|
|
|
gfs2_log_flush(ip->i_gl->gl_name.ln_sbd, ip->i_gl,
|
2018-01-08 15:34:17 +00:00
|
|
|
GFS2_LOG_HEAD_FLUSH_NORMAL | GFS2_LFC_DO_SYNC);
|
2023-06-22 16:04:45 +00:00
|
|
|
if (!error) {
|
|
|
|
for (x = 0; x < num_qd; x++)
|
|
|
|
qda[x]->qd_sync_gen = sdp->sd_quota_sync_gen;
|
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-09-23 12:50:49 +00:00
|
|
|
static int update_qd(struct gfs2_sbd *sdp, struct gfs2_quota_data *qd)
|
|
|
|
{
|
|
|
|
struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
|
|
|
|
struct gfs2_quota q;
|
|
|
|
struct gfs2_quota_lvb *qlvb;
|
|
|
|
loff_t pos;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
memset(&q, 0, sizeof(struct gfs2_quota));
|
|
|
|
pos = qd2offset(qd);
|
2012-04-16 15:40:55 +00:00
|
|
|
error = gfs2_internal_read(ip, (char *)&q, &pos, sizeof(q));
|
2009-09-23 12:50:49 +00:00
|
|
|
if (error < 0)
|
|
|
|
return error;
|
|
|
|
|
2012-11-14 18:47:37 +00:00
|
|
|
qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lksb.sb_lvbptr;
|
2009-09-23 12:50:49 +00:00
|
|
|
qlvb->qb_magic = cpu_to_be32(GFS2_MAGIC);
|
|
|
|
qlvb->__pad = 0;
|
|
|
|
qlvb->qb_limit = q.qu_limit;
|
|
|
|
qlvb->qb_warn = q.qu_warn;
|
|
|
|
qlvb->qb_value = q.qu_value;
|
|
|
|
qd->qd_qb = *qlvb;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
|
|
|
|
struct gfs2_holder *q_gh)
|
|
|
|
{
|
2023-06-16 15:46:50 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_holder i_gh;
|
|
|
|
int error;
|
|
|
|
|
2023-06-16 15:46:50 +00:00
|
|
|
gfs2_assert_warn(sdp, sdp == qd->qd_gl->gl_name.ln_sbd);
|
2006-09-04 16:04:26 +00:00
|
|
|
restart:
|
2006-01-16 16:50:04 +00:00
|
|
|
error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_SHARED, 0, q_gh);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2015-04-08 14:03:56 +00:00
|
|
|
if (test_and_clear_bit(QDF_REFRESH, &qd->qd_flags))
|
|
|
|
force_refresh = FORCE;
|
|
|
|
|
2012-11-14 18:47:37 +00:00
|
|
|
qd->qd_qb = *(struct gfs2_quota_lvb *)qd->qd_gl->gl_lksb.sb_lvbptr;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2006-09-01 15:05:15 +00:00
|
|
|
if (force_refresh || qd->qd_qb.qb_magic != cpu_to_be32(GFS2_MAGIC)) {
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(q_gh);
|
2009-09-11 14:21:56 +00:00
|
|
|
error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE,
|
|
|
|
GL_NOCACHE, q_gh);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2006-09-01 15:05:15 +00:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
|
2009-09-23 12:50:49 +00:00
|
|
|
error = update_qd(sdp, qd);
|
|
|
|
if (error)
|
2009-09-15 19:42:56 +00:00
|
|
|
goto fail_gunlock;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2009-09-23 12:50:49 +00:00
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
2009-09-11 14:21:56 +00:00
|
|
|
gfs2_glock_dq_uninit(q_gh);
|
|
|
|
force_refresh = 0;
|
|
|
|
goto restart;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
fail_gunlock:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
2006-09-04 16:04:26 +00:00
|
|
|
fail:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_glock_dq_uninit(q_gh);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-02-01 04:27:54 +00:00
|
|
|
int gfs2_quota_lock(struct gfs2_inode *ip, kuid_t uid, kgid_t gid)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2011-03-08 15:40:42 +00:00
|
|
|
struct gfs2_quota_data *qd;
|
2015-07-24 14:45:43 +00:00
|
|
|
u32 x;
|
2023-06-20 18:49:57 +00:00
|
|
|
int error;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2023-10-21 22:06:41 +00:00
|
|
|
if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
|
2006-01-16 16:50:04 +00:00
|
|
|
return 0;
|
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
error = gfs2_quota_hold(ip, uid, gid);
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
sort(ip->i_qadata->qa_qd, ip->i_qadata->qa_qd_num,
|
2012-05-18 13:28:23 +00:00
|
|
|
sizeof(struct gfs2_quota_data *), sort_qd, NULL);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
|
|
|
|
qd = ip->i_qadata->qa_qd[x];
|
|
|
|
error = do_glock(qd, NO_FORCE, &ip->i_qadata->qa_qd_ghs[x]);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!error)
|
|
|
|
set_bit(GIF_QD_LOCKED, &ip->i_flags);
|
|
|
|
else {
|
|
|
|
while (x--)
|
2015-10-26 15:40:28 +00:00
|
|
|
gfs2_glock_dq_uninit(&ip->i_qadata->qa_qd_ghs[x]);
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_quota_unhold(ip);
|
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2023-05-31 17:31:52 +00:00
|
|
|
static bool need_sync(struct gfs2_quota_data *qd)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2023-06-16 15:46:50 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_tune *gt = &sdp->sd_tune;
|
2006-09-04 16:49:07 +00:00
|
|
|
s64 value;
|
2006-01-16 16:50:04 +00:00
|
|
|
unsigned int num, den;
|
|
|
|
|
|
|
|
if (!qd->qd_qb.qb_limit)
|
2023-05-31 17:31:52 +00:00
|
|
|
return false;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_lock(&qd_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
value = qd->qd_change;
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_unlock(&qd_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
spin_lock(>->gt_spin);
|
|
|
|
num = gt->gt_quota_scale_num;
|
|
|
|
den = gt->gt_quota_scale_den;
|
|
|
|
spin_unlock(>->gt_spin);
|
|
|
|
|
2023-08-30 12:57:47 +00:00
|
|
|
if (value <= 0)
|
2023-05-31 17:31:52 +00:00
|
|
|
return false;
|
2006-09-01 15:05:15 +00:00
|
|
|
else if ((s64)be64_to_cpu(qd->qd_qb.qb_value) >=
|
|
|
|
(s64)be64_to_cpu(qd->qd_qb.qb_limit))
|
2023-05-31 17:31:52 +00:00
|
|
|
return false;
|
2006-01-16 16:50:04 +00:00
|
|
|
else {
|
|
|
|
value *= gfs2_jindex_size(sdp) * num;
|
2008-07-11 13:39:56 +00:00
|
|
|
value = div_s64(value, den);
|
2006-09-01 15:05:15 +00:00
|
|
|
value += (s64)be64_to_cpu(qd->qd_qb.qb_value);
|
2006-09-04 16:49:07 +00:00
|
|
|
if (value < (s64)be64_to_cpu(qd->qd_qb.qb_limit))
|
2023-05-31 17:31:52 +00:00
|
|
|
return false;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2023-05-31 17:31:52 +00:00
|
|
|
return true;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void gfs2_quota_unlock(struct gfs2_inode *ip)
|
|
|
|
{
|
2013-10-04 10:31:05 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2023-06-22 16:37:37 +00:00
|
|
|
struct gfs2_quota_data *qda[2 * GFS2_MAXQUOTAS];
|
2006-01-16 16:50:04 +00:00
|
|
|
unsigned int count = 0;
|
2015-07-24 14:45:43 +00:00
|
|
|
u32 x;
|
2013-10-04 10:31:05 +00:00
|
|
|
int found;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
if (!test_and_clear_bit(GIF_QD_LOCKED, &ip->i_flags))
|
2020-05-05 16:55:03 +00:00
|
|
|
return;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_quota_data *qd;
|
2023-05-31 17:31:52 +00:00
|
|
|
bool sync;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
qd = ip->i_qadata->qa_qd[x];
|
2006-01-16 16:50:04 +00:00
|
|
|
sync = need_sync(qd);
|
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
gfs2_glock_dq_uninit(&ip->i_qadata->qa_qd_ghs[x]);
|
2013-10-04 10:31:05 +00:00
|
|
|
if (!sync)
|
|
|
|
continue;
|
|
|
|
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_lock(&qd_lock);
|
2013-10-04 10:31:05 +00:00
|
|
|
found = qd_check_sync(sdp, qd, NULL);
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_unlock(&qd_lock);
|
2013-10-04 10:31:05 +00:00
|
|
|
|
|
|
|
if (!found)
|
|
|
|
continue;
|
|
|
|
|
2023-06-23 13:07:55 +00:00
|
|
|
if (!qd_bh_get_or_undo(sdp, qd))
|
|
|
|
qda[count++] = qd;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (count) {
|
|
|
|
do_sync(count, qda);
|
|
|
|
for (x = 0; x < count; x++)
|
|
|
|
qd_unlock(qda[x]);
|
|
|
|
}
|
|
|
|
|
|
|
|
gfs2_quota_unhold(ip);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define MAX_LINE 256
|
|
|
|
|
2023-10-20 19:02:59 +00:00
|
|
|
static void print_message(struct gfs2_quota_data *qd, char *type)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2023-06-16 15:46:50 +00:00
|
|
|
struct gfs2_sbd *sdp = qd->qd_sbd;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2023-10-20 19:02:59 +00:00
|
|
|
if (sdp->sd_args.ar_quota != GFS2_QUOTA_QUIET) {
|
2023-06-28 18:52:42 +00:00
|
|
|
fs_info(sdp, "quota %s for %s %u\n",
|
|
|
|
type,
|
|
|
|
(qd->qd_id.type == USRQUOTA) ? "user" : "group",
|
|
|
|
from_kqid(&init_user_ns, qd->qd_id));
|
2023-10-20 19:02:59 +00:00
|
|
|
}
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2015-03-18 17:04:37 +00:00
|
|
|
/**
|
|
|
|
* gfs2_quota_check - check if allocating new blocks will exceed quota
|
|
|
|
* @ip: The inode for which this check is being performed
|
|
|
|
* @uid: The uid to check against
|
|
|
|
* @gid: The gid to check against
|
|
|
|
* @ap: The allocation parameters. ap->target contains the requested
|
|
|
|
* blocks. ap->min_target, if set, contains the minimum blks
|
|
|
|
* requested.
|
|
|
|
*
|
|
|
|
* Returns: 0 on success.
|
|
|
|
* min_req = ap->min_target ? ap->min_target : ap->target;
|
2018-10-02 09:22:41 +00:00
|
|
|
* quota must allow at least min_req blks for success and
|
2015-03-18 17:04:37 +00:00
|
|
|
* ap->allowed is set to the number of blocks allowed
|
|
|
|
*
|
|
|
|
* -EDQUOT otherwise, quota violation. ap->allowed is set to number
|
|
|
|
* of blocks available.
|
|
|
|
*/
|
2015-03-18 17:03:41 +00:00
|
|
|
int gfs2_quota_check(struct gfs2_inode *ip, kuid_t uid, kgid_t gid,
|
|
|
|
struct gfs2_alloc_parms *ap)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_quota_data *qd;
|
2015-03-18 17:04:37 +00:00
|
|
|
s64 value, warn, limit;
|
2015-07-24 14:45:43 +00:00
|
|
|
u32 x;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error = 0;
|
|
|
|
|
2015-03-18 17:04:37 +00:00
|
|
|
ap->allowed = UINT_MAX; /* Assume we are permitted a whole lot */
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!test_bit(GIF_QD_LOCKED, &ip->i_flags))
|
|
|
|
return 0;
|
|
|
|
|
2015-10-26 15:40:28 +00:00
|
|
|
for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
|
|
|
|
qd = ip->i_qadata->qa_qd[x];
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-02-01 03:52:08 +00:00
|
|
|
if (!(qid_eq(qd->qd_id, make_kqid_uid(uid)) ||
|
|
|
|
qid_eq(qd->qd_id, make_kqid_gid(gid))))
|
2006-01-16 16:50:04 +00:00
|
|
|
continue;
|
|
|
|
|
2015-03-18 17:04:37 +00:00
|
|
|
warn = (s64)be64_to_cpu(qd->qd_qb.qb_warn);
|
|
|
|
limit = (s64)be64_to_cpu(qd->qd_qb.qb_limit);
|
2006-09-01 15:05:15 +00:00
|
|
|
value = (s64)be64_to_cpu(qd->qd_qb.qb_value);
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_lock(&qd_lock);
|
2015-03-18 17:04:37 +00:00
|
|
|
value += qd->qd_change;
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_unlock(&qd_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2015-03-18 17:04:37 +00:00
|
|
|
if (limit > 0 && (limit - value) < ap->allowed)
|
|
|
|
ap->allowed = limit - value;
|
|
|
|
/* If we can't meet the target */
|
|
|
|
if (limit && limit < (value + (s64)ap->target)) {
|
|
|
|
/* If no min_target specified or we don't meet
|
|
|
|
* min_target, return -EDQUOT */
|
|
|
|
if (!ap->min_target || ap->min_target > ap->allowed) {
|
2015-06-02 16:03:04 +00:00
|
|
|
if (!test_and_set_bit(QDF_QMSG_QUIET,
|
|
|
|
&qd->qd_flags)) {
|
|
|
|
print_message(qd, "exceeded");
|
|
|
|
quota_send_warning(qd->qd_id,
|
|
|
|
sdp->sd_vfs->s_dev,
|
|
|
|
QUOTA_NL_BHARDWARN);
|
|
|
|
}
|
2015-03-18 17:04:37 +00:00
|
|
|
error = -EDQUOT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else if (warn && warn < value &&
|
2006-01-16 16:50:04 +00:00
|
|
|
time_after_eq(jiffies, qd->qd_last_warn +
|
2015-03-18 17:04:37 +00:00
|
|
|
gfs2_tune_get(sdp, gt_quota_warn_period)
|
|
|
|
* HZ)) {
|
2013-02-01 03:52:08 +00:00
|
|
|
quota_send_warning(qd->qd_id,
|
2009-09-28 11:49:15 +00:00
|
|
|
sdp->sd_vfs->s_dev, QUOTA_NL_BSOFTWARN);
|
2023-10-20 19:02:59 +00:00
|
|
|
print_message(qd, "warning");
|
|
|
|
error = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
qd->qd_last_warn = jiffies;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2006-09-04 16:49:07 +00:00
|
|
|
void gfs2_quota_change(struct gfs2_inode *ip, s64 change,
|
2013-02-01 04:27:54 +00:00
|
|
|
kuid_t uid, kgid_t gid)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
|
|
|
struct gfs2_quota_data *qd;
|
2015-07-24 14:45:43 +00:00
|
|
|
u32 x;
|
2015-10-26 15:40:28 +00:00
|
|
|
struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2023-10-21 22:06:41 +00:00
|
|
|
if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF ||
|
2015-10-26 15:40:28 +00:00
|
|
|
gfs2_assert_warn(sdp, change))
|
2006-01-16 16:50:04 +00:00
|
|
|
return;
|
2008-11-04 10:05:22 +00:00
|
|
|
if (ip->i_diskflags & GFS2_DIF_SYSTEM)
|
2006-01-16 16:50:04 +00:00
|
|
|
return;
|
|
|
|
|
2020-05-05 16:50:24 +00:00
|
|
|
if (gfs2_assert_withdraw(sdp, ip->i_qadata &&
|
|
|
|
ip->i_qadata->qa_ref > 0))
|
|
|
|
return;
|
2015-10-26 15:40:28 +00:00
|
|
|
for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
|
|
|
|
qd = ip->i_qadata->qa_qd[x];
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-02-01 03:52:08 +00:00
|
|
|
if (qid_eq(qd->qd_id, make_kqid_uid(uid)) ||
|
|
|
|
qid_eq(qd->qd_id, make_kqid_gid(gid))) {
|
gfs2: Add quota_change type
Function do_qc has two main uses: (1) to re-sync the local quota changes
(qd) to the master quotas, and (2) normal quota changes. In the case of
normal quota changes, the change can be positive or negative, as the
quota usage goes up and down.
Before this patch function do_qc was distinguishing one from another by
whether the resulting value is or isn't zero: In the case of a re-sync
(called do_sync) the quota value is moved from the temporary value to a
master value, so the amount is added to one and subtracted from the
other. The problem is that since the values can be positive or negative
we can occasionally run into situations where we are not doing a re-sync
but the quota change just happens to cancel out the previous value.
In the case of a re-sync extra references and locks are taken, and so
do_qc needs to release them. In the case of a normal quota change, no
extra references and locks are taken, so it must not try to release
them.
The problem is: if the quota change is not a re-sync but the value just
happens to cancel out the original quota change, the resulting zero
value fools do_qc into thinking this is a re-sync and therefore it must
release the extra references. This results in problems, mainly having to
do with slot reference numbers going smaller than zero.
This patch introduces new constants, QC_SYNC and QC_CHANGE so do_qc can
really tell the difference. For QC_SYNC calls it must release the extra
references acquired by gfs2_quota_unlock's call to qd_check_sync. For
QC_CHANGE calls it does not have extra references to put.
Note that this allows quota changes back to a value of zero, and so I
removed an assert warning related to that.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2023-06-28 14:54:41 +00:00
|
|
|
do_qc(qd, change, QC_CHANGE);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-06-08 17:30:16 +00:00
|
|
|
static bool qd_changed(struct gfs2_sbd *sdp)
|
|
|
|
{
|
|
|
|
struct gfs2_quota_data *qd;
|
|
|
|
bool changed = false;
|
|
|
|
|
|
|
|
spin_lock(&qd_lock);
|
|
|
|
list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
|
|
|
|
if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
|
|
|
|
!test_bit(QDF_CHANGE, &qd->qd_flags))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
changed = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
spin_unlock(&qd_lock);
|
|
|
|
return changed;
|
|
|
|
}
|
|
|
|
|
2012-07-03 14:45:28 +00:00
|
|
|
int gfs2_quota_sync(struct super_block *sb, int type)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
2009-09-11 13:36:44 +00:00
|
|
|
struct gfs2_sbd *sdp = sb->s_fs_info;
|
2006-01-16 16:50:04 +00:00
|
|
|
struct gfs2_quota_data **qda;
|
2019-08-31 20:29:12 +00:00
|
|
|
unsigned int max_qd = PAGE_SIZE / sizeof(struct gfs2_holder);
|
2006-01-16 16:50:04 +00:00
|
|
|
unsigned int num_qd;
|
|
|
|
unsigned int x;
|
|
|
|
int error = 0;
|
|
|
|
|
2023-06-08 17:30:16 +00:00
|
|
|
if (!qd_changed(sdp))
|
|
|
|
return 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
|
|
|
qda = kcalloc(max_qd, sizeof(struct gfs2_quota_data *), GFP_KERNEL);
|
|
|
|
if (!qda)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2013-10-04 11:29:34 +00:00
|
|
|
mutex_lock(&sdp->sd_quota_sync_mutex);
|
|
|
|
sdp->sd_quota_sync_gen++;
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
do {
|
|
|
|
num_qd = 0;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
error = qd_fish(sdp, qda + num_qd);
|
|
|
|
if (error || !qda[num_qd])
|
|
|
|
break;
|
|
|
|
if (++num_qd == max_qd)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (num_qd) {
|
|
|
|
if (!error)
|
|
|
|
error = do_sync(num_qd, qda);
|
|
|
|
|
|
|
|
for (x = 0; x < num_qd; x++)
|
|
|
|
qd_unlock(qda[x]);
|
|
|
|
}
|
|
|
|
} while (!error && num_qd == max_qd);
|
|
|
|
|
2013-10-04 11:29:34 +00:00
|
|
|
mutex_unlock(&sdp->sd_quota_sync_mutex);
|
2006-01-16 16:50:04 +00:00
|
|
|
kfree(qda);
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2013-02-01 03:42:40 +00:00
|
|
|
int gfs2_quota_refresh(struct gfs2_sbd *sdp, struct kqid qid)
|
2006-01-16 16:50:04 +00:00
|
|
|
{
|
|
|
|
struct gfs2_quota_data *qd;
|
|
|
|
struct gfs2_holder q_gh;
|
|
|
|
int error;
|
|
|
|
|
2013-02-01 03:52:08 +00:00
|
|
|
error = qd_get(sdp, qid, &qd);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
error = do_glock(qd, FORCE, &q_gh);
|
|
|
|
if (!error)
|
|
|
|
gfs2_glock_dq_uninit(&q_gh);
|
|
|
|
|
|
|
|
qd_put(qd);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
int gfs2_quota_init(struct gfs2_sbd *sdp)
|
|
|
|
{
|
2006-06-14 19:32:57 +00:00
|
|
|
struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
|
2010-08-11 08:53:11 +00:00
|
|
|
u64 size = i_size_read(sdp->sd_qc_inode);
|
|
|
|
unsigned int blocks = size >> sdp->sd_sb.sb_bsize_shift;
|
2006-01-16 16:50:04 +00:00
|
|
|
unsigned int x, slot = 0;
|
|
|
|
unsigned int found = 0;
|
2013-12-12 10:47:59 +00:00
|
|
|
unsigned int hash;
|
2013-12-12 17:29:32 +00:00
|
|
|
unsigned int bm_size;
|
2006-09-04 16:49:07 +00:00
|
|
|
u64 dblock;
|
|
|
|
u32 extlen = 0;
|
2006-01-16 16:50:04 +00:00
|
|
|
int error;
|
|
|
|
|
2010-08-11 08:53:11 +00:00
|
|
|
if (gfs2_check_internal_file_size(sdp->sd_qc_inode, 1, 64 << 20))
|
2006-09-25 13:26:04 +00:00
|
|
|
return -EIO;
|
2010-08-11 08:53:11 +00:00
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
sdp->sd_quota_slots = blocks * sdp->sd_qc_per_block;
|
2013-12-12 17:29:32 +00:00
|
|
|
bm_size = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * sizeof(unsigned long));
|
|
|
|
bm_size *= sizeof(unsigned long);
|
2006-01-16 16:50:04 +00:00
|
|
|
error = -ENOMEM;
|
2014-02-26 18:07:56 +00:00
|
|
|
sdp->sd_quota_bitmap = kzalloc(bm_size, GFP_NOFS | __GFP_NOWARN);
|
2013-12-12 17:29:32 +00:00
|
|
|
if (sdp->sd_quota_bitmap == NULL)
|
2014-02-26 18:07:56 +00:00
|
|
|
sdp->sd_quota_bitmap = __vmalloc(bm_size, GFP_NOFS |
|
2020-06-02 04:51:40 +00:00
|
|
|
__GFP_ZERO);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (!sdp->sd_quota_bitmap)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
for (x = 0; x < blocks; x++) {
|
|
|
|
struct buffer_head *bh;
|
2013-11-26 15:17:09 +00:00
|
|
|
const struct gfs2_quota_change *qc;
|
2006-01-16 16:50:04 +00:00
|
|
|
unsigned int y;
|
|
|
|
|
|
|
|
if (!extlen) {
|
2021-03-31 21:17:38 +00:00
|
|
|
extlen = 32;
|
|
|
|
error = gfs2_get_extent(&ip->i_inode, x, &dblock, &extlen);
|
2006-01-16 16:50:04 +00:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
error = -EIO;
|
2006-09-21 21:05:23 +00:00
|
|
|
bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
|
|
|
|
if (!bh)
|
|
|
|
goto fail;
|
2006-01-16 16:50:04 +00:00
|
|
|
if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC)) {
|
|
|
|
brelse(bh);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
2013-11-26 15:17:09 +00:00
|
|
|
qc = (const struct gfs2_quota_change *)(bh->b_data + sizeof(struct gfs2_meta_header));
|
2006-09-21 21:05:23 +00:00
|
|
|
for (y = 0; y < sdp->sd_qc_per_block && slot < sdp->sd_quota_slots;
|
2006-01-16 16:50:04 +00:00
|
|
|
y++, slot++) {
|
|
|
|
struct gfs2_quota_data *qd;
|
2013-11-26 15:17:09 +00:00
|
|
|
s64 qc_change = be64_to_cpu(qc->qc_change);
|
|
|
|
u32 qc_flags = be32_to_cpu(qc->qc_flags);
|
|
|
|
enum quota_type qtype = (qc_flags & GFS2_QCF_USER) ?
|
|
|
|
USRQUOTA : GRPQUOTA;
|
|
|
|
struct kqid qc_id = make_kqid(&init_user_ns, qtype,
|
|
|
|
be32_to_cpu(qc->qc_id));
|
|
|
|
qc++;
|
|
|
|
if (!qc_change)
|
2006-01-16 16:50:04 +00:00
|
|
|
continue;
|
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
hash = gfs2_qd_hash(sdp, qc_id);
|
|
|
|
qd = qd_alloc(hash, sdp, qc_id);
|
|
|
|
if (qd == NULL) {
|
2006-01-16 16:50:04 +00:00
|
|
|
brelse(bh);
|
|
|
|
goto fail;
|
|
|
|
}
|
|
|
|
|
|
|
|
set_bit(QDF_CHANGE, &qd->qd_flags);
|
2013-11-26 15:17:09 +00:00
|
|
|
qd->qd_change = qc_change;
|
2006-01-16 16:50:04 +00:00
|
|
|
qd->qd_slot = slot;
|
2023-06-16 18:22:04 +00:00
|
|
|
qd->qd_slot_ref = 1;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_lock(&qd_lock);
|
2013-12-12 17:29:32 +00:00
|
|
|
BUG_ON(test_and_set_bit(slot, sdp->sd_quota_bitmap));
|
2006-01-16 16:50:04 +00:00
|
|
|
list_add(&qd->qd_list, &sdp->sd_quota_list);
|
|
|
|
atomic_inc(&sdp->sd_quota_count);
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_unlock(&qd_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-12-12 10:47:59 +00:00
|
|
|
spin_lock_bucket(hash);
|
|
|
|
hlist_bl_add_head_rcu(&qd->qd_hlist, &qd_hash_table[hash]);
|
|
|
|
spin_unlock_bucket(hash);
|
|
|
|
|
2006-01-16 16:50:04 +00:00
|
|
|
found++;
|
|
|
|
}
|
|
|
|
|
|
|
|
brelse(bh);
|
|
|
|
dblock++;
|
|
|
|
extlen--;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (found)
|
|
|
|
fs_info(sdp, "found %u quota changes\n", found);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2006-09-04 16:04:26 +00:00
|
|
|
fail:
|
2006-01-16 16:50:04 +00:00
|
|
|
gfs2_quota_cleanup(sdp);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
void gfs2_quota_cleanup(struct gfs2_sbd *sdp)
|
|
|
|
{
|
|
|
|
struct gfs2_quota_data *qd;
|
2023-08-23 19:38:04 +00:00
|
|
|
LIST_HEAD(dispose);
|
2023-08-23 15:15:47 +00:00
|
|
|
int count;
|
2006-01-16 16:50:04 +00:00
|
|
|
|
gfs2: fix kernel BUG in gfs2_quota_cleanup
[Syz report]
kernel BUG at fs/gfs2/quota.c:1508!
invalid opcode: 0000 [#1] PREEMPT SMP KASAN
CPU: 0 PID: 5060 Comm: syz-executor505 Not tainted 6.7.0-rc3-syzkaller-00134-g994d5c58e50e #0
Hardware name: Google Google Compute Engine/Google Compute Engine, BIOS Google 11/10/2023
RIP: 0010:gfs2_quota_cleanup+0x6b5/0x6c0 fs/gfs2/quota.c:1508
Code: fe e9 cf fd ff ff 44 89 e9 80 e1 07 80 c1 03 38 c1 0f 8c 2d fe ff ff 4c 89 ef e8 b6 19 23 fe e9 20 fe ff ff e8 ec 11 c7 fd 90 <0f> 0b e8 84 9c 4f 07 0f 1f 40 00 66 0f 1f 00 55 41 57 41 56 41 54
RSP: 0018:ffffc9000409f9e0 EFLAGS: 00010293
RAX: ffffffff83c76854 RBX: 0000000000000002 RCX: ffff888026001dc0
RDX: 0000000000000000 RSI: 0000000000000002 RDI: 0000000000000000
RBP: ffffc9000409fb00 R08: ffffffff83c762b0 R09: 1ffff1100fd38015
R10: dffffc0000000000 R11: ffffed100fd38016 R12: dffffc0000000000
R13: ffff88807e9c0828 R14: ffff888014693580 R15: ffff88807e9c0000
FS: 0000000000000000(0000) GS:ffff8880b9800000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007f16d1bd70f8 CR3: 0000000027199000 CR4: 00000000003506f0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
<TASK>
gfs2_put_super+0x2e1/0x940 fs/gfs2/super.c:611
generic_shutdown_super+0x13a/0x2c0 fs/super.c:696
kill_block_super+0x44/0x90 fs/super.c:1667
deactivate_locked_super+0xc1/0x130 fs/super.c:484
cleanup_mnt+0x426/0x4c0 fs/namespace.c:1256
task_work_run+0x24a/0x300 kernel/task_work.c:180
exit_task_work include/linux/task_work.h:38 [inline]
do_exit+0xa34/0x2750 kernel/exit.c:871
do_group_exit+0x206/0x2c0 kernel/exit.c:1021
__do_sys_exit_group kernel/exit.c:1032 [inline]
__se_sys_exit_group kernel/exit.c:1030 [inline]
__x64_sys_exit_group+0x3f/0x40 kernel/exit.c:1030
do_syscall_x64 arch/x86/entry/common.c:51 [inline]
do_syscall_64+0x45/0x110 arch/x86/entry/common.c:82
entry_SYSCALL_64_after_hwframe+0x63/0x6b
...
[pid 5060] fsconfig(4, FSCONFIG_CMD_RECONFIGURE, NULL, NULL, 0) = 0
[pid 5060] exit_group(1) = ?
...
[Analysis]
When the task exits, it will execute cleanup_mnt() to recycle the mounted gfs2
file system, but it performs a system call fsconfig(4, FSCONFIG_CMD_RECONFIGURE,
NULL, NULL, 0) before executing the task exit operation.
This will execute the following kernel path to complete the setting of
SDF_JOURNAL_LIVE for sd_flags:
SYSCALL_DEFINE5(fsconfig, ..)->
vfs_fsconfig_locked()->
vfs_cmd_reconfigure()->
gfs2_reconfigure()->
gfs2_make_fs_rw()->
set_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
[Fix]
Add SDF_NORECOVERY check in gfs2_quota_cleanup() to avoid checking
SDF_JOURNAL_LIVE on the path where gfs2 is being unmounted.
Reported-and-tested-by: syzbot+3b6e67ac2b646da57862@syzkaller.appspotmail.com
Fixes: f66af88e3321 ("gfs2: Stop using gfs2_make_fs_ro for withdraw")
Signed-off-by: Edward Adam Davis <eadavis@qq.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
2023-12-02 09:25:49 +00:00
|
|
|
BUG_ON(!test_bit(SDF_NORECOVERY, &sdp->sd_flags) &&
|
|
|
|
test_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags));
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_lock(&qd_lock);
|
2023-08-23 19:38:04 +00:00
|
|
|
list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
|
2023-08-23 15:15:47 +00:00
|
|
|
spin_lock(&qd->qd_lockref.lock);
|
|
|
|
if (qd->qd_lockref.count != 0) {
|
|
|
|
spin_unlock(&qd->qd_lockref.lock);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
lockref_mark_dead(&qd->qd_lockref);
|
|
|
|
spin_unlock(&qd->qd_lockref.lock);
|
2013-12-12 10:47:59 +00:00
|
|
|
|
list_lru: allow explicit memcg and NUMA node selection
Patch series "workload-specific and memory pressure-driven zswap
writeback", v8.
There are currently several issues with zswap writeback:
1. There is only a single global LRU for zswap, making it impossible to
perform worload-specific shrinking - an memcg under memory pressure
cannot determine which pages in the pool it owns, and often ends up
writing pages from other memcgs. This issue has been previously
observed in practice and mitigated by simply disabling
memcg-initiated shrinking:
https://lore.kernel.org/all/20230530232435.3097106-1-nphamcs@gmail.com/T/#u
But this solution leaves a lot to be desired, as we still do not
have an avenue for an memcg to free up its own memory locked up in
the zswap pool.
2. We only shrink the zswap pool when the user-defined limit is hit.
This means that if we set the limit too high, cold data that are
unlikely to be used again will reside in the pool, wasting precious
memory. It is hard to predict how much zswap space will be needed
ahead of time, as this depends on the workload (specifically, on
factors such as memory access patterns and compressibility of the
memory pages).
This patch series solves these issues by separating the global zswap LRU
into per-memcg and per-NUMA LRUs, and performs workload-specific (i.e
memcg- and NUMA-aware) zswap writeback under memory pressure. The new
shrinker does not have any parameter that must be tuned by the user, and
can be opted in or out on a per-memcg basis.
As a proof of concept, we ran the following synthetic benchmark: build the
linux kernel in a memory-limited cgroup, and allocate some cold data in
tmpfs to see if the shrinker could write them out and improved the overall
performance. Depending on the amount of cold data generated, we observe
from 14% to 35% reduction in kernel CPU time used in the kernel builds.
This patch (of 6):
The interface of list_lru is based on the assumption that the list node
and the data it represents belong to the same allocated on the correct
node/memcg. While this assumption is valid for existing slab objects LRU
such as dentries and inodes, it is undocumented, and rather inflexible for
certain potential list_lru users (such as the upcoming zswap shrinker and
the THP shrinker). It has caused us a lot of issues during our
development.
This patch changes list_lru interface so that the caller must explicitly
specify numa node and memcg when adding and removing objects. The old
list_lru_add() and list_lru_del() are renamed to list_lru_add_obj() and
list_lru_del_obj(), respectively.
It also extends the list_lru API with a new function, list_lru_putback,
which undoes a previous list_lru_isolate call. Unlike list_lru_add, it
does not increment the LRU node count (as list_lru_isolate does not
decrement the node count). list_lru_putback also allows for explicit
memcg and NUMA node selection.
Link: https://lkml.kernel.org/r/20231130194023.4102148-1-nphamcs@gmail.com
Link: https://lkml.kernel.org/r/20231130194023.4102148-2-nphamcs@gmail.com
Signed-off-by: Nhat Pham <nphamcs@gmail.com>
Suggested-by: Johannes Weiner <hannes@cmpxchg.org>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Tested-by: Bagas Sanjaya <bagasdotme@gmail.com>
Cc: Chris Li <chrisl@kernel.org>
Cc: Dan Streetman <ddstreet@ieee.org>
Cc: Domenico Cerasuolo <cerasuolodomenico@gmail.com>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Muchun Song <muchun.song@linux.dev>
Cc: Roman Gushchin <roman.gushchin@linux.dev>
Cc: Seth Jennings <sjenning@redhat.com>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Vitaly Wool <vitaly.wool@konsulko.com>
Cc: Yosry Ahmed <yosryahmed@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
2023-11-30 19:40:18 +00:00
|
|
|
list_lru_del_obj(&gfs2_qd_lru, &qd->qd_lru);
|
2023-08-23 19:38:04 +00:00
|
|
|
list_add(&qd->qd_lru, &dispose);
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
2013-11-01 18:52:08 +00:00
|
|
|
spin_unlock(&qd_lock);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2023-08-22 12:18:21 +00:00
|
|
|
gfs2_qd_list_dispose(&dispose);
|
2023-08-23 15:15:47 +00:00
|
|
|
|
|
|
|
wait_event_timeout(sdp->sd_kill_wait,
|
|
|
|
(count = atomic_read(&sdp->sd_quota_count)) == 0,
|
|
|
|
HZ * 60);
|
|
|
|
|
|
|
|
if (count != 0)
|
|
|
|
fs_err(sdp, "%d left-over quota data objects\n", count);
|
2006-01-16 16:50:04 +00:00
|
|
|
|
2014-11-20 05:18:38 +00:00
|
|
|
kvfree(sdp->sd_quota_bitmap);
|
|
|
|
sdp->sd_quota_bitmap = NULL;
|
2006-01-16 16:50:04 +00:00
|
|
|
}
|
|
|
|
|
2008-11-17 14:25:37 +00:00
|
|
|
static void quotad_error(struct gfs2_sbd *sdp, const char *msg, int error)
|
|
|
|
{
|
|
|
|
if (error == 0 || error == -EROFS)
|
|
|
|
return;
|
2023-12-20 16:16:29 +00:00
|
|
|
if (!gfs2_withdrawing_or_withdrawn(sdp)) {
|
2019-04-16 18:23:28 +00:00
|
|
|
if (!cmpxchg(&sdp->sd_log_error, 0, error))
|
|
|
|
fs_err(sdp, "gfs2_quotad: %s error %d\n", msg, error);
|
GFS2: Withdraw for IO errors writing to the journal or statfs
Before this patch, if GFS2 encountered IO errors while writing to
the journal, it would not report the problem, so they would go
unnoticed, sometimes for many hours. Sometimes this would only be
noticed later, when recovery tried to do journal replay and failed
due to invalid metadata at the blocks that resulted in IO errors.
This patch makes GFS2's log daemon check for IO errors. If it
encounters one, it withdraws from the file system and reports
why in dmesg. A similar action is taken when IO errors occur when
writing to the system statfs file.
These errors are also reported back to any callers of fsync, since
that requires the journal to be flushed. Therefore, any IO errors
that would previously go unnoticed are now noticed and the file
system is withdrawn as early as possible, thus preventing further
file system damage.
Also note that this reintroduces superblock variable sd_log_error,
which Christoph removed with commit f729b66fca.
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
2017-08-16 16:30:06 +00:00
|
|
|
wake_up(&sdp->sd_logd_waitq);
|
|
|
|
}
|
2008-11-17 14:25:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void quotad_check_timeo(struct gfs2_sbd *sdp, const char *msg,
|
2009-09-11 13:36:44 +00:00
|
|
|
int (*fxn)(struct super_block *sb, int type),
|
2008-11-17 14:25:37 +00:00
|
|
|
unsigned long t, unsigned long *timeo,
|
|
|
|
unsigned int *new_timeo)
|
|
|
|
{
|
|
|
|
if (t >= *timeo) {
|
2009-09-11 13:36:44 +00:00
|
|
|
int error = fxn(sdp->sd_vfs, 0);
|
2008-11-17 14:25:37 +00:00
|
|
|
quotad_error(sdp, msg, error);
|
|
|
|
*timeo = gfs2_tune_get_i(&sdp->sd_tune, new_timeo) * HZ;
|
|
|
|
} else {
|
|
|
|
*timeo -= t;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-20 07:39:44 +00:00
|
|
|
void gfs2_wake_up_statfs(struct gfs2_sbd *sdp) {
|
|
|
|
if (!sdp->sd_statfs_force_sync) {
|
|
|
|
sdp->sd_statfs_force_sync = 1;
|
|
|
|
wake_up(&sdp->sd_quota_wait);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-11-17 14:25:37 +00:00
|
|
|
/**
|
|
|
|
* gfs2_quotad - Write cached quota changes into the quota file
|
2021-03-30 16:44:29 +00:00
|
|
|
* @data: Pointer to GFS2 superblock
|
2008-11-17 14:25:37 +00:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
int gfs2_quotad(void *data)
|
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = data;
|
|
|
|
struct gfs2_tune *tune = &sdp->sd_tune;
|
|
|
|
unsigned long statfs_timeo = 0;
|
|
|
|
unsigned long quotad_timeo = 0;
|
|
|
|
unsigned long t = 0;
|
|
|
|
|
2023-12-18 05:35:57 +00:00
|
|
|
set_freezable();
|
2008-11-17 14:25:37 +00:00
|
|
|
while (!kthread_should_stop()) {
|
2023-12-20 16:16:29 +00:00
|
|
|
if (gfs2_withdrawing_or_withdrawn(sdp))
|
2023-08-25 09:18:38 +00:00
|
|
|
break;
|
|
|
|
|
2008-11-17 14:25:37 +00:00
|
|
|
/* Update the master statfs file */
|
2009-10-20 07:39:44 +00:00
|
|
|
if (sdp->sd_statfs_force_sync) {
|
|
|
|
int error = gfs2_statfs_sync(sdp->sd_vfs, 0);
|
|
|
|
quotad_error(sdp, "statfs", error);
|
|
|
|
statfs_timeo = gfs2_tune_get(sdp, gt_statfs_quantum) * HZ;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
quotad_check_timeo(sdp, "statfs", gfs2_statfs_sync, t,
|
|
|
|
&statfs_timeo,
|
|
|
|
&tune->gt_statfs_quantum);
|
2008-11-17 14:25:37 +00:00
|
|
|
|
|
|
|
/* Update quota file */
|
2013-06-03 10:12:59 +00:00
|
|
|
quotad_check_timeo(sdp, "sync", gfs2_quota_sync, t,
|
2008-11-17 14:25:37 +00:00
|
|
|
"ad_timeo, &tune->gt_quota_quantum);
|
|
|
|
|
|
|
|
t = min(quotad_timeo, statfs_timeo);
|
|
|
|
|
2023-12-18 05:35:58 +00:00
|
|
|
t = wait_event_freezable_timeout(sdp->sd_quota_wait,
|
2023-08-25 09:18:38 +00:00
|
|
|
sdp->sd_statfs_force_sync ||
|
2023-12-20 16:16:29 +00:00
|
|
|
gfs2_withdrawing_or_withdrawn(sdp) ||
|
2023-08-25 09:18:38 +00:00
|
|
|
kthread_should_stop(),
|
2023-08-25 09:06:20 +00:00
|
|
|
t);
|
|
|
|
|
|
|
|
if (sdp->sd_statfs_force_sync)
|
2008-11-18 13:38:48 +00:00
|
|
|
t = 0;
|
2008-11-17 14:25:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-11-19 15:41:07 +00:00
|
|
|
static int gfs2_quota_get_state(struct super_block *sb, struct qc_state *state)
|
2009-09-11 14:57:27 +00:00
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = sb->s_fs_info;
|
|
|
|
|
2014-11-19 15:41:07 +00:00
|
|
|
memset(state, 0, sizeof(*state));
|
2010-05-04 22:10:56 +00:00
|
|
|
|
|
|
|
switch (sdp->sd_args.ar_quota) {
|
2023-06-28 18:52:42 +00:00
|
|
|
case GFS2_QUOTA_QUIET:
|
|
|
|
fallthrough;
|
2010-05-04 22:10:56 +00:00
|
|
|
case GFS2_QUOTA_ON:
|
2014-11-19 15:41:07 +00:00
|
|
|
state->s_state[USRQUOTA].flags |= QCI_LIMITS_ENFORCED;
|
|
|
|
state->s_state[GRPQUOTA].flags |= QCI_LIMITS_ENFORCED;
|
2020-08-23 22:36:59 +00:00
|
|
|
fallthrough;
|
2010-05-04 22:10:56 +00:00
|
|
|
case GFS2_QUOTA_ACCOUNT:
|
2014-11-19 15:41:07 +00:00
|
|
|
state->s_state[USRQUOTA].flags |= QCI_ACCT_ENABLED |
|
|
|
|
QCI_SYSFILE;
|
|
|
|
state->s_state[GRPQUOTA].flags |= QCI_ACCT_ENABLED |
|
|
|
|
QCI_SYSFILE;
|
2010-05-04 22:10:56 +00:00
|
|
|
break;
|
|
|
|
case GFS2_QUOTA_OFF:
|
|
|
|
break;
|
|
|
|
}
|
2009-09-11 14:57:27 +00:00
|
|
|
if (sdp->sd_quota_inode) {
|
2014-11-19 15:41:07 +00:00
|
|
|
state->s_state[USRQUOTA].ino =
|
|
|
|
GFS2_I(sdp->sd_quota_inode)->i_no_addr;
|
|
|
|
state->s_state[USRQUOTA].blocks = sdp->sd_quota_inode->i_blocks;
|
2009-09-11 14:57:27 +00:00
|
|
|
}
|
2014-11-19 15:41:07 +00:00
|
|
|
state->s_state[USRQUOTA].nextents = 1; /* unsupported */
|
|
|
|
state->s_state[GRPQUOTA] = state->s_state[USRQUOTA];
|
|
|
|
state->s_incoredqs = list_lru_count(&gfs2_qd_lru);
|
2009-09-11 14:57:27 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-16 09:07:49 +00:00
|
|
|
static int gfs2_get_dqblk(struct super_block *sb, struct kqid qid,
|
2014-10-09 14:03:13 +00:00
|
|
|
struct qc_dqblk *fdq)
|
2009-09-28 10:52:16 +00:00
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = sb->s_fs_info;
|
|
|
|
struct gfs2_quota_lvb *qlvb;
|
|
|
|
struct gfs2_quota_data *qd;
|
|
|
|
struct gfs2_holder q_gh;
|
|
|
|
int error;
|
|
|
|
|
2014-10-09 14:03:13 +00:00
|
|
|
memset(fdq, 0, sizeof(*fdq));
|
2009-09-28 10:52:16 +00:00
|
|
|
|
|
|
|
if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
|
|
|
|
return -ESRCH; /* Crazy XFS error code */
|
|
|
|
|
2013-02-01 04:09:30 +00:00
|
|
|
if ((qid.type != USRQUOTA) &&
|
|
|
|
(qid.type != GRPQUOTA))
|
2009-09-28 10:52:16 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-02-01 03:52:08 +00:00
|
|
|
error = qd_get(sdp, qid, &qd);
|
2009-09-28 10:52:16 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
error = do_glock(qd, FORCE, &q_gh);
|
|
|
|
if (error)
|
|
|
|
goto out;
|
|
|
|
|
2012-11-14 18:47:37 +00:00
|
|
|
qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lksb.sb_lvbptr;
|
2014-10-09 14:03:13 +00:00
|
|
|
fdq->d_spc_hardlimit = be64_to_cpu(qlvb->qb_limit) << sdp->sd_sb.sb_bsize_shift;
|
|
|
|
fdq->d_spc_softlimit = be64_to_cpu(qlvb->qb_warn) << sdp->sd_sb.sb_bsize_shift;
|
|
|
|
fdq->d_space = be64_to_cpu(qlvb->qb_value) << sdp->sd_sb.sb_bsize_shift;
|
2009-09-28 10:52:16 +00:00
|
|
|
|
|
|
|
gfs2_glock_dq_uninit(&q_gh);
|
|
|
|
out:
|
|
|
|
qd_put(qd);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-09-23 12:50:49 +00:00
|
|
|
/* GFS2 only supports a subset of the XFS fields */
|
2014-10-09 14:03:13 +00:00
|
|
|
#define GFS2_FIELDMASK (QC_SPC_SOFT|QC_SPC_HARD|QC_SPACE)
|
2009-09-23 12:50:49 +00:00
|
|
|
|
2012-09-16 09:07:49 +00:00
|
|
|
static int gfs2_set_dqblk(struct super_block *sb, struct kqid qid,
|
2014-10-09 14:03:13 +00:00
|
|
|
struct qc_dqblk *fdq)
|
2009-09-23 12:50:49 +00:00
|
|
|
{
|
|
|
|
struct gfs2_sbd *sdp = sb->s_fs_info;
|
|
|
|
struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
|
|
|
|
struct gfs2_quota_data *qd;
|
|
|
|
struct gfs2_holder q_gh, i_gh;
|
|
|
|
unsigned int data_blocks, ind_blocks;
|
|
|
|
unsigned int blocks = 0;
|
|
|
|
int alloc_required;
|
|
|
|
loff_t offset;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
|
|
|
|
return -ESRCH; /* Crazy XFS error code */
|
|
|
|
|
2013-02-01 04:09:30 +00:00
|
|
|
if ((qid.type != USRQUOTA) &&
|
|
|
|
(qid.type != GRPQUOTA))
|
2009-09-23 12:50:49 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (fdq->d_fieldmask & ~GFS2_FIELDMASK)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-02-01 03:52:08 +00:00
|
|
|
error = qd_get(sdp, qid, &qd);
|
2009-09-23 12:50:49 +00:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
2020-02-27 18:47:53 +00:00
|
|
|
error = gfs2_qa_get(ip);
|
2012-06-06 10:17:59 +00:00
|
|
|
if (error)
|
|
|
|
goto out_put;
|
|
|
|
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_lock(&ip->i_inode);
|
2009-09-23 12:50:49 +00:00
|
|
|
error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE, 0, &q_gh);
|
|
|
|
if (error)
|
2012-06-06 10:17:59 +00:00
|
|
|
goto out_unlockput;
|
2009-09-23 12:50:49 +00:00
|
|
|
error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
|
|
|
|
if (error)
|
|
|
|
goto out_q;
|
|
|
|
|
|
|
|
/* Check for existing entry, if none then alloc new blocks */
|
|
|
|
error = update_qd(sdp, qd);
|
|
|
|
if (error)
|
|
|
|
goto out_i;
|
|
|
|
|
|
|
|
/* If nothing has changed, this is a no-op */
|
2014-10-09 14:03:13 +00:00
|
|
|
if ((fdq->d_fieldmask & QC_SPC_SOFT) &&
|
|
|
|
((fdq->d_spc_softlimit >> sdp->sd_sb.sb_bsize_shift) == be64_to_cpu(qd->qd_qb.qb_warn)))
|
|
|
|
fdq->d_fieldmask ^= QC_SPC_SOFT;
|
2010-11-18 16:26:46 +00:00
|
|
|
|
2014-10-09 14:03:13 +00:00
|
|
|
if ((fdq->d_fieldmask & QC_SPC_HARD) &&
|
|
|
|
((fdq->d_spc_hardlimit >> sdp->sd_sb.sb_bsize_shift) == be64_to_cpu(qd->qd_qb.qb_limit)))
|
|
|
|
fdq->d_fieldmask ^= QC_SPC_HARD;
|
2010-11-18 16:26:46 +00:00
|
|
|
|
2014-10-09 14:03:13 +00:00
|
|
|
if ((fdq->d_fieldmask & QC_SPACE) &&
|
|
|
|
((fdq->d_space >> sdp->sd_sb.sb_bsize_shift) == be64_to_cpu(qd->qd_qb.qb_value)))
|
|
|
|
fdq->d_fieldmask ^= QC_SPACE;
|
2010-11-18 16:26:46 +00:00
|
|
|
|
2009-09-23 12:50:49 +00:00
|
|
|
if (fdq->d_fieldmask == 0)
|
|
|
|
goto out_i;
|
|
|
|
|
|
|
|
offset = qd2offset(qd);
|
2010-06-24 23:21:20 +00:00
|
|
|
alloc_required = gfs2_write_alloc_required(ip, offset, sizeof(struct gfs2_quota));
|
2011-02-07 16:22:41 +00:00
|
|
|
if (gfs2_is_stuffed(ip))
|
|
|
|
alloc_required = 1;
|
2009-09-23 12:50:49 +00:00
|
|
|
if (alloc_required) {
|
2023-10-20 20:02:04 +00:00
|
|
|
struct gfs2_alloc_parms ap = {};
|
2009-09-23 12:50:49 +00:00
|
|
|
gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
|
|
|
|
&data_blocks, &ind_blocks);
|
2011-11-21 18:36:17 +00:00
|
|
|
blocks = 1 + data_blocks + ind_blocks;
|
2013-10-02 10:13:25 +00:00
|
|
|
ap.target = blocks;
|
|
|
|
error = gfs2_inplace_reserve(ip, &ap);
|
2009-09-23 12:50:49 +00:00
|
|
|
if (error)
|
2011-11-21 18:36:17 +00:00
|
|
|
goto out_i;
|
2012-07-30 13:53:19 +00:00
|
|
|
blocks += gfs2_rg_blocks(ip, blocks);
|
2009-09-23 12:50:49 +00:00
|
|
|
}
|
|
|
|
|
2011-02-07 16:22:41 +00:00
|
|
|
/* Some quotas span block boundaries and can update two blocks,
|
|
|
|
adding an extra block to the transaction to handle such quotas */
|
|
|
|
error = gfs2_trans_begin(sdp, blocks + RES_DINODE + 2, 0);
|
2009-09-23 12:50:49 +00:00
|
|
|
if (error)
|
|
|
|
goto out_release;
|
|
|
|
|
|
|
|
/* Apply changes */
|
2023-05-31 15:25:29 +00:00
|
|
|
error = gfs2_adjust_quota(sdp, offset, 0, qd, fdq);
|
2015-06-02 16:03:04 +00:00
|
|
|
if (!error)
|
|
|
|
clear_bit(QDF_QMSG_QUIET, &qd->qd_flags);
|
2009-09-23 12:50:49 +00:00
|
|
|
|
|
|
|
gfs2_trans_end(sdp);
|
|
|
|
out_release:
|
2011-11-21 18:36:17 +00:00
|
|
|
if (alloc_required)
|
2009-09-23 12:50:49 +00:00
|
|
|
gfs2_inplace_release(ip);
|
|
|
|
out_i:
|
|
|
|
gfs2_glock_dq_uninit(&i_gh);
|
|
|
|
out_q:
|
|
|
|
gfs2_glock_dq_uninit(&q_gh);
|
2012-06-06 10:17:59 +00:00
|
|
|
out_unlockput:
|
2020-02-27 18:47:53 +00:00
|
|
|
gfs2_qa_put(ip);
|
2016-01-22 20:40:57 +00:00
|
|
|
inode_unlock(&ip->i_inode);
|
2012-06-06 10:17:59 +00:00
|
|
|
out_put:
|
2009-09-23 12:50:49 +00:00
|
|
|
qd_put(qd);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2009-09-15 08:59:02 +00:00
|
|
|
const struct quotactl_ops gfs2_quotactl_ops = {
|
|
|
|
.quota_sync = gfs2_quota_sync,
|
2014-11-19 15:41:07 +00:00
|
|
|
.get_state = gfs2_quota_get_state,
|
2010-05-06 21:04:58 +00:00
|
|
|
.get_dqblk = gfs2_get_dqblk,
|
2010-05-06 21:05:17 +00:00
|
|
|
.set_dqblk = gfs2_set_dqblk,
|
2009-09-15 08:59:02 +00:00
|
|
|
};
|
2013-12-12 10:47:59 +00:00
|
|
|
|
|
|
|
void __init gfs2_quota_hash_init(void)
|
|
|
|
{
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
for(i = 0; i < GFS2_QD_HASH_SIZE; i++)
|
|
|
|
INIT_HLIST_BL_HEAD(&qd_hash_table[i]);
|
|
|
|
}
|