blob: a3bde91645c29489fce1097456955235f2a63a12 [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Bob Peterson0d0868b2007-12-11 18:51:25 -06003 * Copyright (C) 2004-2007 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
10/*
11 * Quota change tags are associated with each transaction that allocates or
12 * deallocates space. Those changes are accumulated locally to each node (in a
13 * per-node file) and then are periodically synced to the quota file. This
14 * avoids the bottleneck of constantly touching the quota file, but introduces
15 * fuzziness in the current usage value of IDs that are being used on different
16 * nodes in the cluster simultaneously. So, it is possible for a user on
17 * multiple nodes to overrun their quota, but that overrun is controlable.
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +010018 * Since quota tags are part of transactions, there is no need for a quota check
David Teiglandb3b94fa2006-01-16 16:50:04 +000019 * program to be run on node crashes or anything like that.
20 *
21 * There are couple of knobs that let the administrator manage the quota
22 * fuzziness. "quota_quantum" sets the maximum time a quota change can be
23 * sitting on one node before being synced to the quota file. (The default is
24 * 60 seconds.) Another knob, "quota_scale" controls how quickly the frequency
25 * of quota file syncs increases as the user moves closer to their limit. The
26 * more frequent the syncs, the more accurate the quota enforcement, but that
27 * means that there is more contention between the nodes for the quota file.
28 * The default value is one. This sets the maximum theoretical quota overrun
29 * (with infinite node with infinite bandwidth) to twice the user's limit. (In
30 * practice, the maximum overrun you see should be much less.) A "quota_scale"
31 * number greater than one makes quota syncs more frequent and reduces the
32 * maximum overrun. Numbers less than one (but greater than zero) make quota
33 * syncs less frequent.
34 *
35 * GFS quotas also use per-ID Lock Value Blocks (LVBs) to cache the contents of
36 * the quota file, so it is not being constantly read.
37 */
38
39#include <linux/sched.h>
40#include <linux/slab.h>
Ying Han1495f232011-05-24 17:12:27 -070041#include <linux/mm.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000042#include <linux/spinlock.h>
43#include <linux/completion.h>
44#include <linux/buffer_head.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000045#include <linux/sort.h>
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000046#include <linux/fs.h>
Steven Whitehouse2e565bb2006-10-02 11:38:25 -040047#include <linux/bio.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050048#include <linux/gfs2_ondisk.h>
Steven Whitehouse37b2c832008-11-17 14:25:37 +000049#include <linux/kthread.h>
50#include <linux/freezer.h>
Steven Whitehouse2ec46502009-09-28 12:49:15 +010051#include <linux/quota.h>
Steven Whitehouse1d371b52009-09-11 15:57:27 +010052#include <linux/dqblk_xfs.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000053
54#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050055#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000056#include "bmap.h"
57#include "glock.h"
58#include "glops.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000059#include "log.h"
60#include "meta_io.h"
61#include "quota.h"
62#include "rgrp.h"
63#include "super.h"
64#include "trans.h"
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000065#include "inode.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050066#include "util.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000067
68#define QUOTA_USER 1
69#define QUOTA_GROUP 0
70
Steven Whitehousebb8d8a62007-06-01 14:11:58 +010071struct gfs2_quota_change_host {
72 u64 qc_change;
73 u32 qc_flags; /* GFS2_QCF_... */
74 u32 qc_id;
75};
76
Abhijith Das0a7ab792009-01-07 16:03:37 -060077static LIST_HEAD(qd_lru_list);
78static atomic_t qd_lru_count = ATOMIC_INIT(0);
Xu Gang1328df72009-04-14 14:54:14 +080079static DEFINE_SPINLOCK(qd_lru_lock);
Abhijith Das0a7ab792009-01-07 16:03:37 -060080
Ying Han1495f232011-05-24 17:12:27 -070081int gfs2_shrink_qd_memory(struct shrinker *shrink, struct shrink_control *sc)
Abhijith Das0a7ab792009-01-07 16:03:37 -060082{
83 struct gfs2_quota_data *qd;
84 struct gfs2_sbd *sdp;
Ying Han1495f232011-05-24 17:12:27 -070085 int nr_to_scan = sc->nr_to_scan;
Abhijith Das0a7ab792009-01-07 16:03:37 -060086
Ying Han1495f232011-05-24 17:12:27 -070087 if (nr_to_scan == 0)
Abhijith Das0a7ab792009-01-07 16:03:37 -060088 goto out;
89
Ying Han1495f232011-05-24 17:12:27 -070090 if (!(sc->gfp_mask & __GFP_FS))
Abhijith Das0a7ab792009-01-07 16:03:37 -060091 return -1;
92
93 spin_lock(&qd_lru_lock);
Ying Han1495f232011-05-24 17:12:27 -070094 while (nr_to_scan && !list_empty(&qd_lru_list)) {
Abhijith Das0a7ab792009-01-07 16:03:37 -060095 qd = list_entry(qd_lru_list.next,
96 struct gfs2_quota_data, qd_reclaim);
97 sdp = qd->qd_gl->gl_sbd;
98
99 /* Free from the filesystem-specific list */
100 list_del(&qd->qd_list);
101
Abhijith Das0a7ab792009-01-07 16:03:37 -0600102 gfs2_assert_warn(sdp, !qd->qd_change);
103 gfs2_assert_warn(sdp, !qd->qd_slot_count);
104 gfs2_assert_warn(sdp, !qd->qd_bh_count);
105
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000106 gfs2_glock_put(qd->qd_gl);
Abhijith Das0a7ab792009-01-07 16:03:37 -0600107 atomic_dec(&sdp->sd_quota_count);
108
109 /* Delete it from the common reclaim list */
110 list_del_init(&qd->qd_reclaim);
111 atomic_dec(&qd_lru_count);
112 spin_unlock(&qd_lru_lock);
113 kmem_cache_free(gfs2_quotad_cachep, qd);
114 spin_lock(&qd_lru_lock);
Ying Han1495f232011-05-24 17:12:27 -0700115 nr_to_scan--;
Abhijith Das0a7ab792009-01-07 16:03:37 -0600116 }
117 spin_unlock(&qd_lru_lock);
118
119out:
120 return (atomic_read(&qd_lru_count) * sysctl_vfs_cache_pressure) / 100;
121}
122
Steven Whitehousecd915492006-09-04 12:49:07 -0400123static u64 qd2offset(struct gfs2_quota_data *qd)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000124{
Steven Whitehousecd915492006-09-04 12:49:07 -0400125 u64 offset;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000126
Steven Whitehousecd915492006-09-04 12:49:07 -0400127 offset = 2 * (u64)qd->qd_id + !test_bit(QDF_USER, &qd->qd_flags);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000128 offset *= sizeof(struct gfs2_quota);
129
130 return offset;
131}
132
Steven Whitehousecd915492006-09-04 12:49:07 -0400133static int qd_alloc(struct gfs2_sbd *sdp, int user, u32 id,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000134 struct gfs2_quota_data **qdp)
135{
136 struct gfs2_quota_data *qd;
137 int error;
138
Steven Whitehouse37b2c832008-11-17 14:25:37 +0000139 qd = kmem_cache_zalloc(gfs2_quotad_cachep, GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000140 if (!qd)
141 return -ENOMEM;
142
Abhijith Das0a7ab792009-01-07 16:03:37 -0600143 atomic_set(&qd->qd_count, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000144 qd->qd_id = id;
145 if (user)
146 set_bit(QDF_USER, &qd->qd_flags);
147 qd->qd_slot = -1;
Abhijith Das0a7ab792009-01-07 16:03:37 -0600148 INIT_LIST_HEAD(&qd->qd_reclaim);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000149
Steven Whitehousecd915492006-09-04 12:49:07 -0400150 error = gfs2_glock_get(sdp, 2 * (u64)id + !user,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000151 &gfs2_quota_glops, CREATE, &qd->qd_gl);
152 if (error)
153 goto fail;
154
David Teiglandb3b94fa2006-01-16 16:50:04 +0000155 *qdp = qd;
156
157 return 0;
158
Steven Whitehousea91ea692006-09-04 12:04:26 -0400159fail:
Steven Whitehouse37b2c832008-11-17 14:25:37 +0000160 kmem_cache_free(gfs2_quotad_cachep, qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000161 return error;
162}
163
Steven Whitehouse6a6ada82009-09-15 16:30:38 +0100164static int qd_get(struct gfs2_sbd *sdp, int user, u32 id,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000165 struct gfs2_quota_data **qdp)
166{
167 struct gfs2_quota_data *qd = NULL, *new_qd = NULL;
168 int error, found;
169
170 *qdp = NULL;
171
172 for (;;) {
173 found = 0;
Abhijith Das0a7ab792009-01-07 16:03:37 -0600174 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000175 list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
176 if (qd->qd_id == id &&
177 !test_bit(QDF_USER, &qd->qd_flags) == !user) {
Abhijith Das0a7ab792009-01-07 16:03:37 -0600178 if (!atomic_read(&qd->qd_count) &&
179 !list_empty(&qd->qd_reclaim)) {
180 /* Remove it from reclaim list */
181 list_del_init(&qd->qd_reclaim);
182 atomic_dec(&qd_lru_count);
183 }
184 atomic_inc(&qd->qd_count);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000185 found = 1;
186 break;
187 }
188 }
189
190 if (!found)
191 qd = NULL;
192
193 if (!qd && new_qd) {
194 qd = new_qd;
195 list_add(&qd->qd_list, &sdp->sd_quota_list);
196 atomic_inc(&sdp->sd_quota_count);
197 new_qd = NULL;
198 }
199
Abhijith Das0a7ab792009-01-07 16:03:37 -0600200 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000201
Steven Whitehouse6a6ada82009-09-15 16:30:38 +0100202 if (qd) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000203 if (new_qd) {
Steven Whitehousef057f6c2009-01-12 10:43:39 +0000204 gfs2_glock_put(new_qd->qd_gl);
Steven Whitehouse37b2c832008-11-17 14:25:37 +0000205 kmem_cache_free(gfs2_quotad_cachep, new_qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000206 }
207 *qdp = qd;
208 return 0;
209 }
210
211 error = qd_alloc(sdp, user, id, &new_qd);
212 if (error)
213 return error;
214 }
215}
216
217static void qd_hold(struct gfs2_quota_data *qd)
218{
219 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
Abhijith Das0a7ab792009-01-07 16:03:37 -0600220 gfs2_assert(sdp, atomic_read(&qd->qd_count));
221 atomic_inc(&qd->qd_count);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000222}
223
224static void qd_put(struct gfs2_quota_data *qd)
225{
Abhijith Das0a7ab792009-01-07 16:03:37 -0600226 if (atomic_dec_and_lock(&qd->qd_count, &qd_lru_lock)) {
227 /* Add to the reclaim list */
228 list_add_tail(&qd->qd_reclaim, &qd_lru_list);
229 atomic_inc(&qd_lru_count);
230 spin_unlock(&qd_lru_lock);
231 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000232}
233
234static int slot_get(struct gfs2_quota_data *qd)
235{
236 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
237 unsigned int c, o = 0, b;
238 unsigned char byte = 0;
239
Steven Whitehouse22077f52009-01-08 14:28:42 +0000240 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000241
242 if (qd->qd_slot_count++) {
Steven Whitehouse22077f52009-01-08 14:28:42 +0000243 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000244 return 0;
245 }
246
247 for (c = 0; c < sdp->sd_quota_chunks; c++)
248 for (o = 0; o < PAGE_SIZE; o++) {
249 byte = sdp->sd_quota_bitmap[c][o];
250 if (byte != 0xFF)
251 goto found;
252 }
253
254 goto fail;
255
Steven Whitehousea91ea692006-09-04 12:04:26 -0400256found:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000257 for (b = 0; b < 8; b++)
258 if (!(byte & (1 << b)))
259 break;
260 qd->qd_slot = c * (8 * PAGE_SIZE) + o * 8 + b;
261
262 if (qd->qd_slot >= sdp->sd_quota_slots)
263 goto fail;
264
265 sdp->sd_quota_bitmap[c][o] |= 1 << b;
266
Steven Whitehouse22077f52009-01-08 14:28:42 +0000267 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000268
269 return 0;
270
Steven Whitehousea91ea692006-09-04 12:04:26 -0400271fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000272 qd->qd_slot_count--;
Steven Whitehouse22077f52009-01-08 14:28:42 +0000273 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000274 return -ENOSPC;
275}
276
277static void slot_hold(struct gfs2_quota_data *qd)
278{
279 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
280
Steven Whitehouse22077f52009-01-08 14:28:42 +0000281 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000282 gfs2_assert(sdp, qd->qd_slot_count);
283 qd->qd_slot_count++;
Steven Whitehouse22077f52009-01-08 14:28:42 +0000284 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000285}
286
287static void slot_put(struct gfs2_quota_data *qd)
288{
289 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
290
Steven Whitehouse22077f52009-01-08 14:28:42 +0000291 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000292 gfs2_assert(sdp, qd->qd_slot_count);
293 if (!--qd->qd_slot_count) {
294 gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, qd->qd_slot, 0);
295 qd->qd_slot = -1;
296 }
Steven Whitehouse22077f52009-01-08 14:28:42 +0000297 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000298}
299
300static int bh_get(struct gfs2_quota_data *qd)
301{
302 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400303 struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000304 unsigned int block, offset;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000305 struct buffer_head *bh;
306 int error;
Steven Whitehouse23591252006-10-13 17:25:45 -0400307 struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 };
David Teiglandb3b94fa2006-01-16 16:50:04 +0000308
Steven Whitehousef55ab262006-02-21 12:51:39 +0000309 mutex_lock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000310
311 if (qd->qd_bh_count++) {
Steven Whitehousef55ab262006-02-21 12:51:39 +0000312 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000313 return 0;
314 }
315
316 block = qd->qd_slot / sdp->sd_qc_per_block;
Bob Peterson0d0868b2007-12-11 18:51:25 -0600317 offset = qd->qd_slot % sdp->sd_qc_per_block;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000318
Steven Whitehouse23591252006-10-13 17:25:45 -0400319 bh_map.b_size = 1 << ip->i_inode.i_blkbits;
Bob Petersone9e1ef22007-12-10 14:13:27 -0600320 error = gfs2_block_map(&ip->i_inode, block, &bh_map, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000321 if (error)
322 goto fail;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400323 error = gfs2_meta_read(ip->i_gl, bh_map.b_blocknr, DIO_WAIT, &bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000324 if (error)
325 goto fail;
326 error = -EIO;
327 if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC))
328 goto fail_brelse;
329
330 qd->qd_bh = bh;
331 qd->qd_bh_qc = (struct gfs2_quota_change *)
332 (bh->b_data + sizeof(struct gfs2_meta_header) +
333 offset * sizeof(struct gfs2_quota_change));
334
Josef Whiter2e95b662007-02-20 00:03:29 -0500335 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000336
337 return 0;
338
Steven Whitehousea91ea692006-09-04 12:04:26 -0400339fail_brelse:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000340 brelse(bh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400341fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000342 qd->qd_bh_count--;
Steven Whitehousef55ab262006-02-21 12:51:39 +0000343 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000344 return error;
345}
346
347static void bh_put(struct gfs2_quota_data *qd)
348{
349 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
350
Steven Whitehousef55ab262006-02-21 12:51:39 +0000351 mutex_lock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000352 gfs2_assert(sdp, qd->qd_bh_count);
353 if (!--qd->qd_bh_count) {
354 brelse(qd->qd_bh);
355 qd->qd_bh = NULL;
356 qd->qd_bh_qc = NULL;
357 }
Steven Whitehousef55ab262006-02-21 12:51:39 +0000358 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000359}
360
361static int qd_fish(struct gfs2_sbd *sdp, struct gfs2_quota_data **qdp)
362{
363 struct gfs2_quota_data *qd = NULL;
364 int error;
365 int found = 0;
366
367 *qdp = NULL;
368
369 if (sdp->sd_vfs->s_flags & MS_RDONLY)
370 return 0;
371
Abhijith Das0a7ab792009-01-07 16:03:37 -0600372 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000373
374 list_for_each_entry(qd, &sdp->sd_quota_list, qd_list) {
375 if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
376 !test_bit(QDF_CHANGE, &qd->qd_flags) ||
377 qd->qd_sync_gen >= sdp->sd_quota_sync_gen)
378 continue;
379
380 list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
381
382 set_bit(QDF_LOCKED, &qd->qd_flags);
Abhijith Das0a7ab792009-01-07 16:03:37 -0600383 gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
384 atomic_inc(&qd->qd_count);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000385 qd->qd_change_sync = qd->qd_change;
386 gfs2_assert_warn(sdp, qd->qd_slot_count);
387 qd->qd_slot_count++;
388 found = 1;
389
390 break;
391 }
392
393 if (!found)
394 qd = NULL;
395
Abhijith Das0a7ab792009-01-07 16:03:37 -0600396 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000397
398 if (qd) {
399 gfs2_assert_warn(sdp, qd->qd_change_sync);
400 error = bh_get(qd);
401 if (error) {
402 clear_bit(QDF_LOCKED, &qd->qd_flags);
403 slot_put(qd);
404 qd_put(qd);
405 return error;
406 }
407 }
408
409 *qdp = qd;
410
411 return 0;
412}
413
414static int qd_trylock(struct gfs2_quota_data *qd)
415{
416 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
417
418 if (sdp->sd_vfs->s_flags & MS_RDONLY)
419 return 0;
420
Abhijith Das0a7ab792009-01-07 16:03:37 -0600421 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000422
423 if (test_bit(QDF_LOCKED, &qd->qd_flags) ||
424 !test_bit(QDF_CHANGE, &qd->qd_flags)) {
Abhijith Das0a7ab792009-01-07 16:03:37 -0600425 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000426 return 0;
427 }
428
429 list_move_tail(&qd->qd_list, &sdp->sd_quota_list);
430
431 set_bit(QDF_LOCKED, &qd->qd_flags);
Abhijith Das0a7ab792009-01-07 16:03:37 -0600432 gfs2_assert_warn(sdp, atomic_read(&qd->qd_count));
433 atomic_inc(&qd->qd_count);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000434 qd->qd_change_sync = qd->qd_change;
435 gfs2_assert_warn(sdp, qd->qd_slot_count);
436 qd->qd_slot_count++;
437
Abhijith Das0a7ab792009-01-07 16:03:37 -0600438 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000439
440 gfs2_assert_warn(sdp, qd->qd_change_sync);
441 if (bh_get(qd)) {
442 clear_bit(QDF_LOCKED, &qd->qd_flags);
443 slot_put(qd);
444 qd_put(qd);
445 return 0;
446 }
447
448 return 1;
449}
450
451static void qd_unlock(struct gfs2_quota_data *qd)
452{
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500453 gfs2_assert_warn(qd->qd_gl->gl_sbd,
454 test_bit(QDF_LOCKED, &qd->qd_flags));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000455 clear_bit(QDF_LOCKED, &qd->qd_flags);
456 bh_put(qd);
457 slot_put(qd);
458 qd_put(qd);
459}
460
Steven Whitehouse33a82522009-09-15 16:25:40 +0100461static int qdsb_get(struct gfs2_sbd *sdp, int user, u32 id,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000462 struct gfs2_quota_data **qdp)
463{
464 int error;
465
Steven Whitehouse6a6ada82009-09-15 16:30:38 +0100466 error = qd_get(sdp, user, id, qdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000467 if (error)
468 return error;
469
470 error = slot_get(*qdp);
471 if (error)
472 goto fail;
473
474 error = bh_get(*qdp);
475 if (error)
476 goto fail_slot;
477
478 return 0;
479
Steven Whitehousea91ea692006-09-04 12:04:26 -0400480fail_slot:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000481 slot_put(*qdp);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400482fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000483 qd_put(*qdp);
484 return error;
485}
486
487static void qdsb_put(struct gfs2_quota_data *qd)
488{
489 bh_put(qd);
490 slot_put(qd);
491 qd_put(qd);
492}
493
Steven Whitehousecd915492006-09-04 12:49:07 -0400494int gfs2_quota_hold(struct gfs2_inode *ip, u32 uid, u32 gid)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000495{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400496 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Bob Peterson5407e242012-05-18 09:28:23 -0400497 struct gfs2_quota_data **qd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000498 int error;
499
Bob Peterson5407e242012-05-18 09:28:23 -0400500 if (ip->i_res == NULL)
501 gfs2_rs_alloc(ip);
502
503 qd = ip->i_res->rs_qa_qd;
504
505 if (gfs2_assert_warn(sdp, !ip->i_res->rs_qa_qd_num) ||
David Teiglandb3b94fa2006-01-16 16:50:04 +0000506 gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags)))
507 return -EIO;
508
509 if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
510 return 0;
511
Steven Whitehouse33a82522009-09-15 16:25:40 +0100512 error = qdsb_get(sdp, QUOTA_USER, ip->i_inode.i_uid, qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000513 if (error)
514 goto out;
Bob Peterson5407e242012-05-18 09:28:23 -0400515 ip->i_res->rs_qa_qd_num++;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000516 qd++;
517
Steven Whitehouse33a82522009-09-15 16:25:40 +0100518 error = qdsb_get(sdp, QUOTA_GROUP, ip->i_inode.i_gid, qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000519 if (error)
520 goto out;
Bob Peterson5407e242012-05-18 09:28:23 -0400521 ip->i_res->rs_qa_qd_num++;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000522 qd++;
523
Steven Whitehouse2933f922006-11-01 13:23:29 -0500524 if (uid != NO_QUOTA_CHANGE && uid != ip->i_inode.i_uid) {
Steven Whitehouse33a82522009-09-15 16:25:40 +0100525 error = qdsb_get(sdp, QUOTA_USER, uid, qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000526 if (error)
527 goto out;
Bob Peterson5407e242012-05-18 09:28:23 -0400528 ip->i_res->rs_qa_qd_num++;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000529 qd++;
530 }
531
Steven Whitehouse2933f922006-11-01 13:23:29 -0500532 if (gid != NO_QUOTA_CHANGE && gid != ip->i_inode.i_gid) {
Steven Whitehouse33a82522009-09-15 16:25:40 +0100533 error = qdsb_get(sdp, QUOTA_GROUP, gid, qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000534 if (error)
535 goto out;
Bob Peterson5407e242012-05-18 09:28:23 -0400536 ip->i_res->rs_qa_qd_num++;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000537 qd++;
538 }
539
Steven Whitehousea91ea692006-09-04 12:04:26 -0400540out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000541 if (error)
542 gfs2_quota_unhold(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000543 return error;
544}
545
546void gfs2_quota_unhold(struct gfs2_inode *ip)
547{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400548 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000549 unsigned int x;
550
Bob Peterson5407e242012-05-18 09:28:23 -0400551 if (ip->i_res == NULL)
552 return;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000553 gfs2_assert_warn(sdp, !test_bit(GIF_QD_LOCKED, &ip->i_flags));
554
Bob Peterson5407e242012-05-18 09:28:23 -0400555 for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
556 qdsb_put(ip->i_res->rs_qa_qd[x]);
557 ip->i_res->rs_qa_qd[x] = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000558 }
Bob Peterson5407e242012-05-18 09:28:23 -0400559 ip->i_res->rs_qa_qd_num = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000560}
561
562static int sort_qd(const void *a, const void *b)
563{
Steven Whitehouse48fac172006-09-05 15:17:12 -0400564 const struct gfs2_quota_data *qd_a = *(const struct gfs2_quota_data **)a;
565 const struct gfs2_quota_data *qd_b = *(const struct gfs2_quota_data **)b;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000566
567 if (!test_bit(QDF_USER, &qd_a->qd_flags) !=
568 !test_bit(QDF_USER, &qd_b->qd_flags)) {
569 if (test_bit(QDF_USER, &qd_a->qd_flags))
Steven Whitehouse48fac172006-09-05 15:17:12 -0400570 return -1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000571 else
Steven Whitehouse48fac172006-09-05 15:17:12 -0400572 return 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000573 }
Steven Whitehouse48fac172006-09-05 15:17:12 -0400574 if (qd_a->qd_id < qd_b->qd_id)
575 return -1;
576 if (qd_a->qd_id > qd_b->qd_id)
577 return 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000578
Steven Whitehouse48fac172006-09-05 15:17:12 -0400579 return 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000580}
581
Steven Whitehousecd915492006-09-04 12:49:07 -0400582static void do_qc(struct gfs2_quota_data *qd, s64 change)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000583{
584 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400585 struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000586 struct gfs2_quota_change *qc = qd->qd_bh_qc;
Steven Whitehousecd915492006-09-04 12:49:07 -0400587 s64 x;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000588
Steven Whitehousef55ab262006-02-21 12:51:39 +0000589 mutex_lock(&sdp->sd_quota_mutex);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000590 gfs2_trans_add_bh(ip->i_gl, qd->qd_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000591
592 if (!test_bit(QDF_CHANGE, &qd->qd_flags)) {
593 qc->qc_change = 0;
594 qc->qc_flags = 0;
595 if (test_bit(QDF_USER, &qd->qd_flags))
596 qc->qc_flags = cpu_to_be32(GFS2_QCF_USER);
597 qc->qc_id = cpu_to_be32(qd->qd_id);
598 }
599
Al Virob44b84d2006-10-14 10:46:30 -0400600 x = be64_to_cpu(qc->qc_change) + change;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000601 qc->qc_change = cpu_to_be64(x);
602
Steven Whitehouse22077f52009-01-08 14:28:42 +0000603 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000604 qd->qd_change = x;
Steven Whitehouse22077f52009-01-08 14:28:42 +0000605 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000606
607 if (!x) {
608 gfs2_assert_warn(sdp, test_bit(QDF_CHANGE, &qd->qd_flags));
609 clear_bit(QDF_CHANGE, &qd->qd_flags);
610 qc->qc_flags = 0;
611 qc->qc_id = 0;
612 slot_put(qd);
613 qd_put(qd);
614 } else if (!test_and_set_bit(QDF_CHANGE, &qd->qd_flags)) {
615 qd_hold(qd);
616 slot_hold(qd);
617 }
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400618
Steven Whitehousef55ab262006-02-21 12:51:39 +0000619 mutex_unlock(&sdp->sd_quota_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000620}
621
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000622/**
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100623 * gfs2_adjust_quota - adjust record of current block usage
624 * @ip: The quota inode
625 * @loc: Offset of the entry in the quota file
Steven Whitehousee285c102009-09-23 13:50:49 +0100626 * @change: The amount of usage change to record
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100627 * @qd: The quota data
Steven Whitehousee285c102009-09-23 13:50:49 +0100628 * @fdq: The updated limits to record
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000629 *
630 * This function was mostly borrowed from gfs2_block_truncate_page which was
631 * in turn mostly borrowed from ext3
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100632 *
633 * Returns: 0 or -ve on error
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000634 */
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100635
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000636static int gfs2_adjust_quota(struct gfs2_inode *ip, loff_t loc,
Steven Whitehousee285c102009-09-23 13:50:49 +0100637 s64 change, struct gfs2_quota_data *qd,
638 struct fs_disk_quota *fdq)
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000639{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400640 struct inode *inode = &ip->i_inode;
Abhijith Das14870b42010-11-18 11:24:24 -0500641 struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000642 struct address_space *mapping = inode->i_mapping;
643 unsigned long index = loc >> PAGE_CACHE_SHIFT;
Abhijith Das1990e912007-05-31 17:52:02 -0500644 unsigned offset = loc & (PAGE_CACHE_SIZE - 1);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000645 unsigned blocksize, iblock, pos;
Steven Whitehouseab9bbda2011-08-15 14:20:36 +0100646 struct buffer_head *bh;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000647 struct page *page;
Abhijith Das7e619bc2010-05-07 17:50:18 -0400648 void *kaddr, *ptr;
649 struct gfs2_quota q, *qp;
650 int err, nbytes;
Steven Whitehousee285c102009-09-23 13:50:49 +0100651 u64 size;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000652
Steven Whitehouse891a8e92011-09-19 10:25:49 +0100653 if (gfs2_is_stuffed(ip)) {
654 err = gfs2_unstuff_dinode(ip, NULL);
655 if (err)
656 return err;
657 }
Abhijith Das7e619bc2010-05-07 17:50:18 -0400658
659 memset(&q, 0, sizeof(struct gfs2_quota));
Andrew Price43066292012-04-16 16:40:55 +0100660 err = gfs2_internal_read(ip, (char *)&q, &loc, sizeof(q));
Abhijith Das7e619bc2010-05-07 17:50:18 -0400661 if (err < 0)
662 return err;
663
664 err = -EIO;
665 qp = &q;
666 qp->qu_value = be64_to_cpu(qp->qu_value);
667 qp->qu_value += change;
668 qp->qu_value = cpu_to_be64(qp->qu_value);
669 qd->qd_qb.qb_value = qp->qu_value;
670 if (fdq) {
671 if (fdq->d_fieldmask & FS_DQ_BSOFT) {
Abhijith Das14870b42010-11-18 11:24:24 -0500672 qp->qu_warn = cpu_to_be64(fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift);
Abhijith Das7e619bc2010-05-07 17:50:18 -0400673 qd->qd_qb.qb_warn = qp->qu_warn;
674 }
675 if (fdq->d_fieldmask & FS_DQ_BHARD) {
Abhijith Das14870b42010-11-18 11:24:24 -0500676 qp->qu_limit = cpu_to_be64(fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift);
Abhijith Das7e619bc2010-05-07 17:50:18 -0400677 qd->qd_qb.qb_limit = qp->qu_limit;
678 }
Abhijith Das802ec9b2010-11-18 11:26:46 -0500679 if (fdq->d_fieldmask & FS_DQ_BCOUNT) {
680 qp->qu_value = cpu_to_be64(fdq->d_bcount >> sdp->sd_fsb2bb_shift);
681 qd->qd_qb.qb_value = qp->qu_value;
682 }
Abhijith Das7e619bc2010-05-07 17:50:18 -0400683 }
684
685 /* Write the quota into the quota file on disk */
686 ptr = qp;
687 nbytes = sizeof(struct gfs2_quota);
688get_a_page:
Bob Peterson220cca22012-03-19 15:25:50 -0400689 page = find_or_create_page(mapping, index, GFP_NOFS);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000690 if (!page)
691 return -ENOMEM;
692
693 blocksize = inode->i_sb->s_blocksize;
694 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
695
696 if (!page_has_buffers(page))
697 create_empty_buffers(page, blocksize, 0);
698
699 bh = page_buffers(page);
700 pos = blocksize;
701 while (offset >= pos) {
702 bh = bh->b_this_page;
703 iblock++;
704 pos += blocksize;
705 }
706
707 if (!buffer_mapped(bh)) {
Bob Petersone9e1ef22007-12-10 14:13:27 -0600708 gfs2_block_map(inode, iblock, bh, 1);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000709 if (!buffer_mapped(bh))
Abhijith Das7e619bc2010-05-07 17:50:18 -0400710 goto unlock_out;
711 /* If it's a newly allocated disk block for quota, zero it */
Abhijith Das8b421602010-07-04 01:33:24 -0400712 if (buffer_new(bh))
713 zero_user(page, pos - blocksize, bh->b_size);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000714 }
715
716 if (PageUptodate(page))
717 set_buffer_uptodate(bh);
718
719 if (!buffer_uptodate(bh)) {
Steven Whitehouse20ed0532011-10-31 09:52:02 +0000720 ll_rw_block(READ | REQ_META, 1, &bh);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000721 wait_on_buffer(bh);
722 if (!buffer_uptodate(bh))
Abhijith Das7e619bc2010-05-07 17:50:18 -0400723 goto unlock_out;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000724 }
725
726 gfs2_trans_add_bh(ip->i_gl, bh, 0);
727
Cong Wangd9349282011-11-25 23:14:30 +0800728 kaddr = kmap_atomic(page);
Abhijith Das7e619bc2010-05-07 17:50:18 -0400729 if (offset + sizeof(struct gfs2_quota) > PAGE_CACHE_SIZE)
730 nbytes = PAGE_CACHE_SIZE - offset;
731 memcpy(kaddr + offset, ptr, nbytes);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000732 flush_dcache_page(page);
Cong Wangd9349282011-11-25 23:14:30 +0800733 kunmap_atomic(kaddr);
Abhijith Das7e619bc2010-05-07 17:50:18 -0400734 unlock_page(page);
735 page_cache_release(page);
Steven Whitehousee285c102009-09-23 13:50:49 +0100736
Abhijith Das7e619bc2010-05-07 17:50:18 -0400737 /* If quota straddles page boundary, we need to update the rest of the
738 * quota at the beginning of the next page */
Abhijith Das8b421602010-07-04 01:33:24 -0400739 if ((offset + sizeof(struct gfs2_quota)) > PAGE_CACHE_SIZE) {
Abhijith Das7e619bc2010-05-07 17:50:18 -0400740 ptr = ptr + nbytes;
741 nbytes = sizeof(struct gfs2_quota) - nbytes;
742 offset = 0;
743 index++;
744 goto get_a_page;
745 }
746
Steven Whitehousee285c102009-09-23 13:50:49 +0100747 size = loc + sizeof(struct gfs2_quota);
Steven Whitehousea2e0f792010-08-11 09:53:11 +0100748 if (size > inode->i_size)
Steven Whitehousee285c102009-09-23 13:50:49 +0100749 i_size_write(inode, size);
Steven Whitehousee285c102009-09-23 13:50:49 +0100750 inode->i_mtime = inode->i_atime = CURRENT_TIME;
Steven Whitehousee285c102009-09-23 13:50:49 +0100751 mark_inode_dirty(inode);
Bob Peterson500242a2012-05-15 14:51:54 -0400752 return 0;
Steven Whitehouseab9bbda2011-08-15 14:20:36 +0100753
Abhijith Das7e619bc2010-05-07 17:50:18 -0400754unlock_out:
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000755 unlock_page(page);
756 page_cache_release(page);
757 return err;
758}
759
David Teiglandb3b94fa2006-01-16 16:50:04 +0000760static int do_sync(unsigned int num_qd, struct gfs2_quota_data **qda)
761{
762 struct gfs2_sbd *sdp = (*qda)->qd_gl->gl_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400763 struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000764 unsigned int data_blocks, ind_blocks;
765 struct gfs2_holder *ghs, i_gh;
766 unsigned int qx, x;
767 struct gfs2_quota_data *qd;
Steven Whitehousef42faf42006-01-30 18:34:10 +0000768 loff_t offset;
Abhijith Das20b95bf2008-03-06 17:43:52 -0600769 unsigned int nalloc = 0, blocks;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000770 int error;
771
Bob Peterson0a305e42012-06-06 11:17:59 +0100772 error = gfs2_rs_alloc(ip);
773 if (error)
774 return error;
775
David Teiglandb3b94fa2006-01-16 16:50:04 +0000776 gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
777 &data_blocks, &ind_blocks);
778
Josef Bacik16c5f062008-04-09 09:33:41 -0400779 ghs = kcalloc(num_qd, sizeof(struct gfs2_holder), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000780 if (!ghs)
781 return -ENOMEM;
782
783 sort(qda, num_qd, sizeof(struct gfs2_quota_data *), sort_qd, NULL);
Steven Whitehousee285c102009-09-23 13:50:49 +0100784 mutex_lock_nested(&ip->i_inode.i_mutex, I_MUTEX_QUOTA);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000785 for (qx = 0; qx < num_qd; qx++) {
Steven Whitehouse1e72c0f2009-09-15 20:42:56 +0100786 error = gfs2_glock_nq_init(qda[qx]->qd_gl, LM_ST_EXCLUSIVE,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000787 GL_NOCACHE, &ghs[qx]);
788 if (error)
789 goto out;
790 }
791
792 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
793 if (error)
794 goto out;
795
796 for (x = 0; x < num_qd; x++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000797 offset = qd2offset(qda[x]);
Bob Peterson461cb412010-06-24 19:21:20 -0400798 if (gfs2_write_alloc_required(ip, offset,
799 sizeof(struct gfs2_quota)))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000800 nalloc++;
801 }
802
Abhijith Das20b95bf2008-03-06 17:43:52 -0600803 /*
804 * 1 blk for unstuffing inode if stuffed. We add this extra
805 * block to the reservation unconditionally. If the inode
806 * doesn't need unstuffing, the block will be released to the
807 * rgrp since it won't be allocated during the transaction
808 */
Abhijith Das7e619bc2010-05-07 17:50:18 -0400809 /* +3 in the end for unstuffing block, inode size update block
810 * and another block in case quota straddles page boundary and
811 * two blocks need to be updated instead of 1 */
812 blocks = num_qd * data_blocks + RES_DINODE + num_qd + 3;
Abhijith Das20b95bf2008-03-06 17:43:52 -0600813
Bob Peterson564e12b2011-11-21 13:36:17 -0500814 error = gfs2_inplace_reserve(ip, 1 +
815 (nalloc * (data_blocks + ind_blocks)));
Abhijith Das20b95bf2008-03-06 17:43:52 -0600816 if (error)
817 goto out_alloc;
818
819 if (nalloc)
Steven Whitehouse54335b12011-09-01 13:31:59 +0100820 blocks += gfs2_rg_blocks(ip) + nalloc * ind_blocks + RES_STATFS;
Abhijith Das20b95bf2008-03-06 17:43:52 -0600821
822 error = gfs2_trans_begin(sdp, blocks, 0);
823 if (error)
824 goto out_ipres;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000825
826 for (x = 0; x < num_qd; x++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000827 qd = qda[x];
828 offset = qd2offset(qd);
Steven Whitehousee285c102009-09-23 13:50:49 +0100829 error = gfs2_adjust_quota(ip, offset, qd->qd_change_sync, qd, NULL);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000830 if (error)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000831 goto out_end_trans;
832
David Teiglandb3b94fa2006-01-16 16:50:04 +0000833 do_qc(qd, -qd->qd_change_sync);
Abhijith Das662e3a52011-03-08 10:40:42 -0500834 set_bit(QDF_REFRESH, &qd->qd_flags);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000835 }
836
837 error = 0;
838
Steven Whitehousea91ea692006-09-04 12:04:26 -0400839out_end_trans:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000840 gfs2_trans_end(sdp);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400841out_ipres:
Abhijith Das20b95bf2008-03-06 17:43:52 -0600842 gfs2_inplace_release(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400843out_alloc:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000844 gfs2_glock_dq_uninit(&i_gh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400845out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000846 while (qx--)
847 gfs2_glock_dq_uninit(&ghs[qx]);
Steven Whitehousee285c102009-09-23 13:50:49 +0100848 mutex_unlock(&ip->i_inode.i_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000849 kfree(ghs);
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400850 gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000851 return error;
852}
853
Steven Whitehousee285c102009-09-23 13:50:49 +0100854static int update_qd(struct gfs2_sbd *sdp, struct gfs2_quota_data *qd)
855{
856 struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
857 struct gfs2_quota q;
858 struct gfs2_quota_lvb *qlvb;
859 loff_t pos;
860 int error;
861
862 memset(&q, 0, sizeof(struct gfs2_quota));
863 pos = qd2offset(qd);
Andrew Price43066292012-04-16 16:40:55 +0100864 error = gfs2_internal_read(ip, (char *)&q, &pos, sizeof(q));
Steven Whitehousee285c102009-09-23 13:50:49 +0100865 if (error < 0)
866 return error;
867
868 qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
869 qlvb->qb_magic = cpu_to_be32(GFS2_MAGIC);
870 qlvb->__pad = 0;
871 qlvb->qb_limit = q.qu_limit;
872 qlvb->qb_warn = q.qu_warn;
873 qlvb->qb_value = q.qu_value;
874 qd->qd_qb = *qlvb;
875
876 return 0;
877}
878
David Teiglandb3b94fa2006-01-16 16:50:04 +0000879static int do_glock(struct gfs2_quota_data *qd, int force_refresh,
880 struct gfs2_holder *q_gh)
881{
882 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400883 struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000884 struct gfs2_holder i_gh;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000885 int error;
886
Steven Whitehousea91ea692006-09-04 12:04:26 -0400887restart:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000888 error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_SHARED, 0, q_gh);
889 if (error)
890 return error;
891
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -0400892 qd->qd_qb = *(struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000893
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -0400894 if (force_refresh || qd->qd_qb.qb_magic != cpu_to_be32(GFS2_MAGIC)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000895 gfs2_glock_dq_uninit(q_gh);
Steven Whitehouse91094d02009-09-11 15:21:56 +0100896 error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE,
897 GL_NOCACHE, q_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000898 if (error)
899 return error;
900
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -0400901 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &i_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000902 if (error)
903 goto fail;
904
Steven Whitehousee285c102009-09-23 13:50:49 +0100905 error = update_qd(sdp, qd);
906 if (error)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000907 goto fail_gunlock;
Steven Whitehousee285c102009-09-23 13:50:49 +0100908
David Teiglandb3b94fa2006-01-16 16:50:04 +0000909 gfs2_glock_dq_uninit(&i_gh);
Steven Whitehouse91094d02009-09-11 15:21:56 +0100910 gfs2_glock_dq_uninit(q_gh);
911 force_refresh = 0;
912 goto restart;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000913 }
914
915 return 0;
916
Steven Whitehousea91ea692006-09-04 12:04:26 -0400917fail_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000918 gfs2_glock_dq_uninit(&i_gh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400919fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000920 gfs2_glock_dq_uninit(q_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000921 return error;
922}
923
Steven Whitehousecd915492006-09-04 12:49:07 -0400924int gfs2_quota_lock(struct gfs2_inode *ip, u32 uid, u32 gid)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000925{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400926 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Abhijith Das662e3a52011-03-08 10:40:42 -0500927 struct gfs2_quota_data *qd;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000928 unsigned int x;
929 int error = 0;
930
Steven Whitehouse891a8e92011-09-19 10:25:49 +0100931 error = gfs2_quota_hold(ip, uid, gid);
932 if (error)
933 return error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000934
935 if (capable(CAP_SYS_RESOURCE) ||
936 sdp->sd_args.ar_quota != GFS2_QUOTA_ON)
937 return 0;
938
Bob Peterson5407e242012-05-18 09:28:23 -0400939 sort(ip->i_res->rs_qa_qd, ip->i_res->rs_qa_qd_num,
940 sizeof(struct gfs2_quota_data *), sort_qd, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000941
Bob Peterson5407e242012-05-18 09:28:23 -0400942 for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
Abhijith Das662e3a52011-03-08 10:40:42 -0500943 int force = NO_FORCE;
Bob Peterson5407e242012-05-18 09:28:23 -0400944 qd = ip->i_res->rs_qa_qd[x];
Abhijith Das662e3a52011-03-08 10:40:42 -0500945 if (test_and_clear_bit(QDF_REFRESH, &qd->qd_flags))
946 force = FORCE;
Bob Peterson5407e242012-05-18 09:28:23 -0400947 error = do_glock(qd, force, &ip->i_res->rs_qa_qd_ghs[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000948 if (error)
949 break;
950 }
951
952 if (!error)
953 set_bit(GIF_QD_LOCKED, &ip->i_flags);
954 else {
955 while (x--)
Bob Peterson5407e242012-05-18 09:28:23 -0400956 gfs2_glock_dq_uninit(&ip->i_res->rs_qa_qd_ghs[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000957 gfs2_quota_unhold(ip);
958 }
959
960 return error;
961}
962
963static int need_sync(struct gfs2_quota_data *qd)
964{
965 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
966 struct gfs2_tune *gt = &sdp->sd_tune;
Steven Whitehousecd915492006-09-04 12:49:07 -0400967 s64 value;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000968 unsigned int num, den;
969 int do_sync = 1;
970
971 if (!qd->qd_qb.qb_limit)
972 return 0;
973
Steven Whitehouse22077f52009-01-08 14:28:42 +0000974 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000975 value = qd->qd_change;
Steven Whitehouse22077f52009-01-08 14:28:42 +0000976 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000977
978 spin_lock(&gt->gt_spin);
979 num = gt->gt_quota_scale_num;
980 den = gt->gt_quota_scale_den;
981 spin_unlock(&gt->gt_spin);
982
983 if (value < 0)
984 do_sync = 0;
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -0400985 else if ((s64)be64_to_cpu(qd->qd_qb.qb_value) >=
986 (s64)be64_to_cpu(qd->qd_qb.qb_limit))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000987 do_sync = 0;
988 else {
989 value *= gfs2_jindex_size(sdp) * num;
David Howells4abaca172008-07-11 14:39:56 +0100990 value = div_s64(value, den);
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -0400991 value += (s64)be64_to_cpu(qd->qd_qb.qb_value);
Steven Whitehousecd915492006-09-04 12:49:07 -0400992 if (value < (s64)be64_to_cpu(qd->qd_qb.qb_limit))
David Teiglandb3b94fa2006-01-16 16:50:04 +0000993 do_sync = 0;
994 }
995
996 return do_sync;
997}
998
999void gfs2_quota_unlock(struct gfs2_inode *ip)
1000{
David Teiglandb3b94fa2006-01-16 16:50:04 +00001001 struct gfs2_quota_data *qda[4];
1002 unsigned int count = 0;
1003 unsigned int x;
1004
1005 if (!test_and_clear_bit(GIF_QD_LOCKED, &ip->i_flags))
1006 goto out;
1007
Bob Peterson5407e242012-05-18 09:28:23 -04001008 for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001009 struct gfs2_quota_data *qd;
1010 int sync;
1011
Bob Peterson5407e242012-05-18 09:28:23 -04001012 qd = ip->i_res->rs_qa_qd[x];
David Teiglandb3b94fa2006-01-16 16:50:04 +00001013 sync = need_sync(qd);
1014
Bob Peterson5407e242012-05-18 09:28:23 -04001015 gfs2_glock_dq_uninit(&ip->i_res->rs_qa_qd_ghs[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001016
1017 if (sync && qd_trylock(qd))
1018 qda[count++] = qd;
1019 }
1020
1021 if (count) {
1022 do_sync(count, qda);
1023 for (x = 0; x < count; x++)
1024 qd_unlock(qda[x]);
1025 }
1026
Steven Whitehousea91ea692006-09-04 12:04:26 -04001027out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001028 gfs2_quota_unhold(ip);
1029}
1030
1031#define MAX_LINE 256
1032
1033static int print_message(struct gfs2_quota_data *qd, char *type)
1034{
1035 struct gfs2_sbd *sdp = qd->qd_gl->gl_sbd;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001036
Steven Whitehouse2ec46502009-09-28 12:49:15 +01001037 printk(KERN_INFO "GFS2: fsid=%s: quota %s for %s %u\n",
Steven Whitehouse02630a12006-07-03 11:20:06 -04001038 sdp->sd_fsname, type,
1039 (test_bit(QDF_USER, &qd->qd_flags)) ? "user" : "group",
1040 qd->qd_id);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001041
1042 return 0;
1043}
1044
Steven Whitehousecd915492006-09-04 12:49:07 -04001045int gfs2_quota_check(struct gfs2_inode *ip, u32 uid, u32 gid)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001046{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001047 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001048 struct gfs2_quota_data *qd;
Steven Whitehousecd915492006-09-04 12:49:07 -04001049 s64 value;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001050 unsigned int x;
1051 int error = 0;
1052
1053 if (!test_bit(GIF_QD_LOCKED, &ip->i_flags))
1054 return 0;
1055
1056 if (sdp->sd_args.ar_quota != GFS2_QUOTA_ON)
1057 return 0;
1058
Bob Peterson5407e242012-05-18 09:28:23 -04001059 for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
1060 qd = ip->i_res->rs_qa_qd[x];
David Teiglandb3b94fa2006-01-16 16:50:04 +00001061
1062 if (!((qd->qd_id == uid && test_bit(QDF_USER, &qd->qd_flags)) ||
1063 (qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))))
1064 continue;
1065
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04001066 value = (s64)be64_to_cpu(qd->qd_qb.qb_value);
Steven Whitehouse22077f52009-01-08 14:28:42 +00001067 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001068 value += qd->qd_change;
Steven Whitehouse22077f52009-01-08 14:28:42 +00001069 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001070
Steven Whitehousecd915492006-09-04 12:49:07 -04001071 if (be64_to_cpu(qd->qd_qb.qb_limit) && (s64)be64_to_cpu(qd->qd_qb.qb_limit) < value) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001072 print_message(qd, "exceeded");
Steven Whitehouse2ec46502009-09-28 12:49:15 +01001073 quota_send_warning(test_bit(QDF_USER, &qd->qd_flags) ?
1074 USRQUOTA : GRPQUOTA, qd->qd_id,
1075 sdp->sd_vfs->s_dev, QUOTA_NL_BHARDWARN);
1076
David Teiglandb3b94fa2006-01-16 16:50:04 +00001077 error = -EDQUOT;
1078 break;
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04001079 } else if (be64_to_cpu(qd->qd_qb.qb_warn) &&
Steven Whitehousecd915492006-09-04 12:49:07 -04001080 (s64)be64_to_cpu(qd->qd_qb.qb_warn) < value &&
David Teiglandb3b94fa2006-01-16 16:50:04 +00001081 time_after_eq(jiffies, qd->qd_last_warn +
Steven Whitehouse568f4c92006-02-27 12:00:42 -05001082 gfs2_tune_get(sdp,
1083 gt_quota_warn_period) * HZ)) {
Steven Whitehouse2ec46502009-09-28 12:49:15 +01001084 quota_send_warning(test_bit(QDF_USER, &qd->qd_flags) ?
1085 USRQUOTA : GRPQUOTA, qd->qd_id,
1086 sdp->sd_vfs->s_dev, QUOTA_NL_BSOFTWARN);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001087 error = print_message(qd, "warning");
1088 qd->qd_last_warn = jiffies;
1089 }
1090 }
1091
1092 return error;
1093}
1094
Steven Whitehousecd915492006-09-04 12:49:07 -04001095void gfs2_quota_change(struct gfs2_inode *ip, s64 change,
1096 u32 uid, u32 gid)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001097{
David Teiglandb3b94fa2006-01-16 16:50:04 +00001098 struct gfs2_quota_data *qd;
1099 unsigned int x;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001100
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001101 if (gfs2_assert_warn(GFS2_SB(&ip->i_inode), change))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001102 return;
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001103 if (ip->i_diskflags & GFS2_DIF_SYSTEM)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001104 return;
1105
Bob Peterson5407e242012-05-18 09:28:23 -04001106 for (x = 0; x < ip->i_res->rs_qa_qd_num; x++) {
1107 qd = ip->i_res->rs_qa_qd[x];
David Teiglandb3b94fa2006-01-16 16:50:04 +00001108
1109 if ((qd->qd_id == uid && test_bit(QDF_USER, &qd->qd_flags)) ||
1110 (qd->qd_id == gid && !test_bit(QDF_USER, &qd->qd_flags))) {
1111 do_qc(qd, change);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001112 }
1113 }
1114}
1115
Jan Karaceed1722012-07-03 16:45:28 +02001116int gfs2_quota_sync(struct super_block *sb, int type)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001117{
Steven Whitehouse8c42d632009-09-11 14:36:44 +01001118 struct gfs2_sbd *sdp = sb->s_fs_info;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001119 struct gfs2_quota_data **qda;
1120 unsigned int max_qd = gfs2_tune_get(sdp, gt_quota_simul_sync);
1121 unsigned int num_qd;
1122 unsigned int x;
1123 int error = 0;
1124
1125 sdp->sd_quota_sync_gen++;
1126
1127 qda = kcalloc(max_qd, sizeof(struct gfs2_quota_data *), GFP_KERNEL);
1128 if (!qda)
1129 return -ENOMEM;
1130
1131 do {
1132 num_qd = 0;
1133
1134 for (;;) {
1135 error = qd_fish(sdp, qda + num_qd);
1136 if (error || !qda[num_qd])
1137 break;
1138 if (++num_qd == max_qd)
1139 break;
1140 }
1141
1142 if (num_qd) {
1143 if (!error)
1144 error = do_sync(num_qd, qda);
1145 if (!error)
1146 for (x = 0; x < num_qd; x++)
1147 qda[x]->qd_sync_gen =
1148 sdp->sd_quota_sync_gen;
1149
1150 for (x = 0; x < num_qd; x++)
1151 qd_unlock(qda[x]);
1152 }
1153 } while (!error && num_qd == max_qd);
1154
1155 kfree(qda);
1156
1157 return error;
1158}
1159
Christoph Hellwig5fb324a2010-02-16 03:44:52 -05001160static int gfs2_quota_sync_timeo(struct super_block *sb, int type)
1161{
Jan Karaceed1722012-07-03 16:45:28 +02001162 return gfs2_quota_sync(sb, type);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -05001163}
1164
Steven Whitehousecd915492006-09-04 12:49:07 -04001165int gfs2_quota_refresh(struct gfs2_sbd *sdp, int user, u32 id)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001166{
1167 struct gfs2_quota_data *qd;
1168 struct gfs2_holder q_gh;
1169 int error;
1170
Steven Whitehouse6a6ada82009-09-15 16:30:38 +01001171 error = qd_get(sdp, user, id, &qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001172 if (error)
1173 return error;
1174
1175 error = do_glock(qd, FORCE, &q_gh);
1176 if (!error)
1177 gfs2_glock_dq_uninit(&q_gh);
1178
1179 qd_put(qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001180 return error;
1181}
1182
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001183static void gfs2_quota_change_in(struct gfs2_quota_change_host *qc, const void *buf)
1184{
1185 const struct gfs2_quota_change *str = buf;
1186
1187 qc->qc_change = be64_to_cpu(str->qc_change);
1188 qc->qc_flags = be32_to_cpu(str->qc_flags);
1189 qc->qc_id = be32_to_cpu(str->qc_id);
1190}
1191
David Teiglandb3b94fa2006-01-16 16:50:04 +00001192int gfs2_quota_init(struct gfs2_sbd *sdp)
1193{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001194 struct gfs2_inode *ip = GFS2_I(sdp->sd_qc_inode);
Steven Whitehousea2e0f792010-08-11 09:53:11 +01001195 u64 size = i_size_read(sdp->sd_qc_inode);
1196 unsigned int blocks = size >> sdp->sd_sb.sb_bsize_shift;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001197 unsigned int x, slot = 0;
1198 unsigned int found = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -04001199 u64 dblock;
1200 u32 extlen = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001201 int error;
1202
Steven Whitehousea2e0f792010-08-11 09:53:11 +01001203 if (gfs2_check_internal_file_size(sdp->sd_qc_inode, 1, 64 << 20))
Steven Whitehouse907b9bc2006-09-25 09:26:04 -04001204 return -EIO;
Steven Whitehousea2e0f792010-08-11 09:53:11 +01001205
David Teiglandb3b94fa2006-01-16 16:50:04 +00001206 sdp->sd_quota_slots = blocks * sdp->sd_qc_per_block;
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001207 sdp->sd_quota_chunks = DIV_ROUND_UP(sdp->sd_quota_slots, 8 * PAGE_SIZE);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001208
1209 error = -ENOMEM;
1210
1211 sdp->sd_quota_bitmap = kcalloc(sdp->sd_quota_chunks,
Josef Bacik16c5f062008-04-09 09:33:41 -04001212 sizeof(unsigned char *), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001213 if (!sdp->sd_quota_bitmap)
1214 return error;
1215
1216 for (x = 0; x < sdp->sd_quota_chunks; x++) {
Josef Bacik16c5f062008-04-09 09:33:41 -04001217 sdp->sd_quota_bitmap[x] = kzalloc(PAGE_SIZE, GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001218 if (!sdp->sd_quota_bitmap[x])
1219 goto fail;
1220 }
1221
1222 for (x = 0; x < blocks; x++) {
1223 struct buffer_head *bh;
1224 unsigned int y;
1225
1226 if (!extlen) {
1227 int new = 0;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001228 error = gfs2_extent_map(&ip->i_inode, x, &new, &dblock, &extlen);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001229 if (error)
1230 goto fail;
1231 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001232 error = -EIO;
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001233 bh = gfs2_meta_ra(ip->i_gl, dblock, extlen);
1234 if (!bh)
1235 goto fail;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001236 if (gfs2_metatype_check(sdp, bh, GFS2_METATYPE_QC)) {
1237 brelse(bh);
1238 goto fail;
1239 }
1240
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001241 for (y = 0; y < sdp->sd_qc_per_block && slot < sdp->sd_quota_slots;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001242 y++, slot++) {
Al Virob62f9632006-10-13 23:46:46 -04001243 struct gfs2_quota_change_host qc;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001244 struct gfs2_quota_data *qd;
1245
1246 gfs2_quota_change_in(&qc, bh->b_data +
1247 sizeof(struct gfs2_meta_header) +
1248 y * sizeof(struct gfs2_quota_change));
1249 if (!qc.qc_change)
1250 continue;
1251
1252 error = qd_alloc(sdp, (qc.qc_flags & GFS2_QCF_USER),
1253 qc.qc_id, &qd);
1254 if (error) {
1255 brelse(bh);
1256 goto fail;
1257 }
1258
1259 set_bit(QDF_CHANGE, &qd->qd_flags);
1260 qd->qd_change = qc.qc_change;
1261 qd->qd_slot = slot;
1262 qd->qd_slot_count = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001263
Abhijith Das0a7ab792009-01-07 16:03:37 -06001264 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001265 gfs2_icbit_munge(sdp, sdp->sd_quota_bitmap, slot, 1);
1266 list_add(&qd->qd_list, &sdp->sd_quota_list);
1267 atomic_inc(&sdp->sd_quota_count);
Abhijith Das0a7ab792009-01-07 16:03:37 -06001268 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001269
1270 found++;
1271 }
1272
1273 brelse(bh);
1274 dblock++;
1275 extlen--;
1276 }
1277
1278 if (found)
1279 fs_info(sdp, "found %u quota changes\n", found);
1280
1281 return 0;
1282
Steven Whitehousea91ea692006-09-04 12:04:26 -04001283fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001284 gfs2_quota_cleanup(sdp);
1285 return error;
1286}
1287
David Teiglandb3b94fa2006-01-16 16:50:04 +00001288void gfs2_quota_cleanup(struct gfs2_sbd *sdp)
1289{
1290 struct list_head *head = &sdp->sd_quota_list;
1291 struct gfs2_quota_data *qd;
1292 unsigned int x;
1293
Abhijith Das0a7ab792009-01-07 16:03:37 -06001294 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001295 while (!list_empty(head)) {
1296 qd = list_entry(head->prev, struct gfs2_quota_data, qd_list);
1297
Abhijith Das0a7ab792009-01-07 16:03:37 -06001298 if (atomic_read(&qd->qd_count) > 1 ||
1299 (atomic_read(&qd->qd_count) &&
1300 !test_bit(QDF_CHANGE, &qd->qd_flags))) {
Abhijith Das0a7ab792009-01-07 16:03:37 -06001301 list_move(&qd->qd_list, head);
1302 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001303 schedule();
Abhijith Das0a7ab792009-01-07 16:03:37 -06001304 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001305 continue;
1306 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001307
Abhijith Das0a7ab792009-01-07 16:03:37 -06001308 list_del(&qd->qd_list);
1309 /* Also remove if this qd exists in the reclaim list */
1310 if (!list_empty(&qd->qd_reclaim)) {
1311 list_del_init(&qd->qd_reclaim);
1312 atomic_dec(&qd_lru_count);
1313 }
1314 atomic_dec(&sdp->sd_quota_count);
1315 spin_unlock(&qd_lru_lock);
1316
1317 if (!atomic_read(&qd->qd_count)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001318 gfs2_assert_warn(sdp, !qd->qd_change);
1319 gfs2_assert_warn(sdp, !qd->qd_slot_count);
1320 } else
1321 gfs2_assert_warn(sdp, qd->qd_slot_count == 1);
1322 gfs2_assert_warn(sdp, !qd->qd_bh_count);
1323
Steven Whitehousef057f6c2009-01-12 10:43:39 +00001324 gfs2_glock_put(qd->qd_gl);
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001325 kmem_cache_free(gfs2_quotad_cachep, qd);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001326
Abhijith Das0a7ab792009-01-07 16:03:37 -06001327 spin_lock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001328 }
Abhijith Das0a7ab792009-01-07 16:03:37 -06001329 spin_unlock(&qd_lru_lock);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001330
1331 gfs2_assert_warn(sdp, !atomic_read(&sdp->sd_quota_count));
1332
1333 if (sdp->sd_quota_bitmap) {
1334 for (x = 0; x < sdp->sd_quota_chunks; x++)
1335 kfree(sdp->sd_quota_bitmap[x]);
1336 kfree(sdp->sd_quota_bitmap);
1337 }
1338}
1339
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001340static void quotad_error(struct gfs2_sbd *sdp, const char *msg, int error)
1341{
1342 if (error == 0 || error == -EROFS)
1343 return;
1344 if (!test_bit(SDF_SHUTDOWN, &sdp->sd_flags))
1345 fs_err(sdp, "gfs2_quotad: %s error %d\n", msg, error);
1346}
1347
1348static void quotad_check_timeo(struct gfs2_sbd *sdp, const char *msg,
Steven Whitehouse8c42d632009-09-11 14:36:44 +01001349 int (*fxn)(struct super_block *sb, int type),
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001350 unsigned long t, unsigned long *timeo,
1351 unsigned int *new_timeo)
1352{
1353 if (t >= *timeo) {
Steven Whitehouse8c42d632009-09-11 14:36:44 +01001354 int error = fxn(sdp->sd_vfs, 0);
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001355 quotad_error(sdp, msg, error);
1356 *timeo = gfs2_tune_get_i(&sdp->sd_tune, new_timeo) * HZ;
1357 } else {
1358 *timeo -= t;
1359 }
1360}
1361
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001362static void quotad_check_trunc_list(struct gfs2_sbd *sdp)
1363{
1364 struct gfs2_inode *ip;
1365
1366 while(1) {
1367 ip = NULL;
1368 spin_lock(&sdp->sd_trunc_lock);
1369 if (!list_empty(&sdp->sd_trunc_list)) {
1370 ip = list_entry(sdp->sd_trunc_list.next,
1371 struct gfs2_inode, i_trunc_list);
1372 list_del_init(&ip->i_trunc_list);
1373 }
1374 spin_unlock(&sdp->sd_trunc_lock);
1375 if (ip == NULL)
1376 return;
1377 gfs2_glock_finish_truncate(ip);
1378 }
1379}
1380
Benjamin Marzinski3d3c10f2009-10-20 02:39:44 -05001381void gfs2_wake_up_statfs(struct gfs2_sbd *sdp) {
1382 if (!sdp->sd_statfs_force_sync) {
1383 sdp->sd_statfs_force_sync = 1;
1384 wake_up(&sdp->sd_quota_wait);
1385 }
1386}
1387
1388
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001389/**
1390 * gfs2_quotad - Write cached quota changes into the quota file
1391 * @sdp: Pointer to GFS2 superblock
1392 *
1393 */
1394
1395int gfs2_quotad(void *data)
1396{
1397 struct gfs2_sbd *sdp = data;
1398 struct gfs2_tune *tune = &sdp->sd_tune;
1399 unsigned long statfs_timeo = 0;
1400 unsigned long quotad_timeo = 0;
1401 unsigned long t = 0;
1402 DEFINE_WAIT(wait);
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001403 int empty;
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001404
1405 while (!kthread_should_stop()) {
1406
1407 /* Update the master statfs file */
Benjamin Marzinski3d3c10f2009-10-20 02:39:44 -05001408 if (sdp->sd_statfs_force_sync) {
1409 int error = gfs2_statfs_sync(sdp->sd_vfs, 0);
1410 quotad_error(sdp, "statfs", error);
1411 statfs_timeo = gfs2_tune_get(sdp, gt_statfs_quantum) * HZ;
1412 }
1413 else
1414 quotad_check_timeo(sdp, "statfs", gfs2_statfs_sync, t,
1415 &statfs_timeo,
1416 &tune->gt_statfs_quantum);
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001417
1418 /* Update quota file */
Christoph Hellwig5fb324a2010-02-16 03:44:52 -05001419 quotad_check_timeo(sdp, "sync", gfs2_quota_sync_timeo, t,
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001420 &quotad_timeo, &tune->gt_quota_quantum);
1421
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001422 /* Check for & recover partially truncated inodes */
1423 quotad_check_trunc_list(sdp);
1424
Tejun Heoa0acae02011-11-21 12:32:22 -08001425 try_to_freeze();
1426
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001427 t = min(quotad_timeo, statfs_timeo);
1428
Steven Whitehouse7fa5d202009-03-31 15:49:08 +01001429 prepare_to_wait(&sdp->sd_quota_wait, &wait, TASK_INTERRUPTIBLE);
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001430 spin_lock(&sdp->sd_trunc_lock);
1431 empty = list_empty(&sdp->sd_trunc_list);
1432 spin_unlock(&sdp->sd_trunc_lock);
Benjamin Marzinski3d3c10f2009-10-20 02:39:44 -05001433 if (empty && !sdp->sd_statfs_force_sync)
Steven Whitehouse813e0c42008-11-18 13:38:48 +00001434 t -= schedule_timeout(t);
1435 else
1436 t = 0;
Steven Whitehouse37b2c832008-11-17 14:25:37 +00001437 finish_wait(&sdp->sd_quota_wait, &wait);
1438 }
1439
1440 return 0;
1441}
1442
Steven Whitehouse1d371b52009-09-11 15:57:27 +01001443static int gfs2_quota_get_xstate(struct super_block *sb,
1444 struct fs_quota_stat *fqs)
1445{
1446 struct gfs2_sbd *sdp = sb->s_fs_info;
1447
1448 memset(fqs, 0, sizeof(struct fs_quota_stat));
1449 fqs->qs_version = FS_QSTAT_VERSION;
Christoph Hellwigad6bb902010-05-05 00:10:56 +02001450
1451 switch (sdp->sd_args.ar_quota) {
1452 case GFS2_QUOTA_ON:
Christoph Hellwigade7ce32010-06-04 10:56:01 +02001453 fqs->qs_flags |= (FS_QUOTA_UDQ_ENFD | FS_QUOTA_GDQ_ENFD);
Christoph Hellwigad6bb902010-05-05 00:10:56 +02001454 /*FALLTHRU*/
1455 case GFS2_QUOTA_ACCOUNT:
Christoph Hellwigade7ce32010-06-04 10:56:01 +02001456 fqs->qs_flags |= (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT);
Christoph Hellwigad6bb902010-05-05 00:10:56 +02001457 break;
1458 case GFS2_QUOTA_OFF:
1459 break;
1460 }
1461
Steven Whitehouse1d371b52009-09-11 15:57:27 +01001462 if (sdp->sd_quota_inode) {
1463 fqs->qs_uquota.qfs_ino = GFS2_I(sdp->sd_quota_inode)->i_no_addr;
1464 fqs->qs_uquota.qfs_nblks = sdp->sd_quota_inode->i_blocks;
1465 }
1466 fqs->qs_uquota.qfs_nextents = 1; /* unsupported */
1467 fqs->qs_gquota = fqs->qs_uquota; /* its the same inode in both cases */
1468 fqs->qs_incoredqs = atomic_read(&qd_lru_count);
1469 return 0;
1470}
1471
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04001472static int gfs2_get_dqblk(struct super_block *sb, int type, qid_t id,
1473 struct fs_disk_quota *fdq)
Steven Whitehouse113d6b32009-09-28 11:52:16 +01001474{
1475 struct gfs2_sbd *sdp = sb->s_fs_info;
1476 struct gfs2_quota_lvb *qlvb;
1477 struct gfs2_quota_data *qd;
1478 struct gfs2_holder q_gh;
1479 int error;
1480
1481 memset(fdq, 0, sizeof(struct fs_disk_quota));
1482
1483 if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
1484 return -ESRCH; /* Crazy XFS error code */
1485
1486 if (type == USRQUOTA)
1487 type = QUOTA_USER;
1488 else if (type == GRPQUOTA)
1489 type = QUOTA_GROUP;
1490 else
1491 return -EINVAL;
1492
1493 error = qd_get(sdp, type, id, &qd);
1494 if (error)
1495 return error;
1496 error = do_glock(qd, FORCE, &q_gh);
1497 if (error)
1498 goto out;
1499
1500 qlvb = (struct gfs2_quota_lvb *)qd->qd_gl->gl_lvb;
1501 fdq->d_version = FS_DQUOT_VERSION;
Christoph Hellwigade7ce32010-06-04 10:56:01 +02001502 fdq->d_flags = (type == QUOTA_USER) ? FS_USER_QUOTA : FS_GROUP_QUOTA;
Steven Whitehouse113d6b32009-09-28 11:52:16 +01001503 fdq->d_id = id;
Abhijith Das14870b42010-11-18 11:24:24 -05001504 fdq->d_blk_hardlimit = be64_to_cpu(qlvb->qb_limit) << sdp->sd_fsb2bb_shift;
1505 fdq->d_blk_softlimit = be64_to_cpu(qlvb->qb_warn) << sdp->sd_fsb2bb_shift;
1506 fdq->d_bcount = be64_to_cpu(qlvb->qb_value) << sdp->sd_fsb2bb_shift;
Steven Whitehouse113d6b32009-09-28 11:52:16 +01001507
1508 gfs2_glock_dq_uninit(&q_gh);
1509out:
1510 qd_put(qd);
1511 return error;
1512}
1513
Steven Whitehousee285c102009-09-23 13:50:49 +01001514/* GFS2 only supports a subset of the XFS fields */
Abhijith Das802ec9b2010-11-18 11:26:46 -05001515#define GFS2_FIELDMASK (FS_DQ_BSOFT|FS_DQ_BHARD|FS_DQ_BCOUNT)
Steven Whitehousee285c102009-09-23 13:50:49 +01001516
Christoph Hellwigc472b432010-05-06 17:05:17 -04001517static int gfs2_set_dqblk(struct super_block *sb, int type, qid_t id,
1518 struct fs_disk_quota *fdq)
Steven Whitehousee285c102009-09-23 13:50:49 +01001519{
1520 struct gfs2_sbd *sdp = sb->s_fs_info;
1521 struct gfs2_inode *ip = GFS2_I(sdp->sd_quota_inode);
1522 struct gfs2_quota_data *qd;
1523 struct gfs2_holder q_gh, i_gh;
1524 unsigned int data_blocks, ind_blocks;
1525 unsigned int blocks = 0;
1526 int alloc_required;
Steven Whitehousee285c102009-09-23 13:50:49 +01001527 loff_t offset;
1528 int error;
1529
1530 if (sdp->sd_args.ar_quota == GFS2_QUOTA_OFF)
1531 return -ESRCH; /* Crazy XFS error code */
1532
1533 switch(type) {
1534 case USRQUOTA:
1535 type = QUOTA_USER;
Christoph Hellwigade7ce32010-06-04 10:56:01 +02001536 if (fdq->d_flags != FS_USER_QUOTA)
Steven Whitehousee285c102009-09-23 13:50:49 +01001537 return -EINVAL;
1538 break;
1539 case GRPQUOTA:
1540 type = QUOTA_GROUP;
Christoph Hellwigade7ce32010-06-04 10:56:01 +02001541 if (fdq->d_flags != FS_GROUP_QUOTA)
Steven Whitehousee285c102009-09-23 13:50:49 +01001542 return -EINVAL;
1543 break;
1544 default:
1545 return -EINVAL;
1546 }
1547
1548 if (fdq->d_fieldmask & ~GFS2_FIELDMASK)
1549 return -EINVAL;
1550 if (fdq->d_id != id)
1551 return -EINVAL;
1552
1553 error = qd_get(sdp, type, id, &qd);
1554 if (error)
1555 return error;
1556
Bob Peterson0a305e42012-06-06 11:17:59 +01001557 error = gfs2_rs_alloc(ip);
1558 if (error)
1559 goto out_put;
1560
Steven Whitehousee285c102009-09-23 13:50:49 +01001561 mutex_lock(&ip->i_inode.i_mutex);
1562 error = gfs2_glock_nq_init(qd->qd_gl, LM_ST_EXCLUSIVE, 0, &q_gh);
1563 if (error)
Bob Peterson0a305e42012-06-06 11:17:59 +01001564 goto out_unlockput;
Steven Whitehousee285c102009-09-23 13:50:49 +01001565 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1566 if (error)
1567 goto out_q;
1568
1569 /* Check for existing entry, if none then alloc new blocks */
1570 error = update_qd(sdp, qd);
1571 if (error)
1572 goto out_i;
1573
1574 /* If nothing has changed, this is a no-op */
1575 if ((fdq->d_fieldmask & FS_DQ_BSOFT) &&
Abhijith Das14870b42010-11-18 11:24:24 -05001576 ((fdq->d_blk_softlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_warn)))
Steven Whitehousee285c102009-09-23 13:50:49 +01001577 fdq->d_fieldmask ^= FS_DQ_BSOFT;
Abhijith Das802ec9b2010-11-18 11:26:46 -05001578
Steven Whitehousee285c102009-09-23 13:50:49 +01001579 if ((fdq->d_fieldmask & FS_DQ_BHARD) &&
Abhijith Das14870b42010-11-18 11:24:24 -05001580 ((fdq->d_blk_hardlimit >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_limit)))
Steven Whitehousee285c102009-09-23 13:50:49 +01001581 fdq->d_fieldmask ^= FS_DQ_BHARD;
Abhijith Das802ec9b2010-11-18 11:26:46 -05001582
1583 if ((fdq->d_fieldmask & FS_DQ_BCOUNT) &&
1584 ((fdq->d_bcount >> sdp->sd_fsb2bb_shift) == be64_to_cpu(qd->qd_qb.qb_value)))
1585 fdq->d_fieldmask ^= FS_DQ_BCOUNT;
1586
Steven Whitehousee285c102009-09-23 13:50:49 +01001587 if (fdq->d_fieldmask == 0)
1588 goto out_i;
1589
1590 offset = qd2offset(qd);
Bob Peterson461cb412010-06-24 19:21:20 -04001591 alloc_required = gfs2_write_alloc_required(ip, offset, sizeof(struct gfs2_quota));
Abhijith Dase79a46a2011-02-07 11:22:41 -05001592 if (gfs2_is_stuffed(ip))
1593 alloc_required = 1;
Steven Whitehousee285c102009-09-23 13:50:49 +01001594 if (alloc_required) {
Steven Whitehousee285c102009-09-23 13:50:49 +01001595 gfs2_write_calc_reserv(ip, sizeof(struct gfs2_quota),
1596 &data_blocks, &ind_blocks);
Bob Peterson564e12b2011-11-21 13:36:17 -05001597 blocks = 1 + data_blocks + ind_blocks;
1598 error = gfs2_inplace_reserve(ip, blocks);
Steven Whitehousee285c102009-09-23 13:50:49 +01001599 if (error)
Bob Peterson564e12b2011-11-21 13:36:17 -05001600 goto out_i;
Steven Whitehouse54335b12011-09-01 13:31:59 +01001601 blocks += gfs2_rg_blocks(ip);
Steven Whitehousee285c102009-09-23 13:50:49 +01001602 }
1603
Abhijith Dase79a46a2011-02-07 11:22:41 -05001604 /* Some quotas span block boundaries and can update two blocks,
1605 adding an extra block to the transaction to handle such quotas */
1606 error = gfs2_trans_begin(sdp, blocks + RES_DINODE + 2, 0);
Steven Whitehousee285c102009-09-23 13:50:49 +01001607 if (error)
1608 goto out_release;
1609
1610 /* Apply changes */
1611 error = gfs2_adjust_quota(ip, offset, 0, qd, fdq);
1612
1613 gfs2_trans_end(sdp);
1614out_release:
Bob Peterson564e12b2011-11-21 13:36:17 -05001615 if (alloc_required)
Steven Whitehousee285c102009-09-23 13:50:49 +01001616 gfs2_inplace_release(ip);
Steven Whitehousee285c102009-09-23 13:50:49 +01001617out_i:
1618 gfs2_glock_dq_uninit(&i_gh);
1619out_q:
1620 gfs2_glock_dq_uninit(&q_gh);
Bob Peterson0a305e42012-06-06 11:17:59 +01001621out_unlockput:
Steven Whitehousee285c102009-09-23 13:50:49 +01001622 mutex_unlock(&ip->i_inode.i_mutex);
Bob Peterson0a305e42012-06-06 11:17:59 +01001623out_put:
Steven Whitehousee285c102009-09-23 13:50:49 +01001624 qd_put(qd);
1625 return error;
1626}
1627
Steven Whitehousecc632e72009-09-15 09:59:02 +01001628const struct quotactl_ops gfs2_quotactl_ops = {
1629 .quota_sync = gfs2_quota_sync,
Steven Whitehouse1d371b52009-09-11 15:57:27 +01001630 .get_xstate = gfs2_quota_get_xstate,
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04001631 .get_dqblk = gfs2_get_dqblk,
Christoph Hellwigc472b432010-05-06 17:05:17 -04001632 .set_dqblk = gfs2_set_dqblk,
Steven Whitehousecc632e72009-09-15 09:59:02 +01001633};