blob: 249db1987764586c37c3b6d75a2fd1c78cae3c48 [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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "xfs_trans.h"
23#include "xfs_sb.h"
24#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_alloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include "xfs_quota.h"
27#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "xfs_bmap_btree.h"
29#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include "xfs_dinode.h"
31#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110032#include "xfs_ialloc.h"
33#include "xfs_itable.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_rtalloc.h"
35#include "xfs_error.h"
Nathan Scotta844f452005-11-02 14:38:42 +110036#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include "xfs_attr.h"
38#include "xfs_buf_item.h"
39#include "xfs_trans_space.h"
40#include "xfs_utils.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include "xfs_qm.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000042#include "xfs_trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043
44/*
45 * The global quota manager. There is only one of these for the entire
46 * system, _not_ one per file system. XQM keeps track of the overall
47 * quota functionality, including maintaining the freelist and hash
48 * tables of dquots.
49 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070050STATIC int xfs_qm_init_quotainos(xfs_mount_t *);
Christoph Hellwigba0f32d2005-06-21 15:36:52 +100051STATIC int xfs_qm_init_quotainfo(xfs_mount_t *);
Ying Han1495f232011-05-24 17:12:27 -070052STATIC int xfs_qm_shake(struct shrinker *, struct shrink_control *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Linus Torvalds1da177e2005-04-16 15:20:36 -070054/*
Christoph Hellwigb84a3a92012-03-14 11:53:34 -050055 * We use the batch lookup interface to iterate over the dquots as it
56 * currently is the only interface into the radix tree code that allows
57 * fuzzy lookups instead of exact matches. Holding the lock over multiple
58 * operations is fine as all callers are used either during mount/umount
59 * or quotaoff.
60 */
61#define XFS_DQ_LOOKUP_BATCH 32
62
63STATIC int
64xfs_qm_dquot_walk(
65 struct xfs_mount *mp,
66 int type,
Christoph Hellwig43ff2122012-04-23 15:58:39 +100067 int (*execute)(struct xfs_dquot *dqp, void *data),
68 void *data)
Christoph Hellwigb84a3a92012-03-14 11:53:34 -050069{
70 struct xfs_quotainfo *qi = mp->m_quotainfo;
71 struct radix_tree_root *tree = XFS_DQUOT_TREE(qi, type);
72 uint32_t next_index;
73 int last_error = 0;
74 int skipped;
75 int nr_found;
76
77restart:
78 skipped = 0;
79 next_index = 0;
80 nr_found = 0;
81
82 while (1) {
83 struct xfs_dquot *batch[XFS_DQ_LOOKUP_BATCH];
84 int error = 0;
85 int i;
86
87 mutex_lock(&qi->qi_tree_lock);
88 nr_found = radix_tree_gang_lookup(tree, (void **)batch,
89 next_index, XFS_DQ_LOOKUP_BATCH);
90 if (!nr_found) {
91 mutex_unlock(&qi->qi_tree_lock);
92 break;
93 }
94
95 for (i = 0; i < nr_found; i++) {
96 struct xfs_dquot *dqp = batch[i];
97
98 next_index = be32_to_cpu(dqp->q_core.d_id) + 1;
99
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000100 error = execute(batch[i], data);
Christoph Hellwigb84a3a92012-03-14 11:53:34 -0500101 if (error == EAGAIN) {
102 skipped++;
103 continue;
104 }
105 if (error && last_error != EFSCORRUPTED)
106 last_error = error;
107 }
108
109 mutex_unlock(&qi->qi_tree_lock);
110
111 /* bail out if the filesystem is corrupted. */
112 if (last_error == EFSCORRUPTED) {
113 skipped = 0;
114 break;
115 }
116 }
117
118 if (skipped) {
119 delay(1);
120 goto restart;
121 }
122
123 return last_error;
124}
125
126
127/*
128 * Purge a dquot from all tracking data structures and free it.
129 */
130STATIC int
131xfs_qm_dqpurge(
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000132 struct xfs_dquot *dqp,
133 void *data)
Christoph Hellwigb84a3a92012-03-14 11:53:34 -0500134{
135 struct xfs_mount *mp = dqp->q_mount;
136 struct xfs_quotainfo *qi = mp->m_quotainfo;
137 struct xfs_dquot *gdqp = NULL;
138
139 xfs_dqlock(dqp);
140 if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0) {
141 xfs_dqunlock(dqp);
142 return EAGAIN;
143 }
144
145 /*
146 * If this quota has a group hint attached, prepare for releasing it
147 * now.
148 */
149 gdqp = dqp->q_gdquot;
150 if (gdqp) {
151 xfs_dqlock(gdqp);
152 dqp->q_gdquot = NULL;
153 }
154
155 dqp->dq_flags |= XFS_DQ_FREEING;
156
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000157 xfs_dqflock(dqp);
Christoph Hellwigb84a3a92012-03-14 11:53:34 -0500158
159 /*
160 * If we are turning this type of quotas off, we don't care
161 * about the dirty metadata sitting in this dquot. OTOH, if
162 * we're unmounting, we do care, so we flush it and wait.
163 */
164 if (XFS_DQ_IS_DIRTY(dqp)) {
Christoph Hellwigfe7257f2012-04-23 15:58:37 +1000165 struct xfs_buf *bp = NULL;
166 int error;
Christoph Hellwigb84a3a92012-03-14 11:53:34 -0500167
168 /*
169 * We don't care about getting disk errors here. We need
170 * to purge this dquot anyway, so we go ahead regardless.
171 */
Christoph Hellwigfe7257f2012-04-23 15:58:37 +1000172 error = xfs_qm_dqflush(dqp, &bp);
173 if (error) {
Christoph Hellwigb84a3a92012-03-14 11:53:34 -0500174 xfs_warn(mp, "%s: dquot %p flush failed",
175 __func__, dqp);
Christoph Hellwigfe7257f2012-04-23 15:58:37 +1000176 } else {
177 error = xfs_bwrite(bp);
178 xfs_buf_relse(bp);
179 }
Christoph Hellwigb84a3a92012-03-14 11:53:34 -0500180 xfs_dqflock(dqp);
181 }
182
183 ASSERT(atomic_read(&dqp->q_pincount) == 0);
184 ASSERT(XFS_FORCED_SHUTDOWN(mp) ||
185 !(dqp->q_logitem.qli_item.li_flags & XFS_LI_IN_AIL));
186
187 xfs_dqfunlock(dqp);
188 xfs_dqunlock(dqp);
189
190 radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags),
191 be32_to_cpu(dqp->q_core.d_id));
192 qi->qi_dquots--;
193
194 /*
195 * We move dquots to the freelist as soon as their reference count
196 * hits zero, so it really should be on the freelist here.
197 */
198 mutex_lock(&qi->qi_lru_lock);
199 ASSERT(!list_empty(&dqp->q_lru));
200 list_del_init(&dqp->q_lru);
201 qi->qi_lru_count--;
202 XFS_STATS_DEC(xs_qm_dquot_unused);
203 mutex_unlock(&qi->qi_lru_lock);
204
205 xfs_qm_dqdestroy(dqp);
206
207 if (gdqp)
208 xfs_qm_dqput(gdqp);
209 return 0;
210}
211
212/*
213 * Purge the dquot cache.
214 */
215void
216xfs_qm_dqpurge_all(
217 struct xfs_mount *mp,
218 uint flags)
219{
220 if (flags & XFS_QMOPT_UQUOTA)
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000221 xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
Christoph Hellwigb84a3a92012-03-14 11:53:34 -0500222 if (flags & XFS_QMOPT_GQUOTA)
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000223 xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
Christoph Hellwigb84a3a92012-03-14 11:53:34 -0500224 if (flags & XFS_QMOPT_PQUOTA)
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000225 xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL);
Christoph Hellwigb84a3a92012-03-14 11:53:34 -0500226}
227
228/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 * Just destroy the quotainfo structure.
230 */
231void
Christoph Hellwig7d095252009-06-08 15:33:32 +0200232xfs_qm_unmount(
233 struct xfs_mount *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234{
Christoph Hellwig7d095252009-06-08 15:33:32 +0200235 if (mp->m_quotainfo) {
Christoph Hellwig8112e9d2010-04-20 17:02:29 +1000236 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 xfs_qm_destroy_quotainfo(mp);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200238 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239}
240
241
242/*
243 * This is called from xfs_mountfs to start quotas and initialize all
244 * necessary data structures like quotainfo. This is also responsible for
245 * running a quotacheck as necessary. We are guaranteed that the superblock
246 * is consistently read in at this point.
David Chinner53aa7912008-04-10 12:20:31 +1000247 *
248 * If we fail here, the mount will continue with quota turned off. We don't
249 * need to inidicate success or failure at all.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 */
David Chinner53aa7912008-04-10 12:20:31 +1000251void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252xfs_qm_mount_quotas(
Christoph Hellwig42490232008-08-13 16:49:32 +1000253 xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 int error = 0;
256 uint sbf;
257
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 /*
259 * If quotas on realtime volumes is not supported, we disable
260 * quotas immediately.
261 */
262 if (mp->m_sb.sb_rextents) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100263 xfs_notice(mp, "Cannot turn on quotas for realtime filesystem");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 mp->m_qflags = 0;
265 goto write_changes;
266 }
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
Nathan Scott155ffd02005-09-02 16:43:48 +1000269
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 /*
271 * Allocate the quotainfo structure inside the mount struct, and
272 * create quotainode(s), and change/rev superblock if necessary.
273 */
David Chinner53aa7912008-04-10 12:20:31 +1000274 error = xfs_qm_init_quotainfo(mp);
275 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 /*
277 * We must turn off quotas.
278 */
279 ASSERT(mp->m_quotainfo == NULL);
280 mp->m_qflags = 0;
281 goto write_changes;
282 }
283 /*
284 * If any of the quotas are not consistent, do a quotacheck.
285 */
Christoph Hellwig42490232008-08-13 16:49:32 +1000286 if (XFS_QM_NEED_QUOTACHECK(mp)) {
David Chinner53aa7912008-04-10 12:20:31 +1000287 error = xfs_qm_quotacheck(mp);
288 if (error) {
289 /* Quotacheck failed and disabled quotas. */
290 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 }
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000293 /*
294 * If one type of quotas is off, then it will lose its
295 * quotachecked status, since we won't be doing accounting for
296 * that type anymore.
297 */
David Chinner53aa7912008-04-10 12:20:31 +1000298 if (!XFS_IS_UQUOTA_ON(mp))
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000299 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
David Chinner53aa7912008-04-10 12:20:31 +1000300 if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
Donald Douwsma646d5bd2007-05-08 13:49:09 +1000301 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
Nathan Scott155ffd02005-09-02 16:43:48 +1000302
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 write_changes:
304 /*
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000305 * We actually don't have to acquire the m_sb_lock at all.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 * This can only be called from mount, and that's single threaded. XXX
307 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000308 spin_lock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 sbf = mp->m_sb.sb_qflags;
310 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000311 spin_unlock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312
313 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
314 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
315 /*
316 * We could only have been turning quotas off.
317 * We aren't in very good shape actually because
318 * the incore structures are convinced that quotas are
319 * off, but the on disk superblock doesn't know that !
320 */
321 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
Dave Chinner53487782011-03-07 10:05:35 +1100322 xfs_alert(mp, "%s: Superblock update failed!",
323 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 }
325 }
326
327 if (error) {
Dave Chinner53487782011-03-07 10:05:35 +1100328 xfs_warn(mp, "Failed to initialize disk quotas.");
Christoph Hellwig7d095252009-06-08 15:33:32 +0200329 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331}
332
333/*
334 * Called from the vfsops layer.
335 */
Christoph Hellwige57481d2008-12-03 12:20:36 +0100336void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337xfs_qm_unmount_quotas(
338 xfs_mount_t *mp)
339{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 /*
341 * Release the dquots that root inode, et al might be holding,
342 * before we flush quotas and blow away the quotainfo structure.
343 */
344 ASSERT(mp->m_rootip);
345 xfs_qm_dqdetach(mp->m_rootip);
346 if (mp->m_rbmip)
347 xfs_qm_dqdetach(mp->m_rbmip);
348 if (mp->m_rsumip)
349 xfs_qm_dqdetach(mp->m_rsumip);
350
351 /*
Christoph Hellwige57481d2008-12-03 12:20:36 +0100352 * Release the quota inodes.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 if (mp->m_quotainfo) {
Christoph Hellwige57481d2008-12-03 12:20:36 +0100355 if (mp->m_quotainfo->qi_uquotaip) {
356 IRELE(mp->m_quotainfo->qi_uquotaip);
357 mp->m_quotainfo->qi_uquotaip = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 }
Christoph Hellwige57481d2008-12-03 12:20:36 +0100359 if (mp->m_quotainfo->qi_gquotaip) {
360 IRELE(mp->m_quotainfo->qi_gquotaip);
361 mp->m_quotainfo->qi_gquotaip = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 }
363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364}
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366STATIC int
367xfs_qm_dqattach_one(
368 xfs_inode_t *ip,
369 xfs_dqid_t id,
370 uint type,
371 uint doalloc,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 xfs_dquot_t *udqhint, /* hint */
373 xfs_dquot_t **IO_idqpp)
374{
375 xfs_dquot_t *dqp;
376 int error;
377
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000378 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 error = 0;
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100380
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 /*
382 * See if we already have it in the inode itself. IO_idqpp is
383 * &i_udquot or &i_gdquot. This made the code look weird, but
384 * made the logic a lot simpler.
385 */
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100386 dqp = *IO_idqpp;
387 if (dqp) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000388 trace_xfs_dqattach_found(dqp);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100389 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 }
391
392 /*
393 * udqhint is the i_udquot field in inode, and is non-NULL only
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000394 * when the type arg is group/project. Its purpose is to save a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
396 * the user dquot.
397 */
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100398 if (udqhint) {
399 ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 xfs_dqlock(udqhint);
401
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100402 /*
403 * No need to take dqlock to look at the id.
404 *
405 * The ID can't change until it gets reclaimed, and it won't
406 * be reclaimed as long as we have a ref from inode and we
407 * hold the ilock.
408 */
409 dqp = udqhint->q_gdquot;
410 if (dqp && be32_to_cpu(dqp->q_core.d_id) == id) {
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100411 ASSERT(*IO_idqpp == NULL);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100412
Christoph Hellwig78e55892011-12-06 21:58:22 +0000413 *IO_idqpp = xfs_qm_dqhold(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 xfs_dqunlock(udqhint);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100415 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 }
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100417
418 /*
419 * We can't hold a dquot lock when we call the dqget code.
420 * We'll deadlock in no time, because of (not conforming to)
421 * lock ordering - the inodelock comes before any dquot lock,
422 * and we may drop and reacquire the ilock in xfs_qm_dqget().
423 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 xfs_dqunlock(udqhint);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100425 }
426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 /*
428 * Find the dquot from somewhere. This bumps the
429 * reference count of dquot and returns it locked.
430 * This can return ENOENT if dquot didn't exist on
431 * disk and we didn't ask it to allocate;
432 * ESRCH if quotas got turned off suddenly.
433 */
Mitsuo Hayasakadb3e74b2011-11-10 01:33:10 +0000434 error = xfs_qm_dqget(ip->i_mount, ip, id, type,
435 doalloc | XFS_QMOPT_DOWARN, &dqp);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100436 if (error)
437 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000439 trace_xfs_dqattach_get(dqp);
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 /*
442 * dqget may have dropped and re-acquired the ilock, but it guarantees
443 * that the dquot returned is the one that should go in the inode.
444 */
445 *IO_idqpp = dqp;
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100446 xfs_dqunlock(dqp);
447 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448}
449
450
451/*
452 * Given a udquot and gdquot, attach a ptr to the group dquot in the
Christoph Hellwigab680bb2011-12-06 21:58:20 +0000453 * udquot as a hint for future lookups.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 */
455STATIC void
456xfs_qm_dqattach_grouphint(
457 xfs_dquot_t *udq,
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100458 xfs_dquot_t *gdq)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
460 xfs_dquot_t *tmp;
461
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100462 xfs_dqlock(udq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Christoph Hellwigab680bb2011-12-06 21:58:20 +0000464 tmp = udq->q_gdquot;
465 if (tmp) {
466 if (tmp == gdq)
467 goto done;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468
469 udq->q_gdquot = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 xfs_qm_dqrele(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 }
472
Christoph Hellwig78e55892011-12-06 21:58:22 +0000473 udq->q_gdquot = xfs_qm_dqhold(gdq);
Christoph Hellwigab680bb2011-12-06 21:58:20 +0000474done:
Christoph Hellwig8e9b6e72009-02-08 21:51:42 +0100475 xfs_dqunlock(udq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476}
477
Christoph Hellwigb4d05e32012-03-27 10:34:46 -0400478static bool
479xfs_qm_need_dqattach(
480 struct xfs_inode *ip)
481{
482 struct xfs_mount *mp = ip->i_mount;
483
484 if (!XFS_IS_QUOTA_RUNNING(mp))
485 return false;
486 if (!XFS_IS_QUOTA_ON(mp))
487 return false;
488 if (!XFS_NOT_DQATTACHED(mp, ip))
489 return false;
490 if (ip->i_ino == mp->m_sb.sb_uquotino ||
491 ip->i_ino == mp->m_sb.sb_gquotino)
492 return false;
493 return true;
494}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
496/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000497 * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
498 * into account.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 * Inode may get unlocked and relocked in here, and the caller must deal with
501 * the consequences.
502 */
503int
Christoph Hellwig7d095252009-06-08 15:33:32 +0200504xfs_qm_dqattach_locked(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 xfs_inode_t *ip,
506 uint flags)
507{
508 xfs_mount_t *mp = ip->i_mount;
509 uint nquotas = 0;
510 int error = 0;
511
Christoph Hellwigb4d05e32012-03-27 10:34:46 -0400512 if (!xfs_qm_need_dqattach(ip))
Jesper Juhl014c2542006-01-15 02:37:08 +0100513 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514
Christoph Hellwig7d095252009-06-08 15:33:32 +0200515 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516
517 if (XFS_IS_UQUOTA_ON(mp)) {
518 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
519 flags & XFS_QMOPT_DQALLOC,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 NULL, &ip->i_udquot);
521 if (error)
522 goto done;
523 nquotas++;
524 }
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000525
526 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000527 if (XFS_IS_OQUOTA_ON(mp)) {
528 error = XFS_IS_GQUOTA_ON(mp) ?
529 xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
530 flags & XFS_QMOPT_DQALLOC,
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000531 ip->i_udquot, &ip->i_gdquot) :
Arkadiusz Mi?kiewicz67430992010-09-26 06:10:18 +0000532 xfs_qm_dqattach_one(ip, xfs_get_projid(ip), XFS_DQ_PROJ,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 flags & XFS_QMOPT_DQALLOC,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 ip->i_udquot, &ip->i_gdquot);
535 /*
536 * Don't worry about the udquot that we may have
537 * attached above. It'll get detached, if not already.
538 */
539 if (error)
540 goto done;
541 nquotas++;
542 }
543
544 /*
545 * Attach this group quota to the user quota as a hint.
546 * This WON'T, in general, result in a thrash.
547 */
548 if (nquotas == 2) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000549 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 ASSERT(ip->i_udquot);
551 ASSERT(ip->i_gdquot);
552
553 /*
Christoph Hellwigab680bb2011-12-06 21:58:20 +0000554 * We do not have i_udquot locked at this point, but this check
555 * is OK since we don't depend on the i_gdquot to be accurate
556 * 100% all the time. It is just a hint, and this will
557 * succeed in general.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 */
Christoph Hellwigab680bb2011-12-06 21:58:20 +0000559 if (ip->i_udquot->q_gdquot != ip->i_gdquot)
560 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 }
562
Christoph Hellwig7d095252009-06-08 15:33:32 +0200563 done:
Christoph Hellwigea15ab32011-07-13 13:43:50 +0200564#ifdef DEBUG
565 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 if (XFS_IS_UQUOTA_ON(mp))
567 ASSERT(ip->i_udquot);
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000568 if (XFS_IS_OQUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 ASSERT(ip->i_gdquot);
570 }
Christoph Hellwig7d095252009-06-08 15:33:32 +0200571 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572#endif
Christoph Hellwig7d095252009-06-08 15:33:32 +0200573 return error;
574}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
Christoph Hellwig7d095252009-06-08 15:33:32 +0200576int
577xfs_qm_dqattach(
578 struct xfs_inode *ip,
579 uint flags)
580{
581 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
Christoph Hellwigb4d05e32012-03-27 10:34:46 -0400583 if (!xfs_qm_need_dqattach(ip))
584 return 0;
585
Christoph Hellwig7d095252009-06-08 15:33:32 +0200586 xfs_ilock(ip, XFS_ILOCK_EXCL);
587 error = xfs_qm_dqattach_locked(ip, flags);
588 xfs_iunlock(ip, XFS_ILOCK_EXCL);
589
Jesper Juhl014c2542006-01-15 02:37:08 +0100590 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591}
592
593/*
594 * Release dquots (and their references) if any.
595 * The inode should be locked EXCL except when this's called by
596 * xfs_ireclaim.
597 */
598void
599xfs_qm_dqdetach(
600 xfs_inode_t *ip)
601{
602 if (!(ip->i_udquot || ip->i_gdquot))
603 return;
604
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000605 trace_xfs_dquot_dqdetach(ip);
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
608 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 if (ip->i_udquot) {
610 xfs_qm_dqrele(ip->i_udquot);
611 ip->i_udquot = NULL;
612 }
613 if (ip->i_gdquot) {
614 xfs_qm_dqrele(ip->i_gdquot);
615 ip->i_gdquot = NULL;
616 }
617}
618
Christoph Hellwiga4edd1d2009-01-19 02:03:11 +0100619/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 * This initializes all the quota information that's kept in the
621 * mount structure
622 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000623STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624xfs_qm_init_quotainfo(
625 xfs_mount_t *mp)
626{
627 xfs_quotainfo_t *qinf;
628 int error;
629 xfs_dquot_t *dqp;
630
631 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
632
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
634
635 /*
636 * See if quotainodes are setup, and if not, allocate them,
637 * and change the superblock accordingly.
638 */
639 if ((error = xfs_qm_init_quotainos(mp))) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000640 kmem_free(qinf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 mp->m_quotainfo = NULL;
Jesper Juhl014c2542006-01-15 02:37:08 +0100642 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 }
644
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000645 INIT_RADIX_TREE(&qinf->qi_uquota_tree, GFP_NOFS);
646 INIT_RADIX_TREE(&qinf->qi_gquota_tree, GFP_NOFS);
647 mutex_init(&qinf->qi_tree_lock);
648
Christoph Hellwigf8739c32012-03-13 08:52:34 +0000649 INIT_LIST_HEAD(&qinf->qi_lru_list);
650 qinf->qi_lru_count = 0;
651 mutex_init(&qinf->qi_lru_lock);
652
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 /* mutex used to serialize quotaoffs */
Jes Sorensen794ee1b2006-01-09 15:59:21 -0800654 mutex_init(&qinf->qi_quotaofflock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655
656 /* Precalc some constants */
657 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
658 ASSERT(qinf->qi_dqchunklen);
659 qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
660 do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
661
662 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
663
664 /*
665 * We try to get the limits from the superuser's limits fields.
666 * This is quite hacky, but it is standard quota practice.
Christoph Hellwig7ae44402011-12-06 21:58:25 +0000667 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 * We look at the USR dquot with id == 0 first, but if user quotas
669 * are not enabled we goto the GRP dquot with id == 0.
670 * We don't really care to keep separate default limits for user
671 * and group quotas, at least not at this point.
Christoph Hellwig7ae44402011-12-06 21:58:25 +0000672 *
673 * Since we may not have done a quotacheck by this point, just read
674 * the dquot without attaching it to any hashtables or lists.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 */
Christoph Hellwig7ae44402011-12-06 21:58:25 +0000676 error = xfs_qm_dqread(mp, 0,
677 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
678 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
679 XFS_DQ_PROJ),
680 XFS_QMOPT_DOWARN, &dqp);
681 if (!error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 xfs_disk_dquot_t *ddqp = &dqp->q_core;
683
684 /*
685 * The warnings and timers set the grace period given to
686 * a user or group before he or she can not perform any
687 * more writing. If it is zero, a default is used.
688 */
Christoph Hellwig1149d962005-11-02 15:01:12 +1100689 qinf->qi_btimelimit = ddqp->d_btimer ?
690 be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
691 qinf->qi_itimelimit = ddqp->d_itimer ?
692 be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
693 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
694 be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
695 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
696 be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
697 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
698 be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
699 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
700 be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
701 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
702 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
703 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
704 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
705 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
706 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 xfs_qm_dqdestroy(dqp);
709 } else {
710 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
711 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
712 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
713 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
714 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
Nathan Scott06d10dd2005-06-21 15:48:47 +1000715 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 }
717
Christoph Hellwigf8739c32012-03-13 08:52:34 +0000718 qinf->qi_shrinker.shrink = xfs_qm_shake;
719 qinf->qi_shrinker.seeks = DEFAULT_SEEKS;
720 register_shrinker(&qinf->qi_shrinker);
Jesper Juhl014c2542006-01-15 02:37:08 +0100721 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722}
723
724
725/*
726 * Gets called when unmounting a filesystem or when all quotas get
727 * turned off.
728 * This purges the quota inodes, destroys locks and frees itself.
729 */
730void
731xfs_qm_destroy_quotainfo(
732 xfs_mount_t *mp)
733{
734 xfs_quotainfo_t *qi;
735
736 qi = mp->m_quotainfo;
737 ASSERT(qi != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738
Christoph Hellwigf8739c32012-03-13 08:52:34 +0000739 unregister_shrinker(&qi->qi_shrinker);
740
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (qi->qi_uquotaip) {
Christoph Hellwig26cc0022008-07-18 17:12:43 +1000742 IRELE(qi->qi_uquotaip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 qi->qi_uquotaip = NULL; /* paranoia */
744 }
745 if (qi->qi_gquotaip) {
Christoph Hellwig26cc0022008-07-18 17:12:43 +1000746 IRELE(qi->qi_gquotaip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 qi->qi_gquotaip = NULL;
748 }
749 mutex_destroy(&qi->qi_quotaofflock);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000750 kmem_free(qi);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 mp->m_quotainfo = NULL;
752}
753
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754/*
755 * Create an inode and return with a reference already taken, but unlocked
756 * This is how we create quota inodes
757 */
758STATIC int
759xfs_qm_qino_alloc(
760 xfs_mount_t *mp,
761 xfs_inode_t **ip,
762 __int64_t sbfields,
763 uint flags)
764{
765 xfs_trans_t *tp;
766 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 int committed;
768
Nathan Scott061f7202006-01-11 15:27:50 +1100769 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 if ((error = xfs_trans_reserve(tp,
771 XFS_QM_QINOCREATE_SPACE_RES(mp),
772 XFS_CREATE_LOG_RES(mp), 0,
773 XFS_TRANS_PERM_LOG_RES,
774 XFS_CREATE_LOG_COUNT))) {
775 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +0100776 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
Christoph Hellwig6c77b0e2010-10-06 18:41:17 +0000779 error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, 1, ip, &committed);
780 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
782 XFS_TRANS_ABORT);
Jesper Juhl014c2542006-01-15 02:37:08 +0100783 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 }
785
786 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787 * Make the changes in the superblock, and log those too.
788 * sbfields arg may contain fields other than *QUOTINO;
789 * VERSIONNUM for example.
790 */
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000791 spin_lock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 if (flags & XFS_QMOPT_SBVERSION) {
Eric Sandeen62118702008-03-06 13:44:28 +1100793 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
795 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
796 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
797 XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
798
Eric Sandeen62118702008-03-06 13:44:28 +1100799 xfs_sb_version_addquota(&mp->m_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 mp->m_sb.sb_uquotino = NULLFSINO;
801 mp->m_sb.sb_gquotino = NULLFSINO;
802
803 /* qflags will get updated _after_ quotacheck */
804 mp->m_sb.sb_qflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805 }
806 if (flags & XFS_QMOPT_UQUOTA)
807 mp->m_sb.sb_uquotino = (*ip)->i_ino;
808 else
809 mp->m_sb.sb_gquotino = (*ip)->i_ino;
Eric Sandeen3685c2a2007-10-11 17:42:32 +1000810 spin_unlock(&mp->m_sb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 xfs_mod_sb(tp, sbfields);
812
Eric Sandeen1c72bf92007-05-08 13:48:42 +1000813 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
Dave Chinner53487782011-03-07 10:05:35 +1100814 xfs_alert(mp, "%s failed (error %d)!", __func__, error);
Jesper Juhl014c2542006-01-15 02:37:08 +0100815 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 }
Jesper Juhl014c2542006-01-15 02:37:08 +0100817 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818}
819
820
David Chinner5b139732008-04-10 12:20:10 +1000821STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822xfs_qm_reset_dqcounts(
823 xfs_mount_t *mp,
824 xfs_buf_t *bp,
825 xfs_dqid_t id,
826 uint type)
827{
828 xfs_disk_dquot_t *ddq;
829 int j;
830
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000831 trace_xfs_reset_dqcounts(bp, _RET_IP_);
832
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 /*
834 * Reset all counters and timers. They'll be
835 * started afresh by xfs_qm_quotacheck.
836 */
837#ifdef DEBUG
838 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
839 do_div(j, sizeof(xfs_dqblk_t));
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000840 ASSERT(mp->m_quotainfo->qi_dqperchunk == j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841#endif
Chandra Seetharaman62926042011-07-22 23:40:15 +0000842 ddq = bp->b_addr;
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000843 for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 /*
845 * Do a sanity check, and if needed, repair the dqblk. Don't
846 * output any warnings because it's perfectly possible to
Nathan Scottc41564b2006-03-29 08:55:14 +1000847 * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100849 (void) xfs_qm_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 "xfs_quotacheck");
Christoph Hellwig1149d962005-11-02 15:01:12 +1100851 ddq->d_bcount = 0;
852 ddq->d_icount = 0;
853 ddq->d_rtbcount = 0;
854 ddq->d_btimer = 0;
855 ddq->d_itimer = 0;
856 ddq->d_rtbtimer = 0;
857 ddq->d_bwarns = 0;
858 ddq->d_iwarns = 0;
859 ddq->d_rtbwarns = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
861 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862}
863
864STATIC int
865xfs_qm_dqiter_bufs(
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000866 struct xfs_mount *mp,
867 xfs_dqid_t firstid,
868 xfs_fsblock_t bno,
869 xfs_filblks_t blkcnt,
870 uint flags,
871 struct list_head *buffer_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872{
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000873 struct xfs_buf *bp;
874 int error;
875 int type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876
877 ASSERT(blkcnt > 0);
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000878 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
879 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 error = 0;
881
882 /*
883 * Blkcnt arg can be a very big number, and might even be
884 * larger than the log itself. So, we have to break it up into
885 * manageable-sized transactions.
886 * Note that we don't start a permanent transaction here; we might
887 * not be able to get a log reservation for the whole thing up front,
888 * and we don't really care to either, because we just discard
889 * everything if we were to crash in the middle of this loop.
890 */
891 while (blkcnt--) {
892 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
893 XFS_FSB_TO_DADDR(mp, bno),
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000894 mp->m_quotainfo->qi_dqchunklen, 0, &bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 if (error)
896 break;
897
David Chinner5b139732008-04-10 12:20:10 +1000898 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000899 xfs_buf_delwri_queue(bp, buffer_list);
Christoph Hellwig61551f12011-08-23 08:28:06 +0000900 xfs_buf_relse(bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 /*
902 * goto the next block.
903 */
904 bno++;
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000905 firstid += mp->m_quotainfo->qi_dqperchunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 }
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000907
Jesper Juhl014c2542006-01-15 02:37:08 +0100908 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909}
910
911/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000912 * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 * caller supplied function for every chunk of dquots that we find.
914 */
915STATIC int
916xfs_qm_dqiterate(
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000917 struct xfs_mount *mp,
918 struct xfs_inode *qip,
919 uint flags,
920 struct list_head *buffer_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921{
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000922 struct xfs_bmbt_irec *map;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 int i, nmaps; /* number of map entries */
924 int error; /* return value */
925 xfs_fileoff_t lblkno;
926 xfs_filblks_t maxlblkcnt;
927 xfs_dqid_t firstid;
928 xfs_fsblock_t rablkno;
929 xfs_filblks_t rablkcnt;
930
931 error = 0;
932 /*
Nathan Scottc41564b2006-03-29 08:55:14 +1000933 * This looks racy, but we can't keep an inode lock across a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 * trans_reserve. But, this gets called during quotacheck, and that
935 * happens only at mount time which is single threaded.
936 */
937 if (qip->i_d.di_nblocks == 0)
Jesper Juhl014c2542006-01-15 02:37:08 +0100938 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939
940 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
941
942 lblkno = 0;
943 maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
944 do {
945 nmaps = XFS_DQITER_MAP_SIZE;
946 /*
947 * We aren't changing the inode itself. Just changing
948 * some of its data. No new blocks are added here, and
949 * the inode is never added to the transaction.
950 */
951 xfs_ilock(qip, XFS_ILOCK_SHARED);
Dave Chinner5c8ed202011-09-18 20:40:45 +0000952 error = xfs_bmapi_read(qip, lblkno, maxlblkcnt - lblkno,
953 map, &nmaps, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 xfs_iunlock(qip, XFS_ILOCK_SHARED);
955 if (error)
956 break;
957
958 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
959 for (i = 0; i < nmaps; i++) {
960 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
961 ASSERT(map[i].br_blockcount);
962
963
964 lblkno += map[i].br_blockcount;
965
966 if (map[i].br_startblock == HOLESTARTBLOCK)
967 continue;
968
969 firstid = (xfs_dqid_t) map[i].br_startoff *
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000970 mp->m_quotainfo->qi_dqperchunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 /*
972 * Do a read-ahead on the next extent.
973 */
974 if ((i+1 < nmaps) &&
975 (map[i+1].br_startblock != HOLESTARTBLOCK)) {
976 rablkcnt = map[i+1].br_blockcount;
977 rablkno = map[i+1].br_startblock;
978 while (rablkcnt--) {
Christoph Hellwig1a1a3e92010-10-06 18:41:18 +0000979 xfs_buf_readahead(mp->m_ddev_targp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 XFS_FSB_TO_DADDR(mp, rablkno),
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000981 mp->m_quotainfo->qi_dqchunklen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982 rablkno++;
983 }
984 }
985 /*
986 * Iterate thru all the blks in the extent and
987 * reset the counters of all the dquots inside them.
988 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000989 error = xfs_qm_dqiter_bufs(mp, firstid,
990 map[i].br_startblock,
991 map[i].br_blockcount,
992 flags, buffer_list);
993 if (error)
994 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 } while (nmaps > 0);
997
Christoph Hellwig43ff2122012-04-23 15:58:39 +1000998out:
Denys Vlasenkof0e2d932008-05-19 16:31:57 +1000999 kmem_free(map);
Jesper Juhl014c2542006-01-15 02:37:08 +01001000 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001}
1002
1003/*
1004 * Called by dqusage_adjust in doing a quotacheck.
Christoph Hellwig52fda112010-09-06 01:44:22 +00001005 *
1006 * Given the inode, and a dquot id this updates both the incore dqout as well
1007 * as the buffer copy. This is so that once the quotacheck is done, we can
1008 * just log all the buffers, as opposed to logging numerous updates to
1009 * individual dquots.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 */
Christoph Hellwig52fda112010-09-06 01:44:22 +00001011STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012xfs_qm_quotacheck_dqadjust(
Christoph Hellwig52fda112010-09-06 01:44:22 +00001013 struct xfs_inode *ip,
1014 xfs_dqid_t id,
1015 uint type,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 xfs_qcnt_t nblks,
1017 xfs_qcnt_t rtblks)
1018{
Christoph Hellwig52fda112010-09-06 01:44:22 +00001019 struct xfs_mount *mp = ip->i_mount;
1020 struct xfs_dquot *dqp;
1021 int error;
1022
1023 error = xfs_qm_dqget(mp, ip, id, type,
1024 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN, &dqp);
1025 if (error) {
1026 /*
1027 * Shouldn't be able to turn off quotas here.
1028 */
1029 ASSERT(error != ESRCH);
1030 ASSERT(error != ENOENT);
1031 return error;
1032 }
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001033
1034 trace_xfs_dqadjust(dqp);
1035
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 /*
1037 * Adjust the inode count and the block count to reflect this inode's
1038 * resource usage.
1039 */
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001040 be64_add_cpu(&dqp->q_core.d_icount, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 dqp->q_res_icount++;
1042 if (nblks) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001043 be64_add_cpu(&dqp->q_core.d_bcount, nblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 dqp->q_res_bcount += nblks;
1045 }
1046 if (rtblks) {
Marcin Slusarz413d57c2008-02-13 15:03:29 -08001047 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 dqp->q_res_rtbcount += rtblks;
1049 }
1050
1051 /*
1052 * Set default limits, adjust timers (since we changed usages)
Christoph Hellwig191f8482010-04-20 17:01:53 +10001053 *
1054 * There are no timers for the default values set in the root dquot.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 */
Christoph Hellwig191f8482010-04-20 17:01:53 +10001056 if (dqp->q_core.d_id) {
Christoph Hellwig52fda112010-09-06 01:44:22 +00001057 xfs_qm_adjust_dqlimits(mp, &dqp->q_core);
1058 xfs_qm_adjust_dqtimers(mp, &dqp->q_core);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059 }
1060
1061 dqp->dq_flags |= XFS_DQ_DIRTY;
Christoph Hellwig52fda112010-09-06 01:44:22 +00001062 xfs_qm_dqput(dqp);
1063 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064}
1065
1066STATIC int
1067xfs_qm_get_rtblks(
1068 xfs_inode_t *ip,
1069 xfs_qcnt_t *O_rtblks)
1070{
1071 xfs_filblks_t rtblks; /* total rt blks */
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001072 xfs_extnum_t idx; /* extent record index */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 xfs_ifork_t *ifp; /* inode fork pointer */
1074 xfs_extnum_t nextents; /* number of extent entries */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 int error;
1076
1077 ASSERT(XFS_IS_REALTIME_INODE(ip));
1078 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1079 if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1080 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
Jesper Juhl014c2542006-01-15 02:37:08 +01001081 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 }
1083 rtblks = 0;
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11001084 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10001085 for (idx = 0; idx < nextents; idx++)
1086 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 *O_rtblks = (xfs_qcnt_t)rtblks;
Jesper Juhl014c2542006-01-15 02:37:08 +01001088 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089}
1090
1091/*
1092 * callback routine supplied to bulkstat(). Given an inumber, find its
1093 * dquots and update them to account for resources taken by that inode.
1094 */
1095/* ARGSUSED */
1096STATIC int
1097xfs_qm_dqusage_adjust(
1098 xfs_mount_t *mp, /* mount point for filesystem */
1099 xfs_ino_t ino, /* inode number to get data for */
1100 void __user *buffer, /* not used */
1101 int ubsize, /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 int *ubused, /* not used */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 int *res) /* result code value */
1104{
1105 xfs_inode_t *ip;
Christoph Hellwig52fda112010-09-06 01:44:22 +00001106 xfs_qcnt_t nblks, rtblks = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 int error;
1108
1109 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1110
1111 /*
1112 * rootino must have its resources accounted for, not so with the quota
1113 * inodes.
1114 */
1115 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1116 *res = BULKSTAT_RV_NOTHING;
1117 return XFS_ERROR(EINVAL);
1118 }
1119
1120 /*
1121 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1122 * interface expects the inode to be exclusively locked because that's
1123 * the case in all other instances. It's OK that we do this because
1124 * quotacheck is done only at mount time.
1125 */
Christoph Hellwig52fda112010-09-06 01:44:22 +00001126 error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip);
1127 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 *res = BULKSTAT_RV_NOTHING;
Jesper Juhl014c2542006-01-15 02:37:08 +01001129 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 }
1131
Christoph Hellwig52fda112010-09-06 01:44:22 +00001132 ASSERT(ip->i_delayed_blks == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133
Christoph Hellwig52fda112010-09-06 01:44:22 +00001134 if (XFS_IS_REALTIME_INODE(ip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 /*
1136 * Walk thru the extent list and count the realtime blocks.
1137 */
Christoph Hellwig52fda112010-09-06 01:44:22 +00001138 error = xfs_qm_get_rtblks(ip, &rtblks);
1139 if (error)
1140 goto error0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
Christoph Hellwig52fda112010-09-06 01:44:22 +00001143 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
1145 /*
1146 * Add the (disk blocks and inode) resources occupied by this
1147 * inode to its dquots. We do this adjustment in the incore dquot,
1148 * and also copy the changes to its buffer.
1149 * We don't care about putting these changes in a transaction
1150 * envelope because if we crash in the middle of a 'quotacheck'
1151 * we have to start from the beginning anyway.
1152 * Once we're done, we'll log all the dquot bufs.
1153 *
Nathan Scottc41564b2006-03-29 08:55:14 +10001154 * The *QUOTA_ON checks below may look pretty racy, but quotachecks
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 * and quotaoffs don't race. (Quotachecks happen at mount time only).
1156 */
1157 if (XFS_IS_UQUOTA_ON(mp)) {
Christoph Hellwig52fda112010-09-06 01:44:22 +00001158 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_uid,
1159 XFS_DQ_USER, nblks, rtblks);
1160 if (error)
1161 goto error0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163
Christoph Hellwig52fda112010-09-06 01:44:22 +00001164 if (XFS_IS_GQUOTA_ON(mp)) {
1165 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_gid,
1166 XFS_DQ_GROUP, nblks, rtblks);
1167 if (error)
1168 goto error0;
1169 }
1170
1171 if (XFS_IS_PQUOTA_ON(mp)) {
Arkadiusz Mi?kiewicz67430992010-09-26 06:10:18 +00001172 error = xfs_qm_quotacheck_dqadjust(ip, xfs_get_projid(ip),
Christoph Hellwig52fda112010-09-06 01:44:22 +00001173 XFS_DQ_PROJ, nblks, rtblks);
1174 if (error)
1175 goto error0;
1176 }
1177
1178 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1179 IRELE(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 *res = BULKSTAT_RV_DIDONE;
Jesper Juhl014c2542006-01-15 02:37:08 +01001181 return 0;
Christoph Hellwig52fda112010-09-06 01:44:22 +00001182
1183error0:
1184 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1185 IRELE(ip);
1186 *res = BULKSTAT_RV_GIVEUP;
1187 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188}
1189
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001190STATIC int
1191xfs_qm_flush_one(
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001192 struct xfs_dquot *dqp,
1193 void *data)
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001194{
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001195 struct list_head *buffer_list = data;
Christoph Hellwigfe7257f2012-04-23 15:58:37 +10001196 struct xfs_buf *bp = NULL;
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001197 int error = 0;
1198
1199 xfs_dqlock(dqp);
1200 if (dqp->dq_flags & XFS_DQ_FREEING)
1201 goto out_unlock;
1202 if (!XFS_DQ_IS_DIRTY(dqp))
1203 goto out_unlock;
1204
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001205 xfs_dqflock(dqp);
Christoph Hellwigfe7257f2012-04-23 15:58:37 +10001206 error = xfs_qm_dqflush(dqp, &bp);
1207 if (error)
1208 goto out_unlock;
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001209
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001210 xfs_buf_delwri_queue(bp, buffer_list);
Christoph Hellwigfe7257f2012-04-23 15:58:37 +10001211 xfs_buf_relse(bp);
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001212out_unlock:
1213 xfs_dqunlock(dqp);
1214 return error;
1215}
1216
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217/*
1218 * Walk thru all the filesystem inodes and construct a consistent view
1219 * of the disk quota world. If the quotacheck fails, disable quotas.
1220 */
1221int
1222xfs_qm_quotacheck(
1223 xfs_mount_t *mp)
1224{
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001225 int done, count, error, error2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 xfs_ino_t lastino;
1227 size_t structsz;
1228 xfs_inode_t *uip, *gip;
1229 uint flags;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001230 LIST_HEAD (buffer_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
1232 count = INT_MAX;
1233 structsz = 1;
1234 lastino = 0;
1235 flags = 0;
1236
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001237 ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1239
Dave Chinner0b932cc2011-03-07 10:08:35 +11001240 xfs_notice(mp, "Quotacheck needed: Please wait.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241
1242 /*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001243 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244 * their counters to zero. We need a clean slate.
1245 * We don't log our changes till later.
1246 */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001247 uip = mp->m_quotainfo->qi_uquotaip;
1248 if (uip) {
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001249 error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA,
1250 &buffer_list);
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001251 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 goto error_return;
1253 flags |= XFS_UQUOTA_CHKD;
1254 }
1255
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001256 gip = mp->m_quotainfo->qi_gquotaip;
1257 if (gip) {
1258 error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001259 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA,
1260 &buffer_list);
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001261 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 goto error_return;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001263 flags |= XFS_OQUOTA_CHKD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 }
1265
1266 do {
1267 /*
1268 * Iterate thru all the inodes in the file system,
1269 * adjusting the corresponding dquot counters in core.
1270 */
Christoph Hellwig7dce11d2010-06-23 18:11:11 +10001271 error = xfs_bulkstat(mp, &lastino, &count,
1272 xfs_qm_dqusage_adjust,
1273 structsz, NULL, &done);
1274 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 break;
1276
Christoph Hellwig7dce11d2010-06-23 18:11:11 +10001277 } while (!done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278
1279 /*
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001280 * We've made all the changes that we need to make incore. Flush them
1281 * down to disk buffers if everything was updated successfully.
David Chinner4b8879d2008-04-10 12:20:17 +10001282 */
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001283 if (XFS_IS_UQUOTA_ON(mp)) {
1284 error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one,
1285 &buffer_list);
1286 }
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001287 if (XFS_IS_GQUOTA_ON(mp)) {
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001288 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one,
1289 &buffer_list);
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001290 if (!error)
1291 error = error2;
1292 }
1293 if (XFS_IS_PQUOTA_ON(mp)) {
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001294 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one,
1295 &buffer_list);
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001296 if (!error)
1297 error = error2;
1298 }
David Chinner4b8879d2008-04-10 12:20:17 +10001299
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001300 error2 = xfs_buf_delwri_submit(&buffer_list);
1301 if (!error)
1302 error = error2;
1303
David Chinner4b8879d2008-04-10 12:20:17 +10001304 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 * We can get this error if we couldn't do a dquot allocation inside
1306 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1307 * dirty dquots that might be cached, we just want to get rid of them
1308 * and turn quotaoff. The dquots won't be attached to any of the inodes
1309 * at this point (because we intentionally didn't in dqget_noattach).
1310 */
1311 if (error) {
Christoph Hellwig8112e9d2010-04-20 17:02:29 +10001312 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 goto error_return;
1314 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315
1316 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 * If one type of quotas is off, then it will lose its
1318 * quotachecked status, since we won't be doing accounting for
1319 * that type anymore.
1320 */
Chandra Seetharaman4177af32012-01-23 17:31:43 +00001321 mp->m_qflags &= ~XFS_ALL_QUOTA_CHKD;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 mp->m_qflags |= flags;
1323
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 error_return:
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001325 while (!list_empty(&buffer_list)) {
1326 struct xfs_buf *bp =
1327 list_first_entry(&buffer_list, struct xfs_buf, b_list);
1328 list_del_init(&bp->b_list);
1329 xfs_buf_relse(bp);
1330 }
1331
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 if (error) {
Dave Chinner0b932cc2011-03-07 10:08:35 +11001333 xfs_warn(mp,
1334 "Quotacheck: Unsuccessful (Error %d): Disabling quotas.",
1335 error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 /*
1337 * We must turn off quotas.
1338 */
1339 ASSERT(mp->m_quotainfo != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001340 xfs_qm_destroy_quotainfo(mp);
David Chinner31d55772008-04-10 12:20:38 +10001341 if (xfs_mount_reset_sbqflags(mp)) {
Dave Chinner0b932cc2011-03-07 10:08:35 +11001342 xfs_warn(mp,
1343 "Quotacheck: Failed to reset quota flags.");
David Chinner31d55772008-04-10 12:20:38 +10001344 }
Dave Chinner0b932cc2011-03-07 10:08:35 +11001345 } else
1346 xfs_notice(mp, "Quotacheck: Done.");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 return (error);
1348}
1349
1350/*
1351 * This is called after the superblock has been read in and we're ready to
1352 * iget the quota inodes.
1353 */
1354STATIC int
1355xfs_qm_init_quotainos(
1356 xfs_mount_t *mp)
1357{
1358 xfs_inode_t *uip, *gip;
1359 int error;
1360 __int64_t sbflags;
1361 uint flags;
1362
1363 ASSERT(mp->m_quotainfo);
1364 uip = gip = NULL;
1365 sbflags = 0;
1366 flags = 0;
1367
1368 /*
1369 * Get the uquota and gquota inodes
1370 */
Eric Sandeen62118702008-03-06 13:44:28 +11001371 if (xfs_sb_version_hasquota(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372 if (XFS_IS_UQUOTA_ON(mp) &&
1373 mp->m_sb.sb_uquotino != NULLFSINO) {
1374 ASSERT(mp->m_sb.sb_uquotino > 0);
1375 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
Dave Chinner7b6259e2010-06-24 11:35:17 +10001376 0, 0, &uip)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001377 return XFS_ERROR(error);
1378 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001379 if (XFS_IS_OQUOTA_ON(mp) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 mp->m_sb.sb_gquotino != NULLFSINO) {
1381 ASSERT(mp->m_sb.sb_gquotino > 0);
1382 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
Dave Chinner7b6259e2010-06-24 11:35:17 +10001383 0, 0, &gip))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 if (uip)
Christoph Hellwig43355092008-03-27 18:01:08 +11001385 IRELE(uip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386 return XFS_ERROR(error);
1387 }
1388 }
1389 } else {
1390 flags |= XFS_QMOPT_SBVERSION;
1391 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1392 XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
1393 }
1394
1395 /*
1396 * Create the two inodes, if they don't exist already. The changes
1397 * made above will get added to a transaction and logged in one of
1398 * the qino_alloc calls below. If the device is readonly,
1399 * temporarily switch to read-write to do this.
1400 */
1401 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1402 if ((error = xfs_qm_qino_alloc(mp, &uip,
1403 sbflags | XFS_SB_UQUOTINO,
1404 flags | XFS_QMOPT_UQUOTA)))
1405 return XFS_ERROR(error);
1406
1407 flags &= ~XFS_QMOPT_SBVERSION;
1408 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001409 if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
1410 flags |= (XFS_IS_GQUOTA_ON(mp) ?
1411 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1412 error = xfs_qm_qino_alloc(mp, &gip,
1413 sbflags | XFS_SB_GQUOTINO, flags);
1414 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 if (uip)
Christoph Hellwig43355092008-03-27 18:01:08 +11001416 IRELE(uip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
1418 return XFS_ERROR(error);
1419 }
1420 }
1421
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001422 mp->m_quotainfo->qi_uquotaip = uip;
1423 mp->m_quotainfo->qi_gquotaip = gip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424
Jesper Juhl014c2542006-01-15 02:37:08 +01001425 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426}
1427
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001428STATIC void
1429xfs_qm_dqfree_one(
1430 struct xfs_dquot *dqp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431{
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001432 struct xfs_mount *mp = dqp->q_mount;
1433 struct xfs_quotainfo *qi = mp->m_quotainfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434
Christoph Hellwig9f920f12012-03-13 08:52:35 +00001435 mutex_lock(&qi->qi_tree_lock);
1436 radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags),
1437 be32_to_cpu(dqp->q_core.d_id));
Christoph Hellwigbf72de32011-12-06 21:58:19 +00001438
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001439 qi->qi_dquots--;
Christoph Hellwigb84a3a92012-03-14 11:53:34 -05001440 mutex_unlock(&qi->qi_tree_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001442 xfs_qm_dqdestroy(dqp);
1443}
Christoph Hellwigbe7ffc32011-12-06 21:58:17 +00001444
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001445STATIC void
1446xfs_qm_dqreclaim_one(
1447 struct xfs_dquot *dqp,
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001448 struct list_head *buffer_list,
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001449 struct list_head *dispose_list)
1450{
1451 struct xfs_mount *mp = dqp->q_mount;
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001452 struct xfs_quotainfo *qi = mp->m_quotainfo;
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001453 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001455 if (!xfs_dqlock_nowait(dqp))
1456 goto out_busy;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001458 /*
1459 * This dquot has acquired a reference in the meantime remove it from
1460 * the freelist and try again.
1461 */
1462 if (dqp->q_nrefs) {
Christoph Hellwig92678552011-12-06 21:58:18 +00001463 xfs_dqunlock(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001465 trace_xfs_dqreclaim_want(dqp);
Christoph Hellwig48776fd2012-03-13 08:52:33 +00001466 XFS_STATS_INC(xs_qm_dqwants);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001467
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001468 list_del_init(&dqp->q_lru);
1469 qi->qi_lru_count--;
Christoph Hellwig48776fd2012-03-13 08:52:33 +00001470 XFS_STATS_DEC(xs_qm_dquot_unused);
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001471 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 }
Christoph Hellwig92678552011-12-06 21:58:18 +00001473
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001474 /*
1475 * Try to grab the flush lock. If this dquot is in the process of
1476 * getting flushed to disk, we don't want to reclaim it.
1477 */
1478 if (!xfs_dqflock_nowait(dqp))
1479 goto out_busy;
Dave Chinner368e1362010-04-13 15:06:50 +10001480
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001481 if (XFS_DQ_IS_DIRTY(dqp)) {
Christoph Hellwigfe7257f2012-04-23 15:58:37 +10001482 struct xfs_buf *bp = NULL;
1483
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001484 trace_xfs_dqreclaim_dirty(dqp);
Dave Chinner368e1362010-04-13 15:06:50 +10001485
Christoph Hellwigfe7257f2012-04-23 15:58:37 +10001486 error = xfs_qm_dqflush(dqp, &bp);
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001487 if (error) {
1488 xfs_warn(mp, "%s: dquot %p flush failed",
1489 __func__, dqp);
Christoph Hellwigfe7257f2012-04-23 15:58:37 +10001490 goto out_busy;
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001491 }
1492
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001493 xfs_buf_delwri_queue(bp, buffer_list);
Christoph Hellwigfe7257f2012-04-23 15:58:37 +10001494 xfs_buf_relse(bp);
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001495 /*
1496 * Give the dquot another try on the freelist, as the
1497 * flushing will take some time.
1498 */
1499 goto out_busy;
Dave Chinner368e1362010-04-13 15:06:50 +10001500 }
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001501 xfs_dqfunlock(dqp);
1502
1503 /*
1504 * Prevent lookups now that we are past the point of no return.
1505 */
1506 dqp->dq_flags |= XFS_DQ_FREEING;
1507 xfs_dqunlock(dqp);
1508
1509 ASSERT(dqp->q_nrefs == 0);
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001510 list_move_tail(&dqp->q_lru, dispose_list);
1511 qi->qi_lru_count--;
Christoph Hellwig48776fd2012-03-13 08:52:33 +00001512 XFS_STATS_DEC(xs_qm_dquot_unused);
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001513
1514 trace_xfs_dqreclaim_done(dqp);
Christoph Hellwig48776fd2012-03-13 08:52:33 +00001515 XFS_STATS_INC(xs_qm_dqreclaims);
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001516 return;
1517
1518out_busy:
1519 xfs_dqunlock(dqp);
1520
1521 /*
1522 * Move the dquot to the tail of the list so that we don't spin on it.
1523 */
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001524 list_move_tail(&dqp->q_lru, &qi->qi_lru_list);
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001525
1526 trace_xfs_dqreclaim_busy(dqp);
Christoph Hellwig48776fd2012-03-13 08:52:33 +00001527 XFS_STATS_INC(xs_qm_dqreclaim_misses);
Dave Chinner368e1362010-04-13 15:06:50 +10001528}
1529
Dave Chinner368e1362010-04-13 15:06:50 +10001530STATIC int
Dave Chinner7f8275d2010-07-19 14:56:17 +10001531xfs_qm_shake(
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001532 struct shrinker *shrink,
1533 struct shrink_control *sc)
Dave Chinner368e1362010-04-13 15:06:50 +10001534{
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001535 struct xfs_quotainfo *qi =
1536 container_of(shrink, struct xfs_quotainfo, qi_shrinker);
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001537 int nr_to_scan = sc->nr_to_scan;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001538 LIST_HEAD (buffer_list);
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001539 LIST_HEAD (dispose_list);
1540 struct xfs_dquot *dqp;
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001541 int error;
Dave Chinner368e1362010-04-13 15:06:50 +10001542
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001543 if ((sc->gfp_mask & (__GFP_FS|__GFP_WAIT)) != (__GFP_FS|__GFP_WAIT))
Dave Chinner368e1362010-04-13 15:06:50 +10001544 return 0;
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001545 if (!nr_to_scan)
1546 goto out;
Dave Chinner368e1362010-04-13 15:06:50 +10001547
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001548 mutex_lock(&qi->qi_lru_lock);
1549 while (!list_empty(&qi->qi_lru_list)) {
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001550 if (nr_to_scan-- <= 0)
1551 break;
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001552 dqp = list_first_entry(&qi->qi_lru_list, struct xfs_dquot,
1553 q_lru);
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001554 xfs_qm_dqreclaim_one(dqp, &buffer_list, &dispose_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555 }
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001556 mutex_unlock(&qi->qi_lru_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001558 error = xfs_buf_delwri_submit(&buffer_list);
1559 if (error)
1560 xfs_warn(NULL, "%s: dquot reclaim failed", __func__);
1561
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001562 while (!list_empty(&dispose_list)) {
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001563 dqp = list_first_entry(&dispose_list, struct xfs_dquot, q_lru);
1564 list_del_init(&dqp->q_lru);
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001565 xfs_qm_dqfree_one(dqp);
1566 }
Christoph Hellwig43ff2122012-04-23 15:58:39 +10001567
Christoph Hellwig92b2e5b32012-02-01 13:57:20 +00001568out:
Christoph Hellwigf8739c32012-03-13 08:52:34 +00001569 return (qi->qi_lru_count / 100) * sysctl_vfs_cache_pressure;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570}
1571
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572/*
1573 * Start a transaction and write the incore superblock changes to
1574 * disk. flags parameter indicates which fields have changed.
1575 */
1576int
1577xfs_qm_write_sb_changes(
1578 xfs_mount_t *mp,
1579 __int64_t flags)
1580{
1581 xfs_trans_t *tp;
1582 int error;
1583
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
1585 if ((error = xfs_trans_reserve(tp, 0,
1586 mp->m_sb.sb_sectsize + 128, 0,
1587 0,
1588 XFS_DEFAULT_LOG_COUNT))) {
1589 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001590 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 }
1592
1593 xfs_mod_sb(tp, flags);
David Chinnere5720ee2008-04-10 12:21:18 +10001594 error = xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
David Chinnere5720ee2008-04-10 12:21:18 +10001596 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597}
1598
1599
1600/* --------------- utility functions for vnodeops ---------------- */
1601
1602
1603/*
Christoph Hellwig6c77b0e2010-10-06 18:41:17 +00001604 * Given an inode, a uid, gid and prid make sure that we have
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 * allocated relevant dquot(s) on disk, and that we won't exceed inode
1606 * quotas by creating this file.
1607 * This also attaches dquot(s) to the given inode after locking it,
1608 * and returns the dquots corresponding to the uid and/or gid.
1609 *
1610 * in : inode (unlocked)
1611 * out : udquot, gdquot with references taken and unlocked
1612 */
1613int
1614xfs_qm_vop_dqalloc(
Christoph Hellwig7d095252009-06-08 15:33:32 +02001615 struct xfs_inode *ip,
1616 uid_t uid,
1617 gid_t gid,
1618 prid_t prid,
1619 uint flags,
1620 struct xfs_dquot **O_udqpp,
1621 struct xfs_dquot **O_gdqpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622{
Christoph Hellwig7d095252009-06-08 15:33:32 +02001623 struct xfs_mount *mp = ip->i_mount;
1624 struct xfs_dquot *uq, *gq;
1625 int error;
1626 uint lockflags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
Christoph Hellwig7d095252009-06-08 15:33:32 +02001628 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 return 0;
1630
1631 lockflags = XFS_ILOCK_EXCL;
1632 xfs_ilock(ip, lockflags);
1633
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001634 if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 gid = ip->i_d.di_gid;
1636
1637 /*
1638 * Attach the dquot(s) to this inode, doing a dquot allocation
1639 * if necessary. The dquot(s) will not be locked.
1640 */
1641 if (XFS_NOT_DQATTACHED(mp, ip)) {
Christoph Hellwig7d095252009-06-08 15:33:32 +02001642 error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);
1643 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 xfs_iunlock(ip, lockflags);
Jesper Juhl014c2542006-01-15 02:37:08 +01001645 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 }
1647 }
1648
1649 uq = gq = NULL;
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001650 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 if (ip->i_d.di_uid != uid) {
1652 /*
1653 * What we need is the dquot that has this uid, and
1654 * if we send the inode to dqget, the uid of the inode
1655 * takes priority over what's sent in the uid argument.
1656 * We must unlock inode here before calling dqget if
1657 * we're not sending the inode, because otherwise
1658 * we'll deadlock by doing trans_reserve while
1659 * holding ilock.
1660 */
1661 xfs_iunlock(ip, lockflags);
1662 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
1663 XFS_DQ_USER,
1664 XFS_QMOPT_DQALLOC |
1665 XFS_QMOPT_DOWARN,
1666 &uq))) {
1667 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001668 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 }
1670 /*
1671 * Get the ilock in the right order.
1672 */
1673 xfs_dqunlock(uq);
1674 lockflags = XFS_ILOCK_SHARED;
1675 xfs_ilock(ip, lockflags);
1676 } else {
1677 /*
1678 * Take an extra reference, because we'll return
1679 * this to caller
1680 */
1681 ASSERT(ip->i_udquot);
Christoph Hellwig78e55892011-12-06 21:58:22 +00001682 uq = xfs_qm_dqhold(ip->i_udquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 }
1684 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001685 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 if (ip->i_d.di_gid != gid) {
1687 xfs_iunlock(ip, lockflags);
1688 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
1689 XFS_DQ_GROUP,
1690 XFS_QMOPT_DQALLOC |
1691 XFS_QMOPT_DOWARN,
1692 &gq))) {
1693 if (uq)
1694 xfs_qm_dqrele(uq);
1695 ASSERT(error != ENOENT);
Jesper Juhl014c2542006-01-15 02:37:08 +01001696 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 }
1698 xfs_dqunlock(gq);
1699 lockflags = XFS_ILOCK_SHARED;
1700 xfs_ilock(ip, lockflags);
1701 } else {
1702 ASSERT(ip->i_gdquot);
Christoph Hellwig78e55892011-12-06 21:58:22 +00001703 gq = xfs_qm_dqhold(ip->i_gdquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001705 } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
Arkadiusz Mi?kiewicz67430992010-09-26 06:10:18 +00001706 if (xfs_get_projid(ip) != prid) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001707 xfs_iunlock(ip, lockflags);
1708 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
1709 XFS_DQ_PROJ,
1710 XFS_QMOPT_DQALLOC |
1711 XFS_QMOPT_DOWARN,
1712 &gq))) {
1713 if (uq)
1714 xfs_qm_dqrele(uq);
1715 ASSERT(error != ENOENT);
1716 return (error);
1717 }
1718 xfs_dqunlock(gq);
1719 lockflags = XFS_ILOCK_SHARED;
1720 xfs_ilock(ip, lockflags);
1721 } else {
1722 ASSERT(ip->i_gdquot);
Christoph Hellwig78e55892011-12-06 21:58:22 +00001723 gq = xfs_qm_dqhold(ip->i_gdquot);
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001724 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 }
1726 if (uq)
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001727 trace_xfs_dquot_dqalloc(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728
1729 xfs_iunlock(ip, lockflags);
1730 if (O_udqpp)
1731 *O_udqpp = uq;
1732 else if (uq)
1733 xfs_qm_dqrele(uq);
1734 if (O_gdqpp)
1735 *O_gdqpp = gq;
1736 else if (gq)
1737 xfs_qm_dqrele(gq);
Jesper Juhl014c2542006-01-15 02:37:08 +01001738 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739}
1740
1741/*
1742 * Actually transfer ownership, and do dquot modifications.
1743 * These were already reserved.
1744 */
1745xfs_dquot_t *
1746xfs_qm_vop_chown(
1747 xfs_trans_t *tp,
1748 xfs_inode_t *ip,
1749 xfs_dquot_t **IO_olddq,
1750 xfs_dquot_t *newdq)
1751{
1752 xfs_dquot_t *prevdq;
Nathan Scott06d10dd2005-06-21 15:48:47 +10001753 uint bfield = XFS_IS_REALTIME_INODE(ip) ?
1754 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
1755
Christoph Hellwig7d095252009-06-08 15:33:32 +02001756
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001757 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
1759
1760 /* old dquot */
1761 prevdq = *IO_olddq;
1762 ASSERT(prevdq);
1763 ASSERT(prevdq != newdq);
1764
Nathan Scott06d10dd2005-06-21 15:48:47 +10001765 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
1766 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
1768 /* the sparkling new dquot */
Nathan Scott06d10dd2005-06-21 15:48:47 +10001769 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
1770 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771
1772 /*
Christoph Hellwig78e55892011-12-06 21:58:22 +00001773 * Take an extra reference, because the inode is going to keep
1774 * this dquot pointer even after the trans_commit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 */
Christoph Hellwig78e55892011-12-06 21:58:22 +00001776 *IO_olddq = xfs_qm_dqhold(newdq);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
Jesper Juhl014c2542006-01-15 02:37:08 +01001778 return prevdq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779}
1780
1781/*
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001782 * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 */
1784int
1785xfs_qm_vop_chown_reserve(
1786 xfs_trans_t *tp,
1787 xfs_inode_t *ip,
1788 xfs_dquot_t *udqp,
1789 xfs_dquot_t *gdqp,
1790 uint flags)
1791{
Christoph Hellwig7d095252009-06-08 15:33:32 +02001792 xfs_mount_t *mp = ip->i_mount;
Nathan Scott9a2a7de2006-03-31 13:04:49 +10001793 uint delblks, blkflags, prjflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq;
Christoph Hellwig7d095252009-06-08 15:33:32 +02001795 int error;
1796
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001798 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1800
1801 delblks = ip->i_delayed_blks;
1802 delblksudq = delblksgdq = unresudq = unresgdq = NULL;
Nathan Scott06d10dd2005-06-21 15:48:47 +10001803 blkflags = XFS_IS_REALTIME_INODE(ip) ?
1804 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805
1806 if (XFS_IS_UQUOTA_ON(mp) && udqp &&
Christoph Hellwig1149d962005-11-02 15:01:12 +11001807 ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 delblksudq = udqp;
1809 /*
1810 * If there are delayed allocation blocks, then we have to
1811 * unreserve those from the old dquot, and add them to the
1812 * new dquot.
1813 */
1814 if (delblks) {
1815 ASSERT(ip->i_udquot);
1816 unresudq = ip->i_udquot;
1817 }
1818 }
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001819 if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
Nathan Scott9a2a7de2006-03-31 13:04:49 +10001820 if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
Arkadiusz Mi?kiewicz67430992010-09-26 06:10:18 +00001821 xfs_get_projid(ip) != be32_to_cpu(gdqp->q_core.d_id))
Nathan Scott9a2a7de2006-03-31 13:04:49 +10001822 prjflags = XFS_QMOPT_ENOSPC;
1823
1824 if (prjflags ||
1825 (XFS_IS_GQUOTA_ON(ip->i_mount) &&
1826 ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +10001827 delblksgdq = gdqp;
1828 if (delblks) {
1829 ASSERT(ip->i_gdquot);
1830 unresgdq = ip->i_gdquot;
1831 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 }
1833 }
1834
1835 if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
1836 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10001837 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 return (error);
1839
1840 /*
1841 * Do the delayed blks reservations/unreservations now. Since, these
1842 * are done without the help of a transaction, if a reservation fails
1843 * its previous reservations won't be automatically undone by trans
1844 * code. So, we have to do it manually here.
1845 */
1846 if (delblks) {
1847 /*
1848 * Do the reservations first. Unreservation can't fail.
1849 */
1850 ASSERT(delblksudq || delblksgdq);
1851 ASSERT(unresudq || unresgdq);
1852 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
1853 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
Nathan Scott9a2a7de2006-03-31 13:04:49 +10001854 flags | blkflags | prjflags)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 return (error);
1856 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
1857 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
Nathan Scott06d10dd2005-06-21 15:48:47 +10001858 blkflags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 }
1860
1861 return (0);
1862}
1863
1864int
1865xfs_qm_vop_rename_dqattach(
Christoph Hellwig7d095252009-06-08 15:33:32 +02001866 struct xfs_inode **i_tab)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867{
Christoph Hellwig7d095252009-06-08 15:33:32 +02001868 struct xfs_mount *mp = i_tab[0]->i_mount;
1869 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870
Christoph Hellwig7d095252009-06-08 15:33:32 +02001871 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
Jesper Juhl014c2542006-01-15 02:37:08 +01001872 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
Christoph Hellwig7d095252009-06-08 15:33:32 +02001874 for (i = 0; (i < 4 && i_tab[i]); i++) {
1875 struct xfs_inode *ip = i_tab[i];
1876 int error;
1877
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 /*
1879 * Watch out for duplicate entries in the table.
1880 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001881 if (i == 0 || ip != i_tab[i-1]) {
1882 if (XFS_NOT_DQATTACHED(mp, ip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 error = xfs_qm_dqattach(ip, 0);
1884 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001885 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 }
1887 }
1888 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001889 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890}
1891
1892void
Christoph Hellwig7d095252009-06-08 15:33:32 +02001893xfs_qm_vop_create_dqattach(
1894 struct xfs_trans *tp,
1895 struct xfs_inode *ip,
1896 struct xfs_dquot *udqp,
1897 struct xfs_dquot *gdqp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898{
Christoph Hellwig7d095252009-06-08 15:33:32 +02001899 struct xfs_mount *mp = tp->t_mountp;
1900
1901 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 return;
1903
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001904 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Christoph Hellwig7d095252009-06-08 15:33:32 +02001905 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906
1907 if (udqp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 ASSERT(ip->i_udquot == NULL);
Christoph Hellwig7d095252009-06-08 15:33:32 +02001909 ASSERT(XFS_IS_UQUOTA_ON(mp));
Christoph Hellwig1149d962005-11-02 15:01:12 +11001910 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
Christoph Hellwig78e55892011-12-06 21:58:22 +00001911
1912 ip->i_udquot = xfs_qm_dqhold(udqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
1914 }
1915 if (gdqp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 ASSERT(ip->i_gdquot == NULL);
Christoph Hellwig7d095252009-06-08 15:33:32 +02001917 ASSERT(XFS_IS_OQUOTA_ON(mp));
1918 ASSERT((XFS_IS_GQUOTA_ON(mp) ?
Arkadiusz Mi?kiewicz67430992010-09-26 06:10:18 +00001919 ip->i_d.di_gid : xfs_get_projid(ip)) ==
Nathan Scottee2a4f72006-01-11 15:33:36 +11001920 be32_to_cpu(gdqp->q_core.d_id));
Christoph Hellwig78e55892011-12-06 21:58:22 +00001921
1922 ip->i_gdquot = xfs_qm_dqhold(gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
1924 }
1925}
1926