blob: 1155208fa830f2953ca0e1019f59b1b9379af7e2 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Nathan Scott4ce31212005-11-02 14:59:41 +11002 * Copyright (c) 2000-2003 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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include "xfs_inode.h"
31#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_rtalloc.h"
33#include "xfs_error.h"
34#include "xfs_itable.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include "xfs_attr.h"
36#include "xfs_buf_item.h"
37#include "xfs_trans_space.h"
38#include "xfs_trans_priv.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "xfs_qm.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000040#include "xfs_trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
Linus Torvalds1da177e2005-04-16 15:20:36 -070042/*
Christoph Hellwigbf72de32011-12-06 21:58:19 +000043 * Lock order:
44 *
45 * ip->i_lock
Christoph Hellwig9f920f12012-03-13 08:52:35 +000046 * qi->qi_tree_lock
Christoph Hellwigb84a3a92012-03-14 11:53:34 -050047 * dquot->q_qlock (xfs_dqlock() and friends)
48 * dquot->q_flush (xfs_dqflock() and friends)
49 * qi->qi_lru_lock
Christoph Hellwigbf72de32011-12-06 21:58:19 +000050 *
51 * If two dquots need to be locked the order is user before group/project,
52 * otherwise by the lowest id first, see xfs_dqlock2.
53 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#ifdef DEBUG
56xfs_buftarg_t *xfs_dqerror_target;
57int xfs_do_dqerror;
58int xfs_dqreq_num;
59int xfs_dqerror_mod = 33;
60#endif
61
Christoph Hellwiga05931c2012-03-13 08:52:37 +000062struct kmem_zone *xfs_qm_dqtrxzone;
63static struct kmem_zone *xfs_qm_dqzone;
64
Christoph Hellwig98b8c7a2009-01-19 02:03:25 +010065static struct lock_class_key xfs_dquot_other_class;
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 * This is called to free all the memory associated with a dquot
69 */
70void
71xfs_qm_dqdestroy(
72 xfs_dquot_t *dqp)
73{
Christoph Hellwigf8739c32012-03-13 08:52:34 +000074 ASSERT(list_empty(&dqp->q_lru));
Linus Torvalds1da177e2005-04-16 15:20:36 -070075
76 mutex_destroy(&dqp->q_qlock);
Christoph Hellwiga05931c2012-03-13 08:52:37 +000077 kmem_zone_free(xfs_qm_dqzone, dqp);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000078
Christoph Hellwig48776fd2012-03-13 08:52:33 +000079 XFS_STATS_DEC(xs_qm_dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080}
81
82/*
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 * If default limits are in force, push them into the dquot now.
84 * We overwrite the dquot limits only if they are zero and this
85 * is not the root dquot.
86 */
87void
88xfs_qm_adjust_dqlimits(
89 xfs_mount_t *mp,
90 xfs_disk_dquot_t *d)
91{
92 xfs_quotainfo_t *q = mp->m_quotainfo;
93
94 ASSERT(d->d_id);
95
96 if (q->qi_bsoftlimit && !d->d_blk_softlimit)
Christoph Hellwig1149d962005-11-02 15:01:12 +110097 d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 if (q->qi_bhardlimit && !d->d_blk_hardlimit)
Christoph Hellwig1149d962005-11-02 15:01:12 +110099 d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 if (q->qi_isoftlimit && !d->d_ino_softlimit)
Christoph Hellwig1149d962005-11-02 15:01:12 +1100101 d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 if (q->qi_ihardlimit && !d->d_ino_hardlimit)
Christoph Hellwig1149d962005-11-02 15:01:12 +1100103 d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)
Christoph Hellwig1149d962005-11-02 15:01:12 +1100105 d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106 if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)
Christoph Hellwig1149d962005-11-02 15:01:12 +1100107 d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108}
109
110/*
111 * Check the limits and timers of a dquot and start or reset timers
112 * if necessary.
113 * This gets called even when quota enforcement is OFF, which makes our
114 * life a little less complicated. (We just don't reject any quota
115 * reservations in that case, when enforcement is off).
116 * We also return 0 as the values of the timers in Q_GETQUOTA calls, when
117 * enforcement's off.
118 * In contrast, warnings are a little different in that they don't
Nathan Scott754002b2005-06-21 15:49:06 +1000119 * 'automatically' get started when limits get exceeded. They do
120 * get reset to zero, however, when we find the count to be under
121 * the soft limit (they are only ever set non-zero via userspace).
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 */
123void
124xfs_qm_adjust_dqtimers(
125 xfs_mount_t *mp,
126 xfs_disk_dquot_t *d)
127{
128 ASSERT(d->d_id);
129
Christoph Hellwigea15ab32011-07-13 13:43:50 +0200130#ifdef DEBUG
Christoph Hellwig1149d962005-11-02 15:01:12 +1100131 if (d->d_blk_hardlimit)
132 ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
133 be64_to_cpu(d->d_blk_hardlimit));
134 if (d->d_ino_hardlimit)
135 ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
136 be64_to_cpu(d->d_ino_hardlimit));
137 if (d->d_rtb_hardlimit)
138 ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
139 be64_to_cpu(d->d_rtb_hardlimit));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140#endif
Christoph Hellwigea15ab32011-07-13 13:43:50 +0200141
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 if (!d->d_btimer) {
Christoph Hellwig1149d962005-11-02 15:01:12 +1100143 if ((d->d_blk_softlimit &&
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000144 (be64_to_cpu(d->d_bcount) >
Christoph Hellwig1149d962005-11-02 15:01:12 +1100145 be64_to_cpu(d->d_blk_softlimit))) ||
146 (d->d_blk_hardlimit &&
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000147 (be64_to_cpu(d->d_bcount) >
Christoph Hellwig1149d962005-11-02 15:01:12 +1100148 be64_to_cpu(d->d_blk_hardlimit)))) {
149 d->d_btimer = cpu_to_be32(get_seconds() +
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000150 mp->m_quotainfo->qi_btimelimit);
Nathan Scott754002b2005-06-21 15:49:06 +1000151 } else {
152 d->d_bwarns = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 }
154 } else {
155 if ((!d->d_blk_softlimit ||
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000156 (be64_to_cpu(d->d_bcount) <=
Christoph Hellwig1149d962005-11-02 15:01:12 +1100157 be64_to_cpu(d->d_blk_softlimit))) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 (!d->d_blk_hardlimit ||
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000159 (be64_to_cpu(d->d_bcount) <=
Christoph Hellwig1149d962005-11-02 15:01:12 +1100160 be64_to_cpu(d->d_blk_hardlimit)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 d->d_btimer = 0;
162 }
163 }
164
165 if (!d->d_itimer) {
Christoph Hellwig1149d962005-11-02 15:01:12 +1100166 if ((d->d_ino_softlimit &&
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000167 (be64_to_cpu(d->d_icount) >
Christoph Hellwig1149d962005-11-02 15:01:12 +1100168 be64_to_cpu(d->d_ino_softlimit))) ||
169 (d->d_ino_hardlimit &&
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000170 (be64_to_cpu(d->d_icount) >
Christoph Hellwig1149d962005-11-02 15:01:12 +1100171 be64_to_cpu(d->d_ino_hardlimit)))) {
172 d->d_itimer = cpu_to_be32(get_seconds() +
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000173 mp->m_quotainfo->qi_itimelimit);
Nathan Scott754002b2005-06-21 15:49:06 +1000174 } else {
175 d->d_iwarns = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 }
177 } else {
178 if ((!d->d_ino_softlimit ||
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000179 (be64_to_cpu(d->d_icount) <=
Christoph Hellwig1149d962005-11-02 15:01:12 +1100180 be64_to_cpu(d->d_ino_softlimit))) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 (!d->d_ino_hardlimit ||
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000182 (be64_to_cpu(d->d_icount) <=
Christoph Hellwig1149d962005-11-02 15:01:12 +1100183 be64_to_cpu(d->d_ino_hardlimit)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 d->d_itimer = 0;
185 }
186 }
187
188 if (!d->d_rtbtimer) {
Christoph Hellwig1149d962005-11-02 15:01:12 +1100189 if ((d->d_rtb_softlimit &&
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000190 (be64_to_cpu(d->d_rtbcount) >
Christoph Hellwig1149d962005-11-02 15:01:12 +1100191 be64_to_cpu(d->d_rtb_softlimit))) ||
192 (d->d_rtb_hardlimit &&
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000193 (be64_to_cpu(d->d_rtbcount) >
Christoph Hellwig1149d962005-11-02 15:01:12 +1100194 be64_to_cpu(d->d_rtb_hardlimit)))) {
195 d->d_rtbtimer = cpu_to_be32(get_seconds() +
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000196 mp->m_quotainfo->qi_rtbtimelimit);
Nathan Scott754002b2005-06-21 15:49:06 +1000197 } else {
198 d->d_rtbwarns = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 }
200 } else {
201 if ((!d->d_rtb_softlimit ||
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000202 (be64_to_cpu(d->d_rtbcount) <=
Christoph Hellwig1149d962005-11-02 15:01:12 +1100203 be64_to_cpu(d->d_rtb_softlimit))) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 (!d->d_rtb_hardlimit ||
Mitsuo Hayasakad0a3fe62012-02-06 12:50:07 +0000205 (be64_to_cpu(d->d_rtbcount) <=
Christoph Hellwig1149d962005-11-02 15:01:12 +1100206 be64_to_cpu(d->d_rtb_hardlimit)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 d->d_rtbtimer = 0;
208 }
209 }
210}
211
212/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 * initialize a buffer full of dquots and log the whole thing
214 */
215STATIC void
216xfs_qm_init_dquot_blk(
217 xfs_trans_t *tp,
218 xfs_mount_t *mp,
219 xfs_dqid_t id,
220 uint type,
221 xfs_buf_t *bp)
222{
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000223 struct xfs_quotainfo *q = mp->m_quotainfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 xfs_dqblk_t *d;
225 int curid, i;
226
227 ASSERT(tp);
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200228 ASSERT(xfs_buf_islocked(bp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Chandra Seetharaman62926042011-07-22 23:40:15 +0000230 d = bp->b_addr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
232 /*
233 * ID of the first dquot in the block - id's are zero based.
234 */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000235 curid = id - (id % q->qi_dqperchunk);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 ASSERT(curid >= 0);
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000237 memset(d, 0, BBTOB(q->qi_dqchunklen));
Christoph Hellwig49d35a52011-12-06 21:58:23 +0000238 for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) {
239 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
240 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
241 d->dd_diskdq.d_id = cpu_to_be32(curid);
242 d->dd_diskdq.d_flags = type;
243 }
244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 xfs_trans_dquot_buf(tp, bp,
Dave Chinnerc1155412010-05-07 11:05:19 +1000246 (type & XFS_DQ_USER ? XFS_BLF_UDQUOT_BUF :
247 ((type & XFS_DQ_PROJ) ? XFS_BLF_PDQUOT_BUF :
248 XFS_BLF_GDQUOT_BUF)));
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000249 xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250}
251
252
253
254/*
255 * Allocate a block and fill it with dquots.
256 * This is called when the bmapi finds a hole.
257 */
258STATIC int
259xfs_qm_dqalloc(
Tim Shimminefa092f2005-09-05 08:29:01 +1000260 xfs_trans_t **tpp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 xfs_mount_t *mp,
262 xfs_dquot_t *dqp,
263 xfs_inode_t *quotip,
264 xfs_fileoff_t offset_fsb,
265 xfs_buf_t **O_bpp)
266{
267 xfs_fsblock_t firstblock;
268 xfs_bmap_free_t flist;
269 xfs_bmbt_irec_t map;
270 int nmaps, error, committed;
271 xfs_buf_t *bp;
Tim Shimminefa092f2005-09-05 08:29:01 +1000272 xfs_trans_t *tp = *tpp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273
274 ASSERT(tp != NULL);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000275
276 trace_xfs_dqalloc(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
278 /*
279 * Initialize the bmap freelist prior to calling bmapi code.
280 */
Eric Sandeen9d87c312009-01-14 23:22:07 -0600281 xfs_bmap_init(&flist, &firstblock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 xfs_ilock(quotip, XFS_ILOCK_EXCL);
283 /*
284 * Return if this type of quotas is turned off while we didn't
285 * have an inode lock
286 */
Chandra Seetharaman6967b962012-01-23 17:31:25 +0000287 if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
289 return (ESRCH);
290 }
291
Christoph Hellwigddc34152011-09-19 15:00:54 +0000292 xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 nmaps = 1;
Dave Chinnerc0dc7822011-09-18 20:40:52 +0000294 error = xfs_bmapi_write(tp, quotip, offset_fsb,
295 XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA,
296 &firstblock, XFS_QM_DQALLOC_SPACE_RES(mp),
297 &map, &nmaps, &flist);
298 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299 goto error0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
301 ASSERT(nmaps == 1);
302 ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
303 (map.br_startblock != HOLESTARTBLOCK));
304
305 /*
306 * Keep track of the blkno to save a lookup later
307 */
308 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
309
310 /* now we can just get the buffer (there's nothing to read yet) */
311 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
312 dqp->q_blkno,
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000313 mp->m_quotainfo->qi_dqchunklen,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 0);
Chandra Seetharaman2a30f36d2011-09-20 13:56:55 +0000315
316 error = xfs_buf_geterror(bp);
317 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 goto error1;
Chandra Seetharaman2a30f36d2011-09-20 13:56:55 +0000319
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 /*
321 * Make a chunk of dquots out of this buffer and log
322 * the entire thing.
323 */
Christoph Hellwig1149d962005-11-02 15:01:12 +1100324 xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000325 dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326
Tim Shimminefa092f2005-09-05 08:29:01 +1000327 /*
328 * xfs_bmap_finish() may commit the current transaction and
329 * start a second transaction if the freelist is not empty.
330 *
331 * Since we still want to modify this buffer, we need to
332 * ensure that the buffer is not released on commit of
333 * the first transaction and ensure the buffer is added to the
334 * second transaction.
335 *
336 * If there is only one transaction then don't stop the buffer
337 * from being released when it commits later on.
338 */
339
340 xfs_trans_bhold(tp, bp);
341
Eric Sandeenf7c99b62007-02-10 18:37:16 +1100342 if ((error = xfs_bmap_finish(tpp, &flist, &committed))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 goto error1;
344 }
345
Tim Shimminefa092f2005-09-05 08:29:01 +1000346 if (committed) {
347 tp = *tpp;
348 xfs_trans_bjoin(tp, bp);
349 } else {
350 xfs_trans_bhold_release(tp, bp);
351 }
352
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 *O_bpp = bp;
354 return 0;
355
356 error1:
357 xfs_bmap_cancel(&flist);
358 error0:
359 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
360
361 return (error);
362}
363
364/*
365 * Maps a dquot to the buffer containing its on-disk version.
366 * This returns a ptr to the buffer containing the on-disk dquot
367 * in the bpp param, and a ptr to the on-disk dquot within that buffer
368 */
369STATIC int
370xfs_qm_dqtobp(
Tim Shimminefa092f2005-09-05 08:29:01 +1000371 xfs_trans_t **tpp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 xfs_dquot_t *dqp,
373 xfs_disk_dquot_t **O_ddpp,
374 xfs_buf_t **O_bpp,
375 uint flags)
376{
377 xfs_bmbt_irec_t map;
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000378 int nmaps = 1, error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 xfs_buf_t *bp;
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000380 xfs_inode_t *quotip = XFS_DQ_TO_QIP(dqp);
381 xfs_mount_t *mp = dqp->q_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 xfs_disk_dquot_t *ddq;
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000383 xfs_dqid_t id = be32_to_cpu(dqp->q_core.d_id);
Tim Shimminefa092f2005-09-05 08:29:01 +1000384 xfs_trans_t *tp = (tpp ? *tpp : NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000386 dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000388 xfs_ilock(quotip, XFS_ILOCK_SHARED);
Chandra Seetharaman6967b962012-01-23 17:31:25 +0000389 if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 /*
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000391 * Return if this type of quotas is turned off while we
392 * didn't have the quota inode lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000395 return ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397
398 /*
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000399 * Find the block map; no allocations yet
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 */
Dave Chinner5c8ed202011-09-18 20:40:45 +0000401 error = xfs_bmapi_read(quotip, dqp->q_fileoffset,
402 XFS_DQUOT_CLUSTER_SIZE_FSB, &map, &nmaps, 0);
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000403
404 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
405 if (error)
406 return error;
407
408 ASSERT(nmaps == 1);
409 ASSERT(map.br_blockcount == 1);
410
411 /*
412 * Offset of dquot in the (fixed sized) dquot chunk.
413 */
414 dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) *
415 sizeof(xfs_dqblk_t);
416
417 ASSERT(map.br_startblock != DELAYSTARTBLOCK);
418 if (map.br_startblock == HOLESTARTBLOCK) {
419 /*
420 * We don't allocate unless we're asked to
421 */
422 if (!(flags & XFS_QMOPT_DQALLOC))
423 return ENOENT;
424
425 ASSERT(tp);
426 error = xfs_qm_dqalloc(tpp, mp, dqp, quotip,
427 dqp->q_fileoffset, &bp);
428 if (error)
429 return error;
430 tp = *tpp;
431 } else {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000432 trace_xfs_dqtobp_read(dqp);
433
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000434 /*
435 * store the blkno etc so that we don't have to do the
436 * mapping all the time
437 */
438 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
439
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +1000440 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
441 dqp->q_blkno,
442 mp->m_quotainfo->qi_dqchunklen,
443 0, &bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 if (error || !bp)
445 return XFS_ERROR(error);
446 }
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000447
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200448 ASSERT(xfs_buf_islocked(bp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
450 /*
451 * calculate the location of the dquot inside the buffer.
452 */
Chandra Seetharaman62926042011-07-22 23:40:15 +0000453 ddq = bp->b_addr + dqp->q_bufoffset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
455 /*
456 * A simple sanity check in case we got a corrupted dquot...
457 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100458 error = xfs_qm_dqcheck(mp, ddq, id, dqp->dq_flags & XFS_DQ_ALLTYPES,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 flags & (XFS_QMOPT_DQREPAIR|XFS_QMOPT_DOWARN),
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100460 "dqtobp");
461 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 if (!(flags & XFS_QMOPT_DQREPAIR)) {
463 xfs_trans_brelse(tp, bp);
464 return XFS_ERROR(EIO);
465 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 }
467
468 *O_bpp = bp;
469 *O_ddpp = ddq;
470
471 return (0);
472}
473
474
475/*
476 * Read in the ondisk dquot using dqtobp() then copy it to an incore version,
477 * and release the buffer immediately.
478 *
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000479 * If XFS_QMOPT_DQALLOC is set, allocate a dquot on disk if it needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 */
Christoph Hellwig7ae44402011-12-06 21:58:25 +0000481int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482xfs_qm_dqread(
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000483 struct xfs_mount *mp,
484 xfs_dqid_t id,
485 uint type,
486 uint flags,
487 struct xfs_dquot **O_dqpp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488{
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000489 struct xfs_dquot *dqp;
490 struct xfs_disk_dquot *ddqp;
491 struct xfs_buf *bp;
492 struct xfs_trans *tp = NULL;
493 int error;
494 int cancelflags = 0;
Tim Shimminefa092f2005-09-05 08:29:01 +1000495
Christoph Hellwig92b2e5b2012-02-01 13:57:20 +0000496
Christoph Hellwiga05931c2012-03-13 08:52:37 +0000497 dqp = kmem_zone_zalloc(xfs_qm_dqzone, KM_SLEEP);
Christoph Hellwig92b2e5b2012-02-01 13:57:20 +0000498
499 dqp->dq_flags = type;
500 dqp->q_core.d_id = cpu_to_be32(id);
501 dqp->q_mount = mp;
Christoph Hellwigf8739c32012-03-13 08:52:34 +0000502 INIT_LIST_HEAD(&dqp->q_lru);
Christoph Hellwig92b2e5b2012-02-01 13:57:20 +0000503 mutex_init(&dqp->q_qlock);
504 init_waitqueue_head(&dqp->q_pinwait);
505
506 /*
507 * Because we want to use a counting completion, complete
508 * the flush completion once to allow a single access to
509 * the flush completion without blocking.
510 */
511 init_completion(&dqp->q_flush);
512 complete(&dqp->q_flush);
513
514 /*
515 * Make sure group quotas have a different lock class than user
516 * quotas.
517 */
518 if (!(type & XFS_DQ_USER))
519 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_other_class);
520
Christoph Hellwig48776fd2012-03-13 08:52:33 +0000521 XFS_STATS_INC(xs_qm_dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000523 trace_xfs_dqread(dqp);
524
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000525 if (flags & XFS_QMOPT_DQALLOC) {
526 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC);
527 error = xfs_trans_reserve(tp, XFS_QM_DQALLOC_SPACE_RES(mp),
528 XFS_WRITE_LOG_RES(mp) +
529 /*
530 * Round the chunklen up to the next multiple
531 * of 128 (buf log item chunk size)).
532 */
533 BBTOB(mp->m_quotainfo->qi_dqchunklen) - 1 + 128,
534 0,
535 XFS_TRANS_PERM_LOG_RES,
536 XFS_WRITE_LOG_COUNT);
537 if (error)
538 goto error1;
539 cancelflags = XFS_TRANS_RELEASE_LOG_RES;
540 }
541
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 /*
543 * get a pointer to the on-disk dquot and the buffer containing it
544 * dqp already knows its own type (GROUP/USER).
545 */
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000546 error = xfs_qm_dqtobp(&tp, dqp, &ddqp, &bp, flags);
547 if (error) {
548 /*
549 * This can happen if quotas got turned off (ESRCH),
550 * or if the dquot didn't exist on disk and we ask to
551 * allocate (ENOENT).
552 */
553 trace_xfs_dqread_fail(dqp);
554 cancelflags |= XFS_TRANS_ABORT;
555 goto error1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 }
557
558 /* copy everything from disk dquot to the incore dquot */
559 memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 xfs_qm_dquot_logitem_init(dqp);
561
562 /*
563 * Reservation counters are defined as reservation plus current usage
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300564 * to avoid having to add every time.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 */
Christoph Hellwig1149d962005-11-02 15:01:12 +1100566 dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
567 dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
568 dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570 /* Mark the buf so that this will stay incore a little longer */
Christoph Hellwig38f23232011-10-10 16:52:45 +0000571 xfs_buf_set_ref(bp, XFS_DQUOT_REF);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
573 /*
574 * We got the buffer with a xfs_trans_read_buf() (in dqtobp())
575 * So we need to release with xfs_trans_brelse().
576 * The strategy here is identical to that of inodes; we lock
577 * the dquot in xfs_qm_dqget() before making it accessible to
578 * others. This is because dquots, like inodes, need a good level of
579 * concurrency, and we don't want to take locks on the entire buffers
580 * for dquot accesses.
581 * Note also that the dquot buffer may even be dirty at this point, if
582 * this particular dquot was repaired. We still aren't afraid to
583 * brelse it because we have the changes incore.
584 */
Christoph Hellwig0c842ad2011-07-08 14:36:19 +0200585 ASSERT(xfs_buf_islocked(bp));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 xfs_trans_brelse(tp, bp);
587
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 if (tp) {
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000589 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
590 if (error)
591 goto error0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 }
593
594 *O_dqpp = dqp;
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000595 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000597error1:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 if (tp)
599 xfs_trans_cancel(tp, cancelflags);
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000600error0:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 xfs_qm_dqdestroy(dqp);
602 *O_dqpp = NULL;
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000603 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604}
605
606/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 * Given the file system, inode OR id, and type (UDQUOT/GDQUOT), return a
608 * a locked dquot, doing an allocation (if requested) as needed.
609 * When both an inode and an id are given, the inode's id takes precedence.
610 * That is, if the id changes while we don't hold the ilock inside this
611 * function, the new dquot is returned, not necessarily the one requested
612 * in the id argument.
613 */
614int
615xfs_qm_dqget(
616 xfs_mount_t *mp,
617 xfs_inode_t *ip, /* locked inode (optional) */
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000618 xfs_dqid_t id, /* uid/projid/gid depending on type */
619 uint type, /* XFS_DQ_USER/XFS_DQ_PROJ/XFS_DQ_GROUP */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 uint flags, /* DQALLOC, DQSUSER, DQREPAIR, DOWARN */
621 xfs_dquot_t **O_dqpp) /* OUT : locked incore dquot */
622{
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000623 struct xfs_quotainfo *qi = mp->m_quotainfo;
624 struct radix_tree_root *tree = XFS_DQUOT_TREE(qi, type);
625 struct xfs_dquot *dqp;
626 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
628 ASSERT(XFS_IS_QUOTA_RUNNING(mp));
629 if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000630 (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
632 return (ESRCH);
633 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634
635#ifdef DEBUG
636 if (xfs_do_dqerror) {
637 if ((xfs_dqerror_target == mp->m_ddev_targp) &&
638 (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
Dave Chinner0b932cc2011-03-07 10:08:35 +1100639 xfs_debug(mp, "Returning error in dqget");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 return (EIO);
641 }
642 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000644 ASSERT(type == XFS_DQ_USER ||
645 type == XFS_DQ_PROJ ||
646 type == XFS_DQ_GROUP);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (ip) {
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000648 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Chandra Seetharaman36731412012-01-23 17:31:30 +0000649 ASSERT(xfs_inode_dquot(ip, type) == NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 }
651#endif
Christoph Hellwig92678552011-12-06 21:58:18 +0000652
653restart:
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000654 mutex_lock(&qi->qi_tree_lock);
655 dqp = radix_tree_lookup(tree, id);
656 if (dqp) {
657 xfs_dqlock(dqp);
658 if (dqp->dq_flags & XFS_DQ_FREEING) {
659 xfs_dqunlock(dqp);
660 mutex_unlock(&qi->qi_tree_lock);
661 trace_xfs_dqget_freeing(dqp);
662 delay(1);
663 goto restart;
664 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000666 dqp->q_nrefs++;
667 mutex_unlock(&qi->qi_tree_lock);
668
669 trace_xfs_dqget_hit(dqp);
Christoph Hellwig48776fd2012-03-13 08:52:33 +0000670 XFS_STATS_INC(xs_qm_dqcachehits);
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000671 *O_dqpp = dqp;
672 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 }
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000674 mutex_unlock(&qi->qi_tree_lock);
675 XFS_STATS_INC(xs_qm_dqcachemisses);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
677 /*
678 * Dquot cache miss. We don't want to keep the inode lock across
679 * a (potential) disk read. Also we don't want to deal with the lock
680 * ordering between quotainode and this inode. OTOH, dropping the inode
681 * lock here means dealing with a chown that can happen before
682 * we re-acquire the lock.
683 */
684 if (ip)
685 xfs_iunlock(ip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
Christoph Hellwig97e7ade2011-12-06 21:58:24 +0000687 error = xfs_qm_dqread(mp, id, type, flags, &dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Christoph Hellwig7ae44402011-12-06 21:58:25 +0000689 if (ip)
690 xfs_ilock(ip, XFS_ILOCK_EXCL);
691
692 if (error)
693 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 if (ip) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 /*
697 * A dquot could be attached to this inode by now, since
698 * we had dropped the ilock.
699 */
Chandra Seetharaman36731412012-01-23 17:31:30 +0000700 if (xfs_this_quota_on(mp, type)) {
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000701 struct xfs_dquot *dqp1;
702
Chandra Seetharaman36731412012-01-23 17:31:30 +0000703 dqp1 = xfs_inode_dquot(ip, type);
704 if (dqp1) {
Christoph Hellwig191f8482010-04-20 17:01:53 +1000705 xfs_qm_dqdestroy(dqp);
Chandra Seetharaman36731412012-01-23 17:31:30 +0000706 dqp = dqp1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 xfs_dqlock(dqp);
708 goto dqret;
709 }
710 } else {
Chandra Seetharaman36731412012-01-23 17:31:30 +0000711 /* inode stays locked on return */
712 xfs_qm_dqdestroy(dqp);
713 return XFS_ERROR(ESRCH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 }
715 }
716
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000717 mutex_lock(&qi->qi_tree_lock);
718 error = -radix_tree_insert(tree, id, dqp);
719 if (unlikely(error)) {
720 WARN_ON(error != EEXIST);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000722 /*
723 * Duplicate found. Just throw away the new dquot and start
724 * over.
725 */
726 mutex_unlock(&qi->qi_tree_lock);
727 trace_xfs_dqget_dup(dqp);
728 xfs_qm_dqdestroy(dqp);
729 XFS_STATS_INC(xs_qm_dquot_dups);
730 goto restart;
731 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732
733 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 * We return a locked dquot to the caller, with a reference taken
735 */
736 xfs_dqlock(dqp);
737 dqp->q_nrefs = 1;
738
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000739 qi->qi_dquots++;
Christoph Hellwig9f920f12012-03-13 08:52:35 +0000740 mutex_unlock(&qi->qi_tree_lock);
741
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 dqret:
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000743 ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL));
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000744 trace_xfs_dqget_miss(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 *O_dqpp = dqp;
746 return (0);
747}
748
749
Christoph Hellwigf8739c32012-03-13 08:52:34 +0000750STATIC void
751xfs_qm_dqput_final(
Christoph Hellwigbf72de32011-12-06 21:58:19 +0000752 struct xfs_dquot *dqp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
Christoph Hellwigf8739c32012-03-13 08:52:34 +0000754 struct xfs_quotainfo *qi = dqp->q_mount->m_quotainfo;
Christoph Hellwigbf72de32011-12-06 21:58:19 +0000755 struct xfs_dquot *gdqp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Christoph Hellwigbf72de32011-12-06 21:58:19 +0000757 trace_xfs_dqput_free(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
Christoph Hellwigf8739c32012-03-13 08:52:34 +0000759 mutex_lock(&qi->qi_lru_lock);
760 if (list_empty(&dqp->q_lru)) {
761 list_add_tail(&dqp->q_lru, &qi->qi_lru_list);
762 qi->qi_lru_count++;
Christoph Hellwig48776fd2012-03-13 08:52:33 +0000763 XFS_STATS_INC(xs_qm_dquot_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 }
Christoph Hellwigf8739c32012-03-13 08:52:34 +0000765 mutex_unlock(&qi->qi_lru_lock);
Christoph Hellwigbf72de32011-12-06 21:58:19 +0000766
767 /*
768 * If we just added a udquot to the freelist, then we want to release
769 * the gdquot reference that it (probably) has. Otherwise it'll keep
770 * the gdquot from getting reclaimed.
771 */
772 gdqp = dqp->q_gdquot;
773 if (gdqp) {
774 xfs_dqlock(gdqp);
775 dqp->q_gdquot = NULL;
776 }
777 xfs_dqunlock(dqp);
778
779 /*
780 * If we had a group quota hint, release it now.
781 */
Christoph Hellwigf8739c32012-03-13 08:52:34 +0000782 if (gdqp)
783 xfs_qm_dqput(gdqp);
784}
785
786/*
787 * Release a reference to the dquot (decrement ref-count) and unlock it.
788 *
789 * If there is a group quota attached to this dquot, carefully release that
790 * too without tripping over deadlocks'n'stuff.
791 */
792void
793xfs_qm_dqput(
794 struct xfs_dquot *dqp)
795{
796 ASSERT(dqp->q_nrefs > 0);
797 ASSERT(XFS_DQ_IS_LOCKED(dqp));
798
799 trace_xfs_dqput(dqp);
800
801 if (--dqp->q_nrefs > 0)
802 xfs_dqunlock(dqp);
803 else
804 xfs_qm_dqput_final(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805}
806
807/*
808 * Release a dquot. Flush it if dirty, then dqput() it.
809 * dquot must not be locked.
810 */
811void
812xfs_qm_dqrele(
813 xfs_dquot_t *dqp)
814{
Christoph Hellwig7d095252009-06-08 15:33:32 +0200815 if (!dqp)
816 return;
817
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000818 trace_xfs_dqrele(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
820 xfs_dqlock(dqp);
821 /*
822 * We don't care to flush it if the dquot is dirty here.
823 * That will create stutters that we want to avoid.
824 * Instead we do a delayed write when we try to reclaim
825 * a dirty dquot. Also xfs_sync will take part of the burden...
826 */
827 xfs_qm_dqput(dqp);
828}
829
Christoph Hellwigca30b2a2010-06-23 18:11:15 +1000830/*
831 * This is the dquot flushing I/O completion routine. It is called
832 * from interrupt level when the buffer containing the dquot is
833 * flushed to disk. It is responsible for removing the dquot logitem
834 * from the AIL if it has not been re-logged, and unlocking the dquot's
835 * flush lock. This behavior is very similar to that of inodes..
836 */
837STATIC void
838xfs_qm_dqflush_done(
839 struct xfs_buf *bp,
840 struct xfs_log_item *lip)
841{
842 xfs_dq_logitem_t *qip = (struct xfs_dq_logitem *)lip;
843 xfs_dquot_t *dqp = qip->qli_dquot;
844 struct xfs_ail *ailp = lip->li_ailp;
845
846 /*
847 * We only want to pull the item from the AIL if its
848 * location in the log has not changed since we started the flush.
849 * Thus, we only bother if the dquot's lsn has
850 * not changed. First we check the lsn outside the lock
851 * since it's cheaper, and then we recheck while
852 * holding the lock before removing the dquot from the AIL.
853 */
854 if ((lip->li_flags & XFS_LI_IN_AIL) &&
855 lip->li_lsn == qip->qli_flush_lsn) {
856
857 /* xfs_trans_ail_delete() drops the AIL lock. */
858 spin_lock(&ailp->xa_lock);
859 if (lip->li_lsn == qip->qli_flush_lsn)
860 xfs_trans_ail_delete(ailp, lip);
861 else
862 spin_unlock(&ailp->xa_lock);
863 }
864
865 /*
866 * Release the dq's flush lock since we're done with it.
867 */
868 xfs_dqfunlock(dqp);
869}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
871/*
872 * Write a modified dquot to disk.
873 * The dquot must be locked and the flush lock too taken by caller.
874 * The flush lock will not be unlocked until the dquot reaches the disk,
875 * but the dquot is free to be unlocked and modified by the caller
876 * in the interim. Dquot is still locked on return. This behavior is
877 * identical to that of inodes.
878 */
879int
880xfs_qm_dqflush(
881 xfs_dquot_t *dqp,
882 uint flags)
883{
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000884 struct xfs_mount *mp = dqp->q_mount;
885 struct xfs_buf *bp;
886 struct xfs_disk_dquot *ddqp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888
889 ASSERT(XFS_DQ_IS_LOCKED(dqp));
David Chinnere1f49cf2008-08-13 16:41:43 +1000890 ASSERT(!completion_done(&dqp->q_flush));
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000891
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000892 trace_xfs_dqflush(dqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
894 /*
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000895 * If not dirty, or it's pinned and we are not supposed to block, nada.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 */
David Chinner2f8a3ce2008-10-30 17:07:20 +1100897 if (!XFS_DQ_IS_DIRTY(dqp) ||
Christoph Hellwigfdedf282011-12-06 21:58:10 +0000898 ((flags & SYNC_TRYLOCK) && atomic_read(&dqp->q_pincount) > 0)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899 xfs_dqfunlock(dqp);
David Chinner2f8a3ce2008-10-30 17:07:20 +1100900 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902 xfs_qm_dqunpin_wait(dqp);
903
904 /*
905 * This may have been unpinned because the filesystem is shutting
906 * down forcibly. If that's the case we must not write this dquot
907 * to disk, because the log record didn't make it to disk!
908 */
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000909 if (XFS_FORCED_SHUTDOWN(mp)) {
910 dqp->dq_flags &= ~XFS_DQ_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 xfs_dqfunlock(dqp);
912 return XFS_ERROR(EIO);
913 }
914
915 /*
916 * Get the buffer containing the on-disk dquot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 */
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000918 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
919 mp->m_quotainfo->qi_dqchunklen, 0, &bp);
920 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 ASSERT(error != ENOENT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 xfs_dqfunlock(dqp);
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000923 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 }
925
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000926 /*
927 * Calculate the location of the dquot inside the buffer.
928 */
Chandra Seetharaman62926042011-07-22 23:40:15 +0000929 ddqp = bp->b_addr + dqp->q_bufoffset;
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000930
931 /*
932 * A simple sanity check in case we got a corrupted dquot..
933 */
Dave Chinnera0fa2b62011-03-07 10:01:35 +1100934 error = xfs_qm_dqcheck(mp, &dqp->q_core, be32_to_cpu(ddqp->d_id), 0,
935 XFS_QMOPT_DOWARN, "dqflush (incore copy)");
936 if (error) {
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000937 xfs_buf_relse(bp);
938 xfs_dqfunlock(dqp);
939 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 return XFS_ERROR(EIO);
941 }
942
943 /* This is the only portion of data that needs to persist */
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000944 memcpy(ddqp, &dqp->q_core, sizeof(xfs_disk_dquot_t));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
946 /*
947 * Clear the dirty field and remember the flush lsn for later use.
948 */
Christoph Hellwigacecf1b2010-09-06 01:44:45 +0000949 dqp->dq_flags &= ~XFS_DQ_DIRTY;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950
David Chinner7b2e2a32008-10-30 17:39:12 +1100951 xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
952 &dqp->q_logitem.qli_item.li_lsn);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
954 /*
955 * Attach an iodone routine so that we can remove this dquot from the
956 * AIL and release the flush lock once the dquot is synced to disk.
957 */
Christoph Hellwigca30b2a2010-06-23 18:11:15 +1000958 xfs_buf_attach_iodone(bp, xfs_qm_dqflush_done,
959 &dqp->q_logitem.qli_item);
960
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961 /*
962 * If the buffer is pinned then push on the log so we won't
963 * get stuck waiting in the write for too long.
964 */
Chandra Seetharaman811e64c2011-07-22 23:40:27 +0000965 if (xfs_buf_ispinned(bp)) {
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000966 trace_xfs_dqflush_force(dqp);
Christoph Hellwiga14a3482010-01-19 09:56:46 +0000967 xfs_log_force(mp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 }
969
Dave Chinner20026d92010-02-04 09:48:58 +1100970 if (flags & SYNC_WAIT)
Christoph Hellwigc2b006c2011-08-23 08:28:07 +0000971 error = xfs_bwrite(bp);
972 else
Christoph Hellwig61551f12011-08-23 08:28:06 +0000973 xfs_buf_delwri_queue(bp);
Christoph Hellwigc2b006c2011-08-23 08:28:07 +0000974
975 xfs_buf_relse(bp);
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000976
977 trace_xfs_dqflush_done(dqp);
978
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 /*
980 * dqp is still locked, but caller is free to unlock it now.
981 */
Dave Chinner20026d92010-02-04 09:48:58 +1100982 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983
984}
985
Christoph Hellwig5bb87a32009-01-19 02:03:19 +0100986/*
987 * Lock two xfs_dquot structures.
988 *
989 * To avoid deadlocks we always lock the quota structure with
990 * the lowerd id first.
991 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992void
993xfs_dqlock2(
994 xfs_dquot_t *d1,
995 xfs_dquot_t *d2)
996{
997 if (d1 && d2) {
998 ASSERT(d1 != d2);
Christoph Hellwig1149d962005-11-02 15:01:12 +1100999 if (be32_to_cpu(d1->q_core.d_id) >
1000 be32_to_cpu(d2->q_core.d_id)) {
Christoph Hellwig5bb87a32009-01-19 02:03:19 +01001001 mutex_lock(&d2->q_qlock);
1002 mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 } else {
Christoph Hellwig5bb87a32009-01-19 02:03:19 +01001004 mutex_lock(&d1->q_qlock);
1005 mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 }
Christoph Hellwig5bb87a32009-01-19 02:03:19 +01001007 } else if (d1) {
1008 mutex_lock(&d1->q_qlock);
1009 } else if (d2) {
1010 mutex_lock(&d2->q_qlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 }
1012}
1013
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 * Give the buffer a little push if it is incore and
1016 * wait on the flush lock.
1017 */
1018void
Christoph Hellwig800b4842011-12-06 21:58:14 +00001019xfs_dqflock_pushbuf_wait(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 xfs_dquot_t *dqp)
1021{
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001022 xfs_mount_t *mp = dqp->q_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 xfs_buf_t *bp;
1024
1025 /*
1026 * Check to see if the dquot has been flushed delayed
1027 * write. If so, grab its buffer and send it
1028 * out immediately. We'll be able to acquire
1029 * the flush lock when the I/O completes.
1030 */
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001031 bp = xfs_incore(mp->m_ddev_targp, dqp->q_blkno,
1032 mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK);
Dave Chinner7d6a7bd2010-01-26 15:13:41 +11001033 if (!bp)
1034 goto out_lock;
Christoph Hellwiga14a3482010-01-19 09:56:46 +00001035
Dave Chinner7d6a7bd2010-01-26 15:13:41 +11001036 if (XFS_BUF_ISDELAYWRITE(bp)) {
Chandra Seetharaman811e64c2011-07-22 23:40:27 +00001037 if (xfs_buf_ispinned(bp))
Christoph Hellwig8a7b8a82010-04-20 17:01:30 +10001038 xfs_log_force(mp, 0);
Dave Chinner7d6a7bd2010-01-26 15:13:41 +11001039 xfs_buf_delwri_promote(bp);
1040 wake_up_process(bp->b_target->bt_task);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 }
Dave Chinner7d6a7bd2010-01-26 15:13:41 +11001042 xfs_buf_relse(bp);
1043out_lock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 xfs_dqflock(dqp);
1045}
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001046
1047int __init
1048xfs_qm_init(void)
1049{
1050 xfs_qm_dqzone =
1051 kmem_zone_init(sizeof(struct xfs_dquot), "xfs_dquot");
1052 if (!xfs_qm_dqzone)
1053 goto out;
1054
1055 xfs_qm_dqtrxzone =
1056 kmem_zone_init(sizeof(struct xfs_dquot_acct), "xfs_dqtrx");
1057 if (!xfs_qm_dqtrxzone)
1058 goto out_free_dqzone;
1059
1060 return 0;
1061
1062out_free_dqzone:
1063 kmem_zone_destroy(xfs_qm_dqzone);
1064out:
1065 return -ENOMEM;
1066}
1067
Gerard Snitselaar1c2ccc62012-03-16 18:36:18 +00001068void
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001069xfs_qm_exit(void)
1070{
1071 kmem_zone_destroy(xfs_qm_dqtrxzone);
1072 kmem_zone_destroy(xfs_qm_dqzone);
1073}