blob: 43ffe59970985abe1c28ac1523cf65142115ca32 [file] [log] [blame]
Thomas Gleixner7336d0e2019-05-31 01:09:56 -07001// SPDX-License-Identifier: GPL-2.0-only
David Teiglandb3b94fa2006-01-16 16:50:04 +00002/*
3 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Bob Peterson0d0868b2007-12-11 18:51:25 -06004 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00005 */
6
7/*
8 * Quota change tags are associated with each transaction that allocates or
9 * deallocates space. Those changes are accumulated locally to each node (in a
10 * per-node file) and then are periodically synced to the quota file. This
11 * avoids the bottleneck of constantly touching the quota file, but introduces
12 * fuzziness in the current usage value of IDs that are being used on different
13 * nodes in the cluster simultaneously. So, it is possible for a user on
14 * multiple nodes to overrun their quota, but that overrun is controlable.
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +010015 * Since quota tags are part of transactions, there is no need for a quota check
David Teiglandb3b94fa2006-01-16 16:50:04 +000016 * program to be run on node crashes or anything like that.
17 *
18 * There are couple of knobs that let the administrator manage the quota
19 * fuzziness. "quota_quantum" sets the maximum time a quota change can be
20 * sitting on one node before being synced to the quota file. (The default is
21 * 60 seconds.) Another knob, "quota_scale" controls how quickly the frequency
22 * of quota file syncs increases as the user moves closer to their limit. The
23 * more frequent the syncs, the more accurate the quota enforcement, but that
24 * means that there is more contention between the nodes for the quota file.
25 * The default value is one. This sets the maximum theoretical quota overrun
26 * (with infinite node with infinite bandwidth) to twice the user's limit. (In
27 * practice, the maximum overrun you see should be much less.) A "quota_scale"
28 * number greater than one makes quota syncs more frequent and reduces the
29 * maximum overrun. Numbers less than one (but greater than zero) make quota
30 * syncs less frequent.
31 *
32 * GFS quotas also use per-ID Lock Value Blocks (LVBs) to cache the contents of
33 * the quota file, so it is not being constantly read.
34 */
35
Joe Perchesd77d1b52014-03-06 12:10:45 -080036#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
37
David Teiglandb3b94fa2006-01-16 16:50:04 +000038#include <linux/sched.h>
39#include <linux/slab.h>
Ying Han1495f232011-05-24 17:12:27 -070040#include <linux/mm.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000041#include <linux/spinlock.h>
42#include <linux/completion.h>
43#include <linux/buffer_head.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000044#include <linux/sort.h>
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000045#include <linux/fs.h>
Steven Whitehouse2e565bb2006-10-02 11:38:25 -040046#include <linux/bio.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050047#include <linux/gfs2_ondisk.h>
Steven Whitehouse37b2c832008-11-17 14:25:37 +000048#include <linux/kthread.h>
49#include <linux/freezer.h>
Steven Whitehouse2ec46502009-09-28 12:49:15 +010050#include <linux/quota.h>
Steven Whitehouse1d371b52009-09-11 15:57:27 +010051#include <linux/dqblk_xfs.h>
Steven Whitehouse9b9f0392013-11-01 14:52:06 -040052#include <linux/lockref.h>
Steven Whitehouse2147dbf2013-11-04 10:15:08 +000053#include <linux/list_lru.h>
Steven Whitehousec754fbb2013-12-12 10:47:59 +000054#include <linux/rcupdate.h>
55#include <linux/rculist_bl.h>
56#include <linux/bit_spinlock.h>
57#include <linux/jhash.h>
Steven Whitehouse1e3d3622014-01-15 12:57:25 +000058#include <linux/vmalloc.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000059
60#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050061#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000062#include "bmap.h"
63#include "glock.h"
64#include "glops.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000065#include "log.h"
66#include "meta_io.h"
67#include "quota.h"
68#include "rgrp.h"
69#include "super.h"
70#include "trans.h"
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000071#include "inode.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050072#include "util.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000073
Steven Whitehousec754fbb2013-12-12 10:47:59 +000074#define GFS2_QD_HASH_SHIFT 12
Fabian Frederick47a9a522016-08-02 12:05:27 -050075#define GFS2_QD_HASH_SIZE BIT(GFS2_QD_HASH_SHIFT)
Steven Whitehousec754fbb2013-12-12 10:47:59 +000076#define GFS2_QD_HASH_MASK (GFS2_QD_HASH_SIZE - 1)
77
78/* Lock order: qd_lock -> bucket lock -> qd->lockref.lock -> lru lock */
Steven Whitehouse2d9e7232013-12-13 11:46:28 +000079/* -> sd_bitmap_lock */
Steven Whitehouse7d808232013-11-01 14:52:08 -040080static DEFINE_SPINLOCK(qd_lock);
Steven Whitehouse2147dbf2013-11-04 10:15:08 +000081struct list_lru gfs2_qd_lru;
Abhijith Das0a7ab792009-01-07 16:03:37 -060082
Steven Whitehousec754fbb2013-12-12 10:47:59 +000083static struct hlist_bl_head qd_hash_table[GFS2_QD_HASH_SIZE];
84
85static unsigned int gfs2_qd_hash(const struct gfs2_sbd *sdp,
86 const struct kqid qid)
87{
88 unsigned int h;
89
90 h = jhash(&sdp, sizeof(struct gfs2_sbd *), 0);
91 h = jhash(&qid, sizeof(struct kqid), h);
92
93 return h & GFS2_QD_HASH_MASK;
94}
95
96static inline void spin_lock_bucket(unsigned int hash)
97{
98 hlist_bl_lock(&qd_hash_table[hash]);
99}
100
101static inline void spin_unlock_bucket(unsigned int hash)
102{
103 hlist_bl_unlock(&qd_hash_table[hash]);
104}
105
106static void gfs2_qd_dealloc(struct rcu_head *rcu)
107{
108 struct gfs2_quota_data *qd = container_of(rcu, struct gfs2_quota_data, qd_rcu);
109 kmem_cache_free(gfs2_quotad_cachep, qd);
110}
111
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000112static void gfs2_qd_dispose(struct list_head *list)
Abhijith Das0a7ab792009-01-07 16:03:37 -0600113{
114 struct gfs2_quota_data *qd;
115 struct gfs2_sbd *sdp;
Abhijith Das0a7ab792009-01-07 16:03:37 -0600116
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000117 while (!list_empty(list)) {
118 qd = list_entry(list->next, struct gfs2_quota_data, qd_lru);
Bob Peterson15562c42015-03-16 11:52:05 -0500119 sdp = qd->qd_gl->gl_name.ln_sbd;
Abhijith Das0a7ab792009-01-07 16:03:37 -0600120
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000121 list_del(&qd->qd_lru);
122
Abhijith Das0a7ab792009-01-07 16:03:37 -0600123 /* Free from the filesystem-specific list */
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000124 spin_lock(&qd_lock);
Abhijith Das0a7ab792009-01-07 16:03:37 -0600125 list_del(&qd->qd_list);
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000126 spin_unlock(&qd_lock);
Abhijith Das0a7ab792009-01-07 16:03:37 -0600127
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000128 spin_lock_bucket(qd->qd_hash);
129 hlist_bl_del_rcu(&qd->qd_hlist);
130 spin_unlock_bucket(qd->qd_hash);
131
Abhijith Das0a7ab792009-01-07 16:03:37 -0600132 gfs2_assert_warn(sdp, !qd->qd_change);
133 gfs2_assert_warn(sdp, !qd->qd_slot_count);
134 gfs2_assert_warn(sdp, !qd->qd_bh_count);
135
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000136 gfs2_glock_put(qd->qd_gl);
Abhijith Das0a7ab792009-01-07 16:03:37 -0600137 atomic_dec(&sdp->sd_quota_count);
138
139 /* Delete it from the common reclaim list */
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000140 call_rcu(&qd->qd_rcu, gfs2_qd_dealloc);
Abhijith Das0a7ab792009-01-07 16:03:37 -0600141 }
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000142}
143
144
Vladimir Davydov3f97b162015-02-12 14:59:35 -0800145static enum lru_status gfs2_qd_isolate(struct list_head *item,
146 struct list_lru_one *lru, spinlock_t *lru_lock, void *arg)
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000147{
148 struct list_head *dispose = arg;
149 struct gfs2_quota_data *qd = list_entry(item, struct gfs2_quota_data, qd_lru);
150
151 if (!spin_trylock(&qd->qd_lockref.lock))
152 return LRU_SKIP;
153
154 if (qd->qd_lockref.count == 0) {
155 lockref_mark_dead(&qd->qd_lockref);
Vladimir Davydov3f97b162015-02-12 14:59:35 -0800156 list_lru_isolate_move(lru, &qd->qd_lru, dispose);
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000157 }
158
159 spin_unlock(&qd->qd_lockref.lock);
160 return LRU_REMOVED;
161}
162
163static unsigned long gfs2_qd_shrink_scan(struct shrinker *shrink,
164 struct shrink_control *sc)
165{
166 LIST_HEAD(dispose);
167 unsigned long freed;
168
169 if (!(sc->gfp_mask & __GFP_FS))
170 return SHRINK_STOP;
171
Vladimir Davydov503c3582015-02-12 14:58:47 -0800172 freed = list_lru_shrink_walk(&gfs2_qd_lru, sc,
173 gfs2_qd_isolate, &dispose);
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000174
175 gfs2_qd_dispose(&dispose);
176
Dave Chinner1ab6c492013-08-28 10:18:09 +1000177 return freed;
178}
Abhijith Das0a7ab792009-01-07 16:03:37 -0600179
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000180static unsigned long gfs2_qd_shrink_count(struct shrinker *shrink,
181 struct shrink_control *sc)
Dave Chinner1ab6c492013-08-28 10:18:09 +1000182{
Vladimir Davydov503c3582015-02-12 14:58:47 -0800183 return vfs_pressure_ratio(list_lru_shrink_count(&gfs2_qd_lru, sc));
Abhijith Das0a7ab792009-01-07 16:03:37 -0600184}
185
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000186struct shrinker gfs2_qd_shrinker = {
187 .count_objects = gfs2_qd_shrink_count,
188 .scan_objects = gfs2_qd_shrink_scan,
189 .seeks = DEFAULT_SEEKS,
190 .flags = SHRINKER_NUMA_AWARE,
191};
192
193
Eric W. Biederman2f6c9892013-01-31 18:33:38 -0800194static u64 qd2index(struct gfs2_quota_data *qd)
195{
Eric W. Biederman05e0a602013-01-31 19:52:08 -0800196 struct kqid qid = qd->qd_id;
197 return (2 * (u64)from_kqid(&init_user_ns, qid)) +
Bob Peterson37f71572013-05-10 11:59:18 -0400198 ((qid.type == USRQUOTA) ? 0 : 1);
Eric W. Biederman2f6c9892013-01-31 18:33:38 -0800199}
200
Steven Whitehousecd915492006-09-04 12:49:07 -0400201static u64 qd2offset(struct gfs2_quota_data *qd)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000202{
Steven Whitehousecd915492006-09-04 12:49:07 -0400203 u64 offset;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000204
Eric W. Biederman2f6c9892013-01-31 18:33:38 -0800205 offset = qd2index(qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000206 offset *= sizeof(struct gfs2_quota);
207
208 return offset;
209}
210
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000211static struct gfs2_quota_data *qd_alloc(unsigned hash, struct gfs2_sbd *sdp, struct kqid qid)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000212{
213 struct gfs2_quota_data *qd;
214 int error;
215
Steven Whitehouse37b2c832008-11-17 14:25:37 +0000216 qd = kmem_cache_zalloc(gfs2_quotad_cachep, GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000217 if (!qd)
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000218 return NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000219
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000220 qd->qd_sbd = sdp;
Steven Whitehouse9b9f0392013-11-01 14:52:06 -0400221 qd->qd_lockref.count = 1;
222 spin_lock_init(&qd->qd_lockref.lock);
Eric W. Biederman05e0a602013-01-31 19:52:08 -0800223 qd->qd_id = qid;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000224 qd->qd_slot = -1;
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000225 INIT_LIST_HEAD(&qd->qd_lru);
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000226 qd->qd_hash = hash;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000227
Eric W. Biederman2f6c9892013-01-31 18:33:38 -0800228 error = gfs2_glock_get(sdp, qd2index(qd),
David Teiglandb3b94fa2006-01-16 16:50:04 +0000229 &gfs2_quota_glops, CREATE, &qd->qd_gl);
230 if (error)
231 goto fail;
232
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000233 return qd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000234
Steven Whitehousea91ea692006-09-04 12:04:26 -0400235fail:
Steven Whitehouse37b2c832008-11-17 14:25:37 +0000236 kmem_cache_free(gfs2_quotad_cachep, qd);
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000237 return NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000238}
239
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000240static struct gfs2_quota_data *gfs2_qd_search_bucket(unsigned int hash,
241 const struct gfs2_sbd *sdp,
242 struct kqid qid)
243{
244 struct gfs2_quota_data *qd;
245 struct hlist_bl_node *h;
246
247 hlist_bl_for_each_entry_rcu(qd, h, &qd_hash_table[hash], qd_hlist) {
248 if (!qid_eq(qd->qd_id, qid))
249 continue;
250 if (qd->qd_sbd != sdp)
251 continue;
252 if (lockref_get_not_dead(&qd->qd_lockref)) {
253 list_lru_del(&gfs2_qd_lru, &qd->qd_lru);
254 return qd;
255 }
256 }
257
258 return NULL;
259}
260
261
Eric W. Biederman05e0a602013-01-31 19:52:08 -0800262static int qd_get(struct gfs2_sbd *sdp, struct kqid qid,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000263 struct gfs2_quota_data **qdp)
264{
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000265 struct gfs2_quota_data *qd, *new_qd;
266 unsigned int hash = gfs2_qd_hash(sdp, qid);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000267
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000268 rcu_read_lock();
269 *qdp = qd = gfs2_qd_search_bucket(hash, sdp, qid);
270 rcu_read_unlock();
David Teiglandb3b94fa2006-01-16 16:50:04 +0000271
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000272 if (qd)
273 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000274
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000275 new_qd = qd_alloc(hash, sdp, qid);
276 if (!new_qd)
277 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000278
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000279 spin_lock(&qd_lock);
280 spin_lock_bucket(hash);
281 *qdp = qd = gfs2_qd_search_bucket(hash, sdp, qid);
282 if (qd == NULL) {
283 *qdp = new_qd;
284 list_add(&new_qd->qd_list, &sdp->sd_quota_list);
285 hlist_bl_add_head_rcu(&new_qd->qd_hlist, &qd_hash_table[hash]);
286 atomic_inc(&sdp->sd_quota_count);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000287 }
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000288 spin_unlock_bucket(hash);
289 spin_unlock(&qd_lock);
290
291 if (qd) {
292 gfs2_glock_put(new_qd->qd_gl);
293 kmem_cache_free(gfs2_quotad_cachep, new_qd);
294 }
295
296 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000297}
298
Steven Whitehousec754fbb2013-12-12 10:47:59 +0000299
David Teiglandb3b94fa2006-01-16 16:50:04 +0000300static void qd_hold(struct gfs2_quota_data *qd)
301{
Bob Peterson15562c42015-03-16 11:52:05 -0500302 struct gfs2_sbd *sdp = qd->qd_gl->gl_name.ln_sbd;
Steven Whitehouse9b9f0392013-11-01 14:52:06 -0400303 gfs2_assert(sdp, !__lockref_is_dead(&qd->qd_lockref));
304 lockref_get(&qd->qd_lockref);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000305}
306
307static void qd_put(struct gfs2_quota_data *qd)
308{
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000309 if (lockref_put_or_lock(&qd->qd_lockref))
310 return;
Steven Whitehouse9b9f0392013-11-01 14:52:06 -0400311
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000312 qd->qd_lockref.count = 0;
313 list_lru_add(&gfs2_qd_lru, &qd->qd_lru);
314 spin_unlock(&qd->qd_lockref.lock);
Steven Whitehouse9b9f0392013-11-01 14:52:06 -0400315
David Teiglandb3b94fa2006-01-16 16:50:04 +0000316}
317
318static int slot_get(struct gfs2_quota_data *qd)
319{
Steven Whitehouseee2411a2013-12-12 17:29:32 +0000320 struct gfs2_sbd *sdp = qd->qd_sbd;
321 unsigned int bit;
322 int error = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000323
Steven Whitehouse2d9e7232013-12-13 11:46:28 +0000324 spin_lock(&sdp->sd_bitmap_lock);
Steven Whitehouseee2411a2013-12-12 17:29:32 +0000325 if (qd->qd_slot_count != 0)
326 goto out;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000327
Steven Whitehouseee2411a2013-12-12 17:29:32 +0000328 error = -ENOSPC;
329 bit = find_first_zero_bit(sdp->sd_quota_bitmap, sdp->sd_quota_slots);
330 if (bit < sdp->sd_quota_slots) {
331 set_bit(bit, sdp->sd_quota_bitmap);
332 qd->qd_slot = bit;
Abhi Dase9fb7c72014-03-31 01:19:29 -0500333 error = 0;
Steven Whitehouseee2411a2013-12-12 17:29:32 +0000334out:
335 qd->qd_slot_count++;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000336 }
Steven Whitehouse2d9e7232013-12-13 11:46:28 +0000337 spin_unlock(&sdp->sd_bitmap_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000338
Steven Whitehouseee2411a2013-12-12 17:29:32 +0000339 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000340}
341
342static void slot_hold(struct gfs2_quota_data *qd)
343{
Steven Whitehouseee2411a2013-12-12 17:29:32 +0000344 struct gfs2_sbd *sdp = qd->qd_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000345
Steven Whitehouse2d9e7232013-12-13 11:46:28 +0000346 spin_lock(&sdp->sd_bitmap_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000347 gfs2_assert(sdp, qd->qd_slot_count);
348 qd->qd_slot_count++;
Steven Whitehouse2d9e7232013-12-13 11:46:28 +0000349 spin_unlock(&sdp->sd_bitmap_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000350}
351
352static void slot_put(struct gfs2_quota_data *qd)
353{
Steven Whitehouseee2411a2013-12-12 17:29:32 +0000354 struct gfs2_sbd *sdp = qd->qd_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000355
Steven Whitehouse2d9e7232013-12-13 11:46:28 +0000356 spin_lock(&sdp->sd_bitmap_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000357 gfs2_assert(sdp, qd->qd_slot_count);
358 if (!--qd->qd_slot_count) {
Steven Whitehouseee2411a2013-12-12 17:29:32 +0000359 BUG_ON(!test_and_clear_bit(qd->qd_slot, sdp->sd_quota_bitmap));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000360 qd->qd_slot = -1;
361 }
Steven Whitehouse2d9e7232013-12-13 11:46:28 +0000362 spin_unlock(&sdp->sd_bitmap_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000363}
364
365static int bh_get(struct gfs2_quota_data *qd)
366{
Bob Peterson15562c42015-03-16 11:52:05 -0500367 struct gfs2_sbd *sdp = qd->qd_gl->gl_name.ln_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400368 struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000369 unsigned int block, offset;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000370 struct buffer_head *bh;
371 int error;
Steven Whitehouse23591252006-10-13 17:25:45 -0400372 struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
David Teiglandb3b94fa2006-01-16 16:50:04 +0000373
Steven Whitehousef55ab262006-02-21 12:51:39 +0000374 mutex_lock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000375
376 if (qd->qd_bh_count++) {
Steven Whitehousef55ab262006-02-21 12:51:39 +0000377 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000378 return 0;
379 }
380
381 block = qd->qd_slot / sdp->sd_qc_per_block;
Bob Peterson0d0868b2007-12-11 18:51:25 -0600382 offset = qd->qd_slot % sdp->sd_qc_per_block;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000383
Fabian Frederick47a9a522016-08-02 12:05:27 -0500384 bh_map.b_size = BIT(ip->i_inode.i_blkbits);
Bob Petersone9e1ef22007-12-10 14:13:27 -0600385 error = gfs2_block_map(&ip->i_inode, block, &bh_map, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000386 if (error)
387 goto fail;
Andreas Gruenbacherc8d57702015-11-11 15:00:35 -0600388 error = gfs2_meta_read(ip->i_gl, bh_map.b_blocknr, DIO_WAIT, 0, &bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000389 if (error)
390 goto fail;
391 error = -EIO;
392 if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC))
393 goto fail_brelse;
394
395 qd->qd_bh = bh;
396 qd->qd_bh_qc = (struct gfs2_quota_change *)
397 (bh->b_data + sizeof(struct gfs2_meta_header) +
398 offset * sizeof(struct gfs2_quota_change));
399
Josef Whiter2e95b662007-02-20 00:03:29 -0500400 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000401
402 return 0;
403
Steven Whitehousea91ea692006-09-04 12:04:26 -0400404fail_brelse:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000405 brelse(bh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400406fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000407 qd->qd_bh_count--;
Steven Whitehousef55ab262006-02-21 12:51:39 +0000408 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000409 return error;
410}
411
412static void bh_put(struct gfs2_quota_data *qd)
413{
Bob Peterson15562c42015-03-16 11:52:05 -0500414 struct gfs2_sbd *sdp = qd->qd_gl->gl_name.ln_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000415
Steven Whitehousef55ab262006-02-21 12:51:39 +0000416 mutex_lock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000417 gfs2_assert(sdp, qd->qd_bh_count);
418 if (!--qd->qd_bh_count) {
419 brelse(qd->qd_bh);
420 qd->qd_bh = NULL;
421 qd->qd_bh_qc = NULL;
422 }
Steven Whitehousef55ab262006-02-21 12:51:39 +0000423 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000424}
425
Steven Whitehouse1bf59bf2013-10-04 11:14:46 +0100426static int qd_check_sync(struct gfs2_sbd *sdp, struct gfs2_quota_data *qd,
427 u64 *sync_gen)
428{
429 if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
430 !test_bit(QDF_CHANGE, &qd->qd_flags) ||
431 (sync_gen && (qd->qd_sync_gen >= *sync_gen)))
432 return 0;
433
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000434 if (!lockref_get_not_dead(&qd->qd_lockref))
435 return 0;
Steven Whitehouse1bf59bf2013-10-04 11:14:46 +0100436
Steven Whitehouse2147dbf2013-11-04 10:15:08 +0000437 list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
Steven Whitehouse1bf59bf2013-10-04 11:14:46 +0100438 set_bit(QDF_LOCKED, &qd->qd_flags);
Steven Whitehouse1bf59bf2013-10-04 11:14:46 +0100439 qd->qd_change_sync = qd->qd_change;
Steven Whitehouse2d9e7232013-12-13 11:46:28 +0000440 slot_hold(qd);
Steven Whitehouse1bf59bf2013-10-04 11:14:46 +0100441 return 1;
442}
443
David Teiglandb3b94fa2006-01-16 16:50:04 +0000444static int qd_fish(struct gfs2_sbd *sdp, struct gfs2_quota_data **qdp)
445{
446 struct gfs2_quota_data *qd = NULL;
447 int error;
448 int found = 0;
449
450 *qdp = NULL;
451
David Howellsbc98a422017-07-17 08:45:34 +0100452 if (sb_rdonly(sdp->sd_vfs))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000453 return 0;
454
Steven Whitehouse7d808232013-11-01 14:52:08 -0400455 spin_lock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000456
457 list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
Steven Whitehouse1bf59bf2013-10-04 11:14:46 +0100458 found = qd_check_sync(sdp, qd, &sdp->sd_quota_sync_gen);
459 if (found)
460 break;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000461 }
462
463 if (!found)
464 qd = NULL;
465
Steven Whitehouse7d808232013-11-01 14:52:08 -0400466 spin_unlock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000467
468 if (qd) {
469 gfs2_assert_warn(sdp, qd->qd_change_sync);
470 error = bh_get(qd);
471 if (error) {
472 clear_bit(QDF_LOCKED, &qd->qd_flags);
473 slot_put(qd);
474 qd_put(qd);
475 return error;
476 }
477 }
478
479 *qdp = qd;
480
481 return 0;
482}
483
David Teiglandb3b94fa2006-01-16 16:50:04 +0000484static void qd_unlock(struct gfs2_quota_data *qd)
485{
Bob Peterson15562c42015-03-16 11:52:05 -0500486 gfs2_assert_warn(qd->qd_gl->gl_name.ln_sbd,
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500487 test_bit(QDF_LOCKED, &qd->qd_flags));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000488 clear_bit(QDF_LOCKED, &qd->qd_flags);
489 bh_put(qd);
490 slot_put(qd);
491 qd_put(qd);
492}
493
Eric W. Biedermanb59c8b62013-01-31 19:35:56 -0800494static int qdsb_get(struct gfs2_sbd *sdp, struct kqid qid,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000495 struct gfs2_quota_data **qdp)
496{
497 int error;
498
Eric W. Biederman05e0a602013-01-31 19:52:08 -0800499 error = qd_get(sdp, qid, qdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000500 if (error)
501 return error;
502
503 error = slot_get(*qdp);
504 if (error)
505 goto fail;
506
507 error = bh_get(*qdp);
508 if (error)
509 goto fail_slot;
510
511 return 0;
512
Steven Whitehousea91ea692006-09-04 12:04:26 -0400513fail_slot:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000514 slot_put(*qdp);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400515fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000516 qd_put(*qdp);
517 return error;
518}
519
520static void qdsb_put(struct gfs2_quota_data *qd)
521{
522 bh_put(qd);
523 slot_put(qd);
524 qd_put(qd);
525}
526
Bob Petersonb54e9a02015-10-26 10:40:28 -0500527/**
528 * gfs2_qa_alloc - make sure we have a quota allocations data structure,
529 * if necessary
530 * @ip: the inode for this reservation
531 */
532int gfs2_qa_alloc(struct gfs2_inode *ip)
533{
534 int error = 0;
535 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
536
537 if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
538 return 0;
539
540 down_write(&ip->i_rw_mutex);
541 if (ip->i_qadata == NULL) {
542 ip->i_qadata = kmem_cache_zalloc(gfs2_qadata_cachep, GFP_NOFS);
543 if (!ip->i_qadata)
544 error = -ENOMEM;
545 }
546 up_write(&ip->i_rw_mutex);
547 return error;
548}
549
Bob Petersona097dc7e2015-07-16 08:28:04 -0500550void gfs2_qa_delete(struct gfs2_inode *ip, atomic_t *wcount)
Bob Petersonb54e9a02015-10-26 10:40:28 -0500551{
552 down_write(&ip->i_rw_mutex);
Bob Petersona097dc7e2015-07-16 08:28:04 -0500553 if (ip->i_qadata && ((wcount == NULL) || (atomic_read(wcount) <= 1))) {
Bob Petersonb54e9a02015-10-26 10:40:28 -0500554 kmem_cache_free(gfs2_qadata_cachep, ip->i_qadata);
555 ip->i_qadata = NULL;
556 }
557 up_write(&ip->i_rw_mutex);
558}
559
Eric W. Biederman7c06b5d2013-01-31 20:27:54 -0800560int gfs2_quota_hold(struct gfs2_inode *ip, kuid_t uid, kgid_t gid)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000561{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400562 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Bob Peterson5407e242012-05-18 09:28:23 -0400563 struct gfs2_quota_data **qd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000564 int error;
565
Bob Petersonb54e9a02015-10-26 10:40:28 -0500566 if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
567 return 0;
568
569 if (ip->i_qadata == NULL) {
570 error = gfs2_rsqa_alloc(ip);
Andrew Priceaaaf68c2012-10-12 16:45:08 +0100571 if (error)
572 return error;
573 }
Bob Peterson5407e242012-05-18 09:28:23 -0400574
Bob Petersonb54e9a02015-10-26 10:40:28 -0500575 qd = ip->i_qadata->qa_qd;
Bob Peterson5407e242012-05-18 09:28:23 -0400576
Bob Petersonb54e9a02015-10-26 10:40:28 -0500577 if (gfs2_assert_warn(sdp, !ip->i_qadata->qa_qd_num) ||
David Teiglandb3b94fa2006-01-16 16:50:04 +0000578 gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags)))
579 return -EIO;
580
Eric W. Biedermanb59c8b62013-01-31 19:35:56 -0800581 error = qdsb_get(sdp, make_kqid_uid(ip->i_inode.i_uid), qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000582 if (error)
583 goto out;
Bob Petersonb54e9a02015-10-26 10:40:28 -0500584 ip->i_qadata->qa_qd_num++;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000585 qd++;
586
Eric W. Biedermanb59c8b62013-01-31 19:35:56 -0800587 error = qdsb_get(sdp, make_kqid_gid(ip->i_inode.i_gid), qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000588 if (error)
589 goto out;
Bob Petersonb54e9a02015-10-26 10:40:28 -0500590 ip->i_qadata->qa_qd_num++;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000591 qd++;
592
Eric W. Biederman6b24c0d2013-01-31 21:56:13 -0800593 if (!uid_eq(uid, NO_UID_QUOTA_CHANGE) &&
594 !uid_eq(uid, ip->i_inode.i_uid)) {
Eric W. Biedermanb59c8b62013-01-31 19:35:56 -0800595 error = qdsb_get(sdp, make_kqid_uid(uid), qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000596 if (error)
597 goto out;
Bob Petersonb54e9a02015-10-26 10:40:28 -0500598 ip->i_qadata->qa_qd_num++;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000599 qd++;
600 }
601
Eric W. Biederman6b24c0d2013-01-31 21:56:13 -0800602 if (!gid_eq(gid, NO_GID_QUOTA_CHANGE) &&
603 !gid_eq(gid, ip->i_inode.i_gid)) {
Eric W. Biedermanb59c8b62013-01-31 19:35:56 -0800604 error = qdsb_get(sdp, make_kqid_gid(gid), qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000605 if (error)
606 goto out;
Bob Petersonb54e9a02015-10-26 10:40:28 -0500607 ip->i_qadata->qa_qd_num++;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000608 qd++;
609 }
610
Steven Whitehousea91ea692006-09-04 12:04:26 -0400611out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000612 if (error)
613 gfs2_quota_unhold(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000614 return error;
615}
616
617void gfs2_quota_unhold(struct gfs2_inode *ip)
618{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400619 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Bob Petersonb58bf402015-07-24 09:45:43 -0500620 u32 x;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000621
Bob Petersonb54e9a02015-10-26 10:40:28 -0500622 if (ip->i_qadata == NULL)
Bob Peterson5407e242012-05-18 09:28:23 -0400623 return;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000624 gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags));
625
Bob Petersonb54e9a02015-10-26 10:40:28 -0500626 for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
627 qdsb_put(ip->i_qadata->qa_qd[x]);
628 ip->i_qadata->qa_qd[x] = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000629 }
Bob Petersonb54e9a02015-10-26 10:40:28 -0500630 ip->i_qadata->qa_qd_num = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000631}
632
633static int sort_qd(const void *a, const void *b)
634{
Steven Whitehouse48fac172006-09-05 15:17:12 -0400635 const struct gfs2_quota_data *qd_a = *(const struct gfs2_quota_data **)a;
636 const struct gfs2_quota_data *qd_b = *(const struct gfs2_quota_data **)b;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000637
Eric W. Biederman05e0a602013-01-31 19:52:08 -0800638 if (qid_lt(qd_a->qd_id, qd_b->qd_id))
Steven Whitehouse48fac172006-09-05 15:17:12 -0400639 return -1;
Eric W. Biederman05e0a602013-01-31 19:52:08 -0800640 if (qid_lt(qd_b->qd_id, qd_a->qd_id))
Steven Whitehouse48fac172006-09-05 15:17:12 -0400641 return 1;
Steven Whitehouse48fac172006-09-05 15:17:12 -0400642 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000643}
644
Steven Whitehousecd915492006-09-04 12:49:07 -0400645static void do_qc(struct gfs2_quota_data *qd, s64 change)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000646{
Bob Peterson15562c42015-03-16 11:52:05 -0500647 struct gfs2_sbd *sdp = qd->qd_gl->gl_name.ln_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400648 struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000649 struct gfs2_quota_change *qc = qd->qd_bh_qc;
Steven Whitehousecd915492006-09-04 12:49:07 -0400650 s64 x;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000651
Steven Whitehousef55ab262006-02-21 12:51:39 +0000652 mutex_lock(&sdp->sd_quota_mutex);
Steven Whitehouse350a9b02012-12-14 12:36:02 +0000653 gfs2_trans_add_meta(ip->i_gl, qd->qd_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000654
655 if (!test_bit(QDF_CHANGE, &qd->qd_flags)) {
656 qc->qc_change = 0;
657 qc->qc_flags = 0;
Eric W. Biederman05e0a602013-01-31 19:52:08 -0800658 if (qd->qd_id.type == USRQUOTA)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000659 qc->qc_flags = cpu_to_be32(GFS2_QCF_USER);
Eric W. Biederman05e0a602013-01-31 19:52:08 -0800660 qc->qc_id = cpu_to_be32(from_kqid(&init_user_ns, qd->qd_id));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000661 }
662
Al Virob44b84d2006-10-14 10:46:30 -0400663 x = be64_to_cpu(qc->qc_change) + change;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000664 qc->qc_change = cpu_to_be64(x);
665
Steven Whitehouse7d808232013-11-01 14:52:08 -0400666 spin_lock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000667 qd->qd_change = x;
Steven Whitehouse7d808232013-11-01 14:52:08 -0400668 spin_unlock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000669
670 if (!x) {
671 gfs2_assert_warn(sdp, test_bit(QDF_CHANGE, &qd->qd_flags));
672 clear_bit(QDF_CHANGE, &qd->qd_flags);
673 qc->qc_flags = 0;
674 qc->qc_id = 0;
675 slot_put(qd);
676 qd_put(qd);
677 } else if (!test_and_set_bit(QDF_CHANGE, &qd->qd_flags)) {
678 qd_hold(qd);
679 slot_hold(qd);
680 }
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400681
Abhi Das9cde2892015-06-02 11:03:04 -0500682 if (change < 0) /* Reset quiet flag if we freed some blocks */
683 clear_bit(QDF_QMSG_QUIET, &qd->qd_flags);
Steven Whitehousef55ab262006-02-21 12:51:39 +0000684 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000685}
686
Abhi Das39a72582015-06-02 11:02:24 -0500687static int gfs2_write_buf_to_page(struct gfs2_inode *ip, unsigned long index,
688 unsigned off, void *buf, unsigned bytes)
689{
690 struct inode *inode = &ip->i_inode;
691 struct gfs2_sbd *sdp = GFS2_SB(inode);
692 struct address_space *mapping = inode->i_mapping;
693 struct page *page;
694 struct buffer_head *bh;
695 void *kaddr;
696 u64 blk;
697 unsigned bsize = sdp->sd_sb.sb_bsize, bnum = 0, boff = 0;
698 unsigned to_write = bytes, pg_off = off;
699 int done = 0;
700
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300701 blk = index << (PAGE_SHIFT - sdp->sd_sb.sb_bsize_shift);
Abhi Das39a72582015-06-02 11:02:24 -0500702 boff = off % bsize;
703
704 page = find_or_create_page(mapping, index, GFP_NOFS);
705 if (!page)
706 return -ENOMEM;
707 if (!page_has_buffers(page))
708 create_empty_buffers(page, bsize, 0);
709
710 bh = page_buffers(page);
711 while (!done) {
712 /* Find the beginning block within the page */
713 if (pg_off >= ((bnum * bsize) + bsize)) {
714 bh = bh->b_this_page;
715 bnum++;
716 blk++;
717 continue;
718 }
719 if (!buffer_mapped(bh)) {
720 gfs2_block_map(inode, blk, bh, 1);
721 if (!buffer_mapped(bh))
722 goto unlock_out;
723 /* If it's a newly allocated disk block, zero it */
724 if (buffer_new(bh))
725 zero_user(page, bnum * bsize, bh->b_size);
726 }
727 if (PageUptodate(page))
728 set_buffer_uptodate(bh);
729 if (!buffer_uptodate(bh)) {
Coly Lie477b242017-07-21 07:48:22 -0500730 ll_rw_block(REQ_OP_READ, REQ_META | REQ_PRIO, 1, &bh);
Abhi Das39a72582015-06-02 11:02:24 -0500731 wait_on_buffer(bh);
732 if (!buffer_uptodate(bh))
733 goto unlock_out;
734 }
Andreas Gruenbacher845802b2018-06-04 07:50:16 -0500735 if (gfs2_is_jdata(ip))
736 gfs2_trans_add_data(ip->i_gl, bh);
737 else
738 gfs2_ordered_add_inode(ip);
Abhi Das39a72582015-06-02 11:02:24 -0500739
740 /* If we need to write to the next block as well */
741 if (to_write > (bsize - boff)) {
742 pg_off += (bsize - boff);
743 to_write -= (bsize - boff);
744 boff = pg_off % bsize;
745 continue;
746 }
747 done = 1;
748 }
749
750 /* Write to the page, now that we have setup the buffer(s) */
751 kaddr = kmap_atomic(page);
752 memcpy(kaddr + off, buf, bytes);
753 flush_dcache_page(page);
754 kunmap_atomic(kaddr);
755 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300756 put_page(page);
Abhi Das39a72582015-06-02 11:02:24 -0500757
758 return 0;
759
760unlock_out:
761 unlock_page(page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300762 put_page(page);
Abhi Das39a72582015-06-02 11:02:24 -0500763 return -EIO;
764}
765
766static int gfs2_write_disk_quota(struct gfs2_inode *ip, struct gfs2_quota *qp,
767 loff_t loc)
768{
769 unsigned long pg_beg;
770 unsigned pg_off, nbytes, overflow = 0;
771 int pg_oflow = 0, error;
772 void *ptr;
773
774 nbytes = sizeof(struct gfs2_quota);
775
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300776 pg_beg = loc >> PAGE_SHIFT;
Andreas Gruenbacher45eb0502019-09-02 17:31:06 +0100777 pg_off = offset_in_page(loc);
Abhi Das39a72582015-06-02 11:02:24 -0500778
779 /* If the quota straddles a page boundary, split the write in two */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300780 if ((pg_off + nbytes) > PAGE_SIZE) {
Abhi Das39a72582015-06-02 11:02:24 -0500781 pg_oflow = 1;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300782 overflow = (pg_off + nbytes) - PAGE_SIZE;
Abhi Das39a72582015-06-02 11:02:24 -0500783 }
784
785 ptr = qp;
786 error = gfs2_write_buf_to_page(ip, pg_beg, pg_off, ptr,
787 nbytes - overflow);
788 /* If there's an overflow, write the remaining bytes to the next page */
789 if (!error && pg_oflow)
790 error = gfs2_write_buf_to_page(ip, pg_beg + 1, 0,
791 ptr + nbytes - overflow,
792 overflow);
793 return error;
794}
795
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000796/**
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100797 * gfs2_adjust_quota - adjust record of current block usage
798 * @ip: The quota inode
799 * @loc: Offset of the entry in the quota file
Steven Whitehousee285c102009-09-23 13:50:49 +0100800 * @change: The amount of usage change to record
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100801 * @qd: The quota data
Steven Whitehousee285c102009-09-23 13:50:49 +0100802 * @fdq: The updated limits to record
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000803 *
804 * This function was mostly borrowed from gfs2_block_truncate_page which was
805 * in turn mostly borrowed from ext3
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100806 *
807 * Returns: 0 or -ve on error
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000808 */
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100809
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000810static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
Steven Whitehousee285c102009-09-23 13:50:49 +0100811 s64 change, struct gfs2_quota_data *qd,
Jan Kara14bf61f2014-10-09 16:03:13 +0200812 struct qc_dqblk *fdq)
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000813{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400814 struct inode *inode = &ip->i_inode;
Abhijith Das14870b42010-11-18 11:24:24 -0500815 struct gfs2_sbd *sdp = GFS2_SB(inode);
Al Viro951b4bd2013-06-02 19:53:40 -0400816 struct gfs2_quota q;
Abhi Das39a72582015-06-02 11:02:24 -0500817 int err;
Steven Whitehousee285c102009-09-23 13:50:49 +0100818 u64 size;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000819
Steven Whitehouse891a8e92011-09-19 10:25:49 +0100820 if (gfs2_is_stuffed(ip)) {
821 err = gfs2_unstuff_dinode(ip, NULL);
822 if (err)
823 return err;
824 }
Abhijith Das7e619bc2010-05-07 17:50:18 -0400825
826 memset(&q, 0, sizeof(struct gfs2_quota));
Andrew Price43066292012-04-16 16:40:55 +0100827 err = gfs2_internal_read(ip, (char *)&q, &loc, sizeof(q));
Abhijith Das7e619bc2010-05-07 17:50:18 -0400828 if (err < 0)
829 return err;
830
Abhi Das39a72582015-06-02 11:02:24 -0500831 loc -= sizeof(q); /* gfs2_internal_read would've advanced the loc ptr */
Abhijith Das7e619bc2010-05-07 17:50:18 -0400832 err = -EIO;
Al Viro951b4bd2013-06-02 19:53:40 -0400833 be64_add_cpu(&q.qu_value, change);
Abhi Das1bdf4532015-06-08 11:20:50 -0500834 if (((s64)be64_to_cpu(q.qu_value)) < 0)
Abhi Das39a72582015-06-02 11:02:24 -0500835 q.qu_value = 0; /* Never go negative on quota usage */
Al Viro951b4bd2013-06-02 19:53:40 -0400836 qd->qd_qb.qb_value = q.qu_value;
Abhijith Das7e619bc2010-05-07 17:50:18 -0400837 if (fdq) {
Jan Kara14bf61f2014-10-09 16:03:13 +0200838 if (fdq->d_fieldmask & QC_SPC_SOFT) {
839 q.qu_warn = cpu_to_be64(fdq->d_spc_softlimit >> sdp->sd_sb.sb_bsize_shift);
Al Viro951b4bd2013-06-02 19:53:40 -0400840 qd->qd_qb.qb_warn = q.qu_warn;
Abhijith Das7e619bc2010-05-07 17:50:18 -0400841 }
Jan Kara14bf61f2014-10-09 16:03:13 +0200842 if (fdq->d_fieldmask & QC_SPC_HARD) {
843 q.qu_limit = cpu_to_be64(fdq->d_spc_hardlimit >> sdp->sd_sb.sb_bsize_shift);
Al Viro951b4bd2013-06-02 19:53:40 -0400844 qd->qd_qb.qb_limit = q.qu_limit;
Abhijith Das7e619bc2010-05-07 17:50:18 -0400845 }
Jan Kara14bf61f2014-10-09 16:03:13 +0200846 if (fdq->d_fieldmask & QC_SPACE) {
847 q.qu_value = cpu_to_be64(fdq->d_space >> sdp->sd_sb.sb_bsize_shift);
Al Viro951b4bd2013-06-02 19:53:40 -0400848 qd->qd_qb.qb_value = q.qu_value;
Abhijith Das802ec9b2010-11-18 11:26:46 -0500849 }
Abhijith Das7e619bc2010-05-07 17:50:18 -0400850 }
851
Abhi Das39a72582015-06-02 11:02:24 -0500852 err = gfs2_write_disk_quota(ip, &q, loc);
853 if (!err) {
854 size = loc + sizeof(struct gfs2_quota);
855 if (size > inode->i_size)
856 i_size_write(inode, size);
Deepa Dinamani078cd822016-09-14 07:48:04 -0700857 inode->i_mtime = inode->i_atime = current_time(inode);
Abhi Das39a72582015-06-02 11:02:24 -0500858 mark_inode_dirty(inode);
859 set_bit(QDF_REFRESH, &qd->qd_flags);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000860 }
861
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000862 return err;
863}
864
David Teiglandb3b94fa2006-01-16 16:50:04 +0000865static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
866{
Bob Peterson15562c42015-03-16 11:52:05 -0500867 struct gfs2_sbd *sdp = (*qda)->qd_gl->gl_name.ln_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400868 struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
Steven Whitehouse7b9cff42013-10-02 11:13:25 +0100869 struct gfs2_alloc_parms ap = { .aflags = 0, };
David Teiglandb3b94fa2006-01-16 16:50:04 +0000870 unsigned int data_blocks, ind_blocks;
871 struct gfs2_holder *ghs, i_gh;
872 unsigned int qx, x;
873 struct gfs2_quota_data *qd;
Steven Whitehouse71f890f2012-07-30 14:53:19 +0100874 unsigned reserved;
Steven Whitehousef42faf42006-01-30 18:34:10 +0000875 loff_t offset;
Abhijith Das20b95bf2008-03-06 17:43:52 -0600876 unsigned int nalloc = 0, blocks;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000877 int error;
878
Bob Petersonb54e9a02015-10-26 10:40:28 -0500879 error = gfs2_rsqa_alloc(ip);
Bob Peterson0a305e42012-06-06 11:17:59 +0100880 if (error)
881 return error;
882
David Teiglandb3b94fa2006-01-16 16:50:04 +0000883 gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
884 &data_blocks, &ind_blocks);
885
Kees Cook6da2ec52018-06-12 13:55:00 -0700886 ghs = kmalloc_array(num_qd, sizeof(struct gfs2_holder), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000887 if (!ghs)
888 return -ENOMEM;
889
890 sort(qda, num_qd, sizeof(struct gfs2_quota_data *), sort_qd, NULL);
Al Viro59551022016-01-22 15:40:57 -0500891 inode_lock(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000892 for (qx = 0; qx < num_qd; qx++) {
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100893 error = gfs2_glock_nq_init(qda[qx]->qd_gl, LM_ST_EXCLUSIVE,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000894 GL_NOCACHE, &ghs[qx]);
895 if (error)
896 goto out;
897 }
898
899 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
900 if (error)
901 goto out;
902
903 for (x = 0; x < num_qd; x++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000904 offset = qd2offset(qda[x]);
Bob Peterson461cb412010-06-24 19:21:20 -0400905 if (gfs2_write_alloc_required(ip, offset,
906 sizeof(struct gfs2_quota)))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000907 nalloc++;
908 }
909
Abhijith Das20b95bf2008-03-06 17:43:52 -0600910 /*
911 * 1 blk for unstuffing inode if stuffed. We add this extra
912 * block to the reservation unconditionally. If the inode
913 * doesn't need unstuffing, the block will be released to the
914 * rgrp since it won't be allocated during the transaction
915 */
Abhijith Das7e619bc2010-05-07 17:50:18 -0400916 /* +3 in the end for unstuffing block, inode size update block
917 * and another block in case quota straddles page boundary and
918 * two blocks need to be updated instead of 1 */
919 blocks = num_qd * data_blocks + RES_DINODE + num_qd + 3;
Abhijith Das20b95bf2008-03-06 17:43:52 -0600920
Steven Whitehouse71f890f2012-07-30 14:53:19 +0100921 reserved = 1 + (nalloc * (data_blocks + ind_blocks));
Steven Whitehouse7b9cff42013-10-02 11:13:25 +0100922 ap.target = reserved;
923 error = gfs2_inplace_reserve(ip, &ap);
Abhijith Das20b95bf2008-03-06 17:43:52 -0600924 if (error)
925 goto out_alloc;
926
927 if (nalloc)
Steven Whitehouse71f890f2012-07-30 14:53:19 +0100928 blocks += gfs2_rg_blocks(ip, reserved) + nalloc * ind_blocks + RES_STATFS;
Abhijith Das20b95bf2008-03-06 17:43:52 -0600929
930 error = gfs2_trans_begin(sdp, blocks, 0);
931 if (error)
932 goto out_ipres;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000933
934 for (x = 0; x < num_qd; x++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000935 qd = qda[x];
936 offset = qd2offset(qd);
Steven Whitehousee285c102009-09-23 13:50:49 +0100937 error = gfs2_adjust_quota(ip, offset, qd->qd_change_sync, qd, NULL);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000938 if (error)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000939 goto out_end_trans;
940
David Teiglandb3b94fa2006-01-16 16:50:04 +0000941 do_qc(qd, -qd->qd_change_sync);
Abhijith Das662e3a52011-03-08 10:40:42 -0500942 set_bit(QDF_REFRESH, &qd->qd_flags);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000943 }
944
945 error = 0;
946
Steven Whitehousea91ea692006-09-04 12:04:26 -0400947out_end_trans:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000948 gfs2_trans_end(sdp);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400949out_ipres:
Abhijith Das20b95bf2008-03-06 17:43:52 -0600950 gfs2_inplace_release(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400951out_alloc:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000952 gfs2_glock_dq_uninit(&i_gh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400953out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000954 while (qx--)
955 gfs2_glock_dq_uninit(&ghs[qx]);
Al Viro59551022016-01-22 15:40:57 -0500956 inode_unlock(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000957 kfree(ghs);
Bob Petersonc1696fb2018-01-17 00:01:33 +0100958 gfs2_log_flush(ip->i_gl->gl_name.ln_sbd, ip->i_gl,
Bob Peterson805c09072018-01-08 10:34:17 -0500959 GFS2_LOG_HEAD_FLUSH_NORMAL | GFS2_LFC_DO_SYNC);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000960 return error;
961}
962
Steven Whitehousee285c102009-09-23 13:50:49 +0100963static int update_qd(struct gfs2_sbd *sdp, struct gfs2_quota_data *qd)
964{
965 struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
966 struct gfs2_quota q;
967 struct gfs2_quota_lvb *qlvb;
968 loff_t pos;
969 int error;
970
971 memset(&q, 0, sizeof(struct gfs2_quota));
972 pos = qd2offset(qd);
Andrew Price43066292012-04-16 16:40:55 +0100973 error = gfs2_internal_read(ip, (char *)&q, &pos, sizeof(q));
Steven Whitehousee285c102009-09-23 13:50:49 +0100974 if (error < 0)
975 return error;
976
David Teigland4e2f8842012-11-14 13:47:37 -0500977 qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lksb.sb_lvbptr;
Steven Whitehousee285c102009-09-23 13:50:49 +0100978 qlvb->qb_magic = cpu_to_be32(GFS2_MAGIC);
979 qlvb->__pad = 0;
980 qlvb->qb_limit = q.qu_limit;
981 qlvb->qb_warn = q.qu_warn;
982 qlvb->qb_value = q.qu_value;
983 qd->qd_qb = *qlvb;
984
985 return 0;
986}
987
David Teiglandb3b94fa2006-01-16 16:50:04 +0000988static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
989 struct gfs2_holder *q_gh)
990{
Bob Peterson15562c42015-03-16 11:52:05 -0500991 struct gfs2_sbd *sdp = qd->qd_gl->gl_name.ln_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400992 struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000993 struct gfs2_holder i_gh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000994 int error;
995
Steven Whitehousea91ea692006-09-04 12:04:26 -0400996restart:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000997 error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_SHARED, 0, q_gh);
998 if (error)
999 return error;
1000
Abhi Das30133172015-04-08 09:03:56 -05001001 if (test_and_clear_bit(QDF_REFRESH, &qd->qd_flags))
1002 force_refresh = FORCE;
1003
David Teigland4e2f8842012-11-14 13:47:37 -05001004 qd->qd_qb = *(struct gfs2_quota_lvb *)qd->qd_gl->gl_lksb.sb_lvbptr;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001005
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04001006 if (force_refresh || qd->qd_qb.qb_magic != cpu_to_be32(GFS2_MAGIC)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001007 gfs2_glock_dq_uninit(q_gh);
Steven Whitehouse91094d02009-09-11 15:21:56 +01001008 error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE,
1009 GL_NOCACHE, q_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001010 if (error)
1011 return error;
1012
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04001013 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001014 if (error)
1015 goto fail;
1016
Steven Whitehousee285c102009-09-23 13:50:49 +01001017 error = update_qd(sdp, qd);
1018 if (error)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001019 goto fail_gunlock;
Steven Whitehousee285c102009-09-23 13:50:49 +01001020
David Teiglandb3b94fa2006-01-16 16:50:04 +00001021 gfs2_glock_dq_uninit(&i_gh);
Steven Whitehouse91094d02009-09-11 15:21:56 +01001022 gfs2_glock_dq_uninit(q_gh);
1023 force_refresh = 0;
1024 goto restart;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001025 }
1026
1027 return 0;
1028
Steven Whitehousea91ea692006-09-04 12:04:26 -04001029fail_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001030 gfs2_glock_dq_uninit(&i_gh);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001031fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001032 gfs2_glock_dq_uninit(q_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001033 return error;
1034}
1035
Eric W. Biederman7c06b5d2013-01-31 20:27:54 -08001036int gfs2_quota_lock(struct gfs2_inode *ip, kuid_t uid, kgid_t gid)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001037{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001038 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Abhijith Das662e3a52011-03-08 10:40:42 -05001039 struct gfs2_quota_data *qd;
Bob Petersonb58bf402015-07-24 09:45:43 -05001040 u32 x;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001041 int error = 0;
1042
David Teiglandb3b94fa2006-01-16 16:50:04 +00001043 if (capable(CAP_SYS_RESOURCE) ||
1044 sdp->sd_args.ar_quota != GFS2_QUOTA_ON)
1045 return 0;
1046
Bob Petersonb54e9a02015-10-26 10:40:28 -05001047 error = gfs2_quota_hold(ip, uid, gid);
1048 if (error)
1049 return error;
1050
1051 sort(ip->i_qadata->qa_qd, ip->i_qadata->qa_qd_num,
Bob Peterson5407e242012-05-18 09:28:23 -04001052 sizeof(struct gfs2_quota_data *), sort_qd, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001053
Bob Petersonb54e9a02015-10-26 10:40:28 -05001054 for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
1055 qd = ip->i_qadata->qa_qd[x];
1056 error = do_glock(qd, NO_FORCE, &ip->i_qadata->qa_qd_ghs[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001057 if (error)
1058 break;
1059 }
1060
1061 if (!error)
1062 set_bit(GIF_QD_LOCKED, &ip->i_flags);
1063 else {
1064 while (x--)
Bob Petersonb54e9a02015-10-26 10:40:28 -05001065 gfs2_glock_dq_uninit(&ip->i_qadata->qa_qd_ghs[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001066 gfs2_quota_unhold(ip);
1067 }
1068
1069 return error;
1070}
1071
1072static int need_sync(struct gfs2_quota_data *qd)
1073{
Bob Peterson15562c42015-03-16 11:52:05 -05001074 struct gfs2_sbd *sdp = qd->qd_gl->gl_name.ln_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001075 struct gfs2_tune *gt = &sdp->sd_tune;
Steven Whitehousecd915492006-09-04 12:49:07 -04001076 s64 value;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001077 unsigned int num, den;
1078 int do_sync = 1;
1079
1080 if (!qd->qd_qb.qb_limit)
1081 return 0;
1082
Steven Whitehouse7d808232013-11-01 14:52:08 -04001083 spin_lock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001084 value = qd->qd_change;
Steven Whitehouse7d808232013-11-01 14:52:08 -04001085 spin_unlock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001086
1087 spin_lock(&gt->gt_spin);
1088 num = gt->gt_quota_scale_num;
1089 den = gt->gt_quota_scale_den;
1090 spin_unlock(&gt->gt_spin);
1091
1092 if (value < 0)
1093 do_sync = 0;
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04001094 else if ((s64)be64_to_cpu(qd->qd_qb.qb_value) >=
1095 (s64)be64_to_cpu(qd->qd_qb.qb_limit))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001096 do_sync = 0;
1097 else {
1098 value *= gfs2_jindex_size(sdp) * num;
David Howells4abaca172008-07-11 14:39:56 +01001099 value = div_s64(value, den);
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04001100 value += (s64)be64_to_cpu(qd->qd_qb.qb_value);
Steven Whitehousecd915492006-09-04 12:49:07 -04001101 if (value < (s64)be64_to_cpu(qd->qd_qb.qb_limit))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001102 do_sync = 0;
1103 }
1104
1105 return do_sync;
1106}
1107
1108void gfs2_quota_unlock(struct gfs2_inode *ip)
1109{
Steven Whitehouseaabd7c72013-10-04 11:31:05 +01001110 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001111 struct gfs2_quota_data *qda[4];
1112 unsigned int count = 0;
Bob Petersonb58bf402015-07-24 09:45:43 -05001113 u32 x;
Steven Whitehouseaabd7c72013-10-04 11:31:05 +01001114 int found;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001115
1116 if (!test_and_clear_bit(GIF_QD_LOCKED, &ip->i_flags))
1117 goto out;
1118
Bob Petersonb54e9a02015-10-26 10:40:28 -05001119 for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001120 struct gfs2_quota_data *qd;
1121 int sync;
1122
Bob Petersonb54e9a02015-10-26 10:40:28 -05001123 qd = ip->i_qadata->qa_qd[x];
David Teiglandb3b94fa2006-01-16 16:50:04 +00001124 sync = need_sync(qd);
1125
Bob Petersonb54e9a02015-10-26 10:40:28 -05001126 gfs2_glock_dq_uninit(&ip->i_qadata->qa_qd_ghs[x]);
Steven Whitehouseaabd7c72013-10-04 11:31:05 +01001127 if (!sync)
1128 continue;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001129
Steven Whitehouse7d808232013-11-01 14:52:08 -04001130 spin_lock(&qd_lock);
Steven Whitehouseaabd7c72013-10-04 11:31:05 +01001131 found = qd_check_sync(sdp, qd, NULL);
Steven Whitehouse7d808232013-11-01 14:52:08 -04001132 spin_unlock(&qd_lock);
Steven Whitehouseaabd7c72013-10-04 11:31:05 +01001133
1134 if (!found)
1135 continue;
1136
1137 gfs2_assert_warn(sdp, qd->qd_change_sync);
1138 if (bh_get(qd)) {
1139 clear_bit(QDF_LOCKED, &qd->qd_flags);
1140 slot_put(qd);
1141 qd_put(qd);
1142 continue;
1143 }
1144
1145 qda[count++] = qd;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001146 }
1147
1148 if (count) {
1149 do_sync(count, qda);
1150 for (x = 0; x < count; x++)
1151 qd_unlock(qda[x]);
1152 }
1153
Steven Whitehousea91ea692006-09-04 12:04:26 -04001154out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001155 gfs2_quota_unhold(ip);
1156}
1157
1158#define MAX_LINE 256
1159
1160static int print_message(struct gfs2_quota_data *qd, char *type)
1161{
Bob Peterson15562c42015-03-16 11:52:05 -05001162 struct gfs2_sbd *sdp = qd->qd_gl->gl_name.ln_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001163
Joe Perches8382e262014-03-06 12:10:46 -08001164 fs_info(sdp, "quota %s for %s %u\n",
1165 type,
Joe Perchesd77d1b52014-03-06 12:10:45 -08001166 (qd->qd_id.type == USRQUOTA) ? "user" : "group",
1167 from_kqid(&init_user_ns, qd->qd_id));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001168
1169 return 0;
1170}
1171
Abhi Das25435e52015-03-18 12:04:37 -05001172/**
1173 * gfs2_quota_check - check if allocating new blocks will exceed quota
1174 * @ip: The inode for which this check is being performed
1175 * @uid: The uid to check against
1176 * @gid: The gid to check against
1177 * @ap: The allocation parameters. ap->target contains the requested
1178 * blocks. ap->min_target, if set, contains the minimum blks
1179 * requested.
1180 *
1181 * Returns: 0 on success.
1182 * min_req = ap->min_target ? ap->min_target : ap->target;
Andreas Gruenbacher243fea42018-10-02 10:22:41 +01001183 * quota must allow at least min_req blks for success and
Abhi Das25435e52015-03-18 12:04:37 -05001184 * ap->allowed is set to the number of blocks allowed
1185 *
1186 * -EDQUOT otherwise, quota violation. ap->allowed is set to number
1187 * of blocks available.
1188 */
Abhi Dasb8fbf472015-03-18 12:03:41 -05001189int gfs2_quota_check(struct gfs2_inode *ip, kuid_t uid, kgid_t gid,
1190 struct gfs2_alloc_parms *ap)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001191{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001192 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001193 struct gfs2_quota_data *qd;
Abhi Das25435e52015-03-18 12:04:37 -05001194 s64 value, warn, limit;
Bob Petersonb58bf402015-07-24 09:45:43 -05001195 u32 x;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001196 int error = 0;
1197
Abhi Das25435e52015-03-18 12:04:37 -05001198 ap->allowed = UINT_MAX; /* Assume we are permitted a whole lot */
David Teiglandb3b94fa2006-01-16 16:50:04 +00001199 if (!test_bit(GIF_QD_LOCKED, &ip->i_flags))
1200 return 0;
1201
1202 if (sdp->sd_args.ar_quota != GFS2_QUOTA_ON)
1203 return 0;
1204
Bob Petersonb54e9a02015-10-26 10:40:28 -05001205 for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
1206 qd = ip->i_qadata->qa_qd[x];
David Teiglandb3b94fa2006-01-16 16:50:04 +00001207
Eric W. Biederman05e0a602013-01-31 19:52:08 -08001208 if (!(qid_eq(qd->qd_id, make_kqid_uid(uid)) ||
1209 qid_eq(qd->qd_id, make_kqid_gid(gid))))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001210 continue;
1211
Abhi Das25435e52015-03-18 12:04:37 -05001212 warn = (s64)be64_to_cpu(qd->qd_qb.qb_warn);
1213 limit = (s64)be64_to_cpu(qd->qd_qb.qb_limit);
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04001214 value = (s64)be64_to_cpu(qd->qd_qb.qb_value);
Steven Whitehouse7d808232013-11-01 14:52:08 -04001215 spin_lock(&qd_lock);
Abhi Das25435e52015-03-18 12:04:37 -05001216 value += qd->qd_change;
Steven Whitehouse7d808232013-11-01 14:52:08 -04001217 spin_unlock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001218
Abhi Das25435e52015-03-18 12:04:37 -05001219 if (limit > 0 && (limit - value) < ap->allowed)
1220 ap->allowed = limit - value;
1221 /* If we can't meet the target */
1222 if (limit && limit < (value + (s64)ap->target)) {
1223 /* If no min_target specified or we don't meet
1224 * min_target, return -EDQUOT */
1225 if (!ap->min_target || ap->min_target > ap->allowed) {
Abhi Das9cde2892015-06-02 11:03:04 -05001226 if (!test_and_set_bit(QDF_QMSG_QUIET,
1227 &qd->qd_flags)) {
1228 print_message(qd, "exceeded");
1229 quota_send_warning(qd->qd_id,
1230 sdp->sd_vfs->s_dev,
1231 QUOTA_NL_BHARDWARN);
1232 }
Abhi Das25435e52015-03-18 12:04:37 -05001233 error = -EDQUOT;
1234 break;
1235 }
1236 } else if (warn && warn < value &&
David Teiglandb3b94fa2006-01-16 16:50:04 +00001237 time_after_eq(jiffies, qd->qd_last_warn +
Abhi Das25435e52015-03-18 12:04:37 -05001238 gfs2_tune_get(sdp, gt_quota_warn_period)
1239 * HZ)) {
Eric W. Biederman05e0a602013-01-31 19:52:08 -08001240 quota_send_warning(qd->qd_id,
Steven Whitehouse2ec46502009-09-28 12:49:15 +01001241 sdp->sd_vfs->s_dev, QUOTA_NL_BSOFTWARN);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001242 error = print_message(qd, "warning");
1243 qd->qd_last_warn = jiffies;
1244 }
1245 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001246 return error;
1247}
1248
Steven Whitehousecd915492006-09-04 12:49:07 -04001249void gfs2_quota_change(struct gfs2_inode *ip, s64 change,
Eric W. Biederman7c06b5d2013-01-31 20:27:54 -08001250 kuid_t uid, kgid_t gid)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001251{
David Teiglandb3b94fa2006-01-16 16:50:04 +00001252 struct gfs2_quota_data *qd;
Bob Petersonb58bf402015-07-24 09:45:43 -05001253 u32 x;
Bob Petersonb54e9a02015-10-26 10:40:28 -05001254 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001255
Bob Petersonb54e9a02015-10-26 10:40:28 -05001256 if (sdp->sd_args.ar_quota != GFS2_QUOTA_ON ||
1257 gfs2_assert_warn(sdp, change))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001258 return;
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001259 if (ip->i_diskflags & GFS2_DIF_SYSTEM)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001260 return;
1261
Bob Petersonb54e9a02015-10-26 10:40:28 -05001262 for (x = 0; x < ip->i_qadata->qa_qd_num; x++) {
1263 qd = ip->i_qadata->qa_qd[x];
David Teiglandb3b94fa2006-01-16 16:50:04 +00001264
Eric W. Biederman05e0a602013-01-31 19:52:08 -08001265 if (qid_eq(qd->qd_id, make_kqid_uid(uid)) ||
1266 qid_eq(qd->qd_id, make_kqid_gid(gid))) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001267 do_qc(qd, change);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001268 }
1269 }
1270}
1271
Jan Karaceed1722012-07-03 16:45:28 +02001272int gfs2_quota_sync(struct super_block *sb, int type)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001273{
Steven Whitehouse8c42d632009-09-11 14:36:44 +01001274 struct gfs2_sbd *sdp = sb->s_fs_info;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001275 struct gfs2_quota_data **qda;
Andreas Gruenbacherf3b64b52019-08-31 21:29:12 +01001276 unsigned int max_qd = PAGE_SIZE / sizeof(struct gfs2_holder);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001277 unsigned int num_qd;
1278 unsigned int x;
1279 int error = 0;
1280
David Teiglandb3b94fa2006-01-16 16:50:04 +00001281 qda = kcalloc(max_qd, sizeof(struct gfs2_quota_data *), GFP_KERNEL);
1282 if (!qda)
1283 return -ENOMEM;
1284
Steven Whitehousee46c7722013-10-04 12:29:34 +01001285 mutex_lock(&sdp->sd_quota_sync_mutex);
1286 sdp->sd_quota_sync_gen++;
1287
David Teiglandb3b94fa2006-01-16 16:50:04 +00001288 do {
1289 num_qd = 0;
1290
1291 for (;;) {
1292 error = qd_fish(sdp, qda + num_qd);
1293 if (error || !qda[num_qd])
1294 break;
1295 if (++num_qd == max_qd)
1296 break;
1297 }
1298
1299 if (num_qd) {
1300 if (!error)
1301 error = do_sync(num_qd, qda);
1302 if (!error)
1303 for (x = 0; x < num_qd; x++)
1304 qda[x]->qd_sync_gen =
1305 sdp->sd_quota_sync_gen;
1306
1307 for (x = 0; x < num_qd; x++)
1308 qd_unlock(qda[x]);
1309 }
1310 } while (!error && num_qd == max_qd);
1311
Steven Whitehousee46c7722013-10-04 12:29:34 +01001312 mutex_unlock(&sdp->sd_quota_sync_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001313 kfree(qda);
1314
1315 return error;
1316}
1317
Eric W. Biedermaned87dab2013-01-31 19:42:40 -08001318int gfs2_quota_refresh(struct gfs2_sbd *sdp, struct kqid qid)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001319{
1320 struct gfs2_quota_data *qd;
1321 struct gfs2_holder q_gh;
1322 int error;
1323
Eric W. Biederman05e0a602013-01-31 19:52:08 -08001324 error = qd_get(sdp, qid, &qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001325 if (error)
1326 return error;
1327
1328 error = do_glock(qd, FORCE, &q_gh);
1329 if (!error)
1330 gfs2_glock_dq_uninit(&q_gh);
1331
1332 qd_put(qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001333 return error;
1334}
1335
David Teiglandb3b94fa2006-01-16 16:50:04 +00001336int gfs2_quota_init(struct gfs2_sbd *sdp)
1337{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001338 struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
Steven Whitehousea2e0f792010-08-11 09:53:11 +01001339 u64 size = i_size_read(sdp->sd_qc_inode);
1340 unsigned int blocks = size >> sdp->sd_sb.sb_bsize_shift;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001341 unsigned int x, slot = 0;
1342 unsigned int found = 0;
Steven Whitehousec754fbb2013-12-12 10:47:59 +00001343 unsigned int hash;
Steven Whitehouseee2411a2013-12-12 17:29:32 +00001344 unsigned int bm_size;
Steven Whitehousecd915492006-09-04 12:49:07 -04001345 u64 dblock;
1346 u32 extlen = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001347 int error;
1348
Steven Whitehousea2e0f792010-08-11 09:53:11 +01001349 if (gfs2_check_internal_file_size(sdp->sd_qc_inode, 1, 64 << 20))
Steven Whitehouse907b9bc2006-09-25 09:26:04 -04001350 return -EIO;
Steven Whitehousea2e0f792010-08-11 09:53:11 +01001351
David Teiglandb3b94fa2006-01-16 16:50:04 +00001352 sdp->sd_quota_slots = blocks * sdp->sd_qc_per_block;
Steven Whitehouseee2411a2013-12-12 17:29:32 +00001353 bm_size = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * sizeof(unsigned long));
1354 bm_size *= sizeof(unsigned long);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001355 error = -ENOMEM;
Fabian Frederickfcf10d32014-02-26 19:07:56 +01001356 sdp->sd_quota_bitmap = kzalloc(bm_size, GFP_NOFS | __GFP_NOWARN);
Steven Whitehouseee2411a2013-12-12 17:29:32 +00001357 if (sdp->sd_quota_bitmap == NULL)
Fabian Frederickfcf10d32014-02-26 19:07:56 +01001358 sdp->sd_quota_bitmap = __vmalloc(bm_size, GFP_NOFS |
1359 __GFP_ZERO, PAGE_KERNEL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001360 if (!sdp->sd_quota_bitmap)
1361 return error;
1362
David Teiglandb3b94fa2006-01-16 16:50:04 +00001363 for (x = 0; x < blocks; x++) {
1364 struct buffer_head *bh;
Steven Whitehouse7aed98f2013-11-26 15:17:09 +00001365 const struct gfs2_quota_change *qc;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001366 unsigned int y;
1367
1368 if (!extlen) {
1369 int new = 0;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001370 error = gfs2_extent_map(&ip->i_inode, x, &new, &dblock, &extlen);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001371 if (error)
1372 goto fail;
1373 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001374 error = -EIO;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001375 bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
1376 if (!bh)
1377 goto fail;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001378 if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC)) {
1379 brelse(bh);
1380 goto fail;
1381 }
1382
Steven Whitehouse7aed98f2013-11-26 15:17:09 +00001383 qc = (const struct gfs2_quota_change *)(bh->b_data + sizeof(struct gfs2_meta_header));
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001384 for (y = 0; y < sdp->sd_qc_per_block && slot < sdp->sd_quota_slots;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001385 y++, slot++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001386 struct gfs2_quota_data *qd;
Steven Whitehouse7aed98f2013-11-26 15:17:09 +00001387 s64 qc_change = be64_to_cpu(qc->qc_change);
1388 u32 qc_flags = be32_to_cpu(qc->qc_flags);
1389 enum quota_type qtype = (qc_flags & GFS2_QCF_USER) ?
1390 USRQUOTA : GRPQUOTA;
1391 struct kqid qc_id = make_kqid(&init_user_ns, qtype,
1392 be32_to_cpu(qc->qc_id));
1393 qc++;
1394 if (!qc_change)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001395 continue;
1396
Steven Whitehousec754fbb2013-12-12 10:47:59 +00001397 hash = gfs2_qd_hash(sdp, qc_id);
1398 qd = qd_alloc(hash, sdp, qc_id);
1399 if (qd == NULL) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001400 brelse(bh);
1401 goto fail;
1402 }
1403
1404 set_bit(QDF_CHANGE, &qd->qd_flags);
Steven Whitehouse7aed98f2013-11-26 15:17:09 +00001405 qd->qd_change = qc_change;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001406 qd->qd_slot = slot;
1407 qd->qd_slot_count = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001408
Steven Whitehouse7d808232013-11-01 14:52:08 -04001409 spin_lock(&qd_lock);
Steven Whitehouseee2411a2013-12-12 17:29:32 +00001410 BUG_ON(test_and_set_bit(slot, sdp->sd_quota_bitmap));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001411 list_add(&qd->qd_list, &sdp->sd_quota_list);
1412 atomic_inc(&sdp->sd_quota_count);
Steven Whitehouse7d808232013-11-01 14:52:08 -04001413 spin_unlock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001414
Steven Whitehousec754fbb2013-12-12 10:47:59 +00001415 spin_lock_bucket(hash);
1416 hlist_bl_add_head_rcu(&qd->qd_hlist, &qd_hash_table[hash]);
1417 spin_unlock_bucket(hash);
1418
David Teiglandb3b94fa2006-01-16 16:50:04 +00001419 found++;
1420 }
1421
1422 brelse(bh);
1423 dblock++;
1424 extlen--;
1425 }
1426
1427 if (found)
1428 fs_info(sdp, "found %u quota changes\n", found);
1429
1430 return 0;
1431
Steven Whitehousea91ea692006-09-04 12:04:26 -04001432fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001433 gfs2_quota_cleanup(sdp);
1434 return error;
1435}
1436
David Teiglandb3b94fa2006-01-16 16:50:04 +00001437void gfs2_quota_cleanup(struct gfs2_sbd *sdp)
1438{
1439 struct list_head *head = &sdp->sd_quota_list;
1440 struct gfs2_quota_data *qd;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001441
Steven Whitehouse7d808232013-11-01 14:52:08 -04001442 spin_lock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001443 while (!list_empty(head)) {
1444 qd = list_entry(head->prev, struct gfs2_quota_data, qd_list);
1445
Abhijith Das0a7ab792009-01-07 16:03:37 -06001446 list_del(&qd->qd_list);
Steven Whitehousec754fbb2013-12-12 10:47:59 +00001447
Abhijith Das0a7ab792009-01-07 16:03:37 -06001448 /* Also remove if this qd exists in the reclaim list */
Steven Whitehouse2147dbf2013-11-04 10:15:08 +00001449 list_lru_del(&gfs2_qd_lru, &qd->qd_lru);
Abhijith Das0a7ab792009-01-07 16:03:37 -06001450 atomic_dec(&sdp->sd_quota_count);
Steven Whitehouse7d808232013-11-01 14:52:08 -04001451 spin_unlock(&qd_lock);
Abhijith Das0a7ab792009-01-07 16:03:37 -06001452
Steven Whitehousec754fbb2013-12-12 10:47:59 +00001453 spin_lock_bucket(qd->qd_hash);
1454 hlist_bl_del_rcu(&qd->qd_hlist);
1455 spin_unlock_bucket(qd->qd_hash);
1456
Steven Whitehouse8ad151c2013-12-12 11:34:09 +00001457 gfs2_assert_warn(sdp, !qd->qd_change);
1458 gfs2_assert_warn(sdp, !qd->qd_slot_count);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001459 gfs2_assert_warn(sdp, !qd->qd_bh_count);
1460
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001461 gfs2_glock_put(qd->qd_gl);
Steven Whitehousec754fbb2013-12-12 10:47:59 +00001462 call_rcu(&qd->qd_rcu, gfs2_qd_dealloc);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001463
Steven Whitehouse7d808232013-11-01 14:52:08 -04001464 spin_lock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001465 }
Steven Whitehouse7d808232013-11-01 14:52:08 -04001466 spin_unlock(&qd_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001467
1468 gfs2_assert_warn(sdp, !atomic_read(&sdp->sd_quota_count));
1469
Al Viro3cdcf632014-11-20 05:18:38 +00001470 kvfree(sdp->sd_quota_bitmap);
1471 sdp->sd_quota_bitmap = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001472}
1473
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001474static void quotad_error(struct gfs2_sbd *sdp, const char *msg, int error)
1475{
1476 if (error == 0 || error == -EROFS)
1477 return;
Bob Petersoneb43e662019-11-14 09:52:15 -05001478 if (!gfs2_withdrawn(sdp)) {
Bob Petersonf34a61352019-04-16 12:23:28 -06001479 if (!cmpxchg(&sdp->sd_log_error, 0, error))
1480 fs_err(sdp, "gfs2_quotad: %s error %d\n", msg, error);
Bob Peterson942b0cd2017-08-16 11:30:06 -05001481 wake_up(&sdp->sd_logd_waitq);
1482 }
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001483}
1484
1485static void quotad_check_timeo(struct gfs2_sbd *sdp, const char *msg,
Steven Whitehouse8c42d632009-09-11 14:36:44 +01001486 int (*fxn)(struct super_block *sb, int type),
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001487 unsigned long t, unsigned long *timeo,
1488 unsigned int *new_timeo)
1489{
1490 if (t >= *timeo) {
Steven Whitehouse8c42d632009-09-11 14:36:44 +01001491 int error = fxn(sdp->sd_vfs, 0);
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001492 quotad_error(sdp, msg, error);
1493 *timeo = gfs2_tune_get_i(&sdp->sd_tune, new_timeo) * HZ;
1494 } else {
1495 *timeo -= t;
1496 }
1497}
1498
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001499static void quotad_check_trunc_list(struct gfs2_sbd *sdp)
1500{
1501 struct gfs2_inode *ip;
1502
1503 while(1) {
1504 ip = NULL;
1505 spin_lock(&sdp->sd_trunc_lock);
1506 if (!list_empty(&sdp->sd_trunc_list)) {
1507 ip = list_entry(sdp->sd_trunc_list.next,
1508 struct gfs2_inode, i_trunc_list);
1509 list_del_init(&ip->i_trunc_list);
1510 }
1511 spin_unlock(&sdp->sd_trunc_lock);
1512 if (ip == NULL)
1513 return;
1514 gfs2_glock_finish_truncate(ip);
1515 }
1516}
1517
Benjamin Marzinski3d3c10f2009-10-20 02:39:44 -05001518void gfs2_wake_up_statfs(struct gfs2_sbd *sdp) {
1519 if (!sdp->sd_statfs_force_sync) {
1520 sdp->sd_statfs_force_sync = 1;
1521 wake_up(&sdp->sd_quota_wait);
1522 }
1523}
1524
1525
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001526/**
1527 * gfs2_quotad - Write cached quota changes into the quota file
1528 * @sdp: Pointer to GFS2 superblock
1529 *
1530 */
1531
1532int gfs2_quotad(void *data)
1533{
1534 struct gfs2_sbd *sdp = data;
1535 struct gfs2_tune *tune = &sdp->sd_tune;
1536 unsigned long statfs_timeo = 0;
1537 unsigned long quotad_timeo = 0;
1538 unsigned long t = 0;
1539 DEFINE_WAIT(wait);
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001540 int empty;
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001541
1542 while (!kthread_should_stop()) {
1543
Bob Peterson601ef0d2020-01-28 20:23:45 +01001544 if (gfs2_withdrawn(sdp))
1545 goto bypass;
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001546 /* Update the master statfs file */
Benjamin Marzinski3d3c10f2009-10-20 02:39:44 -05001547 if (sdp->sd_statfs_force_sync) {
1548 int error = gfs2_statfs_sync(sdp->sd_vfs, 0);
1549 quotad_error(sdp, "statfs", error);
1550 statfs_timeo = gfs2_tune_get(sdp, gt_statfs_quantum) * HZ;
1551 }
1552 else
1553 quotad_check_timeo(sdp, "statfs", gfs2_statfs_sync, t,
1554 &statfs_timeo,
1555 &tune->gt_statfs_quantum);
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001556
1557 /* Update quota file */
Steven Whitehouseedd2e9a2013-06-03 11:12:59 +01001558 quotad_check_timeo(sdp, "sync", gfs2_quota_sync, t,
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001559 &quotad_timeo, &tune->gt_quota_quantum);
1560
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001561 /* Check for & recover partially truncated inodes */
1562 quotad_check_trunc_list(sdp);
1563
Tejun Heoa0acae02011-11-21 12:32:22 -08001564 try_to_freeze();
1565
Bob Peterson601ef0d2020-01-28 20:23:45 +01001566bypass:
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001567 t = min(quotad_timeo, statfs_timeo);
1568
Steven Whitehouse7fa5d202009-03-31 15:49:08 +01001569 prepare_to_wait(&sdp->sd_quota_wait, &wait, TASK_INTERRUPTIBLE);
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001570 spin_lock(&sdp->sd_trunc_lock);
1571 empty = list_empty(&sdp->sd_trunc_list);
1572 spin_unlock(&sdp->sd_trunc_lock);
Benjamin Marzinski3d3c10f2009-10-20 02:39:44 -05001573 if (empty && !sdp->sd_statfs_force_sync)
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001574 t -= schedule_timeout(t);
1575 else
1576 t = 0;
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001577 finish_wait(&sdp->sd_quota_wait, &wait);
1578 }
1579
1580 return 0;
1581}
1582
Jan Karae54b2e22014-11-19 16:41:07 +01001583static int gfs2_quota_get_state(struct super_block *sb, struct qc_state *state)
Steven Whitehouse1d371b52009-09-11 15:57:27 +01001584{
1585 struct gfs2_sbd *sdp = sb->s_fs_info;
1586
Jan Karae54b2e22014-11-19 16:41:07 +01001587 memset(state, 0, sizeof(*state));
Christoph Hellwigad6bb902010-05-05 00:10:56 +02001588
1589 switch (sdp->sd_args.ar_quota) {
1590 case GFS2_QUOTA_ON:
Jan Karae54b2e22014-11-19 16:41:07 +01001591 state->s_state[USRQUOTA].flags |= QCI_LIMITS_ENFORCED;
1592 state->s_state[GRPQUOTA].flags |= QCI_LIMITS_ENFORCED;
Christoph Hellwigad6bb902010-05-05 00:10:56 +02001593 /*FALLTHRU*/
1594 case GFS2_QUOTA_ACCOUNT:
Jan Karae54b2e22014-11-19 16:41:07 +01001595 state->s_state[USRQUOTA].flags |= QCI_ACCT_ENABLED |
1596 QCI_SYSFILE;
1597 state->s_state[GRPQUOTA].flags |= QCI_ACCT_ENABLED |
1598 QCI_SYSFILE;
Christoph Hellwigad6bb902010-05-05 00:10:56 +02001599 break;
1600 case GFS2_QUOTA_OFF:
1601 break;
1602 }
Steven Whitehouse1d371b52009-09-11 15:57:27 +01001603 if (sdp->sd_quota_inode) {
Jan Karae54b2e22014-11-19 16:41:07 +01001604 state->s_state[USRQUOTA].ino =
1605 GFS2_I(sdp->sd_quota_inode)->i_no_addr;
1606 state->s_state[USRQUOTA].blocks = sdp->sd_quota_inode->i_blocks;
Steven Whitehouse1d371b52009-09-11 15:57:27 +01001607 }
Jan Karae54b2e22014-11-19 16:41:07 +01001608 state->s_state[USRQUOTA].nextents = 1; /* unsupported */
1609 state->s_state[GRPQUOTA] = state->s_state[USRQUOTA];
1610 state->s_incoredqs = list_lru_count(&gfs2_qd_lru);
Steven Whitehouse1d371b52009-09-11 15:57:27 +01001611 return 0;
1612}
1613
Eric W. Biederman74a8a102012-09-16 02:07:49 -07001614static int gfs2_get_dqblk(struct super_block *sb, struct kqid qid,
Jan Kara14bf61f2014-10-09 16:03:13 +02001615 struct qc_dqblk *fdq)
Steven Whitehouse113d6b32009-09-28 11:52:16 +01001616{
1617 struct gfs2_sbd *sdp = sb->s_fs_info;
1618 struct gfs2_quota_lvb *qlvb;
1619 struct gfs2_quota_data *qd;
1620 struct gfs2_holder q_gh;
1621 int error;
1622
Jan Kara14bf61f2014-10-09 16:03:13 +02001623 memset(fdq, 0, sizeof(*fdq));
Steven Whitehouse113d6b32009-09-28 11:52:16 +01001624
1625 if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
1626 return -ESRCH; /* Crazy XFS error code */
1627
Eric W. Biederman236c64e2013-01-31 20:09:30 -08001628 if ((qid.type != USRQUOTA) &&
1629 (qid.type != GRPQUOTA))
Steven Whitehouse113d6b32009-09-28 11:52:16 +01001630 return -EINVAL;
1631
Eric W. Biederman05e0a602013-01-31 19:52:08 -08001632 error = qd_get(sdp, qid, &qd);
Steven Whitehouse113d6b32009-09-28 11:52:16 +01001633 if (error)
1634 return error;
1635 error = do_glock(qd, FORCE, &q_gh);
1636 if (error)
1637 goto out;
1638
David Teigland4e2f8842012-11-14 13:47:37 -05001639 qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lksb.sb_lvbptr;
Jan Kara14bf61f2014-10-09 16:03:13 +02001640 fdq->d_spc_hardlimit = be64_to_cpu(qlvb->qb_limit) << sdp->sd_sb.sb_bsize_shift;
1641 fdq->d_spc_softlimit = be64_to_cpu(qlvb->qb_warn) << sdp->sd_sb.sb_bsize_shift;
1642 fdq->d_space = be64_to_cpu(qlvb->qb_value) << sdp->sd_sb.sb_bsize_shift;
Steven Whitehouse113d6b32009-09-28 11:52:16 +01001643
1644 gfs2_glock_dq_uninit(&q_gh);
1645out:
1646 qd_put(qd);
1647 return error;
1648}
1649
Steven Whitehousee285c102009-09-23 13:50:49 +01001650/* GFS2 only supports a subset of the XFS fields */
Jan Kara14bf61f2014-10-09 16:03:13 +02001651#define GFS2_FIELDMASK (QC_SPC_SOFT|QC_SPC_HARD|QC_SPACE)
Steven Whitehousee285c102009-09-23 13:50:49 +01001652
Eric W. Biederman74a8a102012-09-16 02:07:49 -07001653static int gfs2_set_dqblk(struct super_block *sb, struct kqid qid,
Jan Kara14bf61f2014-10-09 16:03:13 +02001654 struct qc_dqblk *fdq)
Steven Whitehousee285c102009-09-23 13:50:49 +01001655{
1656 struct gfs2_sbd *sdp = sb->s_fs_info;
1657 struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
1658 struct gfs2_quota_data *qd;
1659 struct gfs2_holder q_gh, i_gh;
1660 unsigned int data_blocks, ind_blocks;
1661 unsigned int blocks = 0;
1662 int alloc_required;
Steven Whitehousee285c102009-09-23 13:50:49 +01001663 loff_t offset;
1664 int error;
1665
1666 if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
1667 return -ESRCH; /* Crazy XFS error code */
1668
Eric W. Biederman236c64e2013-01-31 20:09:30 -08001669 if ((qid.type != USRQUOTA) &&
1670 (qid.type != GRPQUOTA))
Steven Whitehousee285c102009-09-23 13:50:49 +01001671 return -EINVAL;
Steven Whitehousee285c102009-09-23 13:50:49 +01001672
1673 if (fdq->d_fieldmask & ~GFS2_FIELDMASK)
1674 return -EINVAL;
Steven Whitehousee285c102009-09-23 13:50:49 +01001675
Eric W. Biederman05e0a602013-01-31 19:52:08 -08001676 error = qd_get(sdp, qid, &qd);
Steven Whitehousee285c102009-09-23 13:50:49 +01001677 if (error)
1678 return error;
1679
Bob Petersonb54e9a02015-10-26 10:40:28 -05001680 error = gfs2_rsqa_alloc(ip);
Bob Peterson0a305e42012-06-06 11:17:59 +01001681 if (error)
1682 goto out_put;
1683
Al Viro59551022016-01-22 15:40:57 -05001684 inode_lock(&ip->i_inode);
Steven Whitehousee285c102009-09-23 13:50:49 +01001685 error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE, 0, &q_gh);
1686 if (error)
Bob Peterson0a305e42012-06-06 11:17:59 +01001687 goto out_unlockput;
Steven Whitehousee285c102009-09-23 13:50:49 +01001688 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1689 if (error)
1690 goto out_q;
1691
1692 /* Check for existing entry, if none then alloc new blocks */
1693 error = update_qd(sdp, qd);
1694 if (error)
1695 goto out_i;
1696
1697 /* If nothing has changed, this is a no-op */
Jan Kara14bf61f2014-10-09 16:03:13 +02001698 if ((fdq->d_fieldmask & QC_SPC_SOFT) &&
1699 ((fdq->d_spc_softlimit >> sdp->sd_sb.sb_bsize_shift) == be64_to_cpu(qd->qd_qb.qb_warn)))
1700 fdq->d_fieldmask ^= QC_SPC_SOFT;
Abhijith Das802ec9b2010-11-18 11:26:46 -05001701
Jan Kara14bf61f2014-10-09 16:03:13 +02001702 if ((fdq->d_fieldmask & QC_SPC_HARD) &&
1703 ((fdq->d_spc_hardlimit >> sdp->sd_sb.sb_bsize_shift) == be64_to_cpu(qd->qd_qb.qb_limit)))
1704 fdq->d_fieldmask ^= QC_SPC_HARD;
Abhijith Das802ec9b2010-11-18 11:26:46 -05001705
Jan Kara14bf61f2014-10-09 16:03:13 +02001706 if ((fdq->d_fieldmask & QC_SPACE) &&
1707 ((fdq->d_space >> sdp->sd_sb.sb_bsize_shift) == be64_to_cpu(qd->qd_qb.qb_value)))
1708 fdq->d_fieldmask ^= QC_SPACE;
Abhijith Das802ec9b2010-11-18 11:26:46 -05001709
Steven Whitehousee285c102009-09-23 13:50:49 +01001710 if (fdq->d_fieldmask == 0)
1711 goto out_i;
1712
1713 offset = qd2offset(qd);
Bob Peterson461cb412010-06-24 19:21:20 -04001714 alloc_required = gfs2_write_alloc_required(ip, offset, sizeof(struct gfs2_quota));
Abhijith Dase79a46a2011-02-07 11:22:41 -05001715 if (gfs2_is_stuffed(ip))
1716 alloc_required = 1;
Steven Whitehousee285c102009-09-23 13:50:49 +01001717 if (alloc_required) {
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01001718 struct gfs2_alloc_parms ap = { .aflags = 0, };
Steven Whitehousee285c102009-09-23 13:50:49 +01001719 gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
1720 &data_blocks, &ind_blocks);
Bob Peterson564e12b2011-11-21 13:36:17 -05001721 blocks = 1 + data_blocks + ind_blocks;
Steven Whitehouse7b9cff42013-10-02 11:13:25 +01001722 ap.target = blocks;
1723 error = gfs2_inplace_reserve(ip, &ap);
Steven Whitehousee285c102009-09-23 13:50:49 +01001724 if (error)
Bob Peterson564e12b2011-11-21 13:36:17 -05001725 goto out_i;
Steven Whitehouse71f890f2012-07-30 14:53:19 +01001726 blocks += gfs2_rg_blocks(ip, blocks);
Steven Whitehousee285c102009-09-23 13:50:49 +01001727 }
1728
Abhijith Dase79a46a2011-02-07 11:22:41 -05001729 /* Some quotas span block boundaries and can update two blocks,
1730 adding an extra block to the transaction to handle such quotas */
1731 error = gfs2_trans_begin(sdp, blocks + RES_DINODE + 2, 0);
Steven Whitehousee285c102009-09-23 13:50:49 +01001732 if (error)
1733 goto out_release;
1734
1735 /* Apply changes */
1736 error = gfs2_adjust_quota(ip, offset, 0, qd, fdq);
Abhi Das9cde2892015-06-02 11:03:04 -05001737 if (!error)
1738 clear_bit(QDF_QMSG_QUIET, &qd->qd_flags);
Steven Whitehousee285c102009-09-23 13:50:49 +01001739
1740 gfs2_trans_end(sdp);
1741out_release:
Bob Peterson564e12b2011-11-21 13:36:17 -05001742 if (alloc_required)
Steven Whitehousee285c102009-09-23 13:50:49 +01001743 gfs2_inplace_release(ip);
Steven Whitehousee285c102009-09-23 13:50:49 +01001744out_i:
1745 gfs2_glock_dq_uninit(&i_gh);
1746out_q:
1747 gfs2_glock_dq_uninit(&q_gh);
Bob Peterson0a305e42012-06-06 11:17:59 +01001748out_unlockput:
Al Viro59551022016-01-22 15:40:57 -05001749 inode_unlock(&ip->i_inode);
Bob Peterson0a305e42012-06-06 11:17:59 +01001750out_put:
Steven Whitehousee285c102009-09-23 13:50:49 +01001751 qd_put(qd);
1752 return error;
1753}
1754
Steven Whitehousecc632e72009-09-15 09:59:02 +01001755const struct quotactl_ops gfs2_quotactl_ops = {
1756 .quota_sync = gfs2_quota_sync,
Jan Karae54b2e22014-11-19 16:41:07 +01001757 .get_state = gfs2_quota_get_state,
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04001758 .get_dqblk = gfs2_get_dqblk,
Christoph Hellwigc472b432010-05-06 17:05:17 -04001759 .set_dqblk = gfs2_set_dqblk,
Steven Whitehousecc632e72009-09-15 09:59:02 +01001760};
Steven Whitehousec754fbb2013-12-12 10:47:59 +00001761
1762void __init gfs2_quota_hash_init(void)
1763{
1764 unsigned i;
1765
1766 for(i = 0; i < GFS2_QD_HASH_SIZE; i++)
1767 INIT_HLIST_BL_HEAD(&qd_hash_table[i]);
1768}