fs/xfs/xfs_dquot.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2003 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #include "xfs.h"
   7 #include "xfs_fs.h"
   8 #include "xfs_format.h"
   9 #include "xfs_log_format.h"
  10 #include "xfs_shared.h"
  11 #include "xfs_trans_resv.h"
  12 #include "xfs_bit.h"
  13 #include "xfs_mount.h"
  14 #include "xfs_defer.h"
  15 #include "xfs_inode.h"
  16 #include "xfs_bmap.h"
  17 #include "xfs_quota.h"
  18 #include "xfs_trans.h"
  19 #include "xfs_buf_item.h"
  20 #include "xfs_trans_space.h"
  21 #include "xfs_trans_priv.h"
  22 #include "xfs_qm.h"
  23 #include "xfs_trace.h"
  24 #include "xfs_log.h"
  25 #include "xfs_bmap_btree.h"
  26 #include "xfs_error.h"
  27
  28 /*
  29  * Lock order:
  30  *
  31  * ip->i_lock
  32  *   qi->qi_tree_lock
  33  *     dquot->q_qlock (xfs_dqlock() and friends)
  34  *       dquot->q_flush (xfs_dqflock() and friends)
  35  *       qi->qi_lru_lock
  36  *
  37  * If two dquots need to be locked the order is user before group/project,
  38  * otherwise by the lowest id first, see xfs_dqlock2.
  39  */
  40
  41 struct kmem_zone                *xfs_qm_dqtrxzone;
  42 static struct kmem_zone         *xfs_qm_dqzone;
  43
  44 static struct lock_class_key xfs_dquot_group_class;
  45 static struct lock_class_key xfs_dquot_project_class;
  46
  47 /*
  48  * This is called to free all the memory associated with a dquot
  49  */
  50 void
  51 xfs_qm_dqdestroy(
  52         struct xfs_dquot        *dqp)
  53 {
  54         ASSERT(list_empty(&dqp->q_lru));
  55
  56         kmem_free(dqp->q_logitem.qli_item.li_lv_shadow);
  57         mutex_destroy(&dqp->q_qlock);
  58
  59         XFS_STATS_DEC(dqp->q_mount, xs_qm_dquot);
  60         kmem_cache_free(xfs_qm_dqzone, dqp);
  61 }
  62
  63 /*
  64  * If default limits are in force, push them into the dquot now.
  65  * We overwrite the dquot limits only if they are zero and this
  66  * is not the root dquot.
  67  */
  68 void
  69 xfs_qm_adjust_dqlimits(
  70         struct xfs_dquot        *dq)
  71 {
  72         struct xfs_mount        *mp = dq->q_mount;
  73         struct xfs_quotainfo    *q = mp->m_quotainfo;
  74         struct xfs_def_quota    *defq;
  75         int                     prealloc = 0;
  76
  77         ASSERT(dq->q_id);
  78         defq = xfs_get_defquota(q, xfs_dquot_type(dq));
  79
  80         if (!dq->q_blk.softlimit) {
  81                 dq->q_blk.softlimit = defq->blk.soft;
  82                 prealloc = 1;
  83         }
  84         if (!dq->q_blk.hardlimit) {
  85                 dq->q_blk.hardlimit = defq->blk.hard;
  86                 prealloc = 1;
  87         }
  88         if (!dq->q_ino.softlimit)
  89                 dq->q_ino.softlimit = defq->ino.soft;
  90         if (!dq->q_ino.hardlimit)
  91                 dq->q_ino.hardlimit = defq->ino.hard;
  92         if (!dq->q_rtb.softlimit)
  93                 dq->q_rtb.softlimit = defq->rtb.soft;
  94         if (!dq->q_rtb.hardlimit)
  95                 dq->q_rtb.hardlimit = defq->rtb.hard;
  96
  97         if (prealloc)
  98                 xfs_dquot_set_prealloc_limits(dq);
  99 }
 100
 101 /*
 102  * Determine if this quota counter is over either limit and set the quota
 103  * timers as appropriate.
 104  */
 105 static inline void
 106 xfs_qm_adjust_res_timer(
 107         struct xfs_dquot_res    *res,
 108         struct xfs_quota_limits *qlim)
 109 {
 110         ASSERT(res->hardlimit == 0 || res->softlimit <= res->hardlimit);
 111
 112         if ((res->softlimit && res->count > res->softlimit) ||
 113             (res->hardlimit && res->count > res->hardlimit)) {
 114                 if (res->timer == 0)
 115                         res->timer = ktime_get_real_seconds() + qlim->time;
 116         } else {
 117                 if (res->timer == 0)
 118                         res->warnings = 0;
 119                 else
 120                         res->timer = 0;
 121         }
 122 }
 123
 124 /*
 125  * Check the limits and timers of a dquot and start or reset timers
 126  * if necessary.
 127  * This gets called even when quota enforcement is OFF, which makes our
 128  * life a little less complicated. (We just don't reject any quota
 129  * reservations in that case, when enforcement is off).
 130  * We also return 0 as the values of the timers in Q_GETQUOTA calls, when
 131  * enforcement's off.
 132  * In contrast, warnings are a little different in that they don't
 133  * 'automatically' get started when limits get exceeded.  They do
 134  * get reset to zero, however, when we find the count to be under
 135  * the soft limit (they are only ever set non-zero via userspace).
 136  */
 137 void
 138 xfs_qm_adjust_dqtimers(
 139         struct xfs_dquot        *dq)
 140 {
 141         struct xfs_mount        *mp = dq->q_mount;
 142         struct xfs_quotainfo    *qi = mp->m_quotainfo;
 143         struct xfs_def_quota    *defq;
 144
 145         ASSERT(dq->q_id);
 146         defq = xfs_get_defquota(qi, xfs_dquot_type(dq));
 147
 148         xfs_qm_adjust_res_timer(&dq->q_blk, &defq->blk);
 149         xfs_qm_adjust_res_timer(&dq->q_ino, &defq->ino);
 150         xfs_qm_adjust_res_timer(&dq->q_rtb, &defq->rtb);
 151 }
 152
 153 /*
 154  * initialize a buffer full of dquots and log the whole thing
 155  */
 156 STATIC void
 157 xfs_qm_init_dquot_blk(
 158         struct xfs_trans        *tp,
 159         struct xfs_mount        *mp,
 160         xfs_dqid_t              id,
 161         xfs_dqtype_t            type,
 162         struct xfs_buf          *bp)
 163 {
 164         struct xfs_quotainfo    *q = mp->m_quotainfo;
 165         struct xfs_dqblk        *d;
 166         xfs_dqid_t              curid;
 167         unsigned int            qflag;
 168         unsigned int            blftype;
 169         int                     i;
 170
 171         ASSERT(tp);
 172         ASSERT(xfs_buf_islocked(bp));
 173
 174         switch (type) {
 175         case XFS_DQTYPE_USER:
 176                 qflag = XFS_UQUOTA_CHKD;
 177                 blftype = XFS_BLF_UDQUOT_BUF;
 178                 break;
 179         case XFS_DQTYPE_PROJ:
 180                 qflag = XFS_PQUOTA_CHKD;
 181                 blftype = XFS_BLF_PDQUOT_BUF;
 182                 break;
 183         case XFS_DQTYPE_GROUP:
 184                 qflag = XFS_GQUOTA_CHKD;
 185                 blftype = XFS_BLF_GDQUOT_BUF;
 186                 break;
 187         default:
 188                 ASSERT(0);
 189                 return;
 190         }
 191
 192         d = bp->b_addr;
 193
 194         /*
 195          * ID of the first dquot in the block - id's are zero based.
 196          */
 197         curid = id - (id % q->qi_dqperchunk);
 198         memset(d, 0, BBTOB(q->qi_dqchunklen));
 199         for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) {
 200                 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
 201                 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
 202                 d->dd_diskdq.d_id = cpu_to_be32(curid);
 203                 d->dd_diskdq.d_type = type;
 204                 if (xfs_sb_version_hascrc(&mp->m_sb)) {
 205                         uuid_copy(&d->dd_uuid, &mp->m_sb.sb_meta_uuid);
 206                         xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
 207                                          XFS_DQUOT_CRC_OFF);
 208                 }
 209         }
 210
 211         xfs_trans_dquot_buf(tp, bp, blftype);
 212
 213         /*
 214          * quotacheck uses delayed writes to update all the dquots on disk in an
 215          * efficient manner instead of logging the individual dquot changes as
 216          * they are made. However if we log the buffer allocated here and crash
 217          * after quotacheck while the logged initialisation is still in the
 218          * active region of the log, log recovery can replay the dquot buffer
 219          * initialisation over the top of the checked dquots and corrupt quota
 220          * accounting.
 221          *
 222          * To avoid this problem, quotacheck cannot log the initialised buffer.
 223          * We must still dirty the buffer and write it back before the
 224          * allocation transaction clears the log. Therefore, mark the buffer as
 225          * ordered instead of logging it directly. This is safe for quotacheck
 226          * because it detects and repairs allocated but initialized dquot blocks
 227          * in the quota inodes.
 228          */
 229         if (!(mp->m_qflags & qflag))
 230                 xfs_trans_ordered_buf(tp, bp);
 231         else
 232                 xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
 233 }
 234
 235 /*
 236  * Initialize the dynamic speculative preallocation thresholds. The lo/hi
 237  * watermarks correspond to the soft and hard limits by default. If a soft limit
 238  * is not specified, we use 95% of the hard limit.
 239  */
 240 void
 241 xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp)
 242 {
 243         uint64_t space;
 244
 245         dqp->q_prealloc_hi_wmark = dqp->q_blk.hardlimit;
 246         dqp->q_prealloc_lo_wmark = dqp->q_blk.softlimit;
 247         if (!dqp->q_prealloc_lo_wmark) {
 248                 dqp->q_prealloc_lo_wmark = dqp->q_prealloc_hi_wmark;
 249                 do_div(dqp->q_prealloc_lo_wmark, 100);
 250                 dqp->q_prealloc_lo_wmark *= 95;
 251         }
 252
 253         space = dqp->q_prealloc_hi_wmark;
 254
 255         do_div(space, 100);
 256         dqp->q_low_space[XFS_QLOWSP_1_PCNT] = space;
 257         dqp->q_low_space[XFS_QLOWSP_3_PCNT] = space * 3;
 258         dqp->q_low_space[XFS_QLOWSP_5_PCNT] = space * 5;
 259 }
 260
 261 /*
 262  * Ensure that the given in-core dquot has a buffer on disk backing it, and
 263  * return the buffer locked and held. This is called when the bmapi finds a
 264  * hole.
 265  */
 266 STATIC int
 267 xfs_dquot_disk_alloc(
 268         struct xfs_trans        **tpp,
 269         struct xfs_dquot        *dqp,
 270         struct xfs_buf          **bpp)
 271 {
 272         struct xfs_bmbt_irec    map;
 273         struct xfs_trans        *tp = *tpp;
 274         struct xfs_mount        *mp = tp->t_mountp;
 275         struct xfs_buf          *bp;
 276         xfs_dqtype_t            qtype = xfs_dquot_type(dqp);
 277         struct xfs_inode        *quotip = xfs_quota_inode(mp, qtype);
 278         int                     nmaps = 1;
 279         int                     error;
 280
 281         trace_xfs_dqalloc(dqp);
 282
 283         xfs_ilock(quotip, XFS_ILOCK_EXCL);
 284         if (!xfs_this_quota_on(dqp->q_mount, qtype)) {
 285                 /*
 286                  * Return if this type of quotas is turned off while we didn't
 287                  * have an inode lock
 288                  */
 289                 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
 290                 return -ESRCH;
 291         }
 292
 293         /* Create the block mapping. */
 294         xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
 295         error = xfs_bmapi_write(tp, quotip, dqp->q_fileoffset,
 296                         XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA, 0, &map,
 297                         &nmaps);
 298         if (error)
 299                 return error;
 300         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         error = xfs_trans_get_buf(tp, mp->m_ddev_targp, dqp->q_blkno,
 312                         mp->m_quotainfo->qi_dqchunklen, 0, &bp);
 313         if (error)
 314                 return error;
 315         bp->b_ops = &xfs_dquot_buf_ops;
 316
 317         /*
 318          * Make a chunk of dquots out of this buffer and log
 319          * the entire thing.
 320          */
 321         xfs_qm_init_dquot_blk(tp, mp, dqp->q_id, qtype, bp);
 322         xfs_buf_set_ref(bp, XFS_DQUOT_REF);
 323
 324         /*
 325          * Hold the buffer and join it to the dfops so that we'll still own
 326          * the buffer when we return to the caller.  The buffer disposal on
 327          * error must be paid attention to very carefully, as it has been
 328          * broken since commit efa092f3d4c6 "[XFS] Fixes a bug in the quota
 329          * code when allocating a new dquot record" in 2005, and the later
 330          * conversion to xfs_defer_ops in commit 310a75a3c6c747 failed to keep
 331          * the buffer locked across the _defer_finish call.  We can now do
 332          * this correctly with xfs_defer_bjoin.
 333          *
 334          * Above, we allocated a disk block for the dquot information and used
 335          * get_buf to initialize the dquot. If the _defer_finish fails, the old
 336          * transaction is gone but the new buffer is not joined or held to any
 337          * transaction, so we must _buf_relse it.
 338          *
 339          * If everything succeeds, the caller of this function is returned a
 340          * buffer that is locked and held to the transaction.  The caller
 341          * is responsible for unlocking any buffer passed back, either
 342          * manually or by committing the transaction.  On error, the buffer is
 343          * released and not passed back.
 344          */
 345         xfs_trans_bhold(tp, bp);
 346         error = xfs_defer_finish(tpp);
 347         if (error) {
 348                 xfs_trans_bhold_release(*tpp, bp);
 349                 xfs_trans_brelse(*tpp, bp);
 350                 return error;
 351         }
 352         *bpp = bp;
 353         return 0;
 354 }
 355
 356 /*
 357  * Read in the in-core dquot's on-disk metadata and return the buffer.
 358  * Returns ENOENT to signal a hole.
 359  */
 360 STATIC int
 361 xfs_dquot_disk_read(
 362         struct xfs_mount        *mp,
 363         struct xfs_dquot        *dqp,
 364         struct xfs_buf          **bpp)
 365 {
 366         struct xfs_bmbt_irec    map;
 367         struct xfs_buf          *bp;
 368         xfs_dqtype_t            qtype = xfs_dquot_type(dqp);
 369         struct xfs_inode        *quotip = xfs_quota_inode(mp, qtype);
 370         uint                    lock_mode;
 371         int                     nmaps = 1;
 372         int                     error;
 373
 374         lock_mode = xfs_ilock_data_map_shared(quotip);
 375         if (!xfs_this_quota_on(mp, qtype)) {
 376                 /*
 377                  * Return if this type of quotas is turned off while we
 378                  * didn't have the quota inode lock.
 379                  */
 380                 xfs_iunlock(quotip, lock_mode);
 381                 return -ESRCH;
 382         }
 383
 384         /*
 385          * Find the block map; no allocations yet
 386          */
 387         error = xfs_bmapi_read(quotip, dqp->q_fileoffset,
 388                         XFS_DQUOT_CLUSTER_SIZE_FSB, &map, &nmaps, 0);
 389         xfs_iunlock(quotip, lock_mode);
 390         if (error)
 391                 return error;
 392
 393         ASSERT(nmaps == 1);
 394         ASSERT(map.br_blockcount >= 1);
 395         ASSERT(map.br_startblock != DELAYSTARTBLOCK);
 396         if (map.br_startblock == HOLESTARTBLOCK)
 397                 return -ENOENT;
 398
 399         trace_xfs_dqtobp_read(dqp);
 400
 401         /*
 402          * store the blkno etc so that we don't have to do the
 403          * mapping all the time
 404          */
 405         dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
 406
 407         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
 408                         mp->m_quotainfo->qi_dqchunklen, 0, &bp,
 409                         &xfs_dquot_buf_ops);
 410         if (error) {
 411                 ASSERT(bp == NULL);
 412                 return error;
 413         }
 414
 415         ASSERT(xfs_buf_islocked(bp));
 416         xfs_buf_set_ref(bp, XFS_DQUOT_REF);
 417         *bpp = bp;
 418
 419         return 0;
 420 }
 421
 422 /* Allocate and initialize everything we need for an incore dquot. */
 423 STATIC struct xfs_dquot *
 424 xfs_dquot_alloc(
 425         struct xfs_mount        *mp,
 426         xfs_dqid_t              id,
 427         xfs_dqtype_t            type)
 428 {
 429         struct xfs_dquot        *dqp;
 430
 431         dqp = kmem_cache_zalloc(xfs_qm_dqzone, GFP_KERNEL | __GFP_NOFAIL);
 432
 433         dqp->q_type = type;
 434         dqp->q_id = id;
 435         dqp->q_mount = mp;
 436         INIT_LIST_HEAD(&dqp->q_lru);
 437         mutex_init(&dqp->q_qlock);
 438         init_waitqueue_head(&dqp->q_pinwait);
 439         dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;
 440         /*
 441          * Offset of dquot in the (fixed sized) dquot chunk.
 442          */
 443         dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) *
 444                         sizeof(xfs_dqblk_t);
 445
 446         /*
 447          * Because we want to use a counting completion, complete
 448          * the flush completion once to allow a single access to
 449          * the flush completion without blocking.
 450          */
 451         init_completion(&dqp->q_flush);
 452         complete(&dqp->q_flush);
 453
 454         /*
 455          * Make sure group quotas have a different lock class than user
 456          * quotas.
 457          */
 458         switch (type) {
 459         case XFS_DQTYPE_USER:
 460                 /* uses the default lock class */
 461                 break;
 462         case XFS_DQTYPE_GROUP:
 463                 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_group_class);
 464                 break;
 465         case XFS_DQTYPE_PROJ:
 466                 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_project_class);
 467                 break;
 468         default:
 469                 ASSERT(0);
 470                 break;
 471         }
 472
 473         xfs_qm_dquot_logitem_init(dqp);
 474
 475         XFS_STATS_INC(mp, xs_qm_dquot);
 476         return dqp;
 477 }
 478
 479 /* Copy the in-core quota fields in from the on-disk buffer. */
 480 STATIC int
 481 xfs_dquot_from_disk(
 482         struct xfs_dquot        *dqp,
 483         struct xfs_buf          *bp)
 484 {
 485         struct xfs_disk_dquot   *ddqp = bp->b_addr + dqp->q_bufoffset;
 486
 487         /*
 488          * Ensure that we got the type and ID we were looking for.
 489          * Everything else was checked by the dquot buffer verifier.
 490          */
 491         if ((ddqp->d_type & XFS_DQTYPE_REC_MASK) != xfs_dquot_type(dqp) ||
 492             be32_to_cpu(ddqp->d_id) != dqp->q_id) {
 493                 xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
 494                           "Metadata corruption detected at %pS, quota %u",
 495                           __this_address, dqp->q_id);
 496                 xfs_alert(bp->b_mount, "Unmount and run xfs_repair");
 497                 return -EFSCORRUPTED;
 498         }
 499
 500         /* copy everything from disk dquot to the incore dquot */
 501         dqp->q_type = ddqp->d_type;
 502         dqp->q_blk.hardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
 503         dqp->q_blk.softlimit = be64_to_cpu(ddqp->d_blk_softlimit);
 504         dqp->q_ino.hardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
 505         dqp->q_ino.softlimit = be64_to_cpu(ddqp->d_ino_softlimit);
 506         dqp->q_rtb.hardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
 507         dqp->q_rtb.softlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
 508
 509         dqp->q_blk.count = be64_to_cpu(ddqp->d_bcount);
 510         dqp->q_ino.count = be64_to_cpu(ddqp->d_icount);
 511         dqp->q_rtb.count = be64_to_cpu(ddqp->d_rtbcount);
 512
 513         dqp->q_blk.warnings = be16_to_cpu(ddqp->d_bwarns);
 514         dqp->q_ino.warnings = be16_to_cpu(ddqp->d_iwarns);
 515         dqp->q_rtb.warnings = be16_to_cpu(ddqp->d_rtbwarns);
 516
 517         dqp->q_blk.timer = be32_to_cpu(ddqp->d_btimer);
 518         dqp->q_ino.timer = be32_to_cpu(ddqp->d_itimer);
 519         dqp->q_rtb.timer = be32_to_cpu(ddqp->d_rtbtimer);
 520
 521         /*
 522          * Reservation counters are defined as reservation plus current usage
 523          * to avoid having to add every time.
 524          */
 525         dqp->q_blk.reserved = dqp->q_blk.count;
 526         dqp->q_ino.reserved = dqp->q_ino.count;
 527         dqp->q_rtb.reserved = dqp->q_rtb.count;
 528
 529         /* initialize the dquot speculative prealloc thresholds */
 530         xfs_dquot_set_prealloc_limits(dqp);
 531         return 0;
 532 }
 533
 534 /* Copy the in-core quota fields into the on-disk buffer. */
 535 void
 536 xfs_dquot_to_disk(
 537         struct xfs_disk_dquot   *ddqp,
 538         struct xfs_dquot        *dqp)
 539 {
 540         ddqp->d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
 541         ddqp->d_version = XFS_DQUOT_VERSION;
 542         ddqp->d_type = dqp->q_type;
 543         ddqp->d_id = cpu_to_be32(dqp->q_id);
 544         ddqp->d_pad0 = 0;
 545         ddqp->d_pad = 0;
 546
 547         ddqp->d_blk_hardlimit = cpu_to_be64(dqp->q_blk.hardlimit);
 548         ddqp->d_blk_softlimit = cpu_to_be64(dqp->q_blk.softlimit);
 549         ddqp->d_ino_hardlimit = cpu_to_be64(dqp->q_ino.hardlimit);
 550         ddqp->d_ino_softlimit = cpu_to_be64(dqp->q_ino.softlimit);
 551         ddqp->d_rtb_hardlimit = cpu_to_be64(dqp->q_rtb.hardlimit);
 552         ddqp->d_rtb_softlimit = cpu_to_be64(dqp->q_rtb.softlimit);
 553
 554         ddqp->d_bcount = cpu_to_be64(dqp->q_blk.count);
 555         ddqp->d_icount = cpu_to_be64(dqp->q_ino.count);
 556         ddqp->d_rtbcount = cpu_to_be64(dqp->q_rtb.count);
 557
 558         ddqp->d_bwarns = cpu_to_be16(dqp->q_blk.warnings);
 559         ddqp->d_iwarns = cpu_to_be16(dqp->q_ino.warnings);
 560         ddqp->d_rtbwarns = cpu_to_be16(dqp->q_rtb.warnings);
 561
 562         ddqp->d_btimer = cpu_to_be32(dqp->q_blk.timer);
 563         ddqp->d_itimer = cpu_to_be32(dqp->q_ino.timer);
 564         ddqp->d_rtbtimer = cpu_to_be32(dqp->q_rtb.timer);
 565 }
 566
 567 /* Allocate and initialize the dquot buffer for this in-core dquot. */
 568 static int
 569 xfs_qm_dqread_alloc(
 570         struct xfs_mount        *mp,
 571         struct xfs_dquot        *dqp,
 572         struct xfs_buf          **bpp)
 573 {
 574         struct xfs_trans        *tp;
 575         int                     error;
 576
 577         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_dqalloc,
 578                         XFS_QM_DQALLOC_SPACE_RES(mp), 0, 0, &tp);
 579         if (error)
 580                 goto err;
 581
 582         error = xfs_dquot_disk_alloc(&tp, dqp, bpp);
 583         if (error)
 584                 goto err_cancel;
 585
 586         error = xfs_trans_commit(tp);
 587         if (error) {
 588                 /*
 589                  * Buffer was held to the transaction, so we have to unlock it
 590                  * manually here because we're not passing it back.
 591                  */
 592                 xfs_buf_relse(*bpp);
 593                 *bpp = NULL;
 594                 goto err;
 595         }
 596         return 0;
 597
 598 err_cancel:
 599         xfs_trans_cancel(tp);
 600 err:
 601         return error;
 602 }
 603
 604 /*
 605  * Read in the ondisk dquot using dqtobp() then copy it to an incore version,
 606  * and release the buffer immediately.  If @can_alloc is true, fill any
 607  * holes in the on-disk metadata.
 608  */
 609 static int
 610 xfs_qm_dqread(
 611         struct xfs_mount        *mp,
 612         xfs_dqid_t              id,
 613         xfs_dqtype_t            type,
 614         bool                    can_alloc,
 615         struct xfs_dquot        **dqpp)
 616 {
 617         struct xfs_dquot        *dqp;
 618         struct xfs_buf          *bp;
 619         int                     error;
 620
 621         dqp = xfs_dquot_alloc(mp, id, type);
 622         trace_xfs_dqread(dqp);
 623
 624         /* Try to read the buffer, allocating if necessary. */
 625         error = xfs_dquot_disk_read(mp, dqp, &bp);
 626         if (error == -ENOENT && can_alloc)
 627                 error = xfs_qm_dqread_alloc(mp, dqp, &bp);
 628         if (error)
 629                 goto err;
 630
 631         /*
 632          * At this point we should have a clean locked buffer.  Copy the data
 633          * to the incore dquot and release the buffer since the incore dquot
 634          * has its own locking protocol so we needn't tie up the buffer any
 635          * further.
 636          */
 637         ASSERT(xfs_buf_islocked(bp));
 638         error = xfs_dquot_from_disk(dqp, bp);
 639         xfs_buf_relse(bp);
 640         if (error)
 641                 goto err;
 642
 643         *dqpp = dqp;
 644         return error;
 645
 646 err:
 647         trace_xfs_dqread_fail(dqp);
 648         xfs_qm_dqdestroy(dqp);
 649         *dqpp = NULL;
 650         return error;
 651 }
 652
 653 /*
 654  * Advance to the next id in the current chunk, or if at the
 655  * end of the chunk, skip ahead to first id in next allocated chunk
 656  * using the SEEK_DATA interface.
 657  */
 658 static int
 659 xfs_dq_get_next_id(
 660         struct xfs_mount        *mp,
 661         xfs_dqtype_t            type,
 662         xfs_dqid_t              *id)
 663 {
 664         struct xfs_inode        *quotip = xfs_quota_inode(mp, type);
 665         xfs_dqid_t              next_id = *id + 1; /* simple advance */
 666         uint                    lock_flags;
 667         struct xfs_bmbt_irec    got;
 668         struct xfs_iext_cursor  cur;
 669         xfs_fsblock_t           start;
 670         int                     error = 0;
 671
 672         /* If we'd wrap past the max ID, stop */
 673         if (next_id < *id)
 674                 return -ENOENT;
 675
 676         /* If new ID is within the current chunk, advancing it sufficed */
 677         if (next_id % mp->m_quotainfo->qi_dqperchunk) {
 678                 *id = next_id;
 679                 return 0;
 680         }
 681
 682         /* Nope, next_id is now past the current chunk, so find the next one */
 683         start = (xfs_fsblock_t)next_id / mp->m_quotainfo->qi_dqperchunk;
 684
 685         lock_flags = xfs_ilock_data_map_shared(quotip);
 686         if (!(quotip->i_df.if_flags & XFS_IFEXTENTS)) {
 687                 error = xfs_iread_extents(NULL, quotip, XFS_DATA_FORK);
 688                 if (error)
 689                         return error;
 690         }
 691
 692         if (xfs_iext_lookup_extent(quotip, &quotip->i_df, start, &cur, &got)) {
 693                 /* contiguous chunk, bump startoff for the id calculation */
 694                 if (got.br_startoff < start)
 695                         got.br_startoff = start;
 696                 *id = got.br_startoff * mp->m_quotainfo->qi_dqperchunk;
 697         } else {
 698                 error = -ENOENT;
 699         }
 700
 701         xfs_iunlock(quotip, lock_flags);
 702
 703         return error;
 704 }
 705
 706 /*
 707  * Look up the dquot in the in-core cache.  If found, the dquot is returned
 708  * locked and ready to go.
 709  */
 710 static struct xfs_dquot *
 711 xfs_qm_dqget_cache_lookup(
 712         struct xfs_mount        *mp,
 713         struct xfs_quotainfo    *qi,
 714         struct radix_tree_root  *tree,
 715         xfs_dqid_t              id)
 716 {
 717         struct xfs_dquot        *dqp;
 718
 719 restart:
 720         mutex_lock(&qi->qi_tree_lock);
 721         dqp = radix_tree_lookup(tree, id);
 722         if (!dqp) {
 723                 mutex_unlock(&qi->qi_tree_lock);
 724                 XFS_STATS_INC(mp, xs_qm_dqcachemisses);
 725                 return NULL;
 726         }
 727
 728         xfs_dqlock(dqp);
 729         if (dqp->q_flags & XFS_DQFLAG_FREEING) {
 730                 xfs_dqunlock(dqp);
 731                 mutex_unlock(&qi->qi_tree_lock);
 732                 trace_xfs_dqget_freeing(dqp);
 733                 delay(1);
 734                 goto restart;
 735         }
 736
 737         dqp->q_nrefs++;
 738         mutex_unlock(&qi->qi_tree_lock);
 739
 740         trace_xfs_dqget_hit(dqp);
 741         XFS_STATS_INC(mp, xs_qm_dqcachehits);
 742         return dqp;
 743 }
 744
 745 /*
 746  * Try to insert a new dquot into the in-core cache.  If an error occurs the
 747  * caller should throw away the dquot and start over.  Otherwise, the dquot
 748  * is returned locked (and held by the cache) as if there had been a cache
 749  * hit.
 750  */
 751 static int
 752 xfs_qm_dqget_cache_insert(
 753         struct xfs_mount        *mp,
 754         struct xfs_quotainfo    *qi,
 755         struct radix_tree_root  *tree,
 756         xfs_dqid_t              id,
 757         struct xfs_dquot        *dqp)
 758 {
 759         int                     error;
 760
 761         mutex_lock(&qi->qi_tree_lock);
 762         error = radix_tree_insert(tree, id, dqp);
 763         if (unlikely(error)) {
 764                 /* Duplicate found!  Caller must try again. */
 765                 WARN_ON(error != -EEXIST);
 766                 mutex_unlock(&qi->qi_tree_lock);
 767                 trace_xfs_dqget_dup(dqp);
 768                 return error;
 769         }
 770
 771         /* Return a locked dquot to the caller, with a reference taken. */
 772         xfs_dqlock(dqp);
 773         dqp->q_nrefs = 1;
 774
 775         qi->qi_dquots++;
 776         mutex_unlock(&qi->qi_tree_lock);
 777
 778         return 0;
 779 }
 780
 781 /* Check our input parameters. */
 782 static int
 783 xfs_qm_dqget_checks(
 784         struct xfs_mount        *mp,
 785         xfs_dqtype_t            type)
 786 {
 787         if (WARN_ON_ONCE(!XFS_IS_QUOTA_RUNNING(mp)))
 788                 return -ESRCH;
 789
 790         switch (type) {
 791         case XFS_DQTYPE_USER:
 792                 if (!XFS_IS_UQUOTA_ON(mp))
 793                         return -ESRCH;
 794                 return 0;
 795         case XFS_DQTYPE_GROUP:
 796                 if (!XFS_IS_GQUOTA_ON(mp))
 797                         return -ESRCH;
 798                 return 0;
 799         case XFS_DQTYPE_PROJ:
 800                 if (!XFS_IS_PQUOTA_ON(mp))
 801                         return -ESRCH;
 802                 return 0;
 803         default:
 804                 WARN_ON_ONCE(0);
 805                 return -EINVAL;
 806         }
 807 }
 808
 809 /*
 810  * Given the file system, id, and type (UDQUOT/GDQUOT), return a locked
 811  * dquot, doing an allocation (if requested) as needed.
 812  */
 813 int
 814 xfs_qm_dqget(
 815         struct xfs_mount        *mp,
 816         xfs_dqid_t              id,
 817         xfs_dqtype_t            type,
 818         bool                    can_alloc,
 819         struct xfs_dquot        **O_dqpp)
 820 {
 821         struct xfs_quotainfo    *qi = mp->m_quotainfo;
 822         struct radix_tree_root  *tree = xfs_dquot_tree(qi, type);
 823         struct xfs_dquot        *dqp;
 824         int                     error;
 825
 826         error = xfs_qm_dqget_checks(mp, type);
 827         if (error)
 828                 return error;
 829
 830 restart:
 831         dqp = xfs_qm_dqget_cache_lookup(mp, qi, tree, id);
 832         if (dqp) {
 833                 *O_dqpp = dqp;
 834                 return 0;
 835         }
 836
 837         error = xfs_qm_dqread(mp, id, type, can_alloc, &dqp);
 838         if (error)
 839                 return error;
 840
 841         error = xfs_qm_dqget_cache_insert(mp, qi, tree, id, dqp);
 842         if (error) {
 843                 /*
 844                  * Duplicate found. Just throw away the new dquot and start
 845                  * over.
 846                  */
 847                 xfs_qm_dqdestroy(dqp);
 848                 XFS_STATS_INC(mp, xs_qm_dquot_dups);
 849                 goto restart;
 850         }
 851
 852         trace_xfs_dqget_miss(dqp);
 853         *O_dqpp = dqp;
 854         return 0;
 855 }
 856
 857 /*
 858  * Given a dquot id and type, read and initialize a dquot from the on-disk
 859  * metadata.  This function is only for use during quota initialization so
 860  * it ignores the dquot cache assuming that the dquot shrinker isn't set up.
 861  * The caller is responsible for _qm_dqdestroy'ing the returned dquot.
 862  */
 863 int
 864 xfs_qm_dqget_uncached(
 865         struct xfs_mount        *mp,
 866         xfs_dqid_t              id,
 867         xfs_dqtype_t            type,
 868         struct xfs_dquot        **dqpp)
 869 {
 870         int                     error;
 871
 872         error = xfs_qm_dqget_checks(mp, type);
 873         if (error)
 874                 return error;
 875
 876         return xfs_qm_dqread(mp, id, type, 0, dqpp);
 877 }
 878
 879 /* Return the quota id for a given inode and type. */
 880 xfs_dqid_t
 881 xfs_qm_id_for_quotatype(
 882         struct xfs_inode        *ip,
 883         xfs_dqtype_t            type)
 884 {
 885         switch (type) {
 886         case XFS_DQTYPE_USER:
 887                 return i_uid_read(VFS_I(ip));
 888         case XFS_DQTYPE_GROUP:
 889                 return i_gid_read(VFS_I(ip));
 890         case XFS_DQTYPE_PROJ:
 891                 return ip->i_d.di_projid;
 892         }
 893         ASSERT(0);
 894         return 0;
 895 }
 896
 897 /*
 898  * Return the dquot for a given inode and type.  If @can_alloc is true, then
 899  * allocate blocks if needed.  The inode's ILOCK must be held and it must not
 900  * have already had an inode attached.
 901  */
 902 int
 903 xfs_qm_dqget_inode(
 904         struct xfs_inode        *ip,
 905         xfs_dqtype_t            type,
 906         bool                    can_alloc,
 907         struct xfs_dquot        **O_dqpp)
 908 {
 909         struct xfs_mount        *mp = ip->i_mount;
 910         struct xfs_quotainfo    *qi = mp->m_quotainfo;
 911         struct radix_tree_root  *tree = xfs_dquot_tree(qi, type);
 912         struct xfs_dquot        *dqp;
 913         xfs_dqid_t              id;
 914         int                     error;
 915
 916         error = xfs_qm_dqget_checks(mp, type);
 917         if (error)
 918                 return error;
 919
 920         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 921         ASSERT(xfs_inode_dquot(ip, type) == NULL);
 922
 923         id = xfs_qm_id_for_quotatype(ip, type);
 924
 925 restart:
 926         dqp = xfs_qm_dqget_cache_lookup(mp, qi, tree, id);
 927         if (dqp) {
 928                 *O_dqpp = dqp;
 929                 return 0;
 930         }
 931
 932         /*
 933          * Dquot cache miss. We don't want to keep the inode lock across
 934          * a (potential) disk read. Also we don't want to deal with the lock
 935          * ordering between quotainode and this inode. OTOH, dropping the inode
 936          * lock here means dealing with a chown that can happen before
 937          * we re-acquire the lock.
 938          */
 939         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 940         error = xfs_qm_dqread(mp, id, type, can_alloc, &dqp);
 941         xfs_ilock(ip, XFS_ILOCK_EXCL);
 942         if (error)
 943                 return error;
 944
 945         /*
 946          * A dquot could be attached to this inode by now, since we had
 947          * dropped the ilock.
 948          */
 949         if (xfs_this_quota_on(mp, type)) {
 950                 struct xfs_dquot        *dqp1;
 951
 952                 dqp1 = xfs_inode_dquot(ip, type);
 953                 if (dqp1) {
 954                         xfs_qm_dqdestroy(dqp);
 955                         dqp = dqp1;
 956                         xfs_dqlock(dqp);
 957                         goto dqret;
 958                 }
 959         } else {
 960                 /* inode stays locked on return */
 961                 xfs_qm_dqdestroy(dqp);
 962                 return -ESRCH;
 963         }
 964
 965         error = xfs_qm_dqget_cache_insert(mp, qi, tree, id, dqp);
 966         if (error) {
 967                 /*
 968                  * Duplicate found. Just throw away the new dquot and start
 969                  * over.
 970                  */
 971                 xfs_qm_dqdestroy(dqp);
 972                 XFS_STATS_INC(mp, xs_qm_dquot_dups);
 973                 goto restart;
 974         }
 975
 976 dqret:
 977         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 978         trace_xfs_dqget_miss(dqp);
 979         *O_dqpp = dqp;
 980         return 0;
 981 }
 982
 983 /*
 984  * Starting at @id and progressing upwards, look for an initialized incore
 985  * dquot, lock it, and return it.
 986  */
 987 int
 988 xfs_qm_dqget_next(
 989         struct xfs_mount        *mp,
 990         xfs_dqid_t              id,
 991         xfs_dqtype_t            type,
 992         struct xfs_dquot        **dqpp)
 993 {
 994         struct xfs_dquot        *dqp;
 995         int                     error = 0;
 996
 997         *dqpp = NULL;
 998         for (; !error; error = xfs_dq_get_next_id(mp, type, &id)) {
 999                 error = xfs_qm_dqget(mp, id, type, false, &dqp);
1000                 if (error == -ENOENT)
1001                         continue;
1002                 else if (error != 0)
1003                         break;
1004
1005                 if (!XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
1006                         *dqpp = dqp;
1007                         return 0;
1008                 }
1009
1010                 xfs_qm_dqput(dqp);
1011         }
1012
1013         return error;
1014 }
1015
1016 /*
1017  * Release a reference to the dquot (decrement ref-count) and unlock it.
1018  *
1019  * If there is a group quota attached to this dquot, carefully release that
1020  * too without tripping over deadlocks'n'stuff.
1021  */
1022 void
1023 xfs_qm_dqput(
1024         struct xfs_dquot        *dqp)
1025 {
1026         ASSERT(dqp->q_nrefs > 0);
1027         ASSERT(XFS_DQ_IS_LOCKED(dqp));
1028
1029         trace_xfs_dqput(dqp);
1030
1031         if (--dqp->q_nrefs == 0) {
1032                 struct xfs_quotainfo    *qi = dqp->q_mount->m_quotainfo;
1033                 trace_xfs_dqput_free(dqp);
1034
1035                 if (list_lru_add(&qi->qi_lru, &dqp->q_lru))
1036                         XFS_STATS_INC(dqp->q_mount, xs_qm_dquot_unused);
1037         }
1038         xfs_dqunlock(dqp);
1039 }
1040
1041 /*
1042  * Release a dquot. Flush it if dirty, then dqput() it.
1043  * dquot must not be locked.
1044  */
1045 void
1046 xfs_qm_dqrele(
1047         struct xfs_dquot        *dqp)
1048 {
1049         if (!dqp)
1050                 return;
1051
1052         trace_xfs_dqrele(dqp);
1053
1054         xfs_dqlock(dqp);
1055         /*
1056          * We don't care to flush it if the dquot is dirty here.
1057          * That will create stutters that we want to avoid.
1058          * Instead we do a delayed write when we try to reclaim
1059          * a dirty dquot. Also xfs_sync will take part of the burden...
1060          */
1061         xfs_qm_dqput(dqp);
1062 }
1063
1064 /*
1065  * This is the dquot flushing I/O completion routine.  It is called
1066  * from interrupt level when the buffer containing the dquot is
1067  * flushed to disk.  It is responsible for removing the dquot logitem
1068  * from the AIL if it has not been re-logged, and unlocking the dquot's
1069  * flush lock. This behavior is very similar to that of inodes..
1070  */
1071 static void
1072 xfs_qm_dqflush_done(
1073         struct xfs_log_item     *lip)
1074 {
1075         struct xfs_dq_logitem   *qip = (struct xfs_dq_logitem *)lip;
1076         struct xfs_dquot        *dqp = qip->qli_dquot;
1077         struct xfs_ail          *ailp = lip->li_ailp;
1078         xfs_lsn_t               tail_lsn;
1079
1080         /*
1081          * We only want to pull the item from the AIL if its
1082          * location in the log has not changed since we started the flush.
1083          * Thus, we only bother if the dquot's lsn has
1084          * not changed. First we check the lsn outside the lock
1085          * since it's cheaper, and then we recheck while
1086          * holding the lock before removing the dquot from the AIL.
1087          */
1088         if (test_bit(XFS_LI_IN_AIL, &lip->li_flags) &&
1089             ((lip->li_lsn == qip->qli_flush_lsn) ||
1090              test_bit(XFS_LI_FAILED, &lip->li_flags))) {
1091
1092                 spin_lock(&ailp->ail_lock);
1093                 xfs_clear_li_failed(lip);
1094                 if (lip->li_lsn == qip->qli_flush_lsn) {
1095                         /* xfs_ail_update_finish() drops the AIL lock */
1096                         tail_lsn = xfs_ail_delete_one(ailp, lip);
1097                         xfs_ail_update_finish(ailp, tail_lsn);
1098                 } else {
1099                         spin_unlock(&ailp->ail_lock);
1100                 }
1101         }
1102
1103         /*
1104          * Release the dq's flush lock since we're done with it.
1105          */
1106         xfs_dqfunlock(dqp);
1107 }
1108
1109 void
1110 xfs_dquot_done(
1111         struct xfs_buf          *bp)
1112 {
1113         struct xfs_log_item     *lip, *n;
1114
1115         list_for_each_entry_safe(lip, n, &bp->b_li_list, li_bio_list) {
1116                 list_del_init(&lip->li_bio_list);
1117                 xfs_qm_dqflush_done(lip);
1118         }
1119 }
1120
1121 /* Check incore dquot for errors before we flush. */
1122 static xfs_failaddr_t
1123 xfs_qm_dqflush_check(
1124         struct xfs_dquot        *dqp)
1125 {
1126         xfs_dqtype_t            type = xfs_dquot_type(dqp);
1127
1128         if (type != XFS_DQTYPE_USER &&
1129             type != XFS_DQTYPE_GROUP &&
1130             type != XFS_DQTYPE_PROJ)
1131                 return __this_address;
1132
1133         if (dqp->q_id == 0)
1134                 return NULL;
1135
1136         if (dqp->q_blk.softlimit && dqp->q_blk.count > dqp->q_blk.softlimit &&
1137             !dqp->q_blk.timer)
1138                 return __this_address;
1139
1140         if (dqp->q_ino.softlimit && dqp->q_ino.count > dqp->q_ino.softlimit &&
1141             !dqp->q_ino.timer)
1142                 return __this_address;
1143
1144         if (dqp->q_rtb.softlimit && dqp->q_rtb.count > dqp->q_rtb.softlimit &&
1145             !dqp->q_rtb.timer)
1146                 return __this_address;
1147
1148         return NULL;
1149 }
1150
1151 /*
1152  * Write a modified dquot to disk.
1153  * The dquot must be locked and the flush lock too taken by caller.
1154  * The flush lock will not be unlocked until the dquot reaches the disk,
1155  * but the dquot is free to be unlocked and modified by the caller
1156  * in the interim. Dquot is still locked on return. This behavior is
1157  * identical to that of inodes.
1158  */
1159 int
1160 xfs_qm_dqflush(
1161         struct xfs_dquot        *dqp,
1162         struct xfs_buf          **bpp)
1163 {
1164         struct xfs_mount        *mp = dqp->q_mount;
1165         struct xfs_log_item     *lip = &dqp->q_logitem.qli_item;
1166         struct xfs_buf          *bp;
1167         struct xfs_dqblk        *dqblk;
1168         xfs_failaddr_t          fa;
1169         int                     error;
1170
1171         ASSERT(XFS_DQ_IS_LOCKED(dqp));
1172         ASSERT(!completion_done(&dqp->q_flush));
1173
1174         trace_xfs_dqflush(dqp);
1175
1176         *bpp = NULL;
1177
1178         xfs_qm_dqunpin_wait(dqp);
1179
1180         /*
1181          * Get the buffer containing the on-disk dquot
1182          */
1183         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
1184                                    mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK,
1185                                    &bp, &xfs_dquot_buf_ops);
1186         if (error == -EAGAIN)
1187                 goto out_unlock;
1188         if (error)
1189                 goto out_abort;
1190
1191         fa = xfs_qm_dqflush_check(dqp);
1192         if (fa) {
1193                 xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
1194                                 dqp->q_id, fa);
1195                 xfs_buf_relse(bp);
1196                 error = -EFSCORRUPTED;
1197                 goto out_abort;
1198         }
1199
1200         /* Flush the incore dquot to the ondisk buffer. */
1201         dqblk = bp->b_addr + dqp->q_bufoffset;
1202         xfs_dquot_to_disk(&dqblk->dd_diskdq, dqp);
1203
1204         /*
1205          * Clear the dirty field and remember the flush lsn for later use.
1206          */
1207         dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
1208
1209         xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
1210                                         &dqp->q_logitem.qli_item.li_lsn);
1211
1212         /*
1213          * copy the lsn into the on-disk dquot now while we have the in memory
1214          * dquot here. This can't be done later in the write verifier as we
1215          * can't get access to the log item at that point in time.
1216          *
1217          * We also calculate the CRC here so that the on-disk dquot in the
1218          * buffer always has a valid CRC. This ensures there is no possibility
1219          * of a dquot without an up-to-date CRC getting to disk.
1220          */
1221         if (xfs_sb_version_hascrc(&mp->m_sb)) {
1222                 dqblk->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
1223                 xfs_update_cksum((char *)dqblk, sizeof(struct xfs_dqblk),
1224                                  XFS_DQUOT_CRC_OFF);
1225         }
1226
1227         /*
1228          * Attach the dquot to the buffer so that we can remove this dquot from
1229          * the AIL and release the flush lock once the dquot is synced to disk.
1230          */
1231         bp->b_flags |= _XBF_DQUOTS;
1232         list_add_tail(&dqp->q_logitem.qli_item.li_bio_list, &bp->b_li_list);
1233
1234         /*
1235          * If the buffer is pinned then push on the log so we won't
1236          * get stuck waiting in the write for too long.
1237          */
1238         if (xfs_buf_ispinned(bp)) {
1239                 trace_xfs_dqflush_force(dqp);
1240                 xfs_log_force(mp, 0);
1241         }
1242
1243         trace_xfs_dqflush_done(dqp);
1244         *bpp = bp;
1245         return 0;
1246
1247 out_abort:
1248         dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
1249         xfs_trans_ail_delete(lip, 0);
1250         xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1251 out_unlock:
1252         xfs_dqfunlock(dqp);
1253         return error;
1254 }
1255
1256 /*
1257  * Lock two xfs_dquot structures.
1258  *
1259  * To avoid deadlocks we always lock the quota structure with
1260  * the lowerd id first.
1261  */
1262 void
1263 xfs_dqlock2(
1264         struct xfs_dquot        *d1,
1265         struct xfs_dquot        *d2)
1266 {
1267         if (d1 && d2) {
1268                 ASSERT(d1 != d2);
1269                 if (d1->q_id > d2->q_id) {
1270                         mutex_lock(&d2->q_qlock);
1271                         mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
1272                 } else {
1273                         mutex_lock(&d1->q_qlock);
1274                         mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED);
1275                 }
1276         } else if (d1) {
1277                 mutex_lock(&d1->q_qlock);
1278         } else if (d2) {
1279                 mutex_lock(&d2->q_qlock);
1280         }
1281 }
1282
1283 int __init
1284 xfs_qm_init(void)
1285 {
1286         xfs_qm_dqzone = kmem_cache_create("xfs_dquot",
1287                                           sizeof(struct xfs_dquot),
1288                                           0, 0, NULL);
1289         if (!xfs_qm_dqzone)
1290                 goto out;
1291
1292         xfs_qm_dqtrxzone = kmem_cache_create("xfs_dqtrx",
1293                                              sizeof(struct xfs_dquot_acct),
1294                                              0, 0, NULL);
1295         if (!xfs_qm_dqtrxzone)
1296                 goto out_free_dqzone;
1297
1298         return 0;
1299
1300 out_free_dqzone:
1301         kmem_cache_destroy(xfs_qm_dqzone);
1302 out:
1303         return -ENOMEM;
1304 }
1305
1306 void
1307 xfs_qm_exit(void)
1308 {
1309         kmem_cache_destroy(xfs_qm_dqtrxzone);
1310         kmem_cache_destroy(xfs_qm_dqzone);
1311 }
1312
1313 /*
1314  * Iterate every dquot of a particular type.  The caller must ensure that the
1315  * particular quota type is active.  iter_fn can return negative error codes,
1316  * or -ECANCELED to indicate that it wants to stop iterating.
1317  */
1318 int
1319 xfs_qm_dqiterate(
1320         struct xfs_mount        *mp,
1321         xfs_dqtype_t            type,
1322         xfs_qm_dqiterate_fn     iter_fn,
1323         void                    *priv)
1324 {
1325         struct xfs_dquot        *dq;
1326         xfs_dqid_t              id = 0;
1327         int                     error;
1328
1329         do {
1330                 error = xfs_qm_dqget_next(mp, id, type, &dq);
1331                 if (error == -ENOENT)
1332                         return 0;
1333                 if (error)
1334                         return error;
1335
1336                 error = iter_fn(dq, type, priv);
1337                 id = dq->q_id;
1338                 xfs_qm_dqput(dq);
1339         } while (error == 0 && id != 0);
1340
1341         return error;
1342 }