fs/xfs/xfs_dquot.c

   1 /*
   2  * Copyright (c) 2000-2003 Silicon Graphics, Inc.
   3  * All Rights Reserved.
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation.
   8  *
   9  * This program is distributed in the hope that it would be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write the Free Software Foundation,
  16  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  */
  18 #include "xfs.h"
  19 #include "xfs_fs.h"
  20 #include "xfs_bit.h"
  21 #include "xfs_log.h"
  22 #include "xfs_trans.h"
  23 #include "xfs_sb.h"
  24 #include "xfs_ag.h"
  25 #include "xfs_alloc.h"
  26 #include "xfs_quota.h"
  27 #include "xfs_mount.h"
  28 #include "xfs_bmap_btree.h"
  29 #include "xfs_inode.h"
  30 #include "xfs_bmap.h"
  31 #include "xfs_rtalloc.h"
  32 #include "xfs_error.h"
  33 #include "xfs_itable.h"
  34 #include "xfs_attr.h"
  35 #include "xfs_buf_item.h"
  36 #include "xfs_trans_space.h"
  37 #include "xfs_trans_priv.h"
  38 #include "xfs_qm.h"
  39 #include "xfs_trace.h"
  40
  41 /*
  42  * Lock order:
  43  *
  44  * ip->i_lock
  45  *   qi->qi_tree_lock
  46  *     dquot->q_qlock (xfs_dqlock() and friends)
  47  *       dquot->q_flush (xfs_dqflock() and friends)
  48  *       qi->qi_lru_lock
  49  *
  50  * If two dquots need to be locked the order is user before group/project,
  51  * otherwise by the lowest id first, see xfs_dqlock2.
  52  */
  53
  54 #ifdef DEBUG
  55 xfs_buftarg_t *xfs_dqerror_target;
  56 int xfs_do_dqerror;
  57 int xfs_dqreq_num;
  58 int xfs_dqerror_mod = 33;
  59 #endif
  60
  61 struct kmem_zone                *xfs_qm_dqtrxzone;
  62 static struct kmem_zone         *xfs_qm_dqzone;
  63
  64 static struct lock_class_key xfs_dquot_other_class;
  65
  66 /*
  67  * This is called to free all the memory associated with a dquot
  68  */
  69 void
  70 xfs_qm_dqdestroy(
  71         xfs_dquot_t     *dqp)
  72 {
  73         ASSERT(list_empty(&dqp->q_lru));
  74
  75         mutex_destroy(&dqp->q_qlock);
  76         kmem_zone_free(xfs_qm_dqzone, dqp);
  77
  78         XFS_STATS_DEC(xs_qm_dquot);
  79 }
  80
  81 /*
  82  * If default limits are in force, push them into the dquot now.
  83  * We overwrite the dquot limits only if they are zero and this
  84  * is not the root dquot.
  85  */
  86 void
  87 xfs_qm_adjust_dqlimits(
  88         struct xfs_mount        *mp,
  89         struct xfs_dquot        *dq)
  90 {
  91         struct xfs_quotainfo    *q = mp->m_quotainfo;
  92         struct xfs_disk_dquot   *d = &dq->q_core;
  93         int                     prealloc = 0;
  94
  95         ASSERT(d->d_id);
  96
  97         if (q->qi_bsoftlimit && !d->d_blk_softlimit) {
  98                 d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit);
  99                 prealloc = 1;
 100         }
 101         if (q->qi_bhardlimit && !d->d_blk_hardlimit) {
 102                 d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit);
 103                 prealloc = 1;
 104         }
 105         if (q->qi_isoftlimit && !d->d_ino_softlimit)
 106                 d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit);
 107         if (q->qi_ihardlimit && !d->d_ino_hardlimit)
 108                 d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit);
 109         if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)
 110                 d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit);
 111         if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)
 112                 d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit);
 113
 114         if (prealloc)
 115                 xfs_dquot_set_prealloc_limits(dq);
 116 }
 117
 118 /*
 119  * Check the limits and timers of a dquot and start or reset timers
 120  * if necessary.
 121  * This gets called even when quota enforcement is OFF, which makes our
 122  * life a little less complicated. (We just don't reject any quota
 123  * reservations in that case, when enforcement is off).
 124  * We also return 0 as the values of the timers in Q_GETQUOTA calls, when
 125  * enforcement's off.
 126  * In contrast, warnings are a little different in that they don't
 127  * 'automatically' get started when limits get exceeded.  They do
 128  * get reset to zero, however, when we find the count to be under
 129  * the soft limit (they are only ever set non-zero via userspace).
 130  */
 131 void
 132 xfs_qm_adjust_dqtimers(
 133         xfs_mount_t             *mp,
 134         xfs_disk_dquot_t        *d)
 135 {
 136         ASSERT(d->d_id);
 137
 138 #ifdef DEBUG
 139         if (d->d_blk_hardlimit)
 140                 ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
 141                        be64_to_cpu(d->d_blk_hardlimit));
 142         if (d->d_ino_hardlimit)
 143                 ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
 144                        be64_to_cpu(d->d_ino_hardlimit));
 145         if (d->d_rtb_hardlimit)
 146                 ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
 147                        be64_to_cpu(d->d_rtb_hardlimit));
 148 #endif
 149
 150         if (!d->d_btimer) {
 151                 if ((d->d_blk_softlimit &&
 152                      (be64_to_cpu(d->d_bcount) >
 153                       be64_to_cpu(d->d_blk_softlimit))) ||
 154                     (d->d_blk_hardlimit &&
 155                      (be64_to_cpu(d->d_bcount) >
 156                       be64_to_cpu(d->d_blk_hardlimit)))) {
 157                         d->d_btimer = cpu_to_be32(get_seconds() +
 158                                         mp->m_quotainfo->qi_btimelimit);
 159                 } else {
 160                         d->d_bwarns = 0;
 161                 }
 162         } else {
 163                 if ((!d->d_blk_softlimit ||
 164                      (be64_to_cpu(d->d_bcount) <=
 165                       be64_to_cpu(d->d_blk_softlimit))) &&
 166                     (!d->d_blk_hardlimit ||
 167                     (be64_to_cpu(d->d_bcount) <=
 168                      be64_to_cpu(d->d_blk_hardlimit)))) {
 169                         d->d_btimer = 0;
 170                 }
 171         }
 172
 173         if (!d->d_itimer) {
 174                 if ((d->d_ino_softlimit &&
 175                      (be64_to_cpu(d->d_icount) >
 176                       be64_to_cpu(d->d_ino_softlimit))) ||
 177                     (d->d_ino_hardlimit &&
 178                      (be64_to_cpu(d->d_icount) >
 179                       be64_to_cpu(d->d_ino_hardlimit)))) {
 180                         d->d_itimer = cpu_to_be32(get_seconds() +
 181                                         mp->m_quotainfo->qi_itimelimit);
 182                 } else {
 183                         d->d_iwarns = 0;
 184                 }
 185         } else {
 186                 if ((!d->d_ino_softlimit ||
 187                      (be64_to_cpu(d->d_icount) <=
 188                       be64_to_cpu(d->d_ino_softlimit)))  &&
 189                     (!d->d_ino_hardlimit ||
 190                      (be64_to_cpu(d->d_icount) <=
 191                       be64_to_cpu(d->d_ino_hardlimit)))) {
 192                         d->d_itimer = 0;
 193                 }
 194         }
 195
 196         if (!d->d_rtbtimer) {
 197                 if ((d->d_rtb_softlimit &&
 198                      (be64_to_cpu(d->d_rtbcount) >
 199                       be64_to_cpu(d->d_rtb_softlimit))) ||
 200                     (d->d_rtb_hardlimit &&
 201                      (be64_to_cpu(d->d_rtbcount) >
 202                       be64_to_cpu(d->d_rtb_hardlimit)))) {
 203                         d->d_rtbtimer = cpu_to_be32(get_seconds() +
 204                                         mp->m_quotainfo->qi_rtbtimelimit);
 205                 } else {
 206                         d->d_rtbwarns = 0;
 207                 }
 208         } else {
 209                 if ((!d->d_rtb_softlimit ||
 210                      (be64_to_cpu(d->d_rtbcount) <=
 211                       be64_to_cpu(d->d_rtb_softlimit))) &&
 212                     (!d->d_rtb_hardlimit ||
 213                      (be64_to_cpu(d->d_rtbcount) <=
 214                       be64_to_cpu(d->d_rtb_hardlimit)))) {
 215                         d->d_rtbtimer = 0;
 216                 }
 217         }
 218 }
 219
 220 /*
 221  * initialize a buffer full of dquots and log the whole thing
 222  */
 223 STATIC void
 224 xfs_qm_init_dquot_blk(
 225         xfs_trans_t     *tp,
 226         xfs_mount_t     *mp,
 227         xfs_dqid_t      id,
 228         uint            type,
 229         xfs_buf_t       *bp)
 230 {
 231         struct xfs_quotainfo    *q = mp->m_quotainfo;
 232         xfs_dqblk_t     *d;
 233         int             curid, i;
 234
 235         ASSERT(tp);
 236         ASSERT(xfs_buf_islocked(bp));
 237
 238         d = bp->b_addr;
 239
 240         /*
 241          * ID of the first dquot in the block - id's are zero based.
 242          */
 243         curid = id - (id % q->qi_dqperchunk);
 244         ASSERT(curid >= 0);
 245         memset(d, 0, BBTOB(q->qi_dqchunklen));
 246         for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) {
 247                 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
 248                 d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
 249                 d->dd_diskdq.d_id = cpu_to_be32(curid);
 250                 d->dd_diskdq.d_flags = type;
 251         }
 252
 253         xfs_trans_dquot_buf(tp, bp,
 254                             (type & XFS_DQ_USER ? XFS_BLF_UDQUOT_BUF :
 255                             ((type & XFS_DQ_PROJ) ? XFS_BLF_PDQUOT_BUF :
 256                              XFS_BLF_GDQUOT_BUF)));
 257         xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
 258 }
 259
 260 /*
 261  * Initialize the dynamic speculative preallocation thresholds. The lo/hi
 262  * watermarks correspond to the soft and hard limits by default. If a soft limit
 263  * is not specified, we use 95% of the hard limit.
 264  */
 265 void
 266 xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp)
 267 {
 268         __uint64_t space;
 269
 270         dqp->q_prealloc_hi_wmark = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
 271         dqp->q_prealloc_lo_wmark = be64_to_cpu(dqp->q_core.d_blk_softlimit);
 272         if (!dqp->q_prealloc_lo_wmark) {
 273                 dqp->q_prealloc_lo_wmark = dqp->q_prealloc_hi_wmark;
 274                 do_div(dqp->q_prealloc_lo_wmark, 100);
 275                 dqp->q_prealloc_lo_wmark *= 95;
 276         }
 277
 278         space = dqp->q_prealloc_hi_wmark;
 279
 280         do_div(space, 100);
 281         dqp->q_low_space[XFS_QLOWSP_1_PCNT] = space;
 282         dqp->q_low_space[XFS_QLOWSP_3_PCNT] = space * 3;
 283         dqp->q_low_space[XFS_QLOWSP_5_PCNT] = space * 5;
 284 }
 285
 286 static void
 287 xfs_dquot_buf_verify(
 288         struct xfs_buf          *bp)
 289 {
 290         struct xfs_mount        *mp = bp->b_target->bt_mount;
 291         struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
 292         struct xfs_disk_dquot   *ddq;
 293         xfs_dqid_t              id = 0;
 294         int                     i;
 295
 296         /*
 297          * On the first read of the buffer, verify that each dquot is valid.
 298          * We don't know what the id of the dquot is supposed to be, just that
 299          * they should be increasing monotonically within the buffer. If the
 300          * first id is corrupt, then it will fail on the second dquot in the
 301          * buffer so corruptions could point to the wrong dquot in this case.
 302          */
 303         for (i = 0; i < mp->m_quotainfo->qi_dqperchunk; i++) {
 304                 int     error;
 305
 306                 ddq = &d[i].dd_diskdq;
 307
 308                 if (i == 0)
 309                         id = be32_to_cpu(ddq->d_id);
 310
 311                 error = xfs_qm_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
 312                                         "xfs_dquot_read_verify");
 313                 if (error) {
 314                         XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, d);
 315                         xfs_buf_ioerror(bp, EFSCORRUPTED);
 316                         break;
 317                 }
 318         }
 319 }
 320
 321 static void
 322 xfs_dquot_buf_read_verify(
 323         struct xfs_buf  *bp)
 324 {
 325         xfs_dquot_buf_verify(bp);
 326 }
 327
 328 void
 329 xfs_dquot_buf_write_verify(
 330         struct xfs_buf  *bp)
 331 {
 332         xfs_dquot_buf_verify(bp);
 333 }
 334
 335 const struct xfs_buf_ops xfs_dquot_buf_ops = {
 336         .verify_read = xfs_dquot_buf_read_verify,
 337         .verify_write = xfs_dquot_buf_write_verify,
 338 };
 339
 340 /*
 341  * Allocate a block and fill it with dquots.
 342  * This is called when the bmapi finds a hole.
 343  */
 344 STATIC int
 345 xfs_qm_dqalloc(
 346         xfs_trans_t     **tpp,
 347         xfs_mount_t     *mp,
 348         xfs_dquot_t     *dqp,
 349         xfs_inode_t     *quotip,
 350         xfs_fileoff_t   offset_fsb,
 351         xfs_buf_t       **O_bpp)
 352 {
 353         xfs_fsblock_t   firstblock;
 354         xfs_bmap_free_t flist;
 355         xfs_bmbt_irec_t map;
 356         int             nmaps, error, committed;
 357         xfs_buf_t       *bp;
 358         xfs_trans_t     *tp = *tpp;
 359
 360         ASSERT(tp != NULL);
 361
 362         trace_xfs_dqalloc(dqp);
 363
 364         /*
 365          * Initialize the bmap freelist prior to calling bmapi code.
 366          */
 367         xfs_bmap_init(&flist, &firstblock);
 368         xfs_ilock(quotip, XFS_ILOCK_EXCL);
 369         /*
 370          * Return if this type of quotas is turned off while we didn't
 371          * have an inode lock
 372          */
 373         if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
 374                 xfs_iunlock(quotip, XFS_ILOCK_EXCL);
 375                 return (ESRCH);
 376         }
 377
 378         xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL);
 379         nmaps = 1;
 380         error = xfs_bmapi_write(tp, quotip, offset_fsb,
 381                                 XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA,
 382                                 &firstblock, XFS_QM_DQALLOC_SPACE_RES(mp),
 383                                 &map, &nmaps, &flist);
 384         if (error)
 385                 goto error0;
 386         ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
 387         ASSERT(nmaps == 1);
 388         ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
 389                (map.br_startblock != HOLESTARTBLOCK));
 390
 391         /*
 392          * Keep track of the blkno to save a lookup later
 393          */
 394         dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
 395
 396         /* now we can just get the buffer (there's nothing to read yet) */
 397         bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
 398                                dqp->q_blkno,
 399                                mp->m_quotainfo->qi_dqchunklen,
 400                                0);
 401
 402         error = xfs_buf_geterror(bp);
 403         if (error)
 404                 goto error1;
 405         bp->b_ops = &xfs_dquot_buf_ops;
 406
 407         /*
 408          * Make a chunk of dquots out of this buffer and log
 409          * the entire thing.
 410          */
 411         xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
 412                               dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
 413
 414         /*
 415          * xfs_bmap_finish() may commit the current transaction and
 416          * start a second transaction if the freelist is not empty.
 417          *
 418          * Since we still want to modify this buffer, we need to
 419          * ensure that the buffer is not released on commit of
 420          * the first transaction and ensure the buffer is added to the
 421          * second transaction.
 422          *
 423          * If there is only one transaction then don't stop the buffer
 424          * from being released when it commits later on.
 425          */
 426
 427         xfs_trans_bhold(tp, bp);
 428
 429         if ((error = xfs_bmap_finish(tpp, &flist, &committed))) {
 430                 goto error1;
 431         }
 432
 433         if (committed) {
 434                 tp = *tpp;
 435                 xfs_trans_bjoin(tp, bp);
 436         } else {
 437                 xfs_trans_bhold_release(tp, bp);
 438         }
 439
 440         *O_bpp = bp;
 441         return 0;
 442
 443       error1:
 444         xfs_bmap_cancel(&flist);
 445       error0:
 446         xfs_iunlock(quotip, XFS_ILOCK_EXCL);
 447
 448         return (error);
 449 }
 450 STATIC int
 451 xfs_qm_dqrepair(
 452         struct xfs_mount        *mp,
 453         struct xfs_trans        *tp,
 454         struct xfs_dquot        *dqp,
 455         xfs_dqid_t              firstid,
 456         struct xfs_buf          **bpp)
 457 {
 458         int                     error;
 459         struct xfs_disk_dquot   *ddq;
 460         struct xfs_dqblk        *d;
 461         int                     i;
 462
 463         /*
 464          * Read the buffer without verification so we get the corrupted
 465          * buffer returned to us. make sure we verify it on write, though.
 466          */
 467         error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, dqp->q_blkno,
 468                                    mp->m_quotainfo->qi_dqchunklen,
 469                                    0, bpp, NULL);
 470
 471         if (error) {
 472                 ASSERT(*bpp == NULL);
 473                 return XFS_ERROR(error);
 474         }
 475         (*bpp)->b_ops = &xfs_dquot_buf_ops;
 476
 477         ASSERT(xfs_buf_islocked(*bpp));
 478         d = (struct xfs_dqblk *)(*bpp)->b_addr;
 479
 480         /* Do the actual repair of dquots in this buffer */
 481         for (i = 0; i < mp->m_quotainfo->qi_dqperchunk; i++) {
 482                 ddq = &d[i].dd_diskdq;
 483                 error = xfs_qm_dqcheck(mp, ddq, firstid + i,
 484                                        dqp->dq_flags & XFS_DQ_ALLTYPES,
 485                                        XFS_QMOPT_DQREPAIR, "xfs_qm_dqrepair");
 486                 if (error) {
 487                         /* repair failed, we're screwed */
 488                         xfs_trans_brelse(tp, *bpp);
 489                         return XFS_ERROR(EIO);
 490                 }
 491         }
 492
 493         return 0;
 494 }
 495
 496 /*
 497  * Maps a dquot to the buffer containing its on-disk version.
 498  * This returns a ptr to the buffer containing the on-disk dquot
 499  * in the bpp param, and a ptr to the on-disk dquot within that buffer
 500  */
 501 STATIC int
 502 xfs_qm_dqtobp(
 503         xfs_trans_t             **tpp,
 504         xfs_dquot_t             *dqp,
 505         xfs_disk_dquot_t        **O_ddpp,
 506         xfs_buf_t               **O_bpp,
 507         uint                    flags)
 508 {
 509         xfs_bmbt_irec_t map;
 510         int             nmaps = 1, error;
 511         xfs_buf_t       *bp;
 512         xfs_inode_t     *quotip = XFS_DQ_TO_QIP(dqp);
 513         xfs_mount_t     *mp = dqp->q_mount;
 514         xfs_dqid_t      id = be32_to_cpu(dqp->q_core.d_id);
 515         xfs_trans_t     *tp = (tpp ? *tpp : NULL);
 516
 517         dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;
 518
 519         xfs_ilock(quotip, XFS_ILOCK_SHARED);
 520         if (!xfs_this_quota_on(dqp->q_mount, dqp->dq_flags)) {
 521                 /*
 522                  * Return if this type of quotas is turned off while we
 523                  * didn't have the quota inode lock.
 524                  */
 525                 xfs_iunlock(quotip, XFS_ILOCK_SHARED);
 526                 return ESRCH;
 527         }
 528
 529         /*
 530          * Find the block map; no allocations yet
 531          */
 532         error = xfs_bmapi_read(quotip, dqp->q_fileoffset,
 533                                XFS_DQUOT_CLUSTER_SIZE_FSB, &map, &nmaps, 0);
 534
 535         xfs_iunlock(quotip, XFS_ILOCK_SHARED);
 536         if (error)
 537                 return error;
 538
 539         ASSERT(nmaps == 1);
 540         ASSERT(map.br_blockcount == 1);
 541
 542         /*
 543          * Offset of dquot in the (fixed sized) dquot chunk.
 544          */
 545         dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) *
 546                 sizeof(xfs_dqblk_t);
 547
 548         ASSERT(map.br_startblock != DELAYSTARTBLOCK);
 549         if (map.br_startblock == HOLESTARTBLOCK) {
 550                 /*
 551                  * We don't allocate unless we're asked to
 552                  */
 553                 if (!(flags & XFS_QMOPT_DQALLOC))
 554                         return ENOENT;
 555
 556                 ASSERT(tp);
 557                 error = xfs_qm_dqalloc(tpp, mp, dqp, quotip,
 558                                         dqp->q_fileoffset, &bp);
 559                 if (error)
 560                         return error;
 561                 tp = *tpp;
 562         } else {
 563                 trace_xfs_dqtobp_read(dqp);
 564
 565                 /*
 566                  * store the blkno etc so that we don't have to do the
 567                  * mapping all the time
 568                  */
 569                 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock);
 570
 571                 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
 572                                            dqp->q_blkno,
 573                                            mp->m_quotainfo->qi_dqchunklen,
 574                                            0, &bp, &xfs_dquot_buf_ops);
 575
 576                 if (error == EFSCORRUPTED && (flags & XFS_QMOPT_DQREPAIR)) {
 577                         xfs_dqid_t firstid = (xfs_dqid_t)map.br_startoff *
 578                                                 mp->m_quotainfo->qi_dqperchunk;
 579                         ASSERT(bp == NULL);
 580                         error = xfs_qm_dqrepair(mp, tp, dqp, firstid, &bp);
 581                 }
 582
 583                 if (error) {
 584                         ASSERT(bp == NULL);
 585                         return XFS_ERROR(error);
 586                 }
 587         }
 588
 589         ASSERT(xfs_buf_islocked(bp));
 590         *O_bpp = bp;
 591         *O_ddpp = bp->b_addr + dqp->q_bufoffset;
 592
 593         return (0);
 594 }
 595
 596
 597 /*
 598  * Read in the ondisk dquot using dqtobp() then copy it to an incore version,
 599  * and release the buffer immediately.
 600  *
 601  * If XFS_QMOPT_DQALLOC is set, allocate a dquot on disk if it needed.
 602  */
 603 int
 604 xfs_qm_dqread(
 605         struct xfs_mount        *mp,
 606         xfs_dqid_t              id,
 607         uint                    type,
 608         uint                    flags,
 609         struct xfs_dquot        **O_dqpp)
 610 {
 611         struct xfs_dquot        *dqp;
 612         struct xfs_disk_dquot   *ddqp;
 613         struct xfs_buf          *bp;
 614         struct xfs_trans        *tp = NULL;
 615         int                     error;
 616         int                     cancelflags = 0;
 617
 618
 619         dqp = kmem_zone_zalloc(xfs_qm_dqzone, KM_SLEEP);
 620
 621         dqp->dq_flags = type;
 622         dqp->q_core.d_id = cpu_to_be32(id);
 623         dqp->q_mount = mp;
 624         INIT_LIST_HEAD(&dqp->q_lru);
 625         mutex_init(&dqp->q_qlock);
 626         init_waitqueue_head(&dqp->q_pinwait);
 627
 628         /*
 629          * Because we want to use a counting completion, complete
 630          * the flush completion once to allow a single access to
 631          * the flush completion without blocking.
 632          */
 633         init_completion(&dqp->q_flush);
 634         complete(&dqp->q_flush);
 635
 636         /*
 637          * Make sure group quotas have a different lock class than user
 638          * quotas.
 639          */
 640         if (!(type & XFS_DQ_USER))
 641                 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_other_class);
 642
 643         XFS_STATS_INC(xs_qm_dquot);
 644
 645         trace_xfs_dqread(dqp);
 646
 647         if (flags & XFS_QMOPT_DQALLOC) {
 648                 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC);
 649                 error = xfs_trans_reserve(tp, XFS_QM_DQALLOC_SPACE_RES(mp),
 650                                           XFS_QM_DQALLOC_LOG_RES(mp), 0,
 651                                           XFS_TRANS_PERM_LOG_RES,
 652                                           XFS_WRITE_LOG_COUNT);
 653                 if (error)
 654                         goto error1;
 655                 cancelflags = XFS_TRANS_RELEASE_LOG_RES;
 656         }
 657
 658         /*
 659          * get a pointer to the on-disk dquot and the buffer containing it
 660          * dqp already knows its own type (GROUP/USER).
 661          */
 662         error = xfs_qm_dqtobp(&tp, dqp, &ddqp, &bp, flags);
 663         if (error) {
 664                 /*
 665                  * This can happen if quotas got turned off (ESRCH),
 666                  * or if the dquot didn't exist on disk and we ask to
 667                  * allocate (ENOENT).
 668                  */
 669                 trace_xfs_dqread_fail(dqp);
 670                 cancelflags |= XFS_TRANS_ABORT;
 671                 goto error1;
 672         }
 673
 674         /* copy everything from disk dquot to the incore dquot */
 675         memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
 676         xfs_qm_dquot_logitem_init(dqp);
 677
 678         /*
 679          * Reservation counters are defined as reservation plus current usage
 680          * to avoid having to add every time.
 681          */
 682         dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
 683         dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
 684         dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
 685
 686         /* initialize the dquot speculative prealloc thresholds */
 687         xfs_dquot_set_prealloc_limits(dqp);
 688
 689         /* Mark the buf so that this will stay incore a little longer */
 690         xfs_buf_set_ref(bp, XFS_DQUOT_REF);
 691
 692         /*
 693          * We got the buffer with a xfs_trans_read_buf() (in dqtobp())
 694          * So we need to release with xfs_trans_brelse().
 695          * The strategy here is identical to that of inodes; we lock
 696          * the dquot in xfs_qm_dqget() before making it accessible to
 697          * others. This is because dquots, like inodes, need a good level of
 698          * concurrency, and we don't want to take locks on the entire buffers
 699          * for dquot accesses.
 700          * Note also that the dquot buffer may even be dirty at this point, if
 701          * this particular dquot was repaired. We still aren't afraid to
 702          * brelse it because we have the changes incore.
 703          */
 704         ASSERT(xfs_buf_islocked(bp));
 705         xfs_trans_brelse(tp, bp);
 706
 707         if (tp) {
 708                 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
 709                 if (error)
 710                         goto error0;
 711         }
 712
 713         *O_dqpp = dqp;
 714         return error;
 715
 716 error1:
 717         if (tp)
 718                 xfs_trans_cancel(tp, cancelflags);
 719 error0:
 720         xfs_qm_dqdestroy(dqp);
 721         *O_dqpp = NULL;
 722         return error;
 723 }
 724
 725 /*
 726  * Given the file system, inode OR id, and type (UDQUOT/GDQUOT), return a
 727  * a locked dquot, doing an allocation (if requested) as needed.
 728  * When both an inode and an id are given, the inode's id takes precedence.
 729  * That is, if the id changes while we don't hold the ilock inside this
 730  * function, the new dquot is returned, not necessarily the one requested
 731  * in the id argument.
 732  */
 733 int
 734 xfs_qm_dqget(
 735         xfs_mount_t     *mp,
 736         xfs_inode_t     *ip,      /* locked inode (optional) */
 737         xfs_dqid_t      id,       /* uid/projid/gid depending on type */
 738         uint            type,     /* XFS_DQ_USER/XFS_DQ_PROJ/XFS_DQ_GROUP */
 739         uint            flags,    /* DQALLOC, DQSUSER, DQREPAIR, DOWARN */
 740         xfs_dquot_t     **O_dqpp) /* OUT : locked incore dquot */
 741 {
 742         struct xfs_quotainfo    *qi = mp->m_quotainfo;
 743         struct radix_tree_root *tree = XFS_DQUOT_TREE(qi, type);
 744         struct xfs_dquot        *dqp;
 745         int                     error;
 746
 747         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 748         if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) ||
 749             (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) ||
 750             (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) {
 751                 return (ESRCH);
 752         }
 753
 754 #ifdef DEBUG
 755         if (xfs_do_dqerror) {
 756                 if ((xfs_dqerror_target == mp->m_ddev_targp) &&
 757                     (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) {
 758                         xfs_debug(mp, "Returning error in dqget");
 759                         return (EIO);
 760                 }
 761         }
 762
 763         ASSERT(type == XFS_DQ_USER ||
 764                type == XFS_DQ_PROJ ||
 765                type == XFS_DQ_GROUP);
 766         if (ip) {
 767                 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 768                 ASSERT(xfs_inode_dquot(ip, type) == NULL);
 769         }
 770 #endif
 771
 772 restart:
 773         mutex_lock(&qi->qi_tree_lock);
 774         dqp = radix_tree_lookup(tree, id);
 775         if (dqp) {
 776                 xfs_dqlock(dqp);
 777                 if (dqp->dq_flags & XFS_DQ_FREEING) {
 778                         xfs_dqunlock(dqp);
 779                         mutex_unlock(&qi->qi_tree_lock);
 780                         trace_xfs_dqget_freeing(dqp);
 781                         delay(1);
 782                         goto restart;
 783                 }
 784
 785                 dqp->q_nrefs++;
 786                 mutex_unlock(&qi->qi_tree_lock);
 787
 788                 trace_xfs_dqget_hit(dqp);
 789                 XFS_STATS_INC(xs_qm_dqcachehits);
 790                 *O_dqpp = dqp;
 791                 return 0;
 792         }
 793         mutex_unlock(&qi->qi_tree_lock);
 794         XFS_STATS_INC(xs_qm_dqcachemisses);
 795
 796         /*
 797          * Dquot cache miss. We don't want to keep the inode lock across
 798          * a (potential) disk read. Also we don't want to deal with the lock
 799          * ordering between quotainode and this inode. OTOH, dropping the inode
 800          * lock here means dealing with a chown that can happen before
 801          * we re-acquire the lock.
 802          */
 803         if (ip)
 804                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
 805
 806         error = xfs_qm_dqread(mp, id, type, flags, &dqp);
 807
 808         if (ip)
 809                 xfs_ilock(ip, XFS_ILOCK_EXCL);
 810
 811         if (error)
 812                 return error;
 813
 814         if (ip) {
 815                 /*
 816                  * A dquot could be attached to this inode by now, since
 817                  * we had dropped the ilock.
 818                  */
 819                 if (xfs_this_quota_on(mp, type)) {
 820                         struct xfs_dquot        *dqp1;
 821
 822                         dqp1 = xfs_inode_dquot(ip, type);
 823                         if (dqp1) {
 824                                 xfs_qm_dqdestroy(dqp);
 825                                 dqp = dqp1;
 826                                 xfs_dqlock(dqp);
 827                                 goto dqret;
 828                         }
 829                 } else {
 830                         /* inode stays locked on return */
 831                         xfs_qm_dqdestroy(dqp);
 832                         return XFS_ERROR(ESRCH);
 833                 }
 834         }
 835
 836         mutex_lock(&qi->qi_tree_lock);
 837         error = -radix_tree_insert(tree, id, dqp);
 838         if (unlikely(error)) {
 839                 WARN_ON(error != EEXIST);
 840
 841                 /*
 842                  * Duplicate found. Just throw away the new dquot and start
 843                  * over.
 844                  */
 845                 mutex_unlock(&qi->qi_tree_lock);
 846                 trace_xfs_dqget_dup(dqp);
 847                 xfs_qm_dqdestroy(dqp);
 848                 XFS_STATS_INC(xs_qm_dquot_dups);
 849                 goto restart;
 850         }
 851
 852         /*
 853          * We return a locked dquot to the caller, with a reference taken
 854          */
 855         xfs_dqlock(dqp);
 856         dqp->q_nrefs = 1;
 857
 858         qi->qi_dquots++;
 859         mutex_unlock(&qi->qi_tree_lock);
 860
 861  dqret:
 862         ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL));
 863         trace_xfs_dqget_miss(dqp);
 864         *O_dqpp = dqp;
 865         return (0);
 866 }
 867
 868
 869 STATIC void
 870 xfs_qm_dqput_final(
 871         struct xfs_dquot        *dqp)
 872 {
 873         struct xfs_quotainfo    *qi = dqp->q_mount->m_quotainfo;
 874         struct xfs_dquot        *gdqp;
 875
 876         trace_xfs_dqput_free(dqp);
 877
 878         mutex_lock(&qi->qi_lru_lock);
 879         if (list_empty(&dqp->q_lru)) {
 880                 list_add_tail(&dqp->q_lru, &qi->qi_lru_list);
 881                 qi->qi_lru_count++;
 882                 XFS_STATS_INC(xs_qm_dquot_unused);
 883         }
 884         mutex_unlock(&qi->qi_lru_lock);
 885
 886         /*
 887          * If we just added a udquot to the freelist, then we want to release
 888          * the gdquot reference that it (probably) has. Otherwise it'll keep
 889          * the gdquot from getting reclaimed.
 890          */
 891         gdqp = dqp->q_gdquot;
 892         if (gdqp) {
 893                 xfs_dqlock(gdqp);
 894                 dqp->q_gdquot = NULL;
 895         }
 896         xfs_dqunlock(dqp);
 897
 898         /*
 899          * If we had a group quota hint, release it now.
 900          */
 901         if (gdqp)
 902                 xfs_qm_dqput(gdqp);
 903 }
 904
 905 /*
 906  * Release a reference to the dquot (decrement ref-count) and unlock it.
 907  *
 908  * If there is a group quota attached to this dquot, carefully release that
 909  * too without tripping over deadlocks'n'stuff.
 910  */
 911 void
 912 xfs_qm_dqput(
 913         struct xfs_dquot        *dqp)
 914 {
 915         ASSERT(dqp->q_nrefs > 0);
 916         ASSERT(XFS_DQ_IS_LOCKED(dqp));
 917
 918         trace_xfs_dqput(dqp);
 919
 920         if (--dqp->q_nrefs > 0)
 921                 xfs_dqunlock(dqp);
 922         else
 923                 xfs_qm_dqput_final(dqp);
 924 }
 925
 926 /*
 927  * Release a dquot. Flush it if dirty, then dqput() it.
 928  * dquot must not be locked.
 929  */
 930 void
 931 xfs_qm_dqrele(
 932         xfs_dquot_t     *dqp)
 933 {
 934         if (!dqp)
 935                 return;
 936
 937         trace_xfs_dqrele(dqp);
 938
 939         xfs_dqlock(dqp);
 940         /*
 941          * We don't care to flush it if the dquot is dirty here.
 942          * That will create stutters that we want to avoid.
 943          * Instead we do a delayed write when we try to reclaim
 944          * a dirty dquot. Also xfs_sync will take part of the burden...
 945          */
 946         xfs_qm_dqput(dqp);
 947 }
 948
 949 /*
 950  * This is the dquot flushing I/O completion routine.  It is called
 951  * from interrupt level when the buffer containing the dquot is
 952  * flushed to disk.  It is responsible for removing the dquot logitem
 953  * from the AIL if it has not been re-logged, and unlocking the dquot's
 954  * flush lock. This behavior is very similar to that of inodes..
 955  */
 956 STATIC void
 957 xfs_qm_dqflush_done(
 958         struct xfs_buf          *bp,
 959         struct xfs_log_item     *lip)
 960 {
 961         xfs_dq_logitem_t        *qip = (struct xfs_dq_logitem *)lip;
 962         xfs_dquot_t             *dqp = qip->qli_dquot;
 963         struct xfs_ail          *ailp = lip->li_ailp;
 964
 965         /*
 966          * We only want to pull the item from the AIL if its
 967          * location in the log has not changed since we started the flush.
 968          * Thus, we only bother if the dquot's lsn has
 969          * not changed. First we check the lsn outside the lock
 970          * since it's cheaper, and then we recheck while
 971          * holding the lock before removing the dquot from the AIL.
 972          */
 973         if ((lip->li_flags & XFS_LI_IN_AIL) &&
 974             lip->li_lsn == qip->qli_flush_lsn) {
 975
 976                 /* xfs_trans_ail_delete() drops the AIL lock. */
 977                 spin_lock(&ailp->xa_lock);
 978                 if (lip->li_lsn == qip->qli_flush_lsn)
 979                         xfs_trans_ail_delete(ailp, lip, SHUTDOWN_CORRUPT_INCORE);
 980                 else
 981                         spin_unlock(&ailp->xa_lock);
 982         }
 983
 984         /*
 985          * Release the dq's flush lock since we're done with it.
 986          */
 987         xfs_dqfunlock(dqp);
 988 }
 989
 990 /*
 991  * Write a modified dquot to disk.
 992  * The dquot must be locked and the flush lock too taken by caller.
 993  * The flush lock will not be unlocked until the dquot reaches the disk,
 994  * but the dquot is free to be unlocked and modified by the caller
 995  * in the interim. Dquot is still locked on return. This behavior is
 996  * identical to that of inodes.
 997  */
 998 int
 999 xfs_qm_dqflush(
1000         struct xfs_dquot        *dqp,
1001         struct xfs_buf          **bpp)
1002 {
1003         struct xfs_mount        *mp = dqp->q_mount;
1004         struct xfs_buf          *bp;
1005         struct xfs_disk_dquot   *ddqp;
1006         int                     error;
1007
1008         ASSERT(XFS_DQ_IS_LOCKED(dqp));
1009         ASSERT(!completion_done(&dqp->q_flush));
1010
1011         trace_xfs_dqflush(dqp);
1012
1013         *bpp = NULL;
1014
1015         xfs_qm_dqunpin_wait(dqp);
1016
1017         /*
1018          * This may have been unpinned because the filesystem is shutting
1019          * down forcibly. If that's the case we must not write this dquot
1020          * to disk, because the log record didn't make it to disk.
1021          *
1022          * We also have to remove the log item from the AIL in this case,
1023          * as we wait for an emptry AIL as part of the unmount process.
1024          */
1025         if (XFS_FORCED_SHUTDOWN(mp)) {
1026                 struct xfs_log_item     *lip = &dqp->q_logitem.qli_item;
1027                 dqp->dq_flags &= ~XFS_DQ_DIRTY;
1028
1029                 spin_lock(&mp->m_ail->xa_lock);
1030                 if (lip->li_flags & XFS_LI_IN_AIL)
1031                         xfs_trans_ail_delete(mp->m_ail, lip,
1032                                              SHUTDOWN_CORRUPT_INCORE);
1033                 else
1034                         spin_unlock(&mp->m_ail->xa_lock);
1035                 error = XFS_ERROR(EIO);
1036                 goto out_unlock;
1037         }
1038
1039         /*
1040          * Get the buffer containing the on-disk dquot
1041          */
1042         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
1043                                    mp->m_quotainfo->qi_dqchunklen, 0, &bp, NULL);
1044         if (error)
1045                 goto out_unlock;
1046
1047         /*
1048          * Calculate the location of the dquot inside the buffer.
1049          */
1050         ddqp = bp->b_addr + dqp->q_bufoffset;
1051
1052         /*
1053          * A simple sanity check in case we got a corrupted dquot..
1054          */
1055         error = xfs_qm_dqcheck(mp, &dqp->q_core, be32_to_cpu(ddqp->d_id), 0,
1056                            XFS_QMOPT_DOWARN, "dqflush (incore copy)");
1057         if (error) {
1058                 xfs_buf_relse(bp);
1059                 xfs_dqfunlock(dqp);
1060                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
1061                 return XFS_ERROR(EIO);
1062         }
1063
1064         /* This is the only portion of data that needs to persist */
1065         memcpy(ddqp, &dqp->q_core, sizeof(xfs_disk_dquot_t));
1066
1067         /*
1068          * Clear the dirty field and remember the flush lsn for later use.
1069          */
1070         dqp->dq_flags &= ~XFS_DQ_DIRTY;
1071
1072         xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn,
1073                                         &dqp->q_logitem.qli_item.li_lsn);
1074
1075         /*
1076          * Attach an iodone routine so that we can remove this dquot from the
1077          * AIL and release the flush lock once the dquot is synced to disk.
1078          */
1079         xfs_buf_attach_iodone(bp, xfs_qm_dqflush_done,
1080                                   &dqp->q_logitem.qli_item);
1081
1082         /*
1083          * If the buffer is pinned then push on the log so we won't
1084          * get stuck waiting in the write for too long.
1085          */
1086         if (xfs_buf_ispinned(bp)) {
1087                 trace_xfs_dqflush_force(dqp);
1088                 xfs_log_force(mp, 0);
1089         }
1090
1091         trace_xfs_dqflush_done(dqp);
1092         *bpp = bp;
1093         return 0;
1094
1095 out_unlock:
1096         xfs_dqfunlock(dqp);
1097         return XFS_ERROR(EIO);
1098 }
1099
1100 /*
1101  * Lock two xfs_dquot structures.
1102  *
1103  * To avoid deadlocks we always lock the quota structure with
1104  * the lowerd id first.
1105  */
1106 void
1107 xfs_dqlock2(
1108         xfs_dquot_t     *d1,
1109         xfs_dquot_t     *d2)
1110 {
1111         if (d1 && d2) {
1112                 ASSERT(d1 != d2);
1113                 if (be32_to_cpu(d1->q_core.d_id) >
1114                     be32_to_cpu(d2->q_core.d_id)) {
1115                         mutex_lock(&d2->q_qlock);
1116                         mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED);
1117                 } else {
1118                         mutex_lock(&d1->q_qlock);
1119                         mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED);
1120                 }
1121         } else if (d1) {
1122                 mutex_lock(&d1->q_qlock);
1123         } else if (d2) {
1124                 mutex_lock(&d2->q_qlock);
1125         }
1126 }
1127
1128 int __init
1129 xfs_qm_init(void)
1130 {
1131         xfs_qm_dqzone =
1132                 kmem_zone_init(sizeof(struct xfs_dquot), "xfs_dquot");
1133         if (!xfs_qm_dqzone)
1134                 goto out;
1135
1136         xfs_qm_dqtrxzone =
1137                 kmem_zone_init(sizeof(struct xfs_dquot_acct), "xfs_dqtrx");
1138         if (!xfs_qm_dqtrxzone)
1139                 goto out_free_dqzone;
1140
1141         return 0;
1142
1143 out_free_dqzone:
1144         kmem_zone_destroy(xfs_qm_dqzone);
1145 out:
1146         return -ENOMEM;
1147 }
1148
1149 void
1150 xfs_qm_exit(void)
1151 {
1152         kmem_zone_destroy(xfs_qm_dqtrxzone);
1153         kmem_zone_destroy(xfs_qm_dqzone);
1154 }