blob: 121f632213a74fe479cfc1e4be9f49c9304b6338 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott4ce31212005-11-02 14:59:41 +11002 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
3 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott4ce31212005-11-02 14:59:41 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott4ce31212005-11-02 14:59:41 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott4ce31212005-11-02 14:59:41 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include "xfs.h"
19#include "xfs_fs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110020#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_trans.h"
24#include "xfs_sb.h"
25#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_alloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_quota.h"
28#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_bmap_btree.h"
30#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_dinode.h"
32#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110033#include "xfs_ialloc.h"
34#include "xfs_itable.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "xfs_rtalloc.h"
36#include "xfs_error.h"
Nathan Scotta844f452005-11-02 14:38:42 +110037#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "xfs_attr.h"
39#include "xfs_buf_item.h"
40#include "xfs_trans_space.h"
41#include "xfs_utils.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include "xfs_qm.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000043#include "xfs_trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
45/*
46 * The global quota manager. There is only one of these for the entire
47 * system, _not_ one per file system. XQM keeps track of the overall
48 * quota functionality, including maintaining the freelist and hash
49 * tables of dquots.
50 */
Christoph Hellwiga0b0b8a2009-03-29 09:51:00 +020051struct mutex xfs_Gqm_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052struct xfs_qm *xfs_Gqm;
Nathan Scott6b3f6b52005-11-02 15:08:25 +110053uint ndquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55kmem_zone_t *qm_dqzone;
56kmem_zone_t *qm_dqtrxzone;
Linus Torvalds1da177e2005-04-16 15:20:36 -070057
David Chinner7989cb82007-02-10 18:34:56 +110058static cred_t xfs_zerocr;
Nathan Scottdae81d42006-02-28 12:30:13 +110059
Linus Torvalds1da177e2005-04-16 15:20:36 -070060STATIC void xfs_qm_list_init(xfs_dqlist_t *, char *, int);
61STATIC void xfs_qm_list_destroy(xfs_dqlist_t *);
62
63STATIC int xfs_qm_init_quotainos(xfs_mount_t *);
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100064STATIC int xfs_qm_init_quotainfo(xfs_mount_t *);
Dave Chinner7f8275d2010-07-19 14:56:17 +100065STATIC int xfs_qm_shake(struct shrinker *, int, gfp_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Rusty Russell8e1f9362007-07-17 04:03:17 -070067static struct shrinker xfs_qm_shaker = {
68 .shrink = xfs_qm_shake,
69 .seeks = DEFAULT_SEEKS,
70};
71
Linus Torvalds1da177e2005-04-16 15:20:36 -070072#ifdef DEBUG
Christoph Hellwiga0b0b8a2009-03-29 09:51:00 +020073extern struct mutex qcheck_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#endif
75
76#ifdef QUOTADEBUG
Dave Chinner3a254042010-04-13 15:06:48 +100077static void
78xfs_qm_dquot_list_print(
79 struct xfs_mount *mp)
80{
81 xfs_dquot_t *dqp;
82 int i = 0;
83
84 list_for_each_entry(dqp, &mp->m_quotainfo->qi_dqlist_lock, qi_mplist) {
85 cmn_err(CE_DEBUG, " %d. \"%d (%s)\" "
86 "bcnt = %lld, icnt = %lld, refs = %d",
87 i++, be32_to_cpu(dqp->q_core.d_id),
88 DQFLAGTO_TYPESTR(dqp),
89 (long long)be64_to_cpu(dqp->q_core.d_bcount),
90 (long long)be64_to_cpu(dqp->q_core.d_icount),
91 dqp->q_nrefs);
92 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
94#else
Dave Chinner3a254042010-04-13 15:06:48 +100095static void xfs_qm_dquot_list_print(struct xfs_mount *mp) { }
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#endif
97
98/*
99 * Initialize the XQM structure.
100 * Note that there is not one quota manager per file system.
101 */
102STATIC struct xfs_qm *
103xfs_Gqm_init(void)
104{
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100105 xfs_dqhash_t *udqhash, *gdqhash;
106 xfs_qm_t *xqm;
Nathan Scott215101c2006-09-28 11:04:43 +1000107 size_t hsize;
108 uint i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109
110 /*
111 * Initialize the dquot hash tables.
112 */
Nathan Scott77e46352006-09-28 11:03:27 +1000113 udqhash = kmem_zalloc_greedy(&hsize,
Eric Sandeen5995cb72007-08-16 16:49:11 +1000114 XFS_QM_HASHSIZE_LOW * sizeof(xfs_dqhash_t),
Christoph Hellwigbdfb0432010-01-20 21:55:30 +0000115 XFS_QM_HASHSIZE_HIGH * sizeof(xfs_dqhash_t));
116 if (!udqhash)
117 goto out;
118
119 gdqhash = kmem_zalloc_large(hsize);
Julia Lawalld67b1b02010-02-06 08:45:15 +0000120 if (!gdqhash)
Christoph Hellwigbdfb0432010-01-20 21:55:30 +0000121 goto out_free_udqhash;
122
Nathan Scott77e46352006-09-28 11:03:27 +1000123 hsize /= sizeof(xfs_dqhash_t);
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100124 ndquot = hsize << 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
Nathan Scott6b3f6b52005-11-02 15:08:25 +1100126 xqm = kmem_zalloc(sizeof(xfs_qm_t), KM_SLEEP);
127 xqm->qm_dqhashmask = hsize - 1;
128 xqm->qm_usr_dqhtable = udqhash;
129 xqm->qm_grp_dqhtable = gdqhash;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 ASSERT(xqm->qm_usr_dqhtable != NULL);
131 ASSERT(xqm->qm_grp_dqhtable != NULL);
132
133 for (i = 0; i < hsize; i++) {
134 xfs_qm_list_init(&(xqm->qm_usr_dqhtable[i]), "uxdqh", i);
135 xfs_qm_list_init(&(xqm->qm_grp_dqhtable[i]), "gxdqh", i);
136 }
137
138 /*
139 * Freelist of all dquots of all file systems
140 */
Dave Chinner3a8406f2010-04-13 15:06:52 +1000141 INIT_LIST_HEAD(&xqm->qm_dqfrlist);
142 xqm->qm_dqfrlist_cnt = 0;
143 mutex_init(&xqm->qm_dqfrlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144
145 /*
146 * dquot zone. we register our own low-memory callback.
147 */
148 if (!qm_dqzone) {
149 xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
150 "xfs_dquots");
151 qm_dqzone = xqm->qm_dqzone;
152 } else
153 xqm->qm_dqzone = qm_dqzone;
154
Rusty Russell8e1f9362007-07-17 04:03:17 -0700155 register_shrinker(&xfs_qm_shaker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 /*
158 * The t_dqinfo portion of transactions.
159 */
160 if (!qm_dqtrxzone) {
161 xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
162 "xfs_dqtrx");
163 qm_dqtrxzone = xqm->qm_dqtrxzone;
164 } else
165 xqm->qm_dqtrxzone = qm_dqtrxzone;
166
167 atomic_set(&xqm->qm_totaldquots, 0);
168 xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
169 xqm->qm_nrefs = 0;
170#ifdef DEBUG
Nathan Scottc2e81432006-01-16 16:21:34 +1100171 mutex_init(&qcheck_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172#endif
173 return xqm;
Christoph Hellwigbdfb0432010-01-20 21:55:30 +0000174
175 out_free_udqhash:
176 kmem_free_large(udqhash);
177 out:
178 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179}
180
181/*
182 * Destroy the global quota manager when its reference count goes to zero.
183 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000184STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185xfs_qm_destroy(
186 struct xfs_qm *xqm)
187{
Dave Chinner3a8406f2010-04-13 15:06:52 +1000188 struct xfs_dquot *dqp, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 int hsize, i;
190
191 ASSERT(xqm != NULL);
192 ASSERT(xqm->qm_nrefs == 0);
Rusty Russell8e1f9362007-07-17 04:03:17 -0700193 unregister_shrinker(&xfs_qm_shaker);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 hsize = xqm->qm_dqhashmask + 1;
195 for (i = 0; i < hsize; i++) {
196 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
197 xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
198 }
Christoph Hellwigbdfb0432010-01-20 21:55:30 +0000199 kmem_free_large(xqm->qm_usr_dqhtable);
200 kmem_free_large(xqm->qm_grp_dqhtable);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 xqm->qm_usr_dqhtable = NULL;
202 xqm->qm_grp_dqhtable = NULL;
203 xqm->qm_dqhashmask = 0;
Dave Chinner3a8406f2010-04-13 15:06:52 +1000204
205 /* frlist cleanup */
206 mutex_lock(&xqm->qm_dqfrlist_lock);
207 list_for_each_entry_safe(dqp, n, &xqm->qm_dqfrlist, q_freelist) {
208 xfs_dqlock(dqp);
209#ifdef QUOTADEBUG
210 cmn_err(CE_DEBUG, "FREELIST destroy 0x%p", dqp);
211#endif
212 list_del_init(&dqp->q_freelist);
213 xfs_Gqm->qm_dqfrlist_cnt--;
214 xfs_dqunlock(dqp);
215 xfs_qm_dqdestroy(dqp);
216 }
217 mutex_unlock(&xqm->qm_dqfrlist_lock);
218 mutex_destroy(&xqm->qm_dqfrlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219#ifdef DEBUG
220 mutex_destroy(&qcheck_lock);
221#endif
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000222 kmem_free(xqm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223}
224
225/*
226 * Called at mount time to let XQM know that another file system is
227 * starting quotas. This isn't crucial information as the individual mount
228 * structures are pretty independent, but it helps the XQM keep a
229 * global view of what's going on.
230 */
231/* ARGSUSED */
232STATIC int
233xfs_qm_hold_quotafs_ref(
234 struct xfs_mount *mp)
235{
236 /*
237 * Need to lock the xfs_Gqm structure for things like this. For example,
238 * the structure could disappear between the entry to this routine and
239 * a HOLD operation if not locked.
240 */
Christoph Hellwige2494582009-02-09 08:38:39 +0100241 mutex_lock(&xfs_Gqm_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
Christoph Hellwigbdfb0432010-01-20 21:55:30 +0000243 if (!xfs_Gqm) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 xfs_Gqm = xfs_Gqm_init();
Julia Lawall38e712a2010-05-26 15:57:23 +0000245 if (!xfs_Gqm) {
246 mutex_unlock(&xfs_Gqm_lock);
Christoph Hellwigbdfb0432010-01-20 21:55:30 +0000247 return ENOMEM;
Julia Lawall38e712a2010-05-26 15:57:23 +0000248 }
Christoph Hellwigbdfb0432010-01-20 21:55:30 +0000249 }
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 /*
252 * We can keep a list of all filesystems with quotas mounted for
253 * debugging and statistical purposes, but ...
254 * Just take a reference and get out.
255 */
Christoph Hellwige2494582009-02-09 08:38:39 +0100256 xfs_Gqm->qm_nrefs++;
257 mutex_unlock(&xfs_Gqm_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
259 return 0;
260}
261
262
263/*
264 * Release the reference that a filesystem took at mount time,
265 * so that we know when we need to destroy the entire quota manager.
266 */
267/* ARGSUSED */
268STATIC void
269xfs_qm_rele_quotafs_ref(
270 struct xfs_mount *mp)
271{
Dave Chinner3a8406f2010-04-13 15:06:52 +1000272 xfs_dquot_t *dqp, *n;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274 ASSERT(xfs_Gqm);
275 ASSERT(xfs_Gqm->qm_nrefs > 0);
276
277 /*
278 * Go thru the freelist and destroy all inactive dquots.
279 */
Dave Chinner3a8406f2010-04-13 15:06:52 +1000280 mutex_lock(&xfs_Gqm->qm_dqfrlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
Dave Chinner3a8406f2010-04-13 15:06:52 +1000282 list_for_each_entry_safe(dqp, n, &xfs_Gqm->qm_dqfrlist, q_freelist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 xfs_dqlock(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
285 ASSERT(dqp->q_mount == NULL);
286 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
Dave Chinnere6a81f12010-04-13 15:06:51 +1000287 ASSERT(list_empty(&dqp->q_hashlist));
Dave Chinner3a254042010-04-13 15:06:48 +1000288 ASSERT(list_empty(&dqp->q_mplist));
Dave Chinner3a8406f2010-04-13 15:06:52 +1000289 list_del_init(&dqp->q_freelist);
290 xfs_Gqm->qm_dqfrlist_cnt--;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 xfs_dqunlock(dqp);
292 xfs_qm_dqdestroy(dqp);
293 } else {
294 xfs_dqunlock(dqp);
295 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 }
Dave Chinner3a8406f2010-04-13 15:06:52 +1000297 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298
299 /*
300 * Destroy the entire XQM. If somebody mounts with quotaon, this'll
301 * be restarted.
302 */
Christoph Hellwige2494582009-02-09 08:38:39 +0100303 mutex_lock(&xfs_Gqm_lock);
304 if (--xfs_Gqm->qm_nrefs == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 xfs_qm_destroy(xfs_Gqm);
306 xfs_Gqm = NULL;
307 }
Christoph Hellwige2494582009-02-09 08:38:39 +0100308 mutex_unlock(&xfs_Gqm_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309}
310
311/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 * Just destroy the quotainfo structure.
313 */
314void
Christoph Hellwig7d095252009-06-08 15:33:32 +0200315xfs_qm_unmount(
316 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
Christoph Hellwig7d095252009-06-08 15:33:32 +0200318 if (mp->m_quotainfo) {
Christoph Hellwig8112e9d2010-04-20 17:02:29 +1000319 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 xfs_qm_destroy_quotainfo(mp);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200321 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322}
323
324
325/*
326 * This is called from xfs_mountfs to start quotas and initialize all
327 * necessary data structures like quotainfo. This is also responsible for
328 * running a quotacheck as necessary. We are guaranteed that the superblock
329 * is consistently read in at this point.
David Chinner53aa7912008-04-10 12:20:31 +1000330 *
331 * If we fail here, the mount will continue with quota turned off. We don't
332 * need to inidicate success or failure at all.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 */
David Chinner53aa7912008-04-10 12:20:31 +1000334void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335xfs_qm_mount_quotas(
Christoph Hellwig42490232008-08-13 16:49:32 +1000336 xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 int error = 0;
339 uint sbf;
340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 /*
342 * If quotas on realtime volumes is not supported, we disable
343 * quotas immediately.
344 */
345 if (mp->m_sb.sb_rextents) {
346 cmn_err(CE_NOTE,
347 "Cannot turn on quotas for realtime filesystem %s",
348 mp->m_fsname);
349 mp->m_qflags = 0;
350 goto write_changes;
351 }
352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
Nathan Scott155ffd02005-09-02 16:43:48 +1000354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 /*
356 * Allocate the quotainfo structure inside the mount struct, and
357 * create quotainode(s), and change/rev superblock if necessary.
358 */
David Chinner53aa7912008-04-10 12:20:31 +1000359 error = xfs_qm_init_quotainfo(mp);
360 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 /*
362 * We must turn off quotas.
363 */
364 ASSERT(mp->m_quotainfo == NULL);
365 mp->m_qflags = 0;
366 goto write_changes;
367 }
368 /*
369 * If any of the quotas are not consistent, do a quotacheck.
370 */
Christoph Hellwig42490232008-08-13 16:49:32 +1000371 if (XFS_QM_NEED_QUOTACHECK(mp)) {
David Chinner53aa7912008-04-10 12:20:31 +1000372 error = xfs_qm_quotacheck(mp);
373 if (error) {
374 /* Quotacheck failed and disabled quotas. */
375 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 }
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000378 /*
379 * If one type of quotas is off, then it will lose its
380 * quotachecked status, since we won't be doing accounting for
381 * that type anymore.
382 */
David Chinner53aa7912008-04-10 12:20:31 +1000383 if (!XFS_IS_UQUOTA_ON(mp))
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000384 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
David Chinner53aa7912008-04-10 12:20:31 +1000385 if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000386 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
Nathan Scott155ffd02005-09-02 16:43:48 +1000387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 write_changes:
389 /*
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000390 * We actually don't have to acquire the m_sb_lock at all.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 * This can only be called from mount, and that's single threaded. XXX
392 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000393 spin_lock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 sbf = mp->m_sb.sb_qflags;
395 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000396 spin_unlock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
399 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
400 /*
401 * We could only have been turning quotas off.
402 * We aren't in very good shape actually because
403 * the incore structures are convinced that quotas are
404 * off, but the on disk superblock doesn't know that !
405 */
406 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
407 xfs_fs_cmn_err(CE_ALERT, mp,
408 "XFS mount_quotas: Superblock update failed!");
409 }
410 }
411
412 if (error) {
413 xfs_fs_cmn_err(CE_WARN, mp,
414 "Failed to initialize disk quotas.");
Christoph Hellwig7d095252009-06-08 15:33:32 +0200415 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 }
Christoph Hellwig7d095252009-06-08 15:33:32 +0200417
418#ifdef QUOTADEBUG
419 if (XFS_IS_QUOTA_ON(mp))
420 xfs_qm_internalqcheck(mp);
421#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422}
423
424/*
425 * Called from the vfsops layer.
426 */
Christoph Hellwige57481d2008-12-03 12:20:36 +0100427void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428xfs_qm_unmount_quotas(
429 xfs_mount_t *mp)
430{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 /*
432 * Release the dquots that root inode, et al might be holding,
433 * before we flush quotas and blow away the quotainfo structure.
434 */
435 ASSERT(mp->m_rootip);
436 xfs_qm_dqdetach(mp->m_rootip);
437 if (mp->m_rbmip)
438 xfs_qm_dqdetach(mp->m_rbmip);
439 if (mp->m_rsumip)
440 xfs_qm_dqdetach(mp->m_rsumip);
441
442 /*
Christoph Hellwige57481d2008-12-03 12:20:36 +0100443 * Release the quota inodes.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 if (mp->m_quotainfo) {
Christoph Hellwige57481d2008-12-03 12:20:36 +0100446 if (mp->m_quotainfo->qi_uquotaip) {
447 IRELE(mp->m_quotainfo->qi_uquotaip);
448 mp->m_quotainfo->qi_uquotaip = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 }
Christoph Hellwige57481d2008-12-03 12:20:36 +0100450 if (mp->m_quotainfo->qi_gquotaip) {
451 IRELE(mp->m_quotainfo->qi_gquotaip);
452 mp->m_quotainfo->qi_gquotaip = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 }
454 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455}
456
457/*
458 * Flush all dquots of the given file system to disk. The dquots are
459 * _not_ purged from memory here, just their data written to disk.
460 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000461STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462xfs_qm_dqflush_all(
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000463 struct xfs_mount *mp,
464 int sync_mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000466 struct xfs_quotainfo *q = mp->m_quotainfo;
467 int recl;
468 struct xfs_dquot *dqp;
469 int niters;
470 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000472 if (!q)
Jesper Juhl014c2542006-01-15 02:37:08 +0100473 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 niters = 0;
475again:
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000476 mutex_lock(&q->qi_dqlist_lock);
477 list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 xfs_dqlock(dqp);
479 if (! XFS_DQ_IS_DIRTY(dqp)) {
480 xfs_dqunlock(dqp);
481 continue;
482 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000483
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 /* XXX a sentinel would be better */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000485 recl = q->qi_dqreclaims;
David Chinnere1f49cf2008-08-13 16:41:43 +1000486 if (!xfs_dqflock_nowait(dqp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 /*
488 * If we can't grab the flush lock then check
489 * to see if the dquot has been flushed delayed
490 * write. If so, grab its buffer and send it
491 * out immediately. We'll be able to acquire
492 * the flush lock when the I/O completes.
493 */
494 xfs_qm_dqflock_pushbuf_wait(dqp);
495 }
496 /*
497 * Let go of the mplist lock. We don't want to hold it
498 * across a disk write.
499 */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000500 mutex_unlock(&q->qi_dqlist_lock);
Dave Chinner20026d92010-02-04 09:48:58 +1100501 error = xfs_qm_dqflush(dqp, sync_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 xfs_dqunlock(dqp);
503 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +0100504 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000506 mutex_lock(&q->qi_dqlist_lock);
507 if (recl != q->qi_dqreclaims) {
508 mutex_unlock(&q->qi_dqlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 /* XXX restart limit */
510 goto again;
511 }
512 }
513
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000514 mutex_unlock(&q->qi_dqlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 /* return ! busy */
Jesper Juhl014c2542006-01-15 02:37:08 +0100516 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517}
518/*
519 * Release the group dquot pointers the user dquots may be
520 * carrying around as a hint. mplist is locked on entry and exit.
521 */
522STATIC void
523xfs_qm_detach_gdquots(
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000524 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525{
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000526 struct xfs_quotainfo *q = mp->m_quotainfo;
527 struct xfs_dquot *dqp, *gdqp;
528 int nrecl;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529
530 again:
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000531 ASSERT(mutex_is_locked(&q->qi_dqlist_lock));
532 list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 xfs_dqlock(dqp);
534 if ((gdqp = dqp->q_gdquot)) {
535 xfs_dqlock(gdqp);
536 dqp->q_gdquot = NULL;
537 }
538 xfs_dqunlock(dqp);
539
540 if (gdqp) {
541 /*
542 * Can't hold the mplist lock across a dqput.
543 * XXXmust convert to marker based iterations here.
544 */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000545 nrecl = q->qi_dqreclaims;
546 mutex_unlock(&q->qi_dqlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 xfs_qm_dqput(gdqp);
548
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000549 mutex_lock(&q->qi_dqlist_lock);
550 if (nrecl != q->qi_dqreclaims)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 goto again;
552 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 }
554}
555
556/*
557 * Go through all the incore dquots of this file system and take them
558 * off the mplist and hashlist, if the dquot type matches the dqtype
559 * parameter. This is used when turning off quota accounting for
560 * users and/or groups, as well as when the filesystem is unmounting.
561 */
562STATIC int
563xfs_qm_dqpurge_int(
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000564 struct xfs_mount *mp,
565 uint flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566{
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000567 struct xfs_quotainfo *q = mp->m_quotainfo;
568 struct xfs_dquot *dqp, *n;
569 uint dqtype;
570 int nrecl;
571 int nmisses;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000573 if (!q)
Jesper Juhl014c2542006-01-15 02:37:08 +0100574 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000577 dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;
579
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000580 mutex_lock(&q->qi_dqlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
582 /*
583 * In the first pass through all incore dquots of this filesystem,
584 * we release the group dquot pointers the user dquots may be
585 * carrying around as a hint. We need to do this irrespective of
586 * what's being turned off.
587 */
588 xfs_qm_detach_gdquots(mp);
589
590 again:
591 nmisses = 0;
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000592 ASSERT(mutex_is_locked(&q->qi_dqlist_lock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 /*
594 * Try to get rid of all of the unwanted dquots. The idea is to
595 * get them off mplist and hashlist, but leave them on freelist.
596 */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000597 list_for_each_entry_safe(dqp, n, &q->qi_dqlist, q_mplist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 /*
599 * It's OK to look at the type without taking dqlock here.
600 * We're holding the mplist lock here, and that's needed for
601 * a dqreclaim.
602 */
Dave Chinner3a254042010-04-13 15:06:48 +1000603 if ((dqp->dq_flags & dqtype) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
Christoph Hellwigc9a192d2009-02-09 08:47:22 +0100606 if (!mutex_trylock(&dqp->q_hash->qh_lock)) {
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000607 nrecl = q->qi_dqreclaims;
608 mutex_unlock(&q->qi_dqlist_lock);
Christoph Hellwigc9a192d2009-02-09 08:47:22 +0100609 mutex_lock(&dqp->q_hash->qh_lock);
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000610 mutex_lock(&q->qi_dqlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
612 /*
613 * XXXTheoretically, we can get into a very long
614 * ping pong game here.
615 * No one can be adding dquots to the mplist at
616 * this point, but somebody might be taking things off.
617 */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000618 if (nrecl != q->qi_dqreclaims) {
Christoph Hellwigc9a192d2009-02-09 08:47:22 +0100619 mutex_unlock(&dqp->q_hash->qh_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 goto again;
621 }
622 }
623
624 /*
625 * Take the dquot off the mplist and hashlist. It may remain on
626 * freelist in INACTIVE state.
627 */
Denys Vlasenko4f0e8a92008-05-19 16:34:04 +1000628 nmisses += xfs_qm_dqpurge(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 }
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000630 mutex_unlock(&q->qi_dqlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 return nmisses;
632}
633
634int
635xfs_qm_dqpurge_all(
636 xfs_mount_t *mp,
637 uint flags)
638{
639 int ndquots;
640
641 /*
642 * Purge the dquot cache.
643 * None of the dquots should really be busy at this point.
644 */
645 if (mp->m_quotainfo) {
646 while ((ndquots = xfs_qm_dqpurge_int(mp, flags))) {
647 delay(ndquots * 10);
648 }
649 }
650 return 0;
651}
652
653STATIC int
654xfs_qm_dqattach_one(
655 xfs_inode_t *ip,
656 xfs_dqid_t id,
657 uint type,
658 uint doalloc,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 xfs_dquot_t *udqhint, /* hint */
660 xfs_dquot_t **IO_idqpp)
661{
662 xfs_dquot_t *dqp;
663 int error;
664
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000665 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 error = 0;
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100667
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 /*
669 * See if we already have it in the inode itself. IO_idqpp is
670 * &i_udquot or &i_gdquot. This made the code look weird, but
671 * made the logic a lot simpler.
672 */
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100673 dqp = *IO_idqpp;
674 if (dqp) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000675 trace_xfs_dqattach_found(dqp);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100676 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 }
678
679 /*
680 * udqhint is the i_udquot field in inode, and is non-NULL only
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000681 * when the type arg is group/project. Its purpose is to save a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
683 * the user dquot.
684 */
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100685 if (udqhint) {
686 ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 xfs_dqlock(udqhint);
688
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100689 /*
690 * No need to take dqlock to look at the id.
691 *
692 * The ID can't change until it gets reclaimed, and it won't
693 * be reclaimed as long as we have a ref from inode and we
694 * hold the ilock.
695 */
696 dqp = udqhint->q_gdquot;
697 if (dqp && be32_to_cpu(dqp->q_core.d_id) == id) {
698 xfs_dqlock(dqp);
699 XFS_DQHOLD(dqp);
700 ASSERT(*IO_idqpp == NULL);
701 *IO_idqpp = dqp;
702
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 xfs_dqunlock(dqp);
704 xfs_dqunlock(udqhint);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100705 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 }
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100707
708 /*
709 * We can't hold a dquot lock when we call the dqget code.
710 * We'll deadlock in no time, because of (not conforming to)
711 * lock ordering - the inodelock comes before any dquot lock,
712 * and we may drop and reacquire the ilock in xfs_qm_dqget().
713 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 xfs_dqunlock(udqhint);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100715 }
716
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 /*
718 * Find the dquot from somewhere. This bumps the
719 * reference count of dquot and returns it locked.
720 * This can return ENOENT if dquot didn't exist on
721 * disk and we didn't ask it to allocate;
722 * ESRCH if quotas got turned off suddenly.
723 */
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100724 error = xfs_qm_dqget(ip->i_mount, ip, id, type, XFS_QMOPT_DOWARN, &dqp);
725 if (error)
726 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000728 trace_xfs_dqattach_get(dqp);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100729
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 /*
731 * dqget may have dropped and re-acquired the ilock, but it guarantees
732 * that the dquot returned is the one that should go in the inode.
733 */
734 *IO_idqpp = dqp;
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100735 xfs_dqunlock(dqp);
736 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737}
738
739
740/*
741 * Given a udquot and gdquot, attach a ptr to the group dquot in the
742 * udquot as a hint for future lookups. The idea sounds simple, but the
743 * execution isn't, because the udquot might have a group dquot attached
Nathan Scottc41564b2006-03-29 08:55:14 +1000744 * already and getting rid of that gets us into lock ordering constraints.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 * The process is complicated more by the fact that the dquots may or may not
746 * be locked on entry.
747 */
748STATIC void
749xfs_qm_dqattach_grouphint(
750 xfs_dquot_t *udq,
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100751 xfs_dquot_t *gdq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752{
753 xfs_dquot_t *tmp;
754
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100755 xfs_dqlock(udq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
757 if ((tmp = udq->q_gdquot)) {
758 if (tmp == gdq) {
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100759 xfs_dqunlock(udq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 return;
761 }
762
763 udq->q_gdquot = NULL;
764 /*
765 * We can't keep any dqlocks when calling dqrele,
766 * because the freelist lock comes before dqlocks.
767 */
768 xfs_dqunlock(udq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 /*
770 * we took a hard reference once upon a time in dqget,
771 * so give it back when the udquot no longer points at it
772 * dqput() does the unlocking of the dquot.
773 */
774 xfs_qm_dqrele(tmp);
775
776 xfs_dqlock(udq);
777 xfs_dqlock(gdq);
778
779 } else {
780 ASSERT(XFS_DQ_IS_LOCKED(udq));
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100781 xfs_dqlock(gdq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 }
783
784 ASSERT(XFS_DQ_IS_LOCKED(udq));
785 ASSERT(XFS_DQ_IS_LOCKED(gdq));
786 /*
787 * Somebody could have attached a gdquot here,
788 * when we dropped the uqlock. If so, just do nothing.
789 */
790 if (udq->q_gdquot == NULL) {
791 XFS_DQHOLD(gdq);
792 udq->q_gdquot = gdq;
793 }
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100794
795 xfs_dqunlock(gdq);
796 xfs_dqunlock(udq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797}
798
799
800/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000801 * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
802 * into account.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 * Inode may get unlocked and relocked in here, and the caller must deal with
805 * the consequences.
806 */
807int
Christoph Hellwig7d095252009-06-08 15:33:32 +0200808xfs_qm_dqattach_locked(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 xfs_inode_t *ip,
810 uint flags)
811{
812 xfs_mount_t *mp = ip->i_mount;
813 uint nquotas = 0;
814 int error = 0;
815
Christoph Hellwig7d095252009-06-08 15:33:32 +0200816 if (!XFS_IS_QUOTA_RUNNING(mp) ||
817 !XFS_IS_QUOTA_ON(mp) ||
818 !XFS_NOT_DQATTACHED(mp, ip) ||
819 ip->i_ino == mp->m_sb.sb_uquotino ||
820 ip->i_ino == mp->m_sb.sb_gquotino)
Jesper Juhl014c2542006-01-15 02:37:08 +0100821 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822
Christoph Hellwig7d095252009-06-08 15:33:32 +0200823 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 if (XFS_IS_UQUOTA_ON(mp)) {
826 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
827 flags & XFS_QMOPT_DQALLOC,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 NULL, &ip->i_udquot);
829 if (error)
830 goto done;
831 nquotas++;
832 }
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000833
834 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000835 if (XFS_IS_OQUOTA_ON(mp)) {
836 error = XFS_IS_GQUOTA_ON(mp) ?
837 xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
838 flags & XFS_QMOPT_DQALLOC,
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000839 ip->i_udquot, &ip->i_gdquot) :
840 xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 flags & XFS_QMOPT_DQALLOC,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 ip->i_udquot, &ip->i_gdquot);
843 /*
844 * Don't worry about the udquot that we may have
845 * attached above. It'll get detached, if not already.
846 */
847 if (error)
848 goto done;
849 nquotas++;
850 }
851
852 /*
853 * Attach this group quota to the user quota as a hint.
854 * This WON'T, in general, result in a thrash.
855 */
856 if (nquotas == 2) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000857 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 ASSERT(ip->i_udquot);
859 ASSERT(ip->i_gdquot);
860
861 /*
862 * We may or may not have the i_udquot locked at this point,
863 * but this check is OK since we don't depend on the i_gdquot to
864 * be accurate 100% all the time. It is just a hint, and this
865 * will succeed in general.
866 */
867 if (ip->i_udquot->q_gdquot == ip->i_gdquot)
868 goto done;
869 /*
870 * Attach i_gdquot to the gdquot hint inside the i_udquot.
871 */
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100872 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 }
874
Christoph Hellwig7d095252009-06-08 15:33:32 +0200875 done:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876#ifdef QUOTADEBUG
877 if (! error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 if (XFS_IS_UQUOTA_ON(mp))
879 ASSERT(ip->i_udquot);
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000880 if (XFS_IS_OQUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 ASSERT(ip->i_gdquot);
882 }
Christoph Hellwig7d095252009-06-08 15:33:32 +0200883 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884#endif
Christoph Hellwig7d095252009-06-08 15:33:32 +0200885 return error;
886}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887
Christoph Hellwig7d095252009-06-08 15:33:32 +0200888int
889xfs_qm_dqattach(
890 struct xfs_inode *ip,
891 uint flags)
892{
893 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
Christoph Hellwig7d095252009-06-08 15:33:32 +0200895 xfs_ilock(ip, XFS_ILOCK_EXCL);
896 error = xfs_qm_dqattach_locked(ip, flags);
897 xfs_iunlock(ip, XFS_ILOCK_EXCL);
898
Jesper Juhl014c2542006-01-15 02:37:08 +0100899 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900}
901
902/*
903 * Release dquots (and their references) if any.
904 * The inode should be locked EXCL except when this's called by
905 * xfs_ireclaim.
906 */
907void
908xfs_qm_dqdetach(
909 xfs_inode_t *ip)
910{
911 if (!(ip->i_udquot || ip->i_gdquot))
912 return;
913
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000914 trace_xfs_dquot_dqdetach(ip);
915
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
917 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 if (ip->i_udquot) {
919 xfs_qm_dqrele(ip->i_udquot);
920 ip->i_udquot = NULL;
921 }
922 if (ip->i_gdquot) {
923 xfs_qm_dqrele(ip->i_gdquot);
924 ip->i_gdquot = NULL;
925 }
926}
927
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928int
929xfs_qm_sync(
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000930 struct xfs_mount *mp,
931 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932{
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000933 struct xfs_quotainfo *q = mp->m_quotainfo;
934 int recl, restarts;
935 struct xfs_dquot *dqp;
936 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937
Christoph Hellwig7d095252009-06-08 15:33:32 +0200938 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
Donald Douwsmad7577622007-11-23 16:27:42 +1100939 return 0;
940
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 restarts = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942
943 again:
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000944 mutex_lock(&q->qi_dqlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 /*
946 * dqpurge_all() also takes the mplist lock and iterate thru all dquots
947 * in quotaoff. However, if the QUOTA_ACTIVE bits are not cleared
948 * when we have the mplist lock, we know that dquots will be consistent
949 * as long as we have it locked.
950 */
Dave Chinner3a254042010-04-13 15:06:48 +1000951 if (!XFS_IS_QUOTA_ON(mp)) {
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000952 mutex_unlock(&q->qi_dqlist_lock);
Jesper Juhl014c2542006-01-15 02:37:08 +0100953 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 }
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000955 ASSERT(mutex_is_locked(&q->qi_dqlist_lock));
956 list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 /*
958 * If this is vfs_sync calling, then skip the dquots that
959 * don't 'seem' to be dirty. ie. don't acquire dqlock.
960 * This is very similar to what xfs_sync does with inodes.
961 */
Christoph Hellwig8b5403a2009-06-08 15:37:16 +0200962 if (flags & SYNC_TRYLOCK) {
963 if (!XFS_DQ_IS_DIRTY(dqp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 continue;
Christoph Hellwig8b5403a2009-06-08 15:37:16 +0200965 if (!xfs_qm_dqlock_nowait(dqp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 continue;
967 } else {
968 xfs_dqlock(dqp);
969 }
970
971 /*
972 * Now, find out for sure if this dquot is dirty or not.
973 */
974 if (! XFS_DQ_IS_DIRTY(dqp)) {
975 xfs_dqunlock(dqp);
976 continue;
977 }
978
979 /* XXX a sentinel would be better */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000980 recl = q->qi_dqreclaims;
David Chinnere1f49cf2008-08-13 16:41:43 +1000981 if (!xfs_dqflock_nowait(dqp)) {
Christoph Hellwig8b5403a2009-06-08 15:37:16 +0200982 if (flags & SYNC_TRYLOCK) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 xfs_dqunlock(dqp);
984 continue;
985 }
986 /*
987 * If we can't grab the flush lock then if the caller
Nathan Scottc41564b2006-03-29 08:55:14 +1000988 * really wanted us to give this our best shot, so
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 * see if we can give a push to the buffer before we wait
990 * on the flush lock. At this point, we know that
Nathan Scottc41564b2006-03-29 08:55:14 +1000991 * even though the dquot is being flushed,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 * it has (new) dirty data.
993 */
994 xfs_qm_dqflock_pushbuf_wait(dqp);
995 }
996 /*
997 * Let go of the mplist lock. We don't want to hold it
998 * across a disk write
999 */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001000 mutex_unlock(&q->qi_dqlist_lock);
Dave Chinner20026d92010-02-04 09:48:58 +11001001 error = xfs_qm_dqflush(dqp, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 xfs_dqunlock(dqp);
1003 if (error && XFS_FORCED_SHUTDOWN(mp))
Jesper Juhl014c2542006-01-15 02:37:08 +01001004 return 0; /* Need to prevent umount failure */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 else if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001006 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001008 mutex_lock(&q->qi_dqlist_lock);
1009 if (recl != q->qi_dqreclaims) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 if (++restarts >= XFS_QM_SYNC_MAX_RESTARTS)
1011 break;
1012
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001013 mutex_unlock(&q->qi_dqlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 goto again;
1015 }
1016 }
1017
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001018 mutex_unlock(&q->qi_dqlist_lock);
Jesper Juhl014c2542006-01-15 02:37:08 +01001019 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020}
1021
Christoph Hellwiga4edd1d2009-01-19 02:03:11 +01001022/*
1023 * The hash chains and the mplist use the same xfs_dqhash structure as
1024 * their list head, but we can take the mplist qh_lock and one of the
1025 * hash qh_locks at the same time without any problem as they aren't
1026 * related.
1027 */
1028static struct lock_class_key xfs_quota_mplist_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
1030/*
1031 * This initializes all the quota information that's kept in the
1032 * mount structure
1033 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10001034STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035xfs_qm_init_quotainfo(
1036 xfs_mount_t *mp)
1037{
1038 xfs_quotainfo_t *qinf;
1039 int error;
1040 xfs_dquot_t *dqp;
1041
1042 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1043
1044 /*
1045 * Tell XQM that we exist as soon as possible.
1046 */
1047 if ((error = xfs_qm_hold_quotafs_ref(mp))) {
Jesper Juhl014c2542006-01-15 02:37:08 +01001048 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 }
1050
1051 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
1052
1053 /*
1054 * See if quotainodes are setup, and if not, allocate them,
1055 * and change the superblock accordingly.
1056 */
1057 if ((error = xfs_qm_init_quotainos(mp))) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001058 kmem_free(qinf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 mp->m_quotainfo = NULL;
Jesper Juhl014c2542006-01-15 02:37:08 +01001060 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 }
1062
Dave Chinner3a254042010-04-13 15:06:48 +10001063 INIT_LIST_HEAD(&qinf->qi_dqlist);
1064 mutex_init(&qinf->qi_dqlist_lock);
1065 lockdep_set_class(&qinf->qi_dqlist_lock, &xfs_quota_mplist_class);
Christoph Hellwiga4edd1d2009-01-19 02:03:11 +01001066
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067 qinf->qi_dqreclaims = 0;
1068
1069 /* mutex used to serialize quotaoffs */
Jes Sorensen794ee1b2006-01-09 15:59:21 -08001070 mutex_init(&qinf->qi_quotaofflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
1072 /* Precalc some constants */
1073 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1074 ASSERT(qinf->qi_dqchunklen);
1075 qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
1076 do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
1077
1078 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
1079
1080 /*
1081 * We try to get the limits from the superuser's limits fields.
1082 * This is quite hacky, but it is standard quota practice.
1083 * We look at the USR dquot with id == 0 first, but if user quotas
1084 * are not enabled we goto the GRP dquot with id == 0.
1085 * We don't really care to keep separate default limits for user
1086 * and group quotas, at least not at this point.
1087 */
1088 error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)0,
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001089 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
1090 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
1091 XFS_DQ_PROJ),
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 XFS_QMOPT_DQSUSER|XFS_QMOPT_DOWARN,
1093 &dqp);
1094 if (! error) {
1095 xfs_disk_dquot_t *ddqp = &dqp->q_core;
1096
1097 /*
1098 * The warnings and timers set the grace period given to
1099 * a user or group before he or she can not perform any
1100 * more writing. If it is zero, a default is used.
1101 */
Christoph Hellwig1149d962005-11-02 15:01:12 +11001102 qinf->qi_btimelimit = ddqp->d_btimer ?
1103 be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
1104 qinf->qi_itimelimit = ddqp->d_itimer ?
1105 be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
1106 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
1107 be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
1108 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
1109 be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
1110 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
1111 be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
1112 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
1113 be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
1114 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
1115 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
1116 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
1117 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
1118 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
1119 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
1121 /*
1122 * We sent the XFS_QMOPT_DQSUSER flag to dqget because
1123 * we don't want this dquot cached. We haven't done a
1124 * quotacheck yet, and quotacheck doesn't like incore dquots.
1125 */
1126 xfs_qm_dqdestroy(dqp);
1127 } else {
1128 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
1129 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
1130 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
1131 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
1132 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
Nathan Scott06d10dd2005-06-21 15:48:47 +10001133 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 }
1135
Jesper Juhl014c2542006-01-15 02:37:08 +01001136 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137}
1138
1139
1140/*
1141 * Gets called when unmounting a filesystem or when all quotas get
1142 * turned off.
1143 * This purges the quota inodes, destroys locks and frees itself.
1144 */
1145void
1146xfs_qm_destroy_quotainfo(
1147 xfs_mount_t *mp)
1148{
1149 xfs_quotainfo_t *qi;
1150
1151 qi = mp->m_quotainfo;
1152 ASSERT(qi != NULL);
1153 ASSERT(xfs_Gqm != NULL);
1154
1155 /*
1156 * Release the reference that XQM kept, so that we know
1157 * when the XQM structure should be freed. We cannot assume
1158 * that xfs_Gqm is non-null after this point.
1159 */
1160 xfs_qm_rele_quotafs_ref(mp);
1161
Dave Chinner3a254042010-04-13 15:06:48 +10001162 ASSERT(list_empty(&qi->qi_dqlist));
1163 mutex_destroy(&qi->qi_dqlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
1165 if (qi->qi_uquotaip) {
Christoph Hellwig26cc0022008-07-18 17:12:43 +10001166 IRELE(qi->qi_uquotaip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 qi->qi_uquotaip = NULL; /* paranoia */
1168 }
1169 if (qi->qi_gquotaip) {
Christoph Hellwig26cc0022008-07-18 17:12:43 +10001170 IRELE(qi->qi_gquotaip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 qi->qi_gquotaip = NULL;
1172 }
1173 mutex_destroy(&qi->qi_quotaofflock);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001174 kmem_free(qi);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 mp->m_quotainfo = NULL;
1176}
1177
1178
1179
1180/* ------------------- PRIVATE STATIC FUNCTIONS ----------------------- */
1181
1182/* ARGSUSED */
1183STATIC void
1184xfs_qm_list_init(
1185 xfs_dqlist_t *list,
1186 char *str,
1187 int n)
1188{
Jes Sorensen794ee1b2006-01-09 15:59:21 -08001189 mutex_init(&list->qh_lock);
Dave Chinnere6a81f12010-04-13 15:06:51 +10001190 INIT_LIST_HEAD(&list->qh_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 list->qh_version = 0;
1192 list->qh_nelems = 0;
1193}
1194
1195STATIC void
1196xfs_qm_list_destroy(
1197 xfs_dqlist_t *list)
1198{
1199 mutex_destroy(&(list->qh_lock));
1200}
1201
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202/*
1203 * Create an inode and return with a reference already taken, but unlocked
1204 * This is how we create quota inodes
1205 */
1206STATIC int
1207xfs_qm_qino_alloc(
1208 xfs_mount_t *mp,
1209 xfs_inode_t **ip,
1210 __int64_t sbfields,
1211 uint flags)
1212{
1213 xfs_trans_t *tp;
1214 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 int committed;
1216
Nathan Scott061f7202006-01-11 15:27:50 +11001217 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 if ((error = xfs_trans_reserve(tp,
1219 XFS_QM_QINOCREATE_SPACE_RES(mp),
1220 XFS_CREATE_LOG_RES(mp), 0,
1221 XFS_TRANS_PERM_LOG_RES,
1222 XFS_CREATE_LOG_COUNT))) {
1223 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001224 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226
David Chinnerb11f94d2007-07-11 11:09:33 +10001227 if ((error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0,
Nathan Scottdae81d42006-02-28 12:30:13 +11001228 &xfs_zerocr, 0, 1, ip, &committed))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
1230 XFS_TRANS_ABORT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001231 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 }
1233
1234 /*
1235 * Keep an extra reference to this quota inode. This inode is
1236 * locked exclusively and joined to the transaction already.
1237 */
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001238 ASSERT(xfs_isilocked(*ip, XFS_ILOCK_EXCL));
Christoph Hellwig26cc0022008-07-18 17:12:43 +10001239 IHOLD(*ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240
1241 /*
1242 * Make the changes in the superblock, and log those too.
1243 * sbfields arg may contain fields other than *QUOTINO;
1244 * VERSIONNUM for example.
1245 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001246 spin_lock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 if (flags & XFS_QMOPT_SBVERSION) {
Eric Sandeen62118702008-03-06 13:44:28 +11001248 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1250 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
1251 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1252 XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
1253
Eric Sandeen62118702008-03-06 13:44:28 +11001254 xfs_sb_version_addquota(&mp->m_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 mp->m_sb.sb_uquotino = NULLFSINO;
1256 mp->m_sb.sb_gquotino = NULLFSINO;
1257
1258 /* qflags will get updated _after_ quotacheck */
1259 mp->m_sb.sb_qflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 }
1261 if (flags & XFS_QMOPT_UQUOTA)
1262 mp->m_sb.sb_uquotino = (*ip)->i_ino;
1263 else
1264 mp->m_sb.sb_gquotino = (*ip)->i_ino;
Eric Sandeen3685c2a2007-10-11 17:42:32 +10001265 spin_unlock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 xfs_mod_sb(tp, sbfields);
1267
Eric Sandeen1c72bf92007-05-08 13:48:42 +10001268 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 xfs_fs_cmn_err(CE_ALERT, mp, "XFS qino_alloc failed!");
Jesper Juhl014c2542006-01-15 02:37:08 +01001270 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001272 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273}
1274
1275
David Chinner5b139732008-04-10 12:20:10 +10001276STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277xfs_qm_reset_dqcounts(
1278 xfs_mount_t *mp,
1279 xfs_buf_t *bp,
1280 xfs_dqid_t id,
1281 uint type)
1282{
1283 xfs_disk_dquot_t *ddq;
1284 int j;
1285
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001286 trace_xfs_reset_dqcounts(bp, _RET_IP_);
1287
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 /*
1289 * Reset all counters and timers. They'll be
1290 * started afresh by xfs_qm_quotacheck.
1291 */
1292#ifdef DEBUG
1293 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1294 do_div(j, sizeof(xfs_dqblk_t));
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001295 ASSERT(mp->m_quotainfo->qi_dqperchunk == j);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296#endif
1297 ddq = (xfs_disk_dquot_t *)XFS_BUF_PTR(bp);
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001298 for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299 /*
1300 * Do a sanity check, and if needed, repair the dqblk. Don't
1301 * output any warnings because it's perfectly possible to
Nathan Scottc41564b2006-03-29 08:55:14 +10001302 * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 */
1304 (void) xfs_qm_dqcheck(ddq, id+j, type, XFS_QMOPT_DQREPAIR,
1305 "xfs_quotacheck");
Christoph Hellwig1149d962005-11-02 15:01:12 +11001306 ddq->d_bcount = 0;
1307 ddq->d_icount = 0;
1308 ddq->d_rtbcount = 0;
1309 ddq->d_btimer = 0;
1310 ddq->d_itimer = 0;
1311 ddq->d_rtbtimer = 0;
1312 ddq->d_bwarns = 0;
1313 ddq->d_iwarns = 0;
1314 ddq->d_rtbwarns = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
1316 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317}
1318
1319STATIC int
1320xfs_qm_dqiter_bufs(
1321 xfs_mount_t *mp,
1322 xfs_dqid_t firstid,
1323 xfs_fsblock_t bno,
1324 xfs_filblks_t blkcnt,
1325 uint flags)
1326{
1327 xfs_buf_t *bp;
1328 int error;
1329 int notcommitted;
1330 int incr;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001331 int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332
1333 ASSERT(blkcnt > 0);
1334 notcommitted = 0;
1335 incr = (blkcnt > XFS_QM_MAX_DQCLUSTER_LOGSZ) ?
1336 XFS_QM_MAX_DQCLUSTER_LOGSZ : blkcnt;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001337 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1338 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 error = 0;
1340
1341 /*
1342 * Blkcnt arg can be a very big number, and might even be
1343 * larger than the log itself. So, we have to break it up into
1344 * manageable-sized transactions.
1345 * Note that we don't start a permanent transaction here; we might
1346 * not be able to get a log reservation for the whole thing up front,
1347 * and we don't really care to either, because we just discard
1348 * everything if we were to crash in the middle of this loop.
1349 */
1350 while (blkcnt--) {
1351 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1352 XFS_FSB_TO_DADDR(mp, bno),
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001353 mp->m_quotainfo->qi_dqchunklen, 0, &bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 if (error)
1355 break;
1356
David Chinner5b139732008-04-10 12:20:10 +10001357 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 xfs_bdwrite(mp, bp);
1359 /*
1360 * goto the next block.
1361 */
1362 bno++;
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001363 firstid += mp->m_quotainfo->qi_dqperchunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001365 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001366}
1367
1368/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001369 * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 * caller supplied function for every chunk of dquots that we find.
1371 */
1372STATIC int
1373xfs_qm_dqiterate(
1374 xfs_mount_t *mp,
1375 xfs_inode_t *qip,
1376 uint flags)
1377{
1378 xfs_bmbt_irec_t *map;
1379 int i, nmaps; /* number of map entries */
1380 int error; /* return value */
1381 xfs_fileoff_t lblkno;
1382 xfs_filblks_t maxlblkcnt;
1383 xfs_dqid_t firstid;
1384 xfs_fsblock_t rablkno;
1385 xfs_filblks_t rablkcnt;
1386
1387 error = 0;
1388 /*
Nathan Scottc41564b2006-03-29 08:55:14 +10001389 * This looks racy, but we can't keep an inode lock across a
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 * trans_reserve. But, this gets called during quotacheck, and that
1391 * happens only at mount time which is single threaded.
1392 */
1393 if (qip->i_d.di_nblocks == 0)
Jesper Juhl014c2542006-01-15 02:37:08 +01001394 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395
1396 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1397
1398 lblkno = 0;
1399 maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1400 do {
1401 nmaps = XFS_DQITER_MAP_SIZE;
1402 /*
1403 * We aren't changing the inode itself. Just changing
1404 * some of its data. No new blocks are added here, and
1405 * the inode is never added to the transaction.
1406 */
1407 xfs_ilock(qip, XFS_ILOCK_SHARED);
1408 error = xfs_bmapi(NULL, qip, lblkno,
1409 maxlblkcnt - lblkno,
1410 XFS_BMAPI_METADATA,
1411 NULL,
Christoph Hellwigb4e91812010-06-23 18:11:15 +10001412 0, map, &nmaps, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1414 if (error)
1415 break;
1416
1417 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1418 for (i = 0; i < nmaps; i++) {
1419 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1420 ASSERT(map[i].br_blockcount);
1421
1422
1423 lblkno += map[i].br_blockcount;
1424
1425 if (map[i].br_startblock == HOLESTARTBLOCK)
1426 continue;
1427
1428 firstid = (xfs_dqid_t) map[i].br_startoff *
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001429 mp->m_quotainfo->qi_dqperchunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430 /*
1431 * Do a read-ahead on the next extent.
1432 */
1433 if ((i+1 < nmaps) &&
1434 (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1435 rablkcnt = map[i+1].br_blockcount;
1436 rablkno = map[i+1].br_startblock;
1437 while (rablkcnt--) {
1438 xfs_baread(mp->m_ddev_targp,
1439 XFS_FSB_TO_DADDR(mp, rablkno),
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001440 mp->m_quotainfo->qi_dqchunklen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 rablkno++;
1442 }
1443 }
1444 /*
1445 * Iterate thru all the blks in the extent and
1446 * reset the counters of all the dquots inside them.
1447 */
1448 if ((error = xfs_qm_dqiter_bufs(mp,
1449 firstid,
1450 map[i].br_startblock,
1451 map[i].br_blockcount,
1452 flags))) {
1453 break;
1454 }
1455 }
1456
1457 if (error)
1458 break;
1459 } while (nmaps > 0);
1460
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10001461 kmem_free(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462
Jesper Juhl014c2542006-01-15 02:37:08 +01001463 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464}
1465
1466/*
1467 * Called by dqusage_adjust in doing a quotacheck.
Christoph Hellwig52fda112010-09-06 01:44:22 +00001468 *
1469 * Given the inode, and a dquot id this updates both the incore dqout as well
1470 * as the buffer copy. This is so that once the quotacheck is done, we can
1471 * just log all the buffers, as opposed to logging numerous updates to
1472 * individual dquots.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 */
Christoph Hellwig52fda112010-09-06 01:44:22 +00001474STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475xfs_qm_quotacheck_dqadjust(
Christoph Hellwig52fda112010-09-06 01:44:22 +00001476 struct xfs_inode *ip,
1477 xfs_dqid_t id,
1478 uint type,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 xfs_qcnt_t nblks,
1480 xfs_qcnt_t rtblks)
1481{
Christoph Hellwig52fda112010-09-06 01:44:22 +00001482 struct xfs_mount *mp = ip->i_mount;
1483 struct xfs_dquot *dqp;
1484 int error;
1485
1486 error = xfs_qm_dqget(mp, ip, id, type,
1487 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN, &dqp);
1488 if (error) {
1489 /*
1490 * Shouldn't be able to turn off quotas here.
1491 */
1492 ASSERT(error != ESRCH);
1493 ASSERT(error != ENOENT);
1494 return error;
1495 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001496
1497 trace_xfs_dqadjust(dqp);
1498
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 /*
1500 * Adjust the inode count and the block count to reflect this inode's
1501 * resource usage.
1502 */
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001503 be64_add_cpu(&dqp->q_core.d_icount, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 dqp->q_res_icount++;
1505 if (nblks) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001506 be64_add_cpu(&dqp->q_core.d_bcount, nblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 dqp->q_res_bcount += nblks;
1508 }
1509 if (rtblks) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001510 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 dqp->q_res_rtbcount += rtblks;
1512 }
1513
1514 /*
1515 * Set default limits, adjust timers (since we changed usages)
Christoph Hellwig191f8482010-04-20 17:01:53 +10001516 *
1517 * There are no timers for the default values set in the root dquot.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 */
Christoph Hellwig191f8482010-04-20 17:01:53 +10001519 if (dqp->q_core.d_id) {
Christoph Hellwig52fda112010-09-06 01:44:22 +00001520 xfs_qm_adjust_dqlimits(mp, &dqp->q_core);
1521 xfs_qm_adjust_dqtimers(mp, &dqp->q_core);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 }
1523
1524 dqp->dq_flags |= XFS_DQ_DIRTY;
Christoph Hellwig52fda112010-09-06 01:44:22 +00001525 xfs_qm_dqput(dqp);
1526 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527}
1528
1529STATIC int
1530xfs_qm_get_rtblks(
1531 xfs_inode_t *ip,
1532 xfs_qcnt_t *O_rtblks)
1533{
1534 xfs_filblks_t rtblks; /* total rt blks */
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001535 xfs_extnum_t idx; /* extent record index */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 xfs_ifork_t *ifp; /* inode fork pointer */
1537 xfs_extnum_t nextents; /* number of extent entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 int error;
1539
1540 ASSERT(XFS_IS_REALTIME_INODE(ip));
1541 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1542 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1543 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
Jesper Juhl014c2542006-01-15 02:37:08 +01001544 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 }
1546 rtblks = 0;
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001547 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10001548 for (idx = 0; idx < nextents; idx++)
1549 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 *O_rtblks = (xfs_qcnt_t)rtblks;
Jesper Juhl014c2542006-01-15 02:37:08 +01001551 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552}
1553
1554/*
1555 * callback routine supplied to bulkstat(). Given an inumber, find its
1556 * dquots and update them to account for resources taken by that inode.
1557 */
1558/* ARGSUSED */
1559STATIC int
1560xfs_qm_dqusage_adjust(
1561 xfs_mount_t *mp, /* mount point for filesystem */
1562 xfs_ino_t ino, /* inode number to get data for */
1563 void __user *buffer, /* not used */
1564 int ubsize, /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565 int *ubused, /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 int *res) /* result code value */
1567{
1568 xfs_inode_t *ip;
Christoph Hellwig52fda112010-09-06 01:44:22 +00001569 xfs_qcnt_t nblks, rtblks = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570 int error;
1571
1572 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1573
1574 /*
1575 * rootino must have its resources accounted for, not so with the quota
1576 * inodes.
1577 */
1578 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1579 *res = BULKSTAT_RV_NOTHING;
1580 return XFS_ERROR(EINVAL);
1581 }
1582
1583 /*
1584 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1585 * interface expects the inode to be exclusively locked because that's
1586 * the case in all other instances. It's OK that we do this because
1587 * quotacheck is done only at mount time.
1588 */
Christoph Hellwig52fda112010-09-06 01:44:22 +00001589 error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip);
1590 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 *res = BULKSTAT_RV_NOTHING;
Jesper Juhl014c2542006-01-15 02:37:08 +01001592 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 }
1594
Christoph Hellwig52fda112010-09-06 01:44:22 +00001595 ASSERT(ip->i_delayed_blks == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596
Christoph Hellwig52fda112010-09-06 01:44:22 +00001597 if (XFS_IS_REALTIME_INODE(ip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 /*
1599 * Walk thru the extent list and count the realtime blocks.
1600 */
Christoph Hellwig52fda112010-09-06 01:44:22 +00001601 error = xfs_qm_get_rtblks(ip, &rtblks);
1602 if (error)
1603 goto error0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605
Christoph Hellwig52fda112010-09-06 01:44:22 +00001606 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607
1608 /*
1609 * Add the (disk blocks and inode) resources occupied by this
1610 * inode to its dquots. We do this adjustment in the incore dquot,
1611 * and also copy the changes to its buffer.
1612 * We don't care about putting these changes in a transaction
1613 * envelope because if we crash in the middle of a 'quotacheck'
1614 * we have to start from the beginning anyway.
1615 * Once we're done, we'll log all the dquot bufs.
1616 *
Nathan Scottc41564b2006-03-29 08:55:14 +10001617 * The *QUOTA_ON checks below may look pretty racy, but quotachecks
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 * and quotaoffs don't race. (Quotachecks happen at mount time only).
1619 */
1620 if (XFS_IS_UQUOTA_ON(mp)) {
Christoph Hellwig52fda112010-09-06 01:44:22 +00001621 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_uid,
1622 XFS_DQ_USER, nblks, rtblks);
1623 if (error)
1624 goto error0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626
Christoph Hellwig52fda112010-09-06 01:44:22 +00001627 if (XFS_IS_GQUOTA_ON(mp)) {
1628 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_gid,
1629 XFS_DQ_GROUP, nblks, rtblks);
1630 if (error)
1631 goto error0;
1632 }
1633
1634 if (XFS_IS_PQUOTA_ON(mp)) {
1635 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_projid,
1636 XFS_DQ_PROJ, nblks, rtblks);
1637 if (error)
1638 goto error0;
1639 }
1640
1641 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1642 IRELE(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 *res = BULKSTAT_RV_DIDONE;
Jesper Juhl014c2542006-01-15 02:37:08 +01001644 return 0;
Christoph Hellwig52fda112010-09-06 01:44:22 +00001645
1646error0:
1647 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1648 IRELE(ip);
1649 *res = BULKSTAT_RV_GIVEUP;
1650 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651}
1652
1653/*
1654 * Walk thru all the filesystem inodes and construct a consistent view
1655 * of the disk quota world. If the quotacheck fails, disable quotas.
1656 */
1657int
1658xfs_qm_quotacheck(
1659 xfs_mount_t *mp)
1660{
1661 int done, count, error;
1662 xfs_ino_t lastino;
1663 size_t structsz;
1664 xfs_inode_t *uip, *gip;
1665 uint flags;
1666
1667 count = INT_MAX;
1668 structsz = 1;
1669 lastino = 0;
1670 flags = 0;
1671
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001672 ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1674
1675 /*
1676 * There should be no cached dquots. The (simplistic) quotacheck
1677 * algorithm doesn't like that.
1678 */
Dave Chinner3a254042010-04-13 15:06:48 +10001679 ASSERT(list_empty(&mp->m_quotainfo->qi_dqlist));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680
1681 cmn_err(CE_NOTE, "XFS quotacheck %s: Please wait.", mp->m_fsname);
1682
1683 /*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001684 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 * their counters to zero. We need a clean slate.
1686 * We don't log our changes till later.
1687 */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001688 uip = mp->m_quotainfo->qi_uquotaip;
1689 if (uip) {
1690 error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA);
1691 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 goto error_return;
1693 flags |= XFS_UQUOTA_CHKD;
1694 }
1695
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001696 gip = mp->m_quotainfo->qi_gquotaip;
1697 if (gip) {
1698 error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1699 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1700 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 goto error_return;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001702 flags |= XFS_OQUOTA_CHKD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 }
1704
1705 do {
1706 /*
1707 * Iterate thru all the inodes in the file system,
1708 * adjusting the corresponding dquot counters in core.
1709 */
Christoph Hellwig7dce11d2010-06-23 18:11:11 +10001710 error = xfs_bulkstat(mp, &lastino, &count,
1711 xfs_qm_dqusage_adjust,
1712 structsz, NULL, &done);
1713 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 break;
1715
Christoph Hellwig7dce11d2010-06-23 18:11:11 +10001716 } while (!done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
1718 /*
David Chinner4b8879d2008-04-10 12:20:17 +10001719 * We've made all the changes that we need to make incore.
1720 * Flush them down to disk buffers if everything was updated
1721 * successfully.
1722 */
1723 if (!error)
Dave Chinner20026d92010-02-04 09:48:58 +11001724 error = xfs_qm_dqflush_all(mp, 0);
David Chinner4b8879d2008-04-10 12:20:17 +10001725
1726 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 * We can get this error if we couldn't do a dquot allocation inside
1728 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1729 * dirty dquots that might be cached, we just want to get rid of them
1730 * and turn quotaoff. The dquots won't be attached to any of the inodes
1731 * at this point (because we intentionally didn't in dqget_noattach).
1732 */
1733 if (error) {
Christoph Hellwig8112e9d2010-04-20 17:02:29 +10001734 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 goto error_return;
1736 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001737
1738 /*
1739 * We didn't log anything, because if we crashed, we'll have to
1740 * start the quotacheck from scratch anyway. However, we must make
1741 * sure that our dquot changes are secure before we put the
1742 * quotacheck'd stamp on the superblock. So, here we do a synchronous
1743 * flush.
1744 */
1745 XFS_bflush(mp->m_ddev_targp);
1746
1747 /*
1748 * If one type of quotas is off, then it will lose its
1749 * quotachecked status, since we won't be doing accounting for
1750 * that type anymore.
1751 */
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001752 mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 mp->m_qflags |= flags;
1754
Dave Chinner3a254042010-04-13 15:06:48 +10001755 xfs_qm_dquot_list_print(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756
1757 error_return:
1758 if (error) {
1759 cmn_err(CE_WARN, "XFS quotacheck %s: Unsuccessful (Error %d): "
1760 "Disabling quotas.",
1761 mp->m_fsname, error);
1762 /*
1763 * We must turn off quotas.
1764 */
1765 ASSERT(mp->m_quotainfo != NULL);
1766 ASSERT(xfs_Gqm != NULL);
1767 xfs_qm_destroy_quotainfo(mp);
David Chinner31d55772008-04-10 12:20:38 +10001768 if (xfs_mount_reset_sbqflags(mp)) {
1769 cmn_err(CE_WARN, "XFS quotacheck %s: "
1770 "Failed to reset quota flags.", mp->m_fsname);
1771 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 } else {
1773 cmn_err(CE_NOTE, "XFS quotacheck %s: Done.", mp->m_fsname);
1774 }
1775 return (error);
1776}
1777
1778/*
1779 * This is called after the superblock has been read in and we're ready to
1780 * iget the quota inodes.
1781 */
1782STATIC int
1783xfs_qm_init_quotainos(
1784 xfs_mount_t *mp)
1785{
1786 xfs_inode_t *uip, *gip;
1787 int error;
1788 __int64_t sbflags;
1789 uint flags;
1790
1791 ASSERT(mp->m_quotainfo);
1792 uip = gip = NULL;
1793 sbflags = 0;
1794 flags = 0;
1795
1796 /*
1797 * Get the uquota and gquota inodes
1798 */
Eric Sandeen62118702008-03-06 13:44:28 +11001799 if (xfs_sb_version_hasquota(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 if (XFS_IS_UQUOTA_ON(mp) &&
1801 mp->m_sb.sb_uquotino != NULLFSINO) {
1802 ASSERT(mp->m_sb.sb_uquotino > 0);
1803 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
Dave Chinner7b6259e2010-06-24 11:35:17 +10001804 0, 0, &uip)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 return XFS_ERROR(error);
1806 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001807 if (XFS_IS_OQUOTA_ON(mp) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 mp->m_sb.sb_gquotino != NULLFSINO) {
1809 ASSERT(mp->m_sb.sb_gquotino > 0);
1810 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
Dave Chinner7b6259e2010-06-24 11:35:17 +10001811 0, 0, &gip))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 if (uip)
Christoph Hellwig43355092008-03-27 18:01:08 +11001813 IRELE(uip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 return XFS_ERROR(error);
1815 }
1816 }
1817 } else {
1818 flags |= XFS_QMOPT_SBVERSION;
1819 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1820 XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
1821 }
1822
1823 /*
1824 * Create the two inodes, if they don't exist already. The changes
1825 * made above will get added to a transaction and logged in one of
1826 * the qino_alloc calls below. If the device is readonly,
1827 * temporarily switch to read-write to do this.
1828 */
1829 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1830 if ((error = xfs_qm_qino_alloc(mp, &uip,
1831 sbflags | XFS_SB_UQUOTINO,
1832 flags | XFS_QMOPT_UQUOTA)))
1833 return XFS_ERROR(error);
1834
1835 flags &= ~XFS_QMOPT_SBVERSION;
1836 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001837 if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
1838 flags |= (XFS_IS_GQUOTA_ON(mp) ?
1839 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1840 error = xfs_qm_qino_alloc(mp, &gip,
1841 sbflags | XFS_SB_GQUOTINO, flags);
1842 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 if (uip)
Christoph Hellwig43355092008-03-27 18:01:08 +11001844 IRELE(uip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001845
1846 return XFS_ERROR(error);
1847 }
1848 }
1849
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001850 mp->m_quotainfo->qi_uquotaip = uip;
1851 mp->m_quotainfo->qi_gquotaip = gip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852
Jesper Juhl014c2542006-01-15 02:37:08 +01001853 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854}
1855
1856
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857
1858/*
1859 * Just pop the least recently used dquot off the freelist and
1860 * recycle it. The returned dquot is locked.
1861 */
1862STATIC xfs_dquot_t *
1863xfs_qm_dqreclaim_one(void)
1864{
1865 xfs_dquot_t *dqpout;
1866 xfs_dquot_t *dqp;
1867 int restarts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
1869 restarts = 0;
1870 dqpout = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871
1872 /* lockorder: hashchainlock, freelistlock, mplistlock, dqlock, dqflock */
Dave Chinner368e1362010-04-13 15:06:50 +10001873startagain:
Dave Chinner3a8406f2010-04-13 15:06:52 +10001874 mutex_lock(&xfs_Gqm->qm_dqfrlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875
Dave Chinner3a8406f2010-04-13 15:06:52 +10001876 list_for_each_entry(dqp, &xfs_Gqm->qm_dqfrlist, q_freelist) {
Dave Chinner3a254042010-04-13 15:06:48 +10001877 struct xfs_mount *mp = dqp->q_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 xfs_dqlock(dqp);
1879
1880 /*
1881 * We are racing with dqlookup here. Naturally we don't
1882 * want to reclaim a dquot that lookup wants. We release the
1883 * freelist lock and start over, so that lookup will grab
1884 * both the dquot and the freelistlock.
1885 */
1886 if (dqp->dq_flags & XFS_DQ_WANT) {
1887 ASSERT(! (dqp->dq_flags & XFS_DQ_INACTIVE));
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001888
1889 trace_xfs_dqreclaim_want(dqp);
1890
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 xfs_dqunlock(dqp);
Dave Chinner3a8406f2010-04-13 15:06:52 +10001892 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
Jesper Juhl014c2542006-01-15 02:37:08 +01001894 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 XQM_STATS_INC(xqmstats.xs_qm_dqwants);
1896 goto startagain;
1897 }
1898
1899 /*
1900 * If the dquot is inactive, we are assured that it is
1901 * not on the mplist or the hashlist, and that makes our
1902 * life easier.
1903 */
1904 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
Dave Chinner3a254042010-04-13 15:06:48 +10001905 ASSERT(mp == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 ASSERT(! XFS_DQ_IS_DIRTY(dqp));
Dave Chinnere6a81f12010-04-13 15:06:51 +10001907 ASSERT(list_empty(&dqp->q_hashlist));
Dave Chinner3a254042010-04-13 15:06:48 +10001908 ASSERT(list_empty(&dqp->q_mplist));
Dave Chinner3a8406f2010-04-13 15:06:52 +10001909 list_del_init(&dqp->q_freelist);
1910 xfs_Gqm->qm_dqfrlist_cnt--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 xfs_dqunlock(dqp);
1912 dqpout = dqp;
1913 XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
1914 break;
1915 }
1916
1917 ASSERT(dqp->q_hash);
Dave Chinner3a254042010-04-13 15:06:48 +10001918 ASSERT(!list_empty(&dqp->q_mplist));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919
1920 /*
1921 * Try to grab the flush lock. If this dquot is in the process of
1922 * getting flushed to disk, we don't want to reclaim it.
1923 */
David Chinnere1f49cf2008-08-13 16:41:43 +10001924 if (!xfs_dqflock_nowait(dqp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 xfs_dqunlock(dqp);
1926 continue;
1927 }
1928
1929 /*
1930 * We have the flush lock so we know that this is not in the
1931 * process of being flushed. So, if this is dirty, flush it
1932 * DELWRI so that we don't get a freelist infested with
1933 * dirty dquots.
1934 */
1935 if (XFS_DQ_IS_DIRTY(dqp)) {
David Chinner3c568362008-04-10 12:20:24 +10001936 int error;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001937
1938 trace_xfs_dqreclaim_dirty(dqp);
1939
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 /*
1941 * We flush it delayed write, so don't bother
1942 * releasing the freelist lock.
1943 */
Dave Chinner20026d92010-02-04 09:48:58 +11001944 error = xfs_qm_dqflush(dqp, 0);
David Chinner3c568362008-04-10 12:20:24 +10001945 if (error) {
Dave Chinner3a254042010-04-13 15:06:48 +10001946 xfs_fs_cmn_err(CE_WARN, mp,
David Chinner3c568362008-04-10 12:20:24 +10001947 "xfs_qm_dqreclaim: dquot %p flush failed", dqp);
1948 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
1950 continue;
1951 }
1952
Dave Chinner368e1362010-04-13 15:06:50 +10001953 /*
1954 * We're trying to get the hashlock out of order. This races
1955 * with dqlookup; so, we giveup and goto the next dquot if
1956 * we couldn't get the hashlock. This way, we won't starve
1957 * a dqlookup process that holds the hashlock that is
1958 * waiting for the freelist lock.
1959 */
1960 if (!mutex_trylock(&dqp->q_hash->qh_lock)) {
1961 restarts++;
1962 goto dqfunlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 }
1964
Dave Chinner368e1362010-04-13 15:06:50 +10001965 /*
1966 * This races with dquot allocation code as well as dqflush_all
1967 * and reclaim code. So, if we failed to grab the mplist lock,
1968 * giveup everything and start over.
1969 */
1970 if (!mutex_trylock(&mp->m_quotainfo->qi_dqlist_lock)) {
1971 restarts++;
1972 mutex_unlock(&dqp->q_hash->qh_lock);
1973 xfs_dqfunlock(dqp);
1974 xfs_dqunlock(dqp);
Dave Chinner3a8406f2010-04-13 15:06:52 +10001975 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
Dave Chinner368e1362010-04-13 15:06:50 +10001976 if (restarts++ >= XFS_QM_RECLAIM_MAX_RESTARTS)
1977 return NULL;
1978 goto startagain;
1979 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001980
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 ASSERT(dqp->q_nrefs == 0);
Dave Chinner3a254042010-04-13 15:06:48 +10001982 list_del_init(&dqp->q_mplist);
1983 mp->m_quotainfo->qi_dquots--;
1984 mp->m_quotainfo->qi_dqreclaims++;
Dave Chinnere6a81f12010-04-13 15:06:51 +10001985 list_del_init(&dqp->q_hashlist);
1986 dqp->q_hash->qh_version++;
Dave Chinner3a8406f2010-04-13 15:06:52 +10001987 list_del_init(&dqp->q_freelist);
1988 xfs_Gqm->qm_dqfrlist_cnt--;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 dqpout = dqp;
Dave Chinner3a254042010-04-13 15:06:48 +10001990 mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);
Dave Chinner368e1362010-04-13 15:06:50 +10001991 mutex_unlock(&dqp->q_hash->qh_lock);
1992dqfunlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 xfs_dqfunlock(dqp);
1994 xfs_dqunlock(dqp);
1995 if (dqpout)
1996 break;
Dave Chinner368e1362010-04-13 15:06:50 +10001997 if (restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
1998 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 }
Dave Chinner3a8406f2010-04-13 15:06:52 +10002000 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
Jesper Juhl014c2542006-01-15 02:37:08 +01002001 return dqpout;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002}
2003
Dave Chinner368e1362010-04-13 15:06:50 +10002004/*
2005 * Traverse the freelist of dquots and attempt to reclaim a maximum of
2006 * 'howmany' dquots. This operation races with dqlookup(), and attempts to
2007 * favor the lookup function ...
2008 */
2009STATIC int
2010xfs_qm_shake_freelist(
2011 int howmany)
2012{
2013 int nreclaimed = 0;
2014 xfs_dquot_t *dqp;
2015
2016 if (howmany <= 0)
2017 return 0;
2018
2019 while (nreclaimed < howmany) {
2020 dqp = xfs_qm_dqreclaim_one();
2021 if (!dqp)
2022 return nreclaimed;
2023 xfs_qm_dqdestroy(dqp);
2024 nreclaimed++;
2025 }
2026 return nreclaimed;
2027}
2028
2029/*
2030 * The kmem_shake interface is invoked when memory is running low.
2031 */
2032/* ARGSUSED */
2033STATIC int
Dave Chinner7f8275d2010-07-19 14:56:17 +10002034xfs_qm_shake(
2035 struct shrinker *shrink,
2036 int nr_to_scan,
2037 gfp_t gfp_mask)
Dave Chinner368e1362010-04-13 15:06:50 +10002038{
2039 int ndqused, nfree, n;
2040
2041 if (!kmem_shake_allow(gfp_mask))
2042 return 0;
2043 if (!xfs_Gqm)
2044 return 0;
2045
Dave Chinner3a8406f2010-04-13 15:06:52 +10002046 nfree = xfs_Gqm->qm_dqfrlist_cnt; /* free dquots */
Dave Chinner368e1362010-04-13 15:06:50 +10002047 /* incore dquots in all f/s's */
2048 ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
2049
2050 ASSERT(ndqused >= 0);
2051
2052 if (nfree <= ndqused && nfree < ndquot)
2053 return 0;
2054
2055 ndqused *= xfs_Gqm->qm_dqfree_ratio; /* target # of free dquots */
2056 n = nfree - ndqused - ndquot; /* # over target */
2057
2058 return xfs_qm_shake_freelist(MAX(nfree, n));
2059}
2060
Linus Torvalds1da177e2005-04-16 15:20:36 -07002061
2062/*------------------------------------------------------------------*/
2063
2064/*
2065 * Return a new incore dquot. Depending on the number of
2066 * dquots in the system, we either allocate a new one on the kernel heap,
2067 * or reclaim a free one.
2068 * Return value is B_TRUE if we allocated a new dquot, B_FALSE if we managed
2069 * to reclaim an existing one from the freelist.
2070 */
2071boolean_t
2072xfs_qm_dqalloc_incore(
2073 xfs_dquot_t **O_dqpp)
2074{
2075 xfs_dquot_t *dqp;
2076
2077 /*
2078 * Check against high water mark to see if we want to pop
2079 * a nincompoop dquot off the freelist.
2080 */
2081 if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
2082 /*
2083 * Try to recycle a dquot from the freelist.
2084 */
2085 if ((dqp = xfs_qm_dqreclaim_one())) {
2086 XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
2087 /*
2088 * Just zero the core here. The rest will get
2089 * reinitialized by caller. XXX we shouldn't even
2090 * do this zero ...
2091 */
2092 memset(&dqp->q_core, 0, sizeof(dqp->q_core));
2093 *O_dqpp = dqp;
Jesper Juhl014c2542006-01-15 02:37:08 +01002094 return B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 }
2096 XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
2097 }
2098
2099 /*
2100 * Allocate a brand new dquot on the kernel heap and return it
2101 * to the caller to initialize.
2102 */
2103 ASSERT(xfs_Gqm->qm_dqzone != NULL);
2104 *O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
2105 atomic_inc(&xfs_Gqm->qm_totaldquots);
2106
Jesper Juhl014c2542006-01-15 02:37:08 +01002107 return B_TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108}
2109
2110
2111/*
2112 * Start a transaction and write the incore superblock changes to
2113 * disk. flags parameter indicates which fields have changed.
2114 */
2115int
2116xfs_qm_write_sb_changes(
2117 xfs_mount_t *mp,
2118 __int64_t flags)
2119{
2120 xfs_trans_t *tp;
2121 int error;
2122
2123#ifdef QUOTADEBUG
2124 cmn_err(CE_NOTE, "Writing superblock quota changes :%s", mp->m_fsname);
2125#endif
2126 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
2127 if ((error = xfs_trans_reserve(tp, 0,
2128 mp->m_sb.sb_sectsize + 128, 0,
2129 0,
2130 XFS_DEFAULT_LOG_COUNT))) {
2131 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01002132 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 }
2134
2135 xfs_mod_sb(tp, flags);
David Chinnere5720ee2008-04-10 12:21:18 +10002136 error = xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137
David Chinnere5720ee2008-04-10 12:21:18 +10002138 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139}
2140
2141
2142/* --------------- utility functions for vnodeops ---------------- */
2143
2144
2145/*
2146 * Given an inode, a uid and gid (from cred_t) make sure that we have
2147 * allocated relevant dquot(s) on disk, and that we won't exceed inode
2148 * quotas by creating this file.
2149 * This also attaches dquot(s) to the given inode after locking it,
2150 * and returns the dquots corresponding to the uid and/or gid.
2151 *
2152 * in : inode (unlocked)
2153 * out : udquot, gdquot with references taken and unlocked
2154 */
2155int
2156xfs_qm_vop_dqalloc(
Christoph Hellwig7d095252009-06-08 15:33:32 +02002157 struct xfs_inode *ip,
2158 uid_t uid,
2159 gid_t gid,
2160 prid_t prid,
2161 uint flags,
2162 struct xfs_dquot **O_udqpp,
2163 struct xfs_dquot **O_gdqpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002164{
Christoph Hellwig7d095252009-06-08 15:33:32 +02002165 struct xfs_mount *mp = ip->i_mount;
2166 struct xfs_dquot *uq, *gq;
2167 int error;
2168 uint lockflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169
Christoph Hellwig7d095252009-06-08 15:33:32 +02002170 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 return 0;
2172
2173 lockflags = XFS_ILOCK_EXCL;
2174 xfs_ilock(ip, lockflags);
2175
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10002176 if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 gid = ip->i_d.di_gid;
2178
2179 /*
2180 * Attach the dquot(s) to this inode, doing a dquot allocation
2181 * if necessary. The dquot(s) will not be locked.
2182 */
2183 if (XFS_NOT_DQATTACHED(mp, ip)) {
Christoph Hellwig7d095252009-06-08 15:33:32 +02002184 error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);
2185 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 xfs_iunlock(ip, lockflags);
Jesper Juhl014c2542006-01-15 02:37:08 +01002187 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188 }
2189 }
2190
2191 uq = gq = NULL;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002192 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 if (ip->i_d.di_uid != uid) {
2194 /*
2195 * What we need is the dquot that has this uid, and
2196 * if we send the inode to dqget, the uid of the inode
2197 * takes priority over what's sent in the uid argument.
2198 * We must unlock inode here before calling dqget if
2199 * we're not sending the inode, because otherwise
2200 * we'll deadlock by doing trans_reserve while
2201 * holding ilock.
2202 */
2203 xfs_iunlock(ip, lockflags);
2204 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
2205 XFS_DQ_USER,
2206 XFS_QMOPT_DQALLOC |
2207 XFS_QMOPT_DOWARN,
2208 &uq))) {
2209 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01002210 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 }
2212 /*
2213 * Get the ilock in the right order.
2214 */
2215 xfs_dqunlock(uq);
2216 lockflags = XFS_ILOCK_SHARED;
2217 xfs_ilock(ip, lockflags);
2218 } else {
2219 /*
2220 * Take an extra reference, because we'll return
2221 * this to caller
2222 */
2223 ASSERT(ip->i_udquot);
2224 uq = ip->i_udquot;
2225 xfs_dqlock(uq);
2226 XFS_DQHOLD(uq);
2227 xfs_dqunlock(uq);
2228 }
2229 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002230 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231 if (ip->i_d.di_gid != gid) {
2232 xfs_iunlock(ip, lockflags);
2233 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
2234 XFS_DQ_GROUP,
2235 XFS_QMOPT_DQALLOC |
2236 XFS_QMOPT_DOWARN,
2237 &gq))) {
2238 if (uq)
2239 xfs_qm_dqrele(uq);
2240 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01002241 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242 }
2243 xfs_dqunlock(gq);
2244 lockflags = XFS_ILOCK_SHARED;
2245 xfs_ilock(ip, lockflags);
2246 } else {
2247 ASSERT(ip->i_gdquot);
2248 gq = ip->i_gdquot;
2249 xfs_dqlock(gq);
2250 XFS_DQHOLD(gq);
2251 xfs_dqunlock(gq);
2252 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002253 } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
2254 if (ip->i_d.di_projid != prid) {
2255 xfs_iunlock(ip, lockflags);
2256 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
2257 XFS_DQ_PROJ,
2258 XFS_QMOPT_DQALLOC |
2259 XFS_QMOPT_DOWARN,
2260 &gq))) {
2261 if (uq)
2262 xfs_qm_dqrele(uq);
2263 ASSERT(error != ENOENT);
2264 return (error);
2265 }
2266 xfs_dqunlock(gq);
2267 lockflags = XFS_ILOCK_SHARED;
2268 xfs_ilock(ip, lockflags);
2269 } else {
2270 ASSERT(ip->i_gdquot);
2271 gq = ip->i_gdquot;
2272 xfs_dqlock(gq);
2273 XFS_DQHOLD(gq);
2274 xfs_dqunlock(gq);
2275 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 }
2277 if (uq)
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00002278 trace_xfs_dquot_dqalloc(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279
2280 xfs_iunlock(ip, lockflags);
2281 if (O_udqpp)
2282 *O_udqpp = uq;
2283 else if (uq)
2284 xfs_qm_dqrele(uq);
2285 if (O_gdqpp)
2286 *O_gdqpp = gq;
2287 else if (gq)
2288 xfs_qm_dqrele(gq);
Jesper Juhl014c2542006-01-15 02:37:08 +01002289 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002290}
2291
2292/*
2293 * Actually transfer ownership, and do dquot modifications.
2294 * These were already reserved.
2295 */
2296xfs_dquot_t *
2297xfs_qm_vop_chown(
2298 xfs_trans_t *tp,
2299 xfs_inode_t *ip,
2300 xfs_dquot_t **IO_olddq,
2301 xfs_dquot_t *newdq)
2302{
2303 xfs_dquot_t *prevdq;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002304 uint bfield = XFS_IS_REALTIME_INODE(ip) ?
2305 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
2306
Christoph Hellwig7d095252009-06-08 15:33:32 +02002307
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002308 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
2310
2311 /* old dquot */
2312 prevdq = *IO_olddq;
2313 ASSERT(prevdq);
2314 ASSERT(prevdq != newdq);
2315
Nathan Scott06d10dd2005-06-21 15:48:47 +10002316 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
2317 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002318
2319 /* the sparkling new dquot */
Nathan Scott06d10dd2005-06-21 15:48:47 +10002320 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
2321 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322
2323 /*
2324 * Take an extra reference, because the inode
2325 * is going to keep this dquot pointer even
2326 * after the trans_commit.
2327 */
2328 xfs_dqlock(newdq);
2329 XFS_DQHOLD(newdq);
2330 xfs_dqunlock(newdq);
2331 *IO_olddq = newdq;
2332
Jesper Juhl014c2542006-01-15 02:37:08 +01002333 return prevdq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334}
2335
2336/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002337 * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338 */
2339int
2340xfs_qm_vop_chown_reserve(
2341 xfs_trans_t *tp,
2342 xfs_inode_t *ip,
2343 xfs_dquot_t *udqp,
2344 xfs_dquot_t *gdqp,
2345 uint flags)
2346{
Christoph Hellwig7d095252009-06-08 15:33:32 +02002347 xfs_mount_t *mp = ip->i_mount;
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002348 uint delblks, blkflags, prjflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq;
Christoph Hellwig7d095252009-06-08 15:33:32 +02002350 int error;
2351
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002353 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002354 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2355
2356 delblks = ip->i_delayed_blks;
2357 delblksudq = delblksgdq = unresudq = unresgdq = NULL;
Nathan Scott06d10dd2005-06-21 15:48:47 +10002358 blkflags = XFS_IS_REALTIME_INODE(ip) ?
2359 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360
2361 if (XFS_IS_UQUOTA_ON(mp) && udqp &&
Christoph Hellwig1149d962005-11-02 15:01:12 +11002362 ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363 delblksudq = udqp;
2364 /*
2365 * If there are delayed allocation blocks, then we have to
2366 * unreserve those from the old dquot, and add them to the
2367 * new dquot.
2368 */
2369 if (delblks) {
2370 ASSERT(ip->i_udquot);
2371 unresudq = ip->i_udquot;
2372 }
2373 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002374 if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002375 if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
2376 ip->i_d.di_projid != be32_to_cpu(gdqp->q_core.d_id))
2377 prjflags = XFS_QMOPT_ENOSPC;
2378
2379 if (prjflags ||
2380 (XFS_IS_GQUOTA_ON(ip->i_mount) &&
2381 ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10002382 delblksgdq = gdqp;
2383 if (delblks) {
2384 ASSERT(ip->i_gdquot);
2385 unresgdq = ip->i_gdquot;
2386 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 }
2388 }
2389
2390 if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2391 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002392 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393 return (error);
2394
2395 /*
2396 * Do the delayed blks reservations/unreservations now. Since, these
2397 * are done without the help of a transaction, if a reservation fails
2398 * its previous reservations won't be automatically undone by trans
2399 * code. So, we have to do it manually here.
2400 */
2401 if (delblks) {
2402 /*
2403 * Do the reservations first. Unreservation can't fail.
2404 */
2405 ASSERT(delblksudq || delblksgdq);
2406 ASSERT(unresudq || unresgdq);
2407 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2408 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10002409 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 return (error);
2411 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2412 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
Nathan Scott06d10dd2005-06-21 15:48:47 +10002413 blkflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 }
2415
2416 return (0);
2417}
2418
2419int
2420xfs_qm_vop_rename_dqattach(
Christoph Hellwig7d095252009-06-08 15:33:32 +02002421 struct xfs_inode **i_tab)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422{
Christoph Hellwig7d095252009-06-08 15:33:32 +02002423 struct xfs_mount *mp = i_tab[0]->i_mount;
2424 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002425
Christoph Hellwig7d095252009-06-08 15:33:32 +02002426 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
Jesper Juhl014c2542006-01-15 02:37:08 +01002427 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428
Christoph Hellwig7d095252009-06-08 15:33:32 +02002429 for (i = 0; (i < 4 && i_tab[i]); i++) {
2430 struct xfs_inode *ip = i_tab[i];
2431 int error;
2432
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 /*
2434 * Watch out for duplicate entries in the table.
2435 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02002436 if (i == 0 || ip != i_tab[i-1]) {
2437 if (XFS_NOT_DQATTACHED(mp, ip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438 error = xfs_qm_dqattach(ip, 0);
2439 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01002440 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002441 }
2442 }
2443 }
Jesper Juhl014c2542006-01-15 02:37:08 +01002444 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445}
2446
2447void
Christoph Hellwig7d095252009-06-08 15:33:32 +02002448xfs_qm_vop_create_dqattach(
2449 struct xfs_trans *tp,
2450 struct xfs_inode *ip,
2451 struct xfs_dquot *udqp,
2452 struct xfs_dquot *gdqp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453{
Christoph Hellwig7d095252009-06-08 15:33:32 +02002454 struct xfs_mount *mp = tp->t_mountp;
2455
2456 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457 return;
2458
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002459 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Christoph Hellwig7d095252009-06-08 15:33:32 +02002460 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461
2462 if (udqp) {
2463 xfs_dqlock(udqp);
2464 XFS_DQHOLD(udqp);
2465 xfs_dqunlock(udqp);
2466 ASSERT(ip->i_udquot == NULL);
2467 ip->i_udquot = udqp;
Christoph Hellwig7d095252009-06-08 15:33:32 +02002468 ASSERT(XFS_IS_UQUOTA_ON(mp));
Christoph Hellwig1149d962005-11-02 15:01:12 +11002469 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2471 }
2472 if (gdqp) {
2473 xfs_dqlock(gdqp);
2474 XFS_DQHOLD(gdqp);
2475 xfs_dqunlock(gdqp);
2476 ASSERT(ip->i_gdquot == NULL);
2477 ip->i_gdquot = gdqp;
Christoph Hellwig7d095252009-06-08 15:33:32 +02002478 ASSERT(XFS_IS_OQUOTA_ON(mp));
2479 ASSERT((XFS_IS_GQUOTA_ON(mp) ?
Nathan Scottee2a4f72006-01-11 15:33:36 +11002480 ip->i_d.di_gid : ip->i_d.di_projid) ==
2481 be32_to_cpu(gdqp->q_core.d_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2483 }
2484}
2485