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                 res->timer = 0;
 140         }
 141 }
 142
 143 /*
 144  * Check the limits and timers of a dquot and start or reset timers
 145  * if necessary.
 146  * This gets called even when quota enforcement is OFF, which makes our
 147  * life a little less complicated. (We just don't reject any quota
 148  * reservations in that case, when enforcement is off).
 149  * We also return 0 as the values of the timers in Q_GETQUOTA calls, when
 150  * enforcement's off.
 151  * In contrast, warnings are a little different in that they don't
 152  * 'automatically' get started when limits get exceeded.  They do
 153  * get reset to zero, however, when we find the count to be under
 154  * the soft limit (they are only ever set non-zero via userspace).
 155  */
 156 void
 157 xfs_qm_adjust_dqtimers(
 158         struct xfs_dquot        *dq)
 159 {
 160         struct xfs_mount        *mp = dq->q_mount;
 161         struct xfs_quotainfo    *qi = mp->m_quotainfo;
 162         struct xfs_def_quota    *defq;
 163
 164         ASSERT(dq->q_id);
 165         defq = xfs_get_defquota(qi, xfs_dquot_type(dq));
 166
 167         xfs_qm_adjust_res_timer(dq->q_mount, &dq->q_blk, &defq->blk);
 168         xfs_qm_adjust_res_timer(dq->q_mount, &dq->q_ino, &defq->ino);
 169         xfs_qm_adjust_res_timer(dq->q_mount, &dq->q_rtb, &defq->rtb);
 170 }
 171
 172 /*
 173  * initialize a buffer full of dquots and log the whole thing
 174  */
 175 STATIC void
 176 xfs_qm_init_dquot_blk(
 177         struct xfs_trans        *tp,
 178         struct xfs_mount        *mp,
 179         xfs_dqid_t              id,
 180         xfs_dqtype_t            type,
 181         struct xfs_buf          *bp)
 182 {
 183         struct xfs_quotainfo    *q = mp->m_quotainfo;
 184         struct xfs_dqblk        *d;
 185         xfs_dqid_t              curid;
 186         unsigned int            qflag;
 187         unsigned int            blftype;
 188         int                     i;
 189
 190         ASSERT(tp);
 191         ASSERT(xfs_buf_islocked(bp));
 192
 193         switch (type) {
 194         case XFS_DQTYPE_USER:
 195                 qflag = XFS_UQUOTA_CHKD;
 196                 blftype = XFS_BLF_UDQUOT_BUF;
 197                 break;
 198         case XFS_DQTYPE_PROJ:
 199                 qflag = XFS_PQUOTA_CHKD;
 200                 blftype = XFS_BLF_PDQUOT_BUF;
 201                 break;
 202         case XFS_DQTYPE_GROUP:
 203                 qflag = XFS_GQUOTA_CHKD;
 204                 blftype = XFS_BLF_GDQUOT_BUF;
 205                 break;
 206         default:
 207                 ASSERT(0);
 208                 return;
 209         }
 210
 211         d = bp->b_addr;
 212
 213         /*
 214          * ID of the first dquot in the block - id's are zero based.
 215          */
 216         curid = id - (id % q->qi_dqperchunk);
 217         memset(d, 0, BBTOB(q->qi_dqchunklen));
 218         for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) {
 219                 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
 220                 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
 221                 d->dd_diskdq.d_id = cpu_to_be32(curid);
 222                 d->dd_diskdq.d_type = type;
 223                 if (curid > 0 && xfs_has_bigtime(mp))
 224                         d->dd_diskdq.d_type |= XFS_DQTYPE_BIGTIME;
 225                 if (xfs_has_crc(mp)) {
 226                         uuid_copy(&d->dd_uuid, &mp->m_sb.sb_meta_uuid);
 227                         xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
 228                                          XFS_DQUOT_CRC_OFF);
 229                 }
 230         }
 231
 232         xfs_trans_dquot_buf(tp, bp, blftype);
 233
 234         /*
 235          * quotacheck uses delayed writes to update all the dquots on disk in an
 236          * efficient manner instead of logging the individual dquot changes as
 237          * they are made. However if we log the buffer allocated here and crash
 238          * after quotacheck while the logged initialisation is still in the
 239          * active region of the log, log recovery can replay the dquot buffer
 240          * initialisation over the top of the checked dquots and corrupt quota
 241          * accounting.
 242          *
 243          * To avoid this problem, quotacheck cannot log the initialised buffer.
 244          * We must still dirty the buffer and write it back before the
 245          * allocation transaction clears the log. Therefore, mark the buffer as
 246          * ordered instead of logging it directly. This is safe for quotacheck
 247          * because it detects and repairs allocated but initialized dquot blocks
 248          * in the quota inodes.
 249          */
 250         if (!(mp->m_qflags & qflag))
 251                 xfs_trans_ordered_buf(tp, bp);
 252         else
 253                 xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
 254 }
 255
 256 /*
 257  * Initialize the dynamic speculative preallocation thresholds. The lo/hi
 258  * watermarks correspond to the soft and hard limits by default. If a soft limit
 259  * is not specified, we use 95% of the hard limit.
 260  */
 261 void
 262 xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp)
 263 {
 264         uint64_t space;
 265
 266         dqp->q_prealloc_hi_wmark = dqp->q_blk.hardlimit;
 267         dqp->q_prealloc_lo_wmark = dqp->q_blk.softlimit;
 268         if (!dqp->q_prealloc_lo_wmark) {
 269                 dqp->q_prealloc_lo_wmark = dqp->q_prealloc_hi_wmark;
 270                 do_div(dqp->q_prealloc_lo_wmark, 100);
 271                 dqp->q_prealloc_lo_wmark *= 95;
 272         }
 273
 274         space = dqp->q_prealloc_hi_wmark;
 275
 276         do_div(space, 100);
 277         dqp->q_low_space[XFS_QLOWSP_1_PCNT] = space;
 278         dqp->q_low_space[XFS_QLOWSP_3_PCNT] = space * 3;
 279         dqp->q_low_space[XFS_QLOWSP_5_PCNT] = space * 5;
 280 }
 281
 282 /*
 283  * Ensure that the given in-core dquot has a buffer on disk backing it, and
 284  * return the buffer locked and held. This is called when the bmapi finds a
 285  * hole.
 286  */
 287 STATIC int
 288 xfs_dquot_disk_alloc(
 289         struct xfs_dquot        *dqp,
 290         struct xfs_buf          **bpp)
 291 {
 292         struct xfs_bmbt_irec    map;
 293         struct xfs_trans        *tp;
 294         struct xfs_mount        *mp = dqp->q_mount;
 295         struct xfs_buf          *bp;
 296         xfs_dqtype_t            qtype = xfs_dquot_type(dqp);
 297         struct xfs_inode        *quotip = xfs_quota_inode(mp, qtype);
 298         int                     nmaps = 1;
 299         int                     error;
 300
 301         trace_xfs_dqalloc(dqp);
 302
 303         error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_dqalloc,
 304                         XFS_QM_DQALLOC_SPACE_RES(mp), 0, 0, &tp);
 305         if (error)
 306                 return error;
 307
 308         xfs_ilock(quotip, XFS_ILOCK_EXCL);
 309         xfs_trans_ijoin(tp, quotip, 0);
 310
 311         if (!xfs_this_quota_on(dqp->q_mount, qtype)) {
 312                 /*
 313                  * Return if this type of quotas is turned off while we didn't
 314                  * have an inode lock
 315                  */
 316                 error = -ESRCH;
 317                 goto err_cancel;
 318         }
 319
 320         error = xfs_iext_count_may_overflow(quotip, XFS_DATA_FORK,
 321                         XFS_IEXT_ADD_NOSPLIT_CNT);
 322         if (error == -EFBIG)
 323                 error = xfs_iext_count_upgrade(tp, quotip,
 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 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.timer = xfs_dquot_from_disk_ts(ddqp, ddqp->d_btimer);
 593         dqp->q_ino.timer = xfs_dquot_from_disk_ts(ddqp, ddqp->d_itimer);
 594         dqp->q_rtb.timer = xfs_dquot_from_disk_ts(ddqp, ddqp->d_rtbtimer);
 595
 596         /*
 597          * Reservation counters are defined as reservation plus current usage
 598          * to avoid having to add every time.
 599          */
 600         dqp->q_blk.reserved = dqp->q_blk.count;
 601         dqp->q_ino.reserved = dqp->q_ino.count;
 602         dqp->q_rtb.reserved = dqp->q_rtb.count;
 603
 604         /* initialize the dquot speculative prealloc thresholds */
 605         xfs_dquot_set_prealloc_limits(dqp);
 606         return 0;
 607 }
 608
 609 /* Copy the in-core quota fields into the on-disk buffer. */
 610 void
 611 xfs_dquot_to_disk(
 612         struct xfs_disk_dquot   *ddqp,
 613         struct xfs_dquot        *dqp)
 614 {
 615         ddqp->d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
 616         ddqp->d_version = XFS_DQUOT_VERSION;
 617         ddqp->d_type = dqp->q_type;
 618         ddqp->d_id = cpu_to_be32(dqp->q_id);
 619         ddqp->d_pad0 = 0;
 620         ddqp->d_pad = 0;
 621
 622         ddqp->d_blk_hardlimit = cpu_to_be64(dqp->q_blk.hardlimit);
 623         ddqp->d_blk_softlimit = cpu_to_be64(dqp->q_blk.softlimit);
 624         ddqp->d_ino_hardlimit = cpu_to_be64(dqp->q_ino.hardlimit);
 625         ddqp->d_ino_softlimit = cpu_to_be64(dqp->q_ino.softlimit);
 626         ddqp->d_rtb_hardlimit = cpu_to_be64(dqp->q_rtb.hardlimit);
 627         ddqp->d_rtb_softlimit = cpu_to_be64(dqp->q_rtb.softlimit);
 628
 629         ddqp->d_bcount = cpu_to_be64(dqp->q_blk.count);
 630         ddqp->d_icount = cpu_to_be64(dqp->q_ino.count);
 631         ddqp->d_rtbcount = cpu_to_be64(dqp->q_rtb.count);
 632
 633         ddqp->d_bwarns = 0;
 634         ddqp->d_iwarns = 0;
 635         ddqp->d_rtbwarns = 0;
 636
 637         ddqp->d_btimer = xfs_dquot_to_disk_ts(dqp, dqp->q_blk.timer);
 638         ddqp->d_itimer = xfs_dquot_to_disk_ts(dqp, dqp->q_ino.timer);
 639         ddqp->d_rtbtimer = xfs_dquot_to_disk_ts(dqp, dqp->q_rtb.timer);
 640 }
 641
 642 /*
 643  * Read in the ondisk dquot using dqtobp() then copy it to an incore version,
 644  * and release the buffer immediately.  If @can_alloc is true, fill any
 645  * holes in the on-disk metadata.
 646  */
 647 static int
 648 xfs_qm_dqread(
 649         struct xfs_mount        *mp,
 650         xfs_dqid_t              id,
 651         xfs_dqtype_t            type,
 652         bool                    can_alloc,
 653         struct xfs_dquot        **dqpp)
 654 {
 655         struct xfs_dquot        *dqp;
 656         struct xfs_buf          *bp;
 657         int                     error;
 658
 659         dqp = xfs_dquot_alloc(mp, id, type);
 660         trace_xfs_dqread(dqp);
 661
 662         /* Try to read the buffer, allocating if necessary. */
 663         error = xfs_dquot_disk_read(mp, dqp, &bp);
 664         if (error == -ENOENT && can_alloc)
 665                 error = xfs_dquot_disk_alloc(dqp, &bp);
 666         if (error)
 667                 goto err;
 668
 669         /*
 670          * At this point we should have a clean locked buffer.  Copy the data
 671          * to the incore dquot and release the buffer since the incore dquot
 672          * has its own locking protocol so we needn't tie up the buffer any
 673          * further.
 674          */
 675         ASSERT(xfs_buf_islocked(bp));
 676         error = xfs_dquot_from_disk(dqp, bp);
 677         xfs_buf_relse(bp);
 678         if (error)
 679                 goto err;
 680
 681         *dqpp = dqp;
 682         return error;
 683
 684 err:
 685         trace_xfs_dqread_fail(dqp);
 686         xfs_qm_dqdestroy(dqp);
 687         *dqpp = NULL;
 688         return error;
 689 }
 690
 691 /*
 692  * Advance to the next id in the current chunk, or if at the
 693  * end of the chunk, skip ahead to first id in next allocated chunk
 694  * using the SEEK_DATA interface.
 695  */
 696 static int
 697 xfs_dq_get_next_id(
 698         struct xfs_mount        *mp,
 699         xfs_dqtype_t            type,
 700         xfs_dqid_t              *id)
 701 {
 702         struct xfs_inode        *quotip = xfs_quota_inode(mp, type);
 703         xfs_dqid_t              next_id = *id + 1; /* simple advance */
 704         uint                    lock_flags;
 705         struct xfs_bmbt_irec    got;
 706         struct xfs_iext_cursor  cur;
 707         xfs_fsblock_t           start;
 708         int                     error = 0;
 709
 710         /* If we'd wrap past the max ID, stop */
 711         if (next_id < *id)
 712                 return -ENOENT;
 713
 714         /* If new ID is within the current chunk, advancing it sufficed */
 715         if (next_id % mp->m_quotainfo->qi_dqperchunk) {
 716                 *id = next_id;
 717                 return 0;
 718         }
 719
 720         /* Nope, next_id is now past the current chunk, so find the next one */
 721         start = (xfs_fsblock_t)next_id / mp->m_quotainfo->qi_dqperchunk;
 722
 723         lock_flags = xfs_ilock_data_map_shared(quotip);
 724         error = xfs_iread_extents(NULL, quotip, XFS_DATA_FORK);
 725         if (error)
 726                 return error;
 727
 728         if (xfs_iext_lookup_extent(quotip, &quotip->i_df, start, &cur, &got)) {
 729                 /* contiguous chunk, bump startoff for the id calculation */
 730                 if (got.br_startoff < start)
 731                         got.br_startoff = start;
 732                 *id = got.br_startoff * mp->m_quotainfo->qi_dqperchunk;
 733         } else {
 734                 error = -ENOENT;
 735         }
 736
 737         xfs_iunlock(quotip, lock_flags);
 738
 739         return error;
 740 }
 741
 742 /*
 743  * Look up the dquot in the in-core cache.  If found, the dquot is returned
 744  * locked and ready to go.
 745  */
 746 static struct xfs_dquot *
 747 xfs_qm_dqget_cache_lookup(
 748         struct xfs_mount        *mp,
 749         struct xfs_quotainfo    *qi,
 750         struct radix_tree_root  *tree,
 751         xfs_dqid_t              id)
 752 {
 753         struct xfs_dquot        *dqp;
 754
 755 restart:
 756         mutex_lock(&qi->qi_tree_lock);
 757         dqp = radix_tree_lookup(tree, id);
 758         if (!dqp) {
 759                 mutex_unlock(&qi->qi_tree_lock);
 760                 XFS_STATS_INC(mp, xs_qm_dqcachemisses);
 761                 return NULL;
 762         }
 763
 764         xfs_dqlock(dqp);
 765         if (dqp->q_flags & XFS_DQFLAG_FREEING) {
 766                 xfs_dqunlock(dqp);
 767                 mutex_unlock(&qi->qi_tree_lock);
 768                 trace_xfs_dqget_freeing(dqp);
 769                 delay(1);
 770                 goto restart;
 771         }
 772
 773         dqp->q_nrefs++;
 774         mutex_unlock(&qi->qi_tree_lock);
 775
 776         trace_xfs_dqget_hit(dqp);
 777         XFS_STATS_INC(mp, xs_qm_dqcachehits);
 778         return dqp;
 779 }
 780
 781 /*
 782  * Try to insert a new dquot into the in-core cache.  If an error occurs the
 783  * caller should throw away the dquot and start over.  Otherwise, the dquot
 784  * is returned locked (and held by the cache) as if there had been a cache
 785  * hit.
 786  */
 787 static int
 788 xfs_qm_dqget_cache_insert(
 789         struct xfs_mount        *mp,
 790         struct xfs_quotainfo    *qi,
 791         struct radix_tree_root  *tree,
 792         xfs_dqid_t              id,
 793         struct xfs_dquot        *dqp)
 794 {
 795         int                     error;
 796
 797         mutex_lock(&qi->qi_tree_lock);
 798         error = radix_tree_insert(tree, id, dqp);
 799         if (unlikely(error)) {
 800                 /* Duplicate found!  Caller must try again. */
 801                 mutex_unlock(&qi->qi_tree_lock);
 802                 trace_xfs_dqget_dup(dqp);
 803                 return error;
 804         }
 805
 806         /* Return a locked dquot to the caller, with a reference taken. */
 807         xfs_dqlock(dqp);
 808         dqp->q_nrefs = 1;
 809
 810         qi->qi_dquots++;
 811         mutex_unlock(&qi->qi_tree_lock);
 812
 813         return 0;
 814 }
 815
 816 /* Check our input parameters. */
 817 static int
 818 xfs_qm_dqget_checks(
 819         struct xfs_mount        *mp,
 820         xfs_dqtype_t            type)
 821 {
 822         switch (type) {
 823         case XFS_DQTYPE_USER:
 824                 if (!XFS_IS_UQUOTA_ON(mp))
 825                         return -ESRCH;
 826                 return 0;
 827         case XFS_DQTYPE_GROUP:
 828                 if (!XFS_IS_GQUOTA_ON(mp))
 829                         return -ESRCH;
 830                 return 0;
 831         case XFS_DQTYPE_PROJ:
 832                 if (!XFS_IS_PQUOTA_ON(mp))
 833                         return -ESRCH;
 834                 return 0;
 835         default:
 836                 WARN_ON_ONCE(0);
 837                 return -EINVAL;
 838         }
 839 }
 840
 841 /*
 842  * Given the file system, id, and type (UDQUOT/GDQUOT/PDQUOT), return a
 843  * locked dquot, doing an allocation (if requested) as needed.
 844  */
 845 int
 846 xfs_qm_dqget(
 847         struct xfs_mount        *mp,
 848         xfs_dqid_t              id,
 849         xfs_dqtype_t            type,
 850         bool                    can_alloc,
 851         struct xfs_dquot        **O_dqpp)
 852 {
 853         struct xfs_quotainfo    *qi = mp->m_quotainfo;
 854         struct radix_tree_root  *tree = xfs_dquot_tree(qi, type);
 855         struct xfs_dquot        *dqp;
 856         int                     error;
 857
 858         error = xfs_qm_dqget_checks(mp, type);
 859         if (error)
 860                 return error;
 861
 862 restart:
 863         dqp = xfs_qm_dqget_cache_lookup(mp, qi, tree, id);
 864         if (dqp) {
 865                 *O_dqpp = dqp;
 866                 return 0;
 867         }
 868
 869         error = xfs_qm_dqread(mp, id, type, can_alloc, &dqp);
 870         if (error)
 871                 return error;
 872
 873         error = xfs_qm_dqget_cache_insert(mp, qi, tree, id, dqp);
 874         if (error) {
 875                 /*
 876                  * Duplicate found. Just throw away the new dquot and start
 877                  * over.
 878                  */
 879                 xfs_qm_dqdestroy(dqp);
 880                 XFS_STATS_INC(mp, xs_qm_dquot_dups);
 881                 goto restart;
 882         }
 883
 884         trace_xfs_dqget_miss(dqp);
 885         *O_dqpp = dqp;
 886         return 0;
 887 }
 888
 889 /*
 890  * Given a dquot id and type, read and initialize a dquot from the on-disk
 891  * metadata.  This function is only for use during quota initialization so
 892  * it ignores the dquot cache assuming that the dquot shrinker isn't set up.
 893  * The caller is responsible for _qm_dqdestroy'ing the returned dquot.
 894  */
 895 int
 896 xfs_qm_dqget_uncached(
 897         struct xfs_mount        *mp,
 898         xfs_dqid_t              id,
 899         xfs_dqtype_t            type,
 900         struct xfs_dquot        **dqpp)
 901 {
 902         int                     error;
 903
 904         error = xfs_qm_dqget_checks(mp, type);
 905         if (error)
 906                 return error;
 907
 908         return xfs_qm_dqread(mp, id, type, 0, dqpp);
 909 }
 910
 911 /* Return the quota id for a given inode and type. */
 912 xfs_dqid_t
 913 xfs_qm_id_for_quotatype(
 914         struct xfs_inode        *ip,
 915         xfs_dqtype_t            type)
 916 {
 917         switch (type) {
 918         case XFS_DQTYPE_USER:
 919                 return i_uid_read(VFS_I(ip));
 920         case XFS_DQTYPE_GROUP:
 921                 return i_gid_read(VFS_I(ip));
 922         case XFS_DQTYPE_PROJ:
 923                 return ip->i_projid;
 924         }
 925         ASSERT(0);
 926         return 0;
 927 }
 928
 929 /*
 930  * Return the dquot for a given inode and type.  If @can_alloc is true, then
 931  * allocate blocks if needed.  The inode's ILOCK must be held and it must not
 932  * have already had an inode attached.
 933  */
 934 int
 935 xfs_qm_dqget_inode(
 936         struct xfs_inode        *ip,
 937         xfs_dqtype_t            type,
 938         bool                    can_alloc,
 939         struct xfs_dquot        **O_dqpp)
 940 {
 941         struct xfs_mount        *mp = ip->i_mount;
 942         struct xfs_quotainfo    *qi = mp->m_quotainfo;
 943         struct radix_tree_root  *tree = xfs_dquot_tree(qi, type);
 944         struct xfs_dquot        *dqp;
 945         xfs_dqid_t              id;
 946         int                     error;
 947
 948         error = xfs_qm_dqget_checks(mp, type);
 949         if (error)
 950                 return error;
 951
 952         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 953         ASSERT(xfs_inode_dquot(ip, type) == NULL);
 954
 955         id = xfs_qm_id_for_quotatype(ip, type);
 956
 957 restart:
 958         dqp = xfs_qm_dqget_cache_lookup(mp, qi, tree, id);
 959         if (dqp) {
 960                 *O_dqpp = dqp;
 961                 return 0;
 962         }
 963
 964         /*
 965          * Dquot cache miss. We don't want to keep the inode lock across
 966          * a (potential) disk read. Also we don't want to deal with the lock
 967          * ordering between quotainode and this inode. OTOH, dropping the inode
 968          * lock here means dealing with a chown that can happen before
 969          * we re-acquire the lock.
 970          */
 971         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 972         error = xfs_qm_dqread(mp, id, type, can_alloc, &dqp);
 973         xfs_ilock(ip, XFS_ILOCK_EXCL);
 974         if (error)
 975                 return error;
 976
 977         /*
 978          * A dquot could be attached to this inode by now, since we had
 979          * dropped the ilock.
 980          */
 981         if (xfs_this_quota_on(mp, type)) {
 982                 struct xfs_dquot        *dqp1;
 983
 984                 dqp1 = xfs_inode_dquot(ip, type);
 985                 if (dqp1) {
 986                         xfs_qm_dqdestroy(dqp);
 987                         dqp = dqp1;
 988                         xfs_dqlock(dqp);
 989                         goto dqret;
 990                 }
 991         } else {
 992                 /* inode stays locked on return */
 993                 xfs_qm_dqdestroy(dqp);
 994                 return -ESRCH;
 995         }
 996
 997         error = xfs_qm_dqget_cache_insert(mp, qi, tree, id, dqp);
 998         if (error) {
 999                 /*
1000                  * Duplicate found. Just throw away the new dquot and start
1001                  * over.
1002                  */
1003                 xfs_qm_dqdestroy(dqp);
1004                 XFS_STATS_INC(mp, xs_qm_dquot_dups);
1005                 goto restart;
1006         }
1007
1008 dqret:
1009         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1010         trace_xfs_dqget_miss(dqp);
1011         *O_dqpp = dqp;
1012         return 0;
1013 }
1014
1015 /*
1016  * Starting at @id and progressing upwards, look for an initialized incore
1017  * dquot, lock it, and return it.
1018  */
1019 int
1020 xfs_qm_dqget_next(
1021         struct xfs_mount        *mp,
1022         xfs_dqid_t              id,
1023         xfs_dqtype_t            type,
1024         struct xfs_dquot        **dqpp)
1025 {
1026         struct xfs_dquot        *dqp;
1027         int                     error = 0;
1028
1029         *dqpp = NULL;
1030         for (; !error; error = xfs_dq_get_next_id(mp, type, &id)) {
1031                 error = xfs_qm_dqget(mp, id, type, false, &dqp);
1032                 if (error == -ENOENT)
1033                         continue;
1034                 else if (error != 0)
1035                         break;
1036
1037                 if (!XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
1038                         *dqpp = dqp;
1039                         return 0;
1040                 }
1041
1042                 xfs_qm_dqput(dqp);
1043         }
1044
1045         return error;
1046 }
1047
1048 /*
1049  * Release a reference to the dquot (decrement ref-count) and unlock it.
1050  *
1051  * If there is a group quota attached to this dquot, carefully release that
1052  * too without tripping over deadlocks'n'stuff.
1053  */
1054 void
1055 xfs_qm_dqput(
1056         struct xfs_dquot        *dqp)
1057 {
1058         ASSERT(dqp->q_nrefs > 0);
1059         ASSERT(XFS_DQ_IS_LOCKED(dqp));
1060
1061         trace_xfs_dqput(dqp);
1062
1063         if (--dqp->q_nrefs == 0) {
1064                 struct xfs_quotainfo    *qi = dqp->q_mount->m_quotainfo;
1065                 trace_xfs_dqput_free(dqp);
1066
1067                 if (list_lru_add(&qi->qi_lru, &dqp->q_lru))
1068                         XFS_STATS_INC(dqp->q_mount, xs_qm_dquot_unused);
1069         }
1070         xfs_dqunlock(dqp);
1071 }
1072
1073 /*
1074  * Release a dquot. Flush it if dirty, then dqput() it.
1075  * dquot must not be locked.
1076  */
1077 void
1078 xfs_qm_dqrele(
1079         struct xfs_dquot        *dqp)
1080 {
1081         if (!dqp)
1082                 return;
1083
1084         trace_xfs_dqrele(dqp);
1085
1086         xfs_dqlock(dqp);
1087         /*
1088          * We don't care to flush it if the dquot is dirty here.
1089          * That will create stutters that we want to avoid.
1090          * Instead we do a delayed write when we try to reclaim
1091          * a dirty dquot. Also xfs_sync will take part of the burden...
1092          */
1093         xfs_qm_dqput(dqp);
1094 }
1095
1096 /*
1097  * This is the dquot flushing I/O completion routine.  It is called
1098  * from interrupt level when the buffer containing the dquot is
1099  * flushed to disk.  It is responsible for removing the dquot logitem
1100  * from the AIL if it has not been re-logged, and unlocking the dquot's
1101  * flush lock. This behavior is very similar to that of inodes..
1102  */
1103 static void
1104 xfs_qm_dqflush_done(
1105         struct xfs_log_item     *lip)
1106 {
1107         struct xfs_dq_logitem   *qip = (struct xfs_dq_logitem *)lip;
1108         struct xfs_dquot        *dqp = qip->qli_dquot;
1109         struct xfs_ail          *ailp = lip->li_ailp;
1110         xfs_lsn_t               tail_lsn;
1111
1112         /*
1113          * We only want to pull the item from the AIL if its
1114          * location in the log has not changed since we started the flush.
1115          * Thus, we only bother if the dquot's lsn has
1116          * not changed. First we check the lsn outside the lock
1117          * since it's cheaper, and then we recheck while
1118          * holding the lock before removing the dquot from the AIL.
1119          */
1120         if (test_bit(XFS_LI_IN_AIL, &lip->li_flags) &&
1121             ((lip->li_lsn == qip->qli_flush_lsn) ||
1122              test_bit(XFS_LI_FAILED, &lip->li_flags))) {
1123
1124                 spin_lock(&ailp->ail_lock);
1125                 xfs_clear_li_failed(lip);
1126                 if (lip->li_lsn == qip->qli_flush_lsn) {
1127                         /* xfs_ail_update_finish() drops the AIL lock */
1128                         tail_lsn = xfs_ail_delete_one(ailp, lip);
1129                         xfs_ail_update_finish(ailp, tail_lsn);
1130                 } else {
1131                         spin_unlock(&ailp->ail_lock);
1132                 }
1133         }
1134
1135         /*
1136          * Release the dq's flush lock since we're done with it.
1137          */
1138         xfs_dqfunlock(dqp);
1139 }
1140
1141 void
1142 xfs_buf_dquot_iodone(
1143         struct xfs_buf          *bp)
1144 {
1145         struct xfs_log_item     *lip, *n;
1146
1147         list_for_each_entry_safe(lip, n, &bp->b_li_list, li_bio_list) {
1148                 list_del_init(&lip->li_bio_list);
1149                 xfs_qm_dqflush_done(lip);
1150         }
1151 }
1152
1153 void
1154 xfs_buf_dquot_io_fail(
1155         struct xfs_buf          *bp)
1156 {
1157         struct xfs_log_item     *lip;
1158
1159         spin_lock(&bp->b_mount->m_ail->ail_lock);
1160         list_for_each_entry(lip, &bp->b_li_list, li_bio_list)
1161                 xfs_set_li_failed(lip, bp);
1162         spin_unlock(&bp->b_mount->m_ail->ail_lock);
1163 }
1164
1165 /* Check incore dquot for errors before we flush. */
1166 static xfs_failaddr_t
1167 xfs_qm_dqflush_check(
1168         struct xfs_dquot        *dqp)
1169 {
1170         xfs_dqtype_t            type = xfs_dquot_type(dqp);
1171
1172         if (type != XFS_DQTYPE_USER &&
1173             type != XFS_DQTYPE_GROUP &&
1174             type != XFS_DQTYPE_PROJ)
1175                 return __this_address;
1176
1177         if (dqp->q_id == 0)
1178                 return NULL;
1179
1180         if (dqp->q_blk.softlimit && dqp->q_blk.count > dqp->q_blk.softlimit &&
1181             !dqp->q_blk.timer)
1182                 return __this_address;
1183
1184         if (dqp->q_ino.softlimit && dqp->q_ino.count > dqp->q_ino.softlimit &&
1185             !dqp->q_ino.timer)
1186                 return __this_address;
1187
1188         if (dqp->q_rtb.softlimit && dqp->q_rtb.count > dqp->q_rtb.softlimit &&
1189             !dqp->q_rtb.timer)
1190                 return __this_address;
1191
1192         /* bigtime flag should never be set on root dquots */
1193         if (dqp->q_type & XFS_DQTYPE_BIGTIME) {
1194                 if (!xfs_has_bigtime(dqp->q_mount))
1195                         return __this_address;
1196                 if (dqp->q_id == 0)
1197                         return __this_address;
1198         }
1199
1200         return NULL;
1201 }
1202
1203 /*
1204  * Write a modified dquot to disk.
1205  * The dquot must be locked and the flush lock too taken by caller.
1206  * The flush lock will not be unlocked until the dquot reaches the disk,
1207  * but the dquot is free to be unlocked and modified by the caller
1208  * in the interim. Dquot is still locked on return. This behavior is
1209  * identical to that of inodes.
1210  */
1211 int
1212 xfs_qm_dqflush(
1213         struct xfs_dquot        *dqp,
1214         struct xfs_buf          **bpp)
1215 {
1216         struct xfs_mount        *mp = dqp->q_mount;
1217         struct xfs_log_item     *lip = &dqp->q_logitem.qli_item;
1218         struct xfs_buf          *bp;
1219         struct xfs_dqblk        *dqblk;
1220         xfs_failaddr_t          fa;
1221         int                     error;
1222
1223         ASSERT(XFS_DQ_IS_LOCKED(dqp));
1224         ASSERT(!completion_done(&dqp->q_flush));
1225
1226         trace_xfs_dqflush(dqp);
1227
1228         *bpp = NULL;
1229
1230         xfs_qm_dqunpin_wait(dqp);
1231
1232         /*
1233          * Get the buffer containing the on-disk dquot
1234          */
1235         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
1236                                    mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK,
1237                                    &bp, &xfs_dquot_buf_ops);
1238         if (error == -EAGAIN)
1239                 goto out_unlock;
1240         if (error)
1241                 goto out_abort;
1242
1243         fa = xfs_qm_dqflush_check(dqp);
1244         if (fa) {
1245                 xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
1246                                 dqp->q_id, fa);
1247                 xfs_buf_relse(bp);
1248                 error = -EFSCORRUPTED;
1249                 goto out_abort;
1250         }
1251
1252         /* Flush the incore dquot to the ondisk buffer. */
1253         dqblk = bp->b_addr + dqp->q_bufoffset;
1254         xfs_dquot_to_disk(&dqblk->dd_diskdq, dqp);
1255
1256         /*
1257          * Clear the dirty field and remember the flush lsn for later use.
1258          */
1259         dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
1260
1261         xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
1262                                         &dqp->q_logitem.qli_item.li_lsn);
1263
1264         /*
1265          * copy the lsn into the on-disk dquot now while we have the in memory
1266          * dquot here. This can't be done later in the write verifier as we
1267          * can't get access to the log item at that point in time.
1268          *
1269          * We also calculate the CRC here so that the on-disk dquot in the
1270          * buffer always has a valid CRC. This ensures there is no possibility
1271          * of a dquot without an up-to-date CRC getting to disk.
1272          */
1273         if (xfs_has_crc(mp)) {
1274                 dqblk->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
1275                 xfs_update_cksum((char *)dqblk, sizeof(struct xfs_dqblk),
1276                                  XFS_DQUOT_CRC_OFF);
1277         }
1278
1279         /*
1280          * Attach the dquot to the buffer so that we can remove this dquot from
1281          * the AIL and release the flush lock once the dquot is synced to disk.
1282          */
1283         bp->b_flags |= _XBF_DQUOTS;
1284         list_add_tail(&dqp->q_logitem.qli_item.li_bio_list, &bp->b_li_list);
1285
1286         /*
1287          * If the buffer is pinned then push on the log so we won't
1288          * get stuck waiting in the write for too long.
1289          */
1290         if (xfs_buf_ispinned(bp)) {
1291                 trace_xfs_dqflush_force(dqp);
1292                 xfs_log_force(mp, 0);
1293         }
1294
1295         trace_xfs_dqflush_done(dqp);
1296         *bpp = bp;
1297         return 0;
1298
1299 out_abort:
1300         dqp->q_flags &= ~XFS_DQFLAG_DIRTY;
1301         xfs_trans_ail_delete(lip, 0);
1302         xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1303 out_unlock:
1304         xfs_dqfunlock(dqp);
1305         return error;
1306 }
1307
1308 /*
1309  * Lock two xfs_dquot structures.
1310  *
1311  * To avoid deadlocks we always lock the quota structure with
1312  * the lowerd id first.
1313  */
1314 void
1315 xfs_dqlock2(
1316         struct xfs_dquot        *d1,
1317         struct xfs_dquot        *d2)
1318 {
1319         if (d1 && d2) {
1320                 ASSERT(d1 != d2);
1321                 if (d1->q_id > d2->q_id) {
1322                         mutex_lock(&d2->q_qlock);
1323                         mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
1324                 } else {
1325                         mutex_lock(&d1->q_qlock);
1326                         mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED);
1327                 }
1328         } else if (d1) {
1329                 mutex_lock(&d1->q_qlock);
1330         } else if (d2) {
1331                 mutex_lock(&d2->q_qlock);
1332         }
1333 }
1334
1335 int __init
1336 xfs_qm_init(void)
1337 {
1338         xfs_dquot_cache = kmem_cache_create("xfs_dquot",
1339                                           sizeof(struct xfs_dquot),
1340                                           0, 0, NULL);
1341         if (!xfs_dquot_cache)
1342                 goto out;
1343
1344         xfs_dqtrx_cache = kmem_cache_create("xfs_dqtrx",
1345                                              sizeof(struct xfs_dquot_acct),
1346                                              0, 0, NULL);
1347         if (!xfs_dqtrx_cache)
1348                 goto out_free_dquot_cache;
1349
1350         return 0;
1351
1352 out_free_dquot_cache:
1353         kmem_cache_destroy(xfs_dquot_cache);
1354 out:
1355         return -ENOMEM;
1356 }
1357
1358 void
1359 xfs_qm_exit(void)
1360 {
1361         kmem_cache_destroy(xfs_dqtrx_cache);
1362         kmem_cache_destroy(xfs_dquot_cache);
1363 }
1364
1365 /*
1366  * Iterate every dquot of a particular type.  The caller must ensure that the
1367  * particular quota type is active.  iter_fn can return negative error codes,
1368  * or -ECANCELED to indicate that it wants to stop iterating.
1369  */
1370 int
1371 xfs_qm_dqiterate(
1372         struct xfs_mount        *mp,
1373         xfs_dqtype_t            type,
1374         xfs_qm_dqiterate_fn     iter_fn,
1375         void                    *priv)
1376 {
1377         struct xfs_dquot        *dq;
1378         xfs_dqid_t              id = 0;
1379         int                     error;
1380
1381         do {
1382                 error = xfs_qm_dqget_next(mp, id, type, &dq);
1383                 if (error == -ENOENT)
1384                         return 0;
1385                 if (error)
1386                         return error;
1387
1388                 error = iter_fn(dq, type, priv);
1389                 id = dq->q_id;
1390                 xfs_qm_dqput(dq);
1391         } while (error == 0 && id != 0);
1392
1393         return error;
1394 }