fs/xfs/xfs_qm.c

   1 /*
   2  * Copyright (c) 2000-2005 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_format.h"
  21 #include "xfs_bit.h"
  22 #include "xfs_log.h"
  23 #include "xfs_trans.h"
  24 #include "xfs_sb.h"
  25 #include "xfs_ag.h"
  26 #include "xfs_alloc.h"
  27 #include "xfs_quota.h"
  28 #include "xfs_mount.h"
  29 #include "xfs_bmap_btree.h"
  30 #include "xfs_ialloc_btree.h"
  31 #include "xfs_dinode.h"
  32 #include "xfs_inode.h"
  33 #include "xfs_ialloc.h"
  34 #include "xfs_itable.h"
  35 #include "xfs_rtalloc.h"
  36 #include "xfs_error.h"
  37 #include "xfs_bmap.h"
  38 #include "xfs_attr.h"
  39 #include "xfs_buf_item.h"
  40 #include "xfs_trans_space.h"
  41 #include "xfs_utils.h"
  42 #include "xfs_qm.h"
  43 #include "xfs_trace.h"
  44 #include "xfs_icache.h"
  45 #include "xfs_cksum.h"
  46
  47 /*
  48  * The global quota manager. There is only one of these for the entire
  49  * system, _not_ one per file system. XQM keeps track of the overall
  50  * quota functionality, including maintaining the freelist and hash
  51  * tables of dquots.
  52  */
  53 STATIC int      xfs_qm_init_quotainos(xfs_mount_t *);
  54 STATIC int      xfs_qm_init_quotainfo(xfs_mount_t *);
  55 STATIC int      xfs_qm_shake(struct shrinker *, struct shrink_control *);
  56
  57 /*
  58  * We use the batch lookup interface to iterate over the dquots as it
  59  * currently is the only interface into the radix tree code that allows
  60  * fuzzy lookups instead of exact matches.  Holding the lock over multiple
  61  * operations is fine as all callers are used either during mount/umount
  62  * or quotaoff.
  63  */
  64 #define XFS_DQ_LOOKUP_BATCH     32
  65
  66 STATIC int
  67 xfs_qm_dquot_walk(
  68         struct xfs_mount        *mp,
  69         int                     type,
  70         int                     (*execute)(struct xfs_dquot *dqp, void *data),
  71         void                    *data)
  72 {
  73         struct xfs_quotainfo    *qi = mp->m_quotainfo;
  74         struct radix_tree_root  *tree = xfs_dquot_tree(qi, type);
  75         uint32_t                next_index;
  76         int                     last_error = 0;
  77         int                     skipped;
  78         int                     nr_found;
  79
  80 restart:
  81         skipped = 0;
  82         next_index = 0;
  83         nr_found = 0;
  84
  85         while (1) {
  86                 struct xfs_dquot *batch[XFS_DQ_LOOKUP_BATCH];
  87                 int             error = 0;
  88                 int             i;
  89
  90                 mutex_lock(&qi->qi_tree_lock);
  91                 nr_found = radix_tree_gang_lookup(tree, (void **)batch,
  92                                         next_index, XFS_DQ_LOOKUP_BATCH);
  93                 if (!nr_found) {
  94                         mutex_unlock(&qi->qi_tree_lock);
  95                         break;
  96                 }
  97
  98                 for (i = 0; i < nr_found; i++) {
  99                         struct xfs_dquot *dqp = batch[i];
 100
 101                         next_index = be32_to_cpu(dqp->q_core.d_id) + 1;
 102
 103                         error = execute(batch[i], data);
 104                         if (error == EAGAIN) {
 105                                 skipped++;
 106                                 continue;
 107                         }
 108                         if (error && last_error != EFSCORRUPTED)
 109                                 last_error = error;
 110                 }
 111
 112                 mutex_unlock(&qi->qi_tree_lock);
 113
 114                 /* bail out if the filesystem is corrupted.  */
 115                 if (last_error == EFSCORRUPTED) {
 116                         skipped = 0;
 117                         break;
 118                 }
 119         }
 120
 121         if (skipped) {
 122                 delay(1);
 123                 goto restart;
 124         }
 125
 126         return last_error;
 127 }
 128
 129
 130 /*
 131  * Purge a dquot from all tracking data structures and free it.
 132  */
 133 STATIC int
 134 xfs_qm_dqpurge(
 135         struct xfs_dquot        *dqp,
 136         void                    *data)
 137 {
 138         struct xfs_mount        *mp = dqp->q_mount;
 139         struct xfs_quotainfo    *qi = mp->m_quotainfo;
 140         struct xfs_dquot        *gdqp = NULL;
 141         struct xfs_dquot        *pdqp = NULL;
 142
 143         xfs_dqlock(dqp);
 144         if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0) {
 145                 xfs_dqunlock(dqp);
 146                 return EAGAIN;
 147         }
 148
 149         /*
 150          * If this quota has a hint attached, prepare for releasing it now.
 151          */
 152         gdqp = dqp->q_gdquot;
 153         if (gdqp) {
 154                 xfs_dqlock(gdqp);
 155                 dqp->q_gdquot = NULL;
 156         }
 157
 158         pdqp = dqp->q_pdquot;
 159         if (pdqp) {
 160                 xfs_dqlock(pdqp);
 161                 dqp->q_pdquot = NULL;
 162         }
 163
 164         dqp->dq_flags |= XFS_DQ_FREEING;
 165
 166         xfs_dqflock(dqp);
 167
 168         /*
 169          * If we are turning this type of quotas off, we don't care
 170          * about the dirty metadata sitting in this dquot. OTOH, if
 171          * we're unmounting, we do care, so we flush it and wait.
 172          */
 173         if (XFS_DQ_IS_DIRTY(dqp)) {
 174                 struct xfs_buf  *bp = NULL;
 175                 int             error;
 176
 177                 /*
 178                  * We don't care about getting disk errors here. We need
 179                  * to purge this dquot anyway, so we go ahead regardless.
 180                  */
 181                 error = xfs_qm_dqflush(dqp, &bp);
 182                 if (error) {
 183                         xfs_warn(mp, "%s: dquot %p flush failed",
 184                                 __func__, dqp);
 185                 } else {
 186                         error = xfs_bwrite(bp);
 187                         xfs_buf_relse(bp);
 188                 }
 189                 xfs_dqflock(dqp);
 190         }
 191
 192         ASSERT(atomic_read(&dqp->q_pincount) == 0);
 193         ASSERT(XFS_FORCED_SHUTDOWN(mp) ||
 194                !(dqp->q_logitem.qli_item.li_flags & XFS_LI_IN_AIL));
 195
 196         xfs_dqfunlock(dqp);
 197         xfs_dqunlock(dqp);
 198
 199         radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
 200                           be32_to_cpu(dqp->q_core.d_id));
 201         qi->qi_dquots--;
 202
 203         /*
 204          * We move dquots to the freelist as soon as their reference count
 205          * hits zero, so it really should be on the freelist here.
 206          */
 207         mutex_lock(&qi->qi_lru_lock);
 208         ASSERT(!list_empty(&dqp->q_lru));
 209         list_del_init(&dqp->q_lru);
 210         qi->qi_lru_count--;
 211         XFS_STATS_DEC(xs_qm_dquot_unused);
 212         mutex_unlock(&qi->qi_lru_lock);
 213
 214         xfs_qm_dqdestroy(dqp);
 215
 216         if (gdqp)
 217                 xfs_qm_dqput(gdqp);
 218         if (pdqp)
 219                 xfs_qm_dqput(pdqp);
 220         return 0;
 221 }
 222
 223 /*
 224  * Purge the dquot cache.
 225  */
 226 void
 227 xfs_qm_dqpurge_all(
 228         struct xfs_mount        *mp,
 229         uint                    flags)
 230 {
 231         if (flags & XFS_QMOPT_UQUOTA)
 232                 xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
 233         if (flags & XFS_QMOPT_GQUOTA)
 234                 xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
 235         if (flags & XFS_QMOPT_PQUOTA)
 236                 xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL);
 237 }
 238
 239 /*
 240  * Just destroy the quotainfo structure.
 241  */
 242 void
 243 xfs_qm_unmount(
 244         struct xfs_mount        *mp)
 245 {
 246         if (mp->m_quotainfo) {
 247                 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
 248                 xfs_qm_destroy_quotainfo(mp);
 249         }
 250 }
 251
 252
 253 /*
 254  * This is called from xfs_mountfs to start quotas and initialize all
 255  * necessary data structures like quotainfo.  This is also responsible for
 256  * running a quotacheck as necessary.  We are guaranteed that the superblock
 257  * is consistently read in at this point.
 258  *
 259  * If we fail here, the mount will continue with quota turned off. We don't
 260  * need to inidicate success or failure at all.
 261  */
 262 void
 263 xfs_qm_mount_quotas(
 264         xfs_mount_t     *mp)
 265 {
 266         int             error = 0;
 267         uint            sbf;
 268
 269         /*
 270          * If quotas on realtime volumes is not supported, we disable
 271          * quotas immediately.
 272          */
 273         if (mp->m_sb.sb_rextents) {
 274                 xfs_notice(mp, "Cannot turn on quotas for realtime filesystem");
 275                 mp->m_qflags = 0;
 276                 goto write_changes;
 277         }
 278
 279         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 280
 281         /*
 282          * Allocate the quotainfo structure inside the mount struct, and
 283          * create quotainode(s), and change/rev superblock if necessary.
 284          */
 285         error = xfs_qm_init_quotainfo(mp);
 286         if (error) {
 287                 /*
 288                  * We must turn off quotas.
 289                  */
 290                 ASSERT(mp->m_quotainfo == NULL);
 291                 mp->m_qflags = 0;
 292                 goto write_changes;
 293         }
 294         /*
 295          * If any of the quotas are not consistent, do a quotacheck.
 296          */
 297         if (XFS_QM_NEED_QUOTACHECK(mp)) {
 298                 error = xfs_qm_quotacheck(mp);
 299                 if (error) {
 300                         /* Quotacheck failed and disabled quotas. */
 301                         return;
 302                 }
 303         }
 304         /*
 305          * If one type of quotas is off, then it will lose its
 306          * quotachecked status, since we won't be doing accounting for
 307          * that type anymore.
 308          */
 309         if (!XFS_IS_UQUOTA_ON(mp))
 310                 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
 311         if (!XFS_IS_GQUOTA_ON(mp))
 312                 mp->m_qflags &= ~XFS_GQUOTA_CHKD;
 313         if (!XFS_IS_PQUOTA_ON(mp))
 314                 mp->m_qflags &= ~XFS_PQUOTA_CHKD;
 315
 316  write_changes:
 317         /*
 318          * We actually don't have to acquire the m_sb_lock at all.
 319          * This can only be called from mount, and that's single threaded. XXX
 320          */
 321         spin_lock(&mp->m_sb_lock);
 322         sbf = mp->m_sb.sb_qflags;
 323         mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
 324         spin_unlock(&mp->m_sb_lock);
 325
 326         if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
 327                 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
 328                         /*
 329                          * We could only have been turning quotas off.
 330                          * We aren't in very good shape actually because
 331                          * the incore structures are convinced that quotas are
 332                          * off, but the on disk superblock doesn't know that !
 333                          */
 334                         ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
 335                         xfs_alert(mp, "%s: Superblock update failed!",
 336                                 __func__);
 337                 }
 338         }
 339
 340         if (error) {
 341                 xfs_warn(mp, "Failed to initialize disk quotas.");
 342                 return;
 343         }
 344 }
 345
 346 /*
 347  * Called from the vfsops layer.
 348  */
 349 void
 350 xfs_qm_unmount_quotas(
 351         xfs_mount_t     *mp)
 352 {
 353         /*
 354          * Release the dquots that root inode, et al might be holding,
 355          * before we flush quotas and blow away the quotainfo structure.
 356          */
 357         ASSERT(mp->m_rootip);
 358         xfs_qm_dqdetach(mp->m_rootip);
 359         if (mp->m_rbmip)
 360                 xfs_qm_dqdetach(mp->m_rbmip);
 361         if (mp->m_rsumip)
 362                 xfs_qm_dqdetach(mp->m_rsumip);
 363
 364         /*
 365          * Release the quota inodes.
 366          */
 367         if (mp->m_quotainfo) {
 368                 if (mp->m_quotainfo->qi_uquotaip) {
 369                         IRELE(mp->m_quotainfo->qi_uquotaip);
 370                         mp->m_quotainfo->qi_uquotaip = NULL;
 371                 }
 372                 if (mp->m_quotainfo->qi_gquotaip) {
 373                         IRELE(mp->m_quotainfo->qi_gquotaip);
 374                         mp->m_quotainfo->qi_gquotaip = NULL;
 375                 }
 376                 if (mp->m_quotainfo->qi_pquotaip) {
 377                         IRELE(mp->m_quotainfo->qi_pquotaip);
 378                         mp->m_quotainfo->qi_pquotaip = NULL;
 379                 }
 380         }
 381 }
 382
 383 STATIC int
 384 xfs_qm_dqattach_one(
 385         xfs_inode_t     *ip,
 386         xfs_dqid_t      id,
 387         uint            type,
 388         uint            doalloc,
 389         xfs_dquot_t     *udqhint, /* hint */
 390         xfs_dquot_t     **IO_idqpp)
 391 {
 392         xfs_dquot_t     *dqp;
 393         int             error;
 394
 395         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 396         error = 0;
 397
 398         /*
 399          * See if we already have it in the inode itself. IO_idqpp is
 400          * &i_udquot or &i_gdquot. This made the code look weird, but
 401          * made the logic a lot simpler.
 402          */
 403         dqp = *IO_idqpp;
 404         if (dqp) {
 405                 trace_xfs_dqattach_found(dqp);
 406                 return 0;
 407         }
 408
 409         /*
 410          * udqhint is the i_udquot field in inode, and is non-NULL only
 411          * when the type arg is group/project. Its purpose is to save a
 412          * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
 413          * the user dquot.
 414          */
 415         if (udqhint) {
 416                 ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
 417                 xfs_dqlock(udqhint);
 418
 419                 /*
 420                  * No need to take dqlock to look at the id.
 421                  *
 422                  * The ID can't change until it gets reclaimed, and it won't
 423                  * be reclaimed as long as we have a ref from inode and we
 424                  * hold the ilock.
 425                  */
 426                 if (type == XFS_DQ_GROUP)
 427                         dqp = udqhint->q_gdquot;
 428                 else
 429                         dqp = udqhint->q_pdquot;
 430                 if (dqp && be32_to_cpu(dqp->q_core.d_id) == id) {
 431                         ASSERT(*IO_idqpp == NULL);
 432
 433                         *IO_idqpp = xfs_qm_dqhold(dqp);
 434                         xfs_dqunlock(udqhint);
 435                         return 0;
 436                 }
 437
 438                 /*
 439                  * We can't hold a dquot lock when we call the dqget code.
 440                  * We'll deadlock in no time, because of (not conforming to)
 441                  * lock ordering - the inodelock comes before any dquot lock,
 442                  * and we may drop and reacquire the ilock in xfs_qm_dqget().
 443                  */
 444                 xfs_dqunlock(udqhint);
 445         }
 446
 447         /*
 448          * Find the dquot from somewhere. This bumps the
 449          * reference count of dquot and returns it locked.
 450          * This can return ENOENT if dquot didn't exist on
 451          * disk and we didn't ask it to allocate;
 452          * ESRCH if quotas got turned off suddenly.
 453          */
 454         error = xfs_qm_dqget(ip->i_mount, ip, id, type,
 455                              doalloc | XFS_QMOPT_DOWARN, &dqp);
 456         if (error)
 457                 return error;
 458
 459         trace_xfs_dqattach_get(dqp);
 460
 461         /*
 462          * dqget may have dropped and re-acquired the ilock, but it guarantees
 463          * that the dquot returned is the one that should go in the inode.
 464          */
 465         *IO_idqpp = dqp;
 466         xfs_dqunlock(dqp);
 467         return 0;
 468 }
 469
 470
 471 /*
 472  * Given a udquot and group/project type, attach the group/project
 473  * dquot pointer to the udquot as a hint for future lookups.
 474  */
 475 STATIC void
 476 xfs_qm_dqattach_hint(
 477         struct xfs_inode        *ip,
 478         int                     type)
 479 {
 480         struct xfs_dquot **dqhintp;
 481         struct xfs_dquot *dqp;
 482         struct xfs_dquot *udq = ip->i_udquot;
 483
 484         ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
 485
 486         xfs_dqlock(udq);
 487
 488         if (type == XFS_DQ_GROUP) {
 489                 dqp = ip->i_gdquot;
 490                 dqhintp = &udq->q_gdquot;
 491         } else {
 492                 dqp = ip->i_pdquot;
 493                 dqhintp = &udq->q_pdquot;
 494         }
 495
 496         if (*dqhintp) {
 497                 struct xfs_dquot *tmp;
 498
 499                 if (*dqhintp == dqp)
 500                         goto done;
 501
 502                 tmp = *dqhintp;
 503                 *dqhintp = NULL;
 504                 xfs_qm_dqrele(tmp);
 505         }
 506
 507         *dqhintp = xfs_qm_dqhold(dqp);
 508 done:
 509         xfs_dqunlock(udq);
 510 }
 511
 512 static bool
 513 xfs_qm_need_dqattach(
 514         struct xfs_inode        *ip)
 515 {
 516         struct xfs_mount        *mp = ip->i_mount;
 517
 518         if (!XFS_IS_QUOTA_RUNNING(mp))
 519                 return false;
 520         if (!XFS_IS_QUOTA_ON(mp))
 521                 return false;
 522         if (!XFS_NOT_DQATTACHED(mp, ip))
 523                 return false;
 524         if (xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
 525                 return false;
 526         return true;
 527 }
 528
 529 /*
 530  * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
 531  * into account.
 532  * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
 533  * Inode may get unlocked and relocked in here, and the caller must deal with
 534  * the consequences.
 535  */
 536 int
 537 xfs_qm_dqattach_locked(
 538         xfs_inode_t     *ip,
 539         uint            flags)
 540 {
 541         xfs_mount_t     *mp = ip->i_mount;
 542         uint            nquotas = 0;
 543         int             error = 0;
 544
 545         if (!xfs_qm_need_dqattach(ip))
 546                 return 0;
 547
 548         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 549
 550         if (XFS_IS_UQUOTA_ON(mp)) {
 551                 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
 552                                                 flags & XFS_QMOPT_DQALLOC,
 553                                                 NULL, &ip->i_udquot);
 554                 if (error)
 555                         goto done;
 556                 nquotas++;
 557         }
 558
 559         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 560         if (XFS_IS_GQUOTA_ON(mp)) {
 561                 error = xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
 562                                                 flags & XFS_QMOPT_DQALLOC,
 563                                                 ip->i_udquot, &ip->i_gdquot);
 564                 /*
 565                  * Don't worry about the udquot that we may have
 566                  * attached above. It'll get detached, if not already.
 567                  */
 568                 if (error)
 569                         goto done;
 570                 nquotas++;
 571         }
 572
 573         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 574         if (XFS_IS_PQUOTA_ON(mp)) {
 575                 error = xfs_qm_dqattach_one(ip, xfs_get_projid(ip), XFS_DQ_PROJ,
 576                                                 flags & XFS_QMOPT_DQALLOC,
 577                                                 ip->i_udquot, &ip->i_pdquot);
 578                 /*
 579                  * Don't worry about the udquot that we may have
 580                  * attached above. It'll get detached, if not already.
 581                  */
 582                 if (error)
 583                         goto done;
 584                 nquotas++;
 585         }
 586
 587         /*
 588          * Attach this group/project quota to the user quota as a hint.
 589          * This WON'T, in general, result in a thrash.
 590          */
 591         if (nquotas > 1 && ip->i_udquot) {
 592                 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 593                 ASSERT(ip->i_gdquot || !XFS_IS_GQUOTA_ON(mp));
 594                 ASSERT(ip->i_pdquot || !XFS_IS_PQUOTA_ON(mp));
 595
 596                 /*
 597                  * We do not have i_udquot locked at this point, but this check
 598                  * is OK since we don't depend on the i_gdquot to be accurate
 599                  * 100% all the time. It is just a hint, and this will
 600                  * succeed in general.
 601                  */
 602                 if (ip->i_udquot->q_gdquot != ip->i_gdquot)
 603                         xfs_qm_dqattach_hint(ip, XFS_DQ_GROUP);
 604
 605                 if (ip->i_udquot->q_pdquot != ip->i_pdquot)
 606                         xfs_qm_dqattach_hint(ip, XFS_DQ_PROJ);
 607         }
 608
 609  done:
 610 #ifdef DEBUG
 611         if (!error) {
 612                 if (XFS_IS_UQUOTA_ON(mp))
 613                         ASSERT(ip->i_udquot);
 614                 if (XFS_IS_GQUOTA_ON(mp))
 615                         ASSERT(ip->i_gdquot);
 616                 if (XFS_IS_PQUOTA_ON(mp))
 617                         ASSERT(ip->i_pdquot);
 618         }
 619         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 620 #endif
 621         return error;
 622 }
 623
 624 int
 625 xfs_qm_dqattach(
 626         struct xfs_inode        *ip,
 627         uint                    flags)
 628 {
 629         int                     error;
 630
 631         if (!xfs_qm_need_dqattach(ip))
 632                 return 0;
 633
 634         xfs_ilock(ip, XFS_ILOCK_EXCL);
 635         error = xfs_qm_dqattach_locked(ip, flags);
 636         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 637
 638         return error;
 639 }
 640
 641 /*
 642  * Release dquots (and their references) if any.
 643  * The inode should be locked EXCL except when this's called by
 644  * xfs_ireclaim.
 645  */
 646 void
 647 xfs_qm_dqdetach(
 648         xfs_inode_t     *ip)
 649 {
 650         if (!(ip->i_udquot || ip->i_gdquot || ip->i_pdquot))
 651                 return;
 652
 653         trace_xfs_dquot_dqdetach(ip);
 654
 655         ASSERT(!xfs_is_quota_inode(&ip->i_mount->m_sb, ip->i_ino));
 656         if (ip->i_udquot) {
 657                 xfs_qm_dqrele(ip->i_udquot);
 658                 ip->i_udquot = NULL;
 659         }
 660         if (ip->i_gdquot) {
 661                 xfs_qm_dqrele(ip->i_gdquot);
 662                 ip->i_gdquot = NULL;
 663         }
 664         if (ip->i_pdquot) {
 665                 xfs_qm_dqrele(ip->i_pdquot);
 666                 ip->i_pdquot = NULL;
 667         }
 668 }
 669
 670 int
 671 xfs_qm_calc_dquots_per_chunk(
 672         struct xfs_mount        *mp,
 673         unsigned int            nbblks) /* basic block units */
 674 {
 675         unsigned int    ndquots;
 676
 677         ASSERT(nbblks > 0);
 678         ndquots = BBTOB(nbblks);
 679         do_div(ndquots, sizeof(xfs_dqblk_t));
 680
 681         return ndquots;
 682 }
 683
 684 /*
 685  * This initializes all the quota information that's kept in the
 686  * mount structure
 687  */
 688 STATIC int
 689 xfs_qm_init_quotainfo(
 690         xfs_mount_t     *mp)
 691 {
 692         xfs_quotainfo_t *qinf;
 693         int             error;
 694         xfs_dquot_t     *dqp;
 695
 696         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 697
 698         qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
 699
 700         /*
 701          * See if quotainodes are setup, and if not, allocate them,
 702          * and change the superblock accordingly.
 703          */
 704         if ((error = xfs_qm_init_quotainos(mp))) {
 705                 kmem_free(qinf);
 706                 mp->m_quotainfo = NULL;
 707                 return error;
 708         }
 709
 710         INIT_RADIX_TREE(&qinf->qi_uquota_tree, GFP_NOFS);
 711         INIT_RADIX_TREE(&qinf->qi_gquota_tree, GFP_NOFS);
 712         INIT_RADIX_TREE(&qinf->qi_pquota_tree, GFP_NOFS);
 713         mutex_init(&qinf->qi_tree_lock);
 714
 715         INIT_LIST_HEAD(&qinf->qi_lru_list);
 716         qinf->qi_lru_count = 0;
 717         mutex_init(&qinf->qi_lru_lock);
 718
 719         /* mutex used to serialize quotaoffs */
 720         mutex_init(&qinf->qi_quotaofflock);
 721
 722         /* Precalc some constants */
 723         qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
 724         qinf->qi_dqperchunk = xfs_qm_calc_dquots_per_chunk(mp,
 725                                                         qinf->qi_dqchunklen);
 726
 727         mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
 728
 729         /*
 730          * We try to get the limits from the superuser's limits fields.
 731          * This is quite hacky, but it is standard quota practice.
 732          *
 733          * We look at the USR dquot with id == 0 first, but if user quotas
 734          * are not enabled we goto the GRP dquot with id == 0.
 735          * We don't really care to keep separate default limits for user
 736          * and group quotas, at least not at this point.
 737          *
 738          * Since we may not have done a quotacheck by this point, just read
 739          * the dquot without attaching it to any hashtables or lists.
 740          */
 741         error = xfs_qm_dqread(mp, 0,
 742                         XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
 743                          (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
 744                           XFS_DQ_PROJ),
 745                         XFS_QMOPT_DOWARN, &dqp);
 746         if (!error) {
 747                 xfs_disk_dquot_t        *ddqp = &dqp->q_core;
 748
 749                 /*
 750                  * The warnings and timers set the grace period given to
 751                  * a user or group before he or she can not perform any
 752                  * more writing. If it is zero, a default is used.
 753                  */
 754                 qinf->qi_btimelimit = ddqp->d_btimer ?
 755                         be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
 756                 qinf->qi_itimelimit = ddqp->d_itimer ?
 757                         be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
 758                 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
 759                         be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
 760                 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
 761                         be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
 762                 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
 763                         be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
 764                 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
 765                         be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
 766                 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
 767                 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
 768                 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
 769                 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
 770                 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
 771                 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
 772
 773                 xfs_qm_dqdestroy(dqp);
 774         } else {
 775                 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
 776                 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
 777                 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
 778                 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
 779                 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
 780                 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
 781         }
 782
 783         qinf->qi_shrinker.shrink = xfs_qm_shake;
 784         qinf->qi_shrinker.seeks = DEFAULT_SEEKS;
 785         register_shrinker(&qinf->qi_shrinker);
 786         return 0;
 787 }
 788
 789
 790 /*
 791  * Gets called when unmounting a filesystem or when all quotas get
 792  * turned off.
 793  * This purges the quota inodes, destroys locks and frees itself.
 794  */
 795 void
 796 xfs_qm_destroy_quotainfo(
 797         xfs_mount_t     *mp)
 798 {
 799         xfs_quotainfo_t *qi;
 800
 801         qi = mp->m_quotainfo;
 802         ASSERT(qi != NULL);
 803
 804         unregister_shrinker(&qi->qi_shrinker);
 805
 806         if (qi->qi_uquotaip) {
 807                 IRELE(qi->qi_uquotaip);
 808                 qi->qi_uquotaip = NULL; /* paranoia */
 809         }
 810         if (qi->qi_gquotaip) {
 811                 IRELE(qi->qi_gquotaip);
 812                 qi->qi_gquotaip = NULL;
 813         }
 814         if (qi->qi_pquotaip) {
 815                 IRELE(qi->qi_pquotaip);
 816                 qi->qi_pquotaip = NULL;
 817         }
 818         mutex_destroy(&qi->qi_quotaofflock);
 819         kmem_free(qi);
 820         mp->m_quotainfo = NULL;
 821 }
 822
 823 /*
 824  * Create an inode and return with a reference already taken, but unlocked
 825  * This is how we create quota inodes
 826  */
 827 STATIC int
 828 xfs_qm_qino_alloc(
 829         xfs_mount_t     *mp,
 830         xfs_inode_t     **ip,
 831         __int64_t       sbfields,
 832         uint            flags)
 833 {
 834         xfs_trans_t     *tp;
 835         int             error;
 836         int             committed;
 837
 838         *ip = NULL;
 839         /*
 840          * With superblock that doesn't have separate pquotino, we
 841          * share an inode between gquota and pquota. If the on-disk
 842          * superblock has GQUOTA and the filesystem is now mounted
 843          * with PQUOTA, just use sb_gquotino for sb_pquotino and
 844          * vice-versa.
 845          */
 846         if (!xfs_sb_version_has_pquotino(&mp->m_sb) &&
 847                         (flags & (XFS_QMOPT_PQUOTA|XFS_QMOPT_GQUOTA))) {
 848                 xfs_ino_t ino = NULLFSINO;
 849
 850                 if ((flags & XFS_QMOPT_PQUOTA) &&
 851                              (mp->m_sb.sb_gquotino != NULLFSINO)) {
 852                         ino = mp->m_sb.sb_gquotino;
 853                         ASSERT(mp->m_sb.sb_pquotino == NULLFSINO);
 854                 } else if ((flags & XFS_QMOPT_GQUOTA) &&
 855                              (mp->m_sb.sb_pquotino != NULLFSINO)) {
 856                         ino = mp->m_sb.sb_pquotino;
 857                         ASSERT(mp->m_sb.sb_gquotino == NULLFSINO);
 858                 }
 859                 if (ino != NULLFSINO) {
 860                         error = xfs_iget(mp, NULL, ino, 0, 0, ip);
 861                         if (error)
 862                                 return error;
 863                         mp->m_sb.sb_gquotino = NULLFSINO;
 864                         mp->m_sb.sb_pquotino = NULLFSINO;
 865                 }
 866         }
 867
 868         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
 869         if ((error = xfs_trans_reserve(tp,
 870                                       XFS_QM_QINOCREATE_SPACE_RES(mp),
 871                                       XFS_CREATE_LOG_RES(mp), 0,
 872                                       XFS_TRANS_PERM_LOG_RES,
 873                                       XFS_CREATE_LOG_COUNT))) {
 874                 xfs_trans_cancel(tp, 0);
 875                 return error;
 876         }
 877
 878         if (!*ip) {
 879                 error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, 1, ip,
 880                                                                 &committed);
 881                 if (error) {
 882                         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
 883                                          XFS_TRANS_ABORT);
 884                         return error;
 885                 }
 886         }
 887
 888         /*
 889          * Make the changes in the superblock, and log those too.
 890          * sbfields arg may contain fields other than *QUOTINO;
 891          * VERSIONNUM for example.
 892          */
 893         spin_lock(&mp->m_sb_lock);
 894         if (flags & XFS_QMOPT_SBVERSION) {
 895                 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
 896                 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
 897                         XFS_SB_GQUOTINO | XFS_SB_PQUOTINO | XFS_SB_QFLAGS)) ==
 898                                 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
 899                                  XFS_SB_GQUOTINO | XFS_SB_PQUOTINO |
 900                                  XFS_SB_QFLAGS));
 901
 902                 xfs_sb_version_addquota(&mp->m_sb);
 903                 mp->m_sb.sb_uquotino = NULLFSINO;
 904                 mp->m_sb.sb_gquotino = NULLFSINO;
 905                 mp->m_sb.sb_pquotino = NULLFSINO;
 906
 907                 /* qflags will get updated fully _after_ quotacheck */
 908                 mp->m_sb.sb_qflags = mp->m_qflags & XFS_ALL_QUOTA_ACCT;
 909         }
 910         if (flags & XFS_QMOPT_UQUOTA)
 911                 mp->m_sb.sb_uquotino = (*ip)->i_ino;
 912         else if (flags & XFS_QMOPT_GQUOTA)
 913                 mp->m_sb.sb_gquotino = (*ip)->i_ino;
 914         else
 915                 mp->m_sb.sb_pquotino = (*ip)->i_ino;
 916         spin_unlock(&mp->m_sb_lock);
 917         xfs_mod_sb(tp, sbfields);
 918
 919         if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
 920                 xfs_alert(mp, "%s failed (error %d)!", __func__, error);
 921                 return error;
 922         }
 923         return 0;
 924 }
 925
 926
 927 STATIC void
 928 xfs_qm_reset_dqcounts(
 929         xfs_mount_t     *mp,
 930         xfs_buf_t       *bp,
 931         xfs_dqid_t      id,
 932         uint            type)
 933 {
 934         struct xfs_dqblk        *dqb;
 935         int                     j;
 936
 937         trace_xfs_reset_dqcounts(bp, _RET_IP_);
 938
 939         /*
 940          * Reset all counters and timers. They'll be
 941          * started afresh by xfs_qm_quotacheck.
 942          */
 943 #ifdef DEBUG
 944         j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
 945         do_div(j, sizeof(xfs_dqblk_t));
 946         ASSERT(mp->m_quotainfo->qi_dqperchunk == j);
 947 #endif
 948         dqb = bp->b_addr;
 949         for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {
 950                 struct xfs_disk_dquot   *ddq;
 951
 952                 ddq = (struct xfs_disk_dquot *)&dqb[j];
 953
 954                 /*
 955                  * Do a sanity check, and if needed, repair the dqblk. Don't
 956                  * output any warnings because it's perfectly possible to
 957                  * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
 958                  */
 959                 (void) xfs_qm_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR,
 960                                       "xfs_quotacheck");
 961                 ddq->d_bcount = 0;
 962                 ddq->d_icount = 0;
 963                 ddq->d_rtbcount = 0;
 964                 ddq->d_btimer = 0;
 965                 ddq->d_itimer = 0;
 966                 ddq->d_rtbtimer = 0;
 967                 ddq->d_bwarns = 0;
 968                 ddq->d_iwarns = 0;
 969                 ddq->d_rtbwarns = 0;
 970
 971                 if (xfs_sb_version_hascrc(&mp->m_sb)) {
 972                         xfs_update_cksum((char *)&dqb[j],
 973                                          sizeof(struct xfs_dqblk),
 974                                          XFS_DQUOT_CRC_OFF);
 975                 }
 976         }
 977 }
 978
 979 STATIC int
 980 xfs_qm_dqiter_bufs(
 981         struct xfs_mount        *mp,
 982         xfs_dqid_t              firstid,
 983         xfs_fsblock_t           bno,
 984         xfs_filblks_t           blkcnt,
 985         uint                    flags,
 986         struct list_head        *buffer_list)
 987 {
 988         struct xfs_buf          *bp;
 989         int                     error;
 990         int                     type;
 991
 992         ASSERT(blkcnt > 0);
 993         type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
 994                 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
 995         error = 0;
 996
 997         /*
 998          * Blkcnt arg can be a very big number, and might even be
 999          * larger than the log itself. So, we have to break it up into
1000          * manageable-sized transactions.
1001          * Note that we don't start a permanent transaction here; we might
1002          * not be able to get a log reservation for the whole thing up front,
1003          * and we don't really care to either, because we just discard
1004          * everything if we were to crash in the middle of this loop.
1005          */
1006         while (blkcnt--) {
1007                 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1008                               XFS_FSB_TO_DADDR(mp, bno),
1009                               mp->m_quotainfo->qi_dqchunklen, 0, &bp,
1010                               &xfs_dquot_buf_ops);
1011
1012                 /*
1013                  * CRC and validation errors will return a EFSCORRUPTED here. If
1014                  * this occurs, re-read without CRC validation so that we can
1015                  * repair the damage via xfs_qm_reset_dqcounts(). This process
1016                  * will leave a trace in the log indicating corruption has
1017                  * been detected.
1018                  */
1019                 if (error == EFSCORRUPTED) {
1020                         error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1021                                       XFS_FSB_TO_DADDR(mp, bno),
1022                                       mp->m_quotainfo->qi_dqchunklen, 0, &bp,
1023                                       NULL);
1024                 }
1025
1026                 if (error)
1027                         break;
1028
1029                 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
1030                 xfs_buf_delwri_queue(bp, buffer_list);
1031                 xfs_buf_relse(bp);
1032
1033                 /* goto the next block. */
1034                 bno++;
1035                 firstid += mp->m_quotainfo->qi_dqperchunk;
1036         }
1037
1038         return error;
1039 }
1040
1041 /*
1042  * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
1043  * caller supplied function for every chunk of dquots that we find.
1044  */
1045 STATIC int
1046 xfs_qm_dqiterate(
1047         struct xfs_mount        *mp,
1048         struct xfs_inode        *qip,
1049         uint                    flags,
1050         struct list_head        *buffer_list)
1051 {
1052         struct xfs_bmbt_irec    *map;
1053         int                     i, nmaps;       /* number of map entries */
1054         int                     error;          /* return value */
1055         xfs_fileoff_t           lblkno;
1056         xfs_filblks_t           maxlblkcnt;
1057         xfs_dqid_t              firstid;
1058         xfs_fsblock_t           rablkno;
1059         xfs_filblks_t           rablkcnt;
1060
1061         error = 0;
1062         /*
1063          * This looks racy, but we can't keep an inode lock across a
1064          * trans_reserve. But, this gets called during quotacheck, and that
1065          * happens only at mount time which is single threaded.
1066          */
1067         if (qip->i_d.di_nblocks == 0)
1068                 return 0;
1069
1070         map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1071
1072         lblkno = 0;
1073         maxlblkcnt = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
1074         do {
1075                 nmaps = XFS_DQITER_MAP_SIZE;
1076                 /*
1077                  * We aren't changing the inode itself. Just changing
1078                  * some of its data. No new blocks are added here, and
1079                  * the inode is never added to the transaction.
1080                  */
1081                 xfs_ilock(qip, XFS_ILOCK_SHARED);
1082                 error = xfs_bmapi_read(qip, lblkno, maxlblkcnt - lblkno,
1083                                        map, &nmaps, 0);
1084                 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1085                 if (error)
1086                         break;
1087
1088                 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1089                 for (i = 0; i < nmaps; i++) {
1090                         ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1091                         ASSERT(map[i].br_blockcount);
1092
1093
1094                         lblkno += map[i].br_blockcount;
1095
1096                         if (map[i].br_startblock == HOLESTARTBLOCK)
1097                                 continue;
1098
1099                         firstid = (xfs_dqid_t) map[i].br_startoff *
1100                                 mp->m_quotainfo->qi_dqperchunk;
1101                         /*
1102                          * Do a read-ahead on the next extent.
1103                          */
1104                         if ((i+1 < nmaps) &&
1105                             (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1106                                 rablkcnt =  map[i+1].br_blockcount;
1107                                 rablkno = map[i+1].br_startblock;
1108                                 while (rablkcnt--) {
1109                                         xfs_buf_readahead(mp->m_ddev_targp,
1110                                                XFS_FSB_TO_DADDR(mp, rablkno),
1111                                                mp->m_quotainfo->qi_dqchunklen,
1112                                                NULL);
1113                                         rablkno++;
1114                                 }
1115                         }
1116                         /*
1117                          * Iterate thru all the blks in the extent and
1118                          * reset the counters of all the dquots inside them.
1119                          */
1120                         error = xfs_qm_dqiter_bufs(mp, firstid,
1121                                                    map[i].br_startblock,
1122                                                    map[i].br_blockcount,
1123                                                    flags, buffer_list);
1124                         if (error)
1125                                 goto out;
1126                 }
1127         } while (nmaps > 0);
1128
1129 out:
1130         kmem_free(map);
1131         return error;
1132 }
1133
1134 /*
1135  * Called by dqusage_adjust in doing a quotacheck.
1136  *
1137  * Given the inode, and a dquot id this updates both the incore dqout as well
1138  * as the buffer copy. This is so that once the quotacheck is done, we can
1139  * just log all the buffers, as opposed to logging numerous updates to
1140  * individual dquots.
1141  */
1142 STATIC int
1143 xfs_qm_quotacheck_dqadjust(
1144         struct xfs_inode        *ip,
1145         xfs_dqid_t              id,
1146         uint                    type,
1147         xfs_qcnt_t              nblks,
1148         xfs_qcnt_t              rtblks)
1149 {
1150         struct xfs_mount        *mp = ip->i_mount;
1151         struct xfs_dquot        *dqp;
1152         int                     error;
1153
1154         error = xfs_qm_dqget(mp, ip, id, type,
1155                              XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN, &dqp);
1156         if (error) {
1157                 /*
1158                  * Shouldn't be able to turn off quotas here.
1159                  */
1160                 ASSERT(error != ESRCH);
1161                 ASSERT(error != ENOENT);
1162                 return error;
1163         }
1164
1165         trace_xfs_dqadjust(dqp);
1166
1167         /*
1168          * Adjust the inode count and the block count to reflect this inode's
1169          * resource usage.
1170          */
1171         be64_add_cpu(&dqp->q_core.d_icount, 1);
1172         dqp->q_res_icount++;
1173         if (nblks) {
1174                 be64_add_cpu(&dqp->q_core.d_bcount, nblks);
1175                 dqp->q_res_bcount += nblks;
1176         }
1177         if (rtblks) {
1178                 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
1179                 dqp->q_res_rtbcount += rtblks;
1180         }
1181
1182         /*
1183          * Set default limits, adjust timers (since we changed usages)
1184          *
1185          * There are no timers for the default values set in the root dquot.
1186          */
1187         if (dqp->q_core.d_id) {
1188                 xfs_qm_adjust_dqlimits(mp, dqp);
1189                 xfs_qm_adjust_dqtimers(mp, &dqp->q_core);
1190         }
1191
1192         dqp->dq_flags |= XFS_DQ_DIRTY;
1193         xfs_qm_dqput(dqp);
1194         return 0;
1195 }
1196
1197 STATIC int
1198 xfs_qm_get_rtblks(
1199         xfs_inode_t     *ip,
1200         xfs_qcnt_t      *O_rtblks)
1201 {
1202         xfs_filblks_t   rtblks;                 /* total rt blks */
1203         xfs_extnum_t    idx;                    /* extent record index */
1204         xfs_ifork_t     *ifp;                   /* inode fork pointer */
1205         xfs_extnum_t    nextents;               /* number of extent entries */
1206         int             error;
1207
1208         ASSERT(XFS_IS_REALTIME_INODE(ip));
1209         ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1210         if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1211                 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
1212                         return error;
1213         }
1214         rtblks = 0;
1215         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
1216         for (idx = 0; idx < nextents; idx++)
1217                 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
1218         *O_rtblks = (xfs_qcnt_t)rtblks;
1219         return 0;
1220 }
1221
1222 /*
1223  * callback routine supplied to bulkstat(). Given an inumber, find its
1224  * dquots and update them to account for resources taken by that inode.
1225  */
1226 /* ARGSUSED */
1227 STATIC int
1228 xfs_qm_dqusage_adjust(
1229         xfs_mount_t     *mp,            /* mount point for filesystem */
1230         xfs_ino_t       ino,            /* inode number to get data for */
1231         void            __user *buffer, /* not used */
1232         int             ubsize,         /* not used */
1233         int             *ubused,        /* not used */
1234         int             *res)           /* result code value */
1235 {
1236         xfs_inode_t     *ip;
1237         xfs_qcnt_t      nblks, rtblks = 0;
1238         int             error;
1239
1240         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1241
1242         /*
1243          * rootino must have its resources accounted for, not so with the quota
1244          * inodes.
1245          */
1246         if (xfs_is_quota_inode(&mp->m_sb, ino)) {
1247                 *res = BULKSTAT_RV_NOTHING;
1248                 return XFS_ERROR(EINVAL);
1249         }
1250
1251         /*
1252          * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1253          * interface expects the inode to be exclusively locked because that's
1254          * the case in all other instances. It's OK that we do this because
1255          * quotacheck is done only at mount time.
1256          */
1257         error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip);
1258         if (error) {
1259                 *res = BULKSTAT_RV_NOTHING;
1260                 return error;
1261         }
1262
1263         ASSERT(ip->i_delayed_blks == 0);
1264
1265         if (XFS_IS_REALTIME_INODE(ip)) {
1266                 /*
1267                  * Walk thru the extent list and count the realtime blocks.
1268                  */
1269                 error = xfs_qm_get_rtblks(ip, &rtblks);
1270                 if (error)
1271                         goto error0;
1272         }
1273
1274         nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1275
1276         /*
1277          * Add the (disk blocks and inode) resources occupied by this
1278          * inode to its dquots. We do this adjustment in the incore dquot,
1279          * and also copy the changes to its buffer.
1280          * We don't care about putting these changes in a transaction
1281          * envelope because if we crash in the middle of a 'quotacheck'
1282          * we have to start from the beginning anyway.
1283          * Once we're done, we'll log all the dquot bufs.
1284          *
1285          * The *QUOTA_ON checks below may look pretty racy, but quotachecks
1286          * and quotaoffs don't race. (Quotachecks happen at mount time only).
1287          */
1288         if (XFS_IS_UQUOTA_ON(mp)) {
1289                 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_uid,
1290                                                    XFS_DQ_USER, nblks, rtblks);
1291                 if (error)
1292                         goto error0;
1293         }
1294
1295         if (XFS_IS_GQUOTA_ON(mp)) {
1296                 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_gid,
1297                                                    XFS_DQ_GROUP, nblks, rtblks);
1298                 if (error)
1299                         goto error0;
1300         }
1301
1302         if (XFS_IS_PQUOTA_ON(mp)) {
1303                 error = xfs_qm_quotacheck_dqadjust(ip, xfs_get_projid(ip),
1304                                                    XFS_DQ_PROJ, nblks, rtblks);
1305                 if (error)
1306                         goto error0;
1307         }
1308
1309         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1310         IRELE(ip);
1311         *res = BULKSTAT_RV_DIDONE;
1312         return 0;
1313
1314 error0:
1315         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1316         IRELE(ip);
1317         *res = BULKSTAT_RV_GIVEUP;
1318         return error;
1319 }
1320
1321 STATIC int
1322 xfs_qm_flush_one(
1323         struct xfs_dquot        *dqp,
1324         void                    *data)
1325 {
1326         struct list_head        *buffer_list = data;
1327         struct xfs_buf          *bp = NULL;
1328         int                     error = 0;
1329
1330         xfs_dqlock(dqp);
1331         if (dqp->dq_flags & XFS_DQ_FREEING)
1332                 goto out_unlock;
1333         if (!XFS_DQ_IS_DIRTY(dqp))
1334                 goto out_unlock;
1335
1336         xfs_dqflock(dqp);
1337         error = xfs_qm_dqflush(dqp, &bp);
1338         if (error)
1339                 goto out_unlock;
1340
1341         xfs_buf_delwri_queue(bp, buffer_list);
1342         xfs_buf_relse(bp);
1343 out_unlock:
1344         xfs_dqunlock(dqp);
1345         return error;
1346 }
1347
1348 /*
1349  * Walk thru all the filesystem inodes and construct a consistent view
1350  * of the disk quota world. If the quotacheck fails, disable quotas.
1351  */
1352 int
1353 xfs_qm_quotacheck(
1354         xfs_mount_t     *mp)
1355 {
1356         int                     done, count, error, error2;
1357         xfs_ino_t               lastino;
1358         size_t                  structsz;
1359         uint                    flags;
1360         LIST_HEAD               (buffer_list);
1361         struct xfs_inode        *uip = mp->m_quotainfo->qi_uquotaip;
1362         struct xfs_inode        *gip = mp->m_quotainfo->qi_gquotaip;
1363         struct xfs_inode        *pip = mp->m_quotainfo->qi_pquotaip;
1364
1365         count = INT_MAX;
1366         structsz = 1;
1367         lastino = 0;
1368         flags = 0;
1369
1370         ASSERT(uip || gip || pip);
1371         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1372
1373         xfs_notice(mp, "Quotacheck needed: Please wait.");
1374
1375         /*
1376          * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
1377          * their counters to zero. We need a clean slate.
1378          * We don't log our changes till later.
1379          */
1380         if (uip) {
1381                 error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA,
1382                                          &buffer_list);
1383                 if (error)
1384                         goto error_return;
1385                 flags |= XFS_UQUOTA_CHKD;
1386         }
1387
1388         if (gip) {
1389                 error = xfs_qm_dqiterate(mp, gip, XFS_QMOPT_GQUOTA,
1390                                          &buffer_list);
1391                 if (error)
1392                         goto error_return;
1393                 flags |= XFS_GQUOTA_CHKD;
1394         }
1395
1396         if (pip) {
1397                 error = xfs_qm_dqiterate(mp, pip, XFS_QMOPT_PQUOTA,
1398                                          &buffer_list);
1399                 if (error)
1400                         goto error_return;
1401                 flags |= XFS_PQUOTA_CHKD;
1402         }
1403
1404         do {
1405                 /*
1406                  * Iterate thru all the inodes in the file system,
1407                  * adjusting the corresponding dquot counters in core.
1408                  */
1409                 error = xfs_bulkstat(mp, &lastino, &count,
1410                                      xfs_qm_dqusage_adjust,
1411                                      structsz, NULL, &done);
1412                 if (error)
1413                         break;
1414
1415         } while (!done);
1416
1417         /*
1418          * We've made all the changes that we need to make incore.  Flush them
1419          * down to disk buffers if everything was updated successfully.
1420          */
1421         if (XFS_IS_UQUOTA_ON(mp)) {
1422                 error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one,
1423                                           &buffer_list);
1424         }
1425         if (XFS_IS_GQUOTA_ON(mp)) {
1426                 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one,
1427                                            &buffer_list);
1428                 if (!error)
1429                         error = error2;
1430         }
1431         if (XFS_IS_PQUOTA_ON(mp)) {
1432                 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one,
1433                                            &buffer_list);
1434                 if (!error)
1435                         error = error2;
1436         }
1437
1438         error2 = xfs_buf_delwri_submit(&buffer_list);
1439         if (!error)
1440                 error = error2;
1441
1442         /*
1443          * We can get this error if we couldn't do a dquot allocation inside
1444          * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1445          * dirty dquots that might be cached, we just want to get rid of them
1446          * and turn quotaoff. The dquots won't be attached to any of the inodes
1447          * at this point (because we intentionally didn't in dqget_noattach).
1448          */
1449         if (error) {
1450                 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
1451                 goto error_return;
1452         }
1453
1454         /*
1455          * If one type of quotas is off, then it will lose its
1456          * quotachecked status, since we won't be doing accounting for
1457          * that type anymore.
1458          */
1459         mp->m_qflags &= ~XFS_ALL_QUOTA_CHKD;
1460         mp->m_qflags |= flags;
1461
1462  error_return:
1463         while (!list_empty(&buffer_list)) {
1464                 struct xfs_buf *bp =
1465                         list_first_entry(&buffer_list, struct xfs_buf, b_list);
1466                 list_del_init(&bp->b_list);
1467                 xfs_buf_relse(bp);
1468         }
1469
1470         if (error) {
1471                 xfs_warn(mp,
1472         "Quotacheck: Unsuccessful (Error %d): Disabling quotas.",
1473                         error);
1474                 /*
1475                  * We must turn off quotas.
1476                  */
1477                 ASSERT(mp->m_quotainfo != NULL);
1478                 xfs_qm_destroy_quotainfo(mp);
1479                 if (xfs_mount_reset_sbqflags(mp)) {
1480                         xfs_warn(mp,
1481                                 "Quotacheck: Failed to reset quota flags.");
1482                 }
1483         } else
1484                 xfs_notice(mp, "Quotacheck: Done.");
1485         return (error);
1486 }
1487
1488 /*
1489  * This is called after the superblock has been read in and we're ready to
1490  * iget the quota inodes.
1491  */
1492 STATIC int
1493 xfs_qm_init_quotainos(
1494         xfs_mount_t     *mp)
1495 {
1496         struct xfs_inode        *uip = NULL;
1497         struct xfs_inode        *gip = NULL;
1498         struct xfs_inode        *pip = NULL;
1499         int                     error;
1500         __int64_t               sbflags = 0;
1501         uint                    flags = 0;
1502
1503         ASSERT(mp->m_quotainfo);
1504
1505         /*
1506          * Get the uquota and gquota inodes
1507          */
1508         if (xfs_sb_version_hasquota(&mp->m_sb)) {
1509                 if (XFS_IS_UQUOTA_ON(mp) &&
1510                     mp->m_sb.sb_uquotino != NULLFSINO) {
1511                         ASSERT(mp->m_sb.sb_uquotino > 0);
1512                         error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
1513                                              0, 0, &uip);
1514                         if (error)
1515                                 return XFS_ERROR(error);
1516                 }
1517                 if (XFS_IS_GQUOTA_ON(mp) &&
1518                     mp->m_sb.sb_gquotino != NULLFSINO) {
1519                         ASSERT(mp->m_sb.sb_gquotino > 0);
1520                         error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
1521                                              0, 0, &gip);
1522                         if (error)
1523                                 goto error_rele;
1524                 }
1525                 if (XFS_IS_PQUOTA_ON(mp) &&
1526                     mp->m_sb.sb_pquotino != NULLFSINO) {
1527                         ASSERT(mp->m_sb.sb_pquotino > 0);
1528                         error = xfs_iget(mp, NULL, mp->m_sb.sb_pquotino,
1529                                              0, 0, &pip);
1530                         if (error)
1531                                 goto error_rele;
1532                 }
1533         } else {
1534                 flags |= XFS_QMOPT_SBVERSION;
1535                 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1536                             XFS_SB_GQUOTINO | XFS_SB_PQUOTINO |
1537                             XFS_SB_QFLAGS);
1538         }
1539
1540         /*
1541          * Create the three inodes, if they don't exist already. The changes
1542          * made above will get added to a transaction and logged in one of
1543          * the qino_alloc calls below.  If the device is readonly,
1544          * temporarily switch to read-write to do this.
1545          */
1546         if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1547                 error = xfs_qm_qino_alloc(mp, &uip,
1548                                               sbflags | XFS_SB_UQUOTINO,
1549                                               flags | XFS_QMOPT_UQUOTA);
1550                 if (error)
1551                         goto error_rele;
1552
1553                 flags &= ~XFS_QMOPT_SBVERSION;
1554         }
1555         if (XFS_IS_GQUOTA_ON(mp) && gip == NULL) {
1556                 error = xfs_qm_qino_alloc(mp, &gip,
1557                                           sbflags | XFS_SB_GQUOTINO,
1558                                           flags | XFS_QMOPT_GQUOTA);
1559                 if (error)
1560                         goto error_rele;
1561
1562                 flags &= ~XFS_QMOPT_SBVERSION;
1563         }
1564         if (XFS_IS_PQUOTA_ON(mp) && pip == NULL) {
1565                 error = xfs_qm_qino_alloc(mp, &pip,
1566                                           sbflags | XFS_SB_PQUOTINO,
1567                                           flags | XFS_QMOPT_PQUOTA);
1568                 if (error)
1569                         goto error_rele;
1570         }
1571
1572         mp->m_quotainfo->qi_uquotaip = uip;
1573         mp->m_quotainfo->qi_gquotaip = gip;
1574         mp->m_quotainfo->qi_pquotaip = pip;
1575
1576         return 0;
1577
1578 error_rele:
1579         if (uip)
1580                 IRELE(uip);
1581         if (gip)
1582                 IRELE(gip);
1583         if (pip)
1584                 IRELE(pip);
1585         return XFS_ERROR(error);
1586 }
1587
1588 STATIC void
1589 xfs_qm_dqfree_one(
1590         struct xfs_dquot        *dqp)
1591 {
1592         struct xfs_mount        *mp = dqp->q_mount;
1593         struct xfs_quotainfo    *qi = mp->m_quotainfo;
1594
1595         mutex_lock(&qi->qi_tree_lock);
1596         radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
1597                           be32_to_cpu(dqp->q_core.d_id));
1598
1599         qi->qi_dquots--;
1600         mutex_unlock(&qi->qi_tree_lock);
1601
1602         xfs_qm_dqdestroy(dqp);
1603 }
1604
1605 STATIC void
1606 xfs_qm_dqreclaim_one(
1607         struct xfs_dquot        *dqp,
1608         struct list_head        *buffer_list,
1609         struct list_head        *dispose_list)
1610 {
1611         struct xfs_mount        *mp = dqp->q_mount;
1612         struct xfs_quotainfo    *qi = mp->m_quotainfo;
1613         int                     error;
1614
1615         if (!xfs_dqlock_nowait(dqp))
1616                 goto out_move_tail;
1617
1618         /*
1619          * This dquot has acquired a reference in the meantime remove it from
1620          * the freelist and try again.
1621          */
1622         if (dqp->q_nrefs) {
1623                 xfs_dqunlock(dqp);
1624
1625                 trace_xfs_dqreclaim_want(dqp);
1626                 XFS_STATS_INC(xs_qm_dqwants);
1627
1628                 list_del_init(&dqp->q_lru);
1629                 qi->qi_lru_count--;
1630                 XFS_STATS_DEC(xs_qm_dquot_unused);
1631                 return;
1632         }
1633
1634         /*
1635          * Try to grab the flush lock. If this dquot is in the process of
1636          * getting flushed to disk, we don't want to reclaim it.
1637          */
1638         if (!xfs_dqflock_nowait(dqp))
1639                 goto out_unlock_move_tail;
1640
1641         if (XFS_DQ_IS_DIRTY(dqp)) {
1642                 struct xfs_buf  *bp = NULL;
1643
1644                 trace_xfs_dqreclaim_dirty(dqp);
1645
1646                 error = xfs_qm_dqflush(dqp, &bp);
1647                 if (error) {
1648                         xfs_warn(mp, "%s: dquot %p flush failed",
1649                                  __func__, dqp);
1650                         goto out_unlock_move_tail;
1651                 }
1652
1653                 xfs_buf_delwri_queue(bp, buffer_list);
1654                 xfs_buf_relse(bp);
1655                 /*
1656                  * Give the dquot another try on the freelist, as the
1657                  * flushing will take some time.
1658                  */
1659                 goto out_unlock_move_tail;
1660         }
1661         xfs_dqfunlock(dqp);
1662
1663         /*
1664          * Prevent lookups now that we are past the point of no return.
1665          */
1666         dqp->dq_flags |= XFS_DQ_FREEING;
1667         xfs_dqunlock(dqp);
1668
1669         ASSERT(dqp->q_nrefs == 0);
1670         list_move_tail(&dqp->q_lru, dispose_list);
1671         qi->qi_lru_count--;
1672         XFS_STATS_DEC(xs_qm_dquot_unused);
1673
1674         trace_xfs_dqreclaim_done(dqp);
1675         XFS_STATS_INC(xs_qm_dqreclaims);
1676         return;
1677
1678         /*
1679          * Move the dquot to the tail of the list so that we don't spin on it.
1680          */
1681 out_unlock_move_tail:
1682         xfs_dqunlock(dqp);
1683 out_move_tail:
1684         list_move_tail(&dqp->q_lru, &qi->qi_lru_list);
1685         trace_xfs_dqreclaim_busy(dqp);
1686         XFS_STATS_INC(xs_qm_dqreclaim_misses);
1687 }
1688
1689 STATIC int
1690 xfs_qm_shake(
1691         struct shrinker         *shrink,
1692         struct shrink_control   *sc)
1693 {
1694         struct xfs_quotainfo    *qi =
1695                 container_of(shrink, struct xfs_quotainfo, qi_shrinker);
1696         int                     nr_to_scan = sc->nr_to_scan;
1697         LIST_HEAD               (buffer_list);
1698         LIST_HEAD               (dispose_list);
1699         struct xfs_dquot        *dqp;
1700         int                     error;
1701
1702         if ((sc->gfp_mask & (__GFP_FS|__GFP_WAIT)) != (__GFP_FS|__GFP_WAIT))
1703                 return 0;
1704         if (!nr_to_scan)
1705                 goto out;
1706
1707         mutex_lock(&qi->qi_lru_lock);
1708         while (!list_empty(&qi->qi_lru_list)) {
1709                 if (nr_to_scan-- <= 0)
1710                         break;
1711                 dqp = list_first_entry(&qi->qi_lru_list, struct xfs_dquot,
1712                                        q_lru);
1713                 xfs_qm_dqreclaim_one(dqp, &buffer_list, &dispose_list);
1714         }
1715         mutex_unlock(&qi->qi_lru_lock);
1716
1717         error = xfs_buf_delwri_submit(&buffer_list);
1718         if (error)
1719                 xfs_warn(NULL, "%s: dquot reclaim failed", __func__);
1720
1721         while (!list_empty(&dispose_list)) {
1722                 dqp = list_first_entry(&dispose_list, struct xfs_dquot, q_lru);
1723                 list_del_init(&dqp->q_lru);
1724                 xfs_qm_dqfree_one(dqp);
1725         }
1726
1727 out:
1728         return (qi->qi_lru_count / 100) * sysctl_vfs_cache_pressure;
1729 }
1730
1731 /*
1732  * Start a transaction and write the incore superblock changes to
1733  * disk. flags parameter indicates which fields have changed.
1734  */
1735 int
1736 xfs_qm_write_sb_changes(
1737         xfs_mount_t     *mp,
1738         __int64_t       flags)
1739 {
1740         xfs_trans_t     *tp;
1741         int             error;
1742
1743         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
1744         error = xfs_trans_reserve(tp, 0, XFS_QM_SBCHANGE_LOG_RES(mp),
1745                                   0, 0, XFS_DEFAULT_LOG_COUNT);
1746         if (error) {
1747                 xfs_trans_cancel(tp, 0);
1748                 return error;
1749         }
1750
1751         xfs_mod_sb(tp, flags);
1752         error = xfs_trans_commit(tp, 0);
1753
1754         return error;
1755 }
1756
1757
1758 /* --------------- utility functions for vnodeops ---------------- */
1759
1760
1761 /*
1762  * Given an inode, a uid, gid and prid make sure that we have
1763  * allocated relevant dquot(s) on disk, and that we won't exceed inode
1764  * quotas by creating this file.
1765  * This also attaches dquot(s) to the given inode after locking it,
1766  * and returns the dquots corresponding to the uid and/or gid.
1767  *
1768  * in   : inode (unlocked)
1769  * out  : udquot, gdquot with references taken and unlocked
1770  */
1771 int
1772 xfs_qm_vop_dqalloc(
1773         struct xfs_inode        *ip,
1774         uid_t                   uid,
1775         gid_t                   gid,
1776         prid_t                  prid,
1777         uint                    flags,
1778         struct xfs_dquot        **O_udqpp,
1779         struct xfs_dquot        **O_gdqpp,
1780         struct xfs_dquot        **O_pdqpp)
1781 {
1782         struct xfs_mount        *mp = ip->i_mount;
1783         struct xfs_dquot        *uq = NULL;
1784         struct xfs_dquot        *gq = NULL;
1785         struct xfs_dquot        *pq = NULL;
1786         int                     error;
1787         uint                    lockflags;
1788
1789         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
1790                 return 0;
1791
1792         lockflags = XFS_ILOCK_EXCL;
1793         xfs_ilock(ip, lockflags);
1794
1795         if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
1796                 gid = ip->i_d.di_gid;
1797
1798         /*
1799          * Attach the dquot(s) to this inode, doing a dquot allocation
1800          * if necessary. The dquot(s) will not be locked.
1801          */
1802         if (XFS_NOT_DQATTACHED(mp, ip)) {
1803                 error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);
1804                 if (error) {
1805                         xfs_iunlock(ip, lockflags);
1806                         return error;
1807                 }
1808         }
1809
1810         if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
1811                 if (ip->i_d.di_uid != uid) {
1812                         /*
1813                          * What we need is the dquot that has this uid, and
1814                          * if we send the inode to dqget, the uid of the inode
1815                          * takes priority over what's sent in the uid argument.
1816                          * We must unlock inode here before calling dqget if
1817                          * we're not sending the inode, because otherwise
1818                          * we'll deadlock by doing trans_reserve while
1819                          * holding ilock.
1820                          */
1821                         xfs_iunlock(ip, lockflags);
1822                         error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
1823                                                  XFS_DQ_USER,
1824                                                  XFS_QMOPT_DQALLOC |
1825                                                  XFS_QMOPT_DOWARN,
1826                                                  &uq);
1827                         if (error) {
1828                                 ASSERT(error != ENOENT);
1829                                 return error;
1830                         }
1831                         /*
1832                          * Get the ilock in the right order.
1833                          */
1834                         xfs_dqunlock(uq);
1835                         lockflags = XFS_ILOCK_SHARED;
1836                         xfs_ilock(ip, lockflags);
1837                 } else {
1838                         /*
1839                          * Take an extra reference, because we'll return
1840                          * this to caller
1841                          */
1842                         ASSERT(ip->i_udquot);
1843                         uq = xfs_qm_dqhold(ip->i_udquot);
1844                 }
1845         }
1846         if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
1847                 if (ip->i_d.di_gid != gid) {
1848                         xfs_iunlock(ip, lockflags);
1849                         error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
1850                                                  XFS_DQ_GROUP,
1851                                                  XFS_QMOPT_DQALLOC |
1852                                                  XFS_QMOPT_DOWARN,
1853                                                  &gq);
1854                         if (error) {
1855                                 ASSERT(error != ENOENT);
1856                                 goto error_rele;
1857                         }
1858                         xfs_dqunlock(gq);
1859                         lockflags = XFS_ILOCK_SHARED;
1860                         xfs_ilock(ip, lockflags);
1861                 } else {
1862                         ASSERT(ip->i_gdquot);
1863                         gq = xfs_qm_dqhold(ip->i_gdquot);
1864                 }
1865         }
1866         if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
1867                 if (xfs_get_projid(ip) != prid) {
1868                         xfs_iunlock(ip, lockflags);
1869                         error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
1870                                                  XFS_DQ_PROJ,
1871                                                  XFS_QMOPT_DQALLOC |
1872                                                  XFS_QMOPT_DOWARN,
1873                                                  &pq);
1874                         if (error) {
1875                                 ASSERT(error != ENOENT);
1876                                 goto error_rele;
1877                         }
1878                         xfs_dqunlock(pq);
1879                         lockflags = XFS_ILOCK_SHARED;
1880                         xfs_ilock(ip, lockflags);
1881                 } else {
1882                         ASSERT(ip->i_pdquot);
1883                         pq = xfs_qm_dqhold(ip->i_pdquot);
1884                 }
1885         }
1886         if (uq)
1887                 trace_xfs_dquot_dqalloc(ip);
1888
1889         xfs_iunlock(ip, lockflags);
1890         if (O_udqpp)
1891                 *O_udqpp = uq;
1892         else if (uq)
1893                 xfs_qm_dqrele(uq);
1894         if (O_gdqpp)
1895                 *O_gdqpp = gq;
1896         else if (gq)
1897                 xfs_qm_dqrele(gq);
1898         if (O_pdqpp)
1899                 *O_pdqpp = pq;
1900         else if (pq)
1901                 xfs_qm_dqrele(pq);
1902         return 0;
1903
1904 error_rele:
1905         if (gq)
1906                 xfs_qm_dqrele(gq);
1907         if (uq)
1908                 xfs_qm_dqrele(uq);
1909         return error;
1910 }
1911
1912 /*
1913  * Actually transfer ownership, and do dquot modifications.
1914  * These were already reserved.
1915  */
1916 xfs_dquot_t *
1917 xfs_qm_vop_chown(
1918         xfs_trans_t     *tp,
1919         xfs_inode_t     *ip,
1920         xfs_dquot_t     **IO_olddq,
1921         xfs_dquot_t     *newdq)
1922 {
1923         xfs_dquot_t     *prevdq;
1924         uint            bfield = XFS_IS_REALTIME_INODE(ip) ?
1925                                  XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
1926
1927
1928         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1929         ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
1930
1931         /* old dquot */
1932         prevdq = *IO_olddq;
1933         ASSERT(prevdq);
1934         ASSERT(prevdq != newdq);
1935
1936         xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
1937         xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
1938
1939         /* the sparkling new dquot */
1940         xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
1941         xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
1942
1943         /*
1944          * Take an extra reference, because the inode is going to keep
1945          * this dquot pointer even after the trans_commit.
1946          */
1947         *IO_olddq = xfs_qm_dqhold(newdq);
1948
1949         return prevdq;
1950 }
1951
1952 /*
1953  * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
1954  */
1955 int
1956 xfs_qm_vop_chown_reserve(
1957         struct xfs_trans        *tp,
1958         struct xfs_inode        *ip,
1959         struct xfs_dquot        *udqp,
1960         struct xfs_dquot        *gdqp,
1961         struct xfs_dquot        *pdqp,
1962         uint                    flags)
1963 {
1964         struct xfs_mount        *mp = ip->i_mount;
1965         uint                    delblks, blkflags, prjflags = 0;
1966         struct xfs_dquot        *udq_unres = NULL;
1967         struct xfs_dquot        *gdq_unres = NULL;
1968         struct xfs_dquot        *pdq_unres = NULL;
1969         struct xfs_dquot        *udq_delblks = NULL;
1970         struct xfs_dquot        *gdq_delblks = NULL;
1971         struct xfs_dquot        *pdq_delblks = NULL;
1972         int                     error;
1973
1974
1975         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
1976         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1977
1978         delblks = ip->i_delayed_blks;
1979         blkflags = XFS_IS_REALTIME_INODE(ip) ?
1980                         XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
1981
1982         if (XFS_IS_UQUOTA_ON(mp) && udqp &&
1983             ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
1984                 udq_delblks = udqp;
1985                 /*
1986                  * If there are delayed allocation blocks, then we have to
1987                  * unreserve those from the old dquot, and add them to the
1988                  * new dquot.
1989                  */
1990                 if (delblks) {
1991                         ASSERT(ip->i_udquot);
1992                         udq_unres = ip->i_udquot;
1993                 }
1994         }
1995         if (XFS_IS_GQUOTA_ON(ip->i_mount) && gdqp &&
1996             ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id)) {
1997                 gdq_delblks = gdqp;
1998                 if (delblks) {
1999                         ASSERT(ip->i_gdquot);
2000                         gdq_unres = ip->i_gdquot;
2001                 }
2002         }
2003
2004         if (XFS_IS_PQUOTA_ON(ip->i_mount) && pdqp &&
2005             xfs_get_projid(ip) != be32_to_cpu(pdqp->q_core.d_id)) {
2006                 prjflags = XFS_QMOPT_ENOSPC;
2007                 pdq_delblks = pdqp;
2008                 if (delblks) {
2009                         ASSERT(ip->i_pdquot);
2010                         pdq_unres = ip->i_pdquot;
2011                 }
2012         }
2013
2014         error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2015                                 udq_delblks, gdq_delblks, pdq_delblks,
2016                                 ip->i_d.di_nblocks, 1,
2017                                 flags | blkflags | prjflags);
2018         if (error)
2019                 return error;
2020
2021         /*
2022          * Do the delayed blks reservations/unreservations now. Since, these
2023          * are done without the help of a transaction, if a reservation fails
2024          * its previous reservations won't be automatically undone by trans
2025          * code. So, we have to do it manually here.
2026          */
2027         if (delblks) {
2028                 /*
2029                  * Do the reservations first. Unreservation can't fail.
2030                  */
2031                 ASSERT(udq_delblks || gdq_delblks || pdq_delblks);
2032                 ASSERT(udq_unres || gdq_unres || pdq_unres);
2033                 error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2034                             udq_delblks, gdq_delblks, pdq_delblks,
2035                             (xfs_qcnt_t)delblks, 0,
2036                             flags | blkflags | prjflags);
2037                 if (error)
2038                         return error;
2039                 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2040                                 udq_unres, gdq_unres, pdq_unres,
2041                                 -((xfs_qcnt_t)delblks), 0, blkflags);
2042         }
2043
2044         return (0);
2045 }
2046
2047 int
2048 xfs_qm_vop_rename_dqattach(
2049         struct xfs_inode        **i_tab)
2050 {
2051         struct xfs_mount        *mp = i_tab[0]->i_mount;
2052         int                     i;
2053
2054         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
2055                 return 0;
2056
2057         for (i = 0; (i < 4 && i_tab[i]); i++) {
2058                 struct xfs_inode        *ip = i_tab[i];
2059                 int                     error;
2060
2061                 /*
2062                  * Watch out for duplicate entries in the table.
2063                  */
2064                 if (i == 0 || ip != i_tab[i-1]) {
2065                         if (XFS_NOT_DQATTACHED(mp, ip)) {
2066                                 error = xfs_qm_dqattach(ip, 0);
2067                                 if (error)
2068                                         return error;
2069                         }
2070                 }
2071         }
2072         return 0;
2073 }
2074
2075 void
2076 xfs_qm_vop_create_dqattach(
2077         struct xfs_trans        *tp,
2078         struct xfs_inode        *ip,
2079         struct xfs_dquot        *udqp,
2080         struct xfs_dquot        *gdqp,
2081         struct xfs_dquot        *pdqp)
2082 {
2083         struct xfs_mount        *mp = tp->t_mountp;
2084
2085         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
2086                 return;
2087
2088         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2089         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2090
2091         if (udqp) {
2092                 ASSERT(ip->i_udquot == NULL);
2093                 ASSERT(XFS_IS_UQUOTA_ON(mp));
2094                 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
2095
2096                 ip->i_udquot = xfs_qm_dqhold(udqp);
2097                 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2098         }
2099         if (gdqp) {
2100                 ASSERT(ip->i_gdquot == NULL);
2101                 ASSERT(XFS_IS_GQUOTA_ON(mp));
2102                 ASSERT(ip->i_d.di_gid == be32_to_cpu(gdqp->q_core.d_id));
2103                 ip->i_gdquot = xfs_qm_dqhold(gdqp);
2104                 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2105         }
2106         if (pdqp) {
2107                 ASSERT(ip->i_pdquot == NULL);
2108                 ASSERT(XFS_IS_PQUOTA_ON(mp));
2109                 ASSERT(xfs_get_projid(ip) == be32_to_cpu(pdqp->q_core.d_id));
2110
2111                 ip->i_pdquot = xfs_qm_dqhold(pdqp);
2112                 xfs_trans_mod_dquot(tp, pdqp, XFS_TRANS_DQ_ICOUNT, 1);
2113         }
2114 }
2115