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