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