fs/xfs/quota/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_bit.h"
  21 #include "xfs_log.h"
  22 #include "xfs_inum.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
  45 /*
  46  * The global quota manager. There is only one of these for the entire
  47  * system, _not_ one per file system. XQM keeps track of the overall
  48  * quota functionality, including maintaining the freelist and hash
  49  * tables of dquots.
  50  */
  51 struct mutex    xfs_Gqm_lock;
  52 struct xfs_qm   *xfs_Gqm;
  53 uint            ndquot;
  54
  55 kmem_zone_t     *qm_dqzone;
  56 kmem_zone_t     *qm_dqtrxzone;
  57
  58 static cred_t   xfs_zerocr;
  59
  60 STATIC void     xfs_qm_list_init(xfs_dqlist_t *, char *, int);
  61 STATIC void     xfs_qm_list_destroy(xfs_dqlist_t *);
  62
  63 STATIC int      xfs_qm_init_quotainos(xfs_mount_t *);
  64 STATIC int      xfs_qm_init_quotainfo(xfs_mount_t *);
  65 STATIC int      xfs_qm_shake(struct shrinker *, int, gfp_t);
  66
  67 static struct shrinker xfs_qm_shaker = {
  68         .shrink = xfs_qm_shake,
  69         .seeks = DEFAULT_SEEKS,
  70 };
  71
  72 #ifdef DEBUG
  73 extern struct mutex     qcheck_lock;
  74 #endif
  75
  76 #ifdef QUOTADEBUG
  77 static void
  78 xfs_qm_dquot_list_print(
  79         struct xfs_mount *mp)
  80 {
  81         xfs_dquot_t     *dqp;
  82         int             i = 0;
  83
  84         list_for_each_entry(dqp, &mp->m_quotainfo->qi_dqlist_lock, qi_mplist) {
  85                 cmn_err(CE_DEBUG, "   %d. \"%d (%s)\"   "
  86                                   "bcnt = %lld, icnt = %lld, refs = %d",
  87                         i++, be32_to_cpu(dqp->q_core.d_id),
  88                         DQFLAGTO_TYPESTR(dqp),
  89                         (long long)be64_to_cpu(dqp->q_core.d_bcount),
  90                         (long long)be64_to_cpu(dqp->q_core.d_icount),
  91                         dqp->q_nrefs);
  92         }
  93 }
  94 #else
  95 static void xfs_qm_dquot_list_print(struct xfs_mount *mp) { }
  96 #endif
  97
  98 /*
  99  * Initialize the XQM structure.
 100  * Note that there is not one quota manager per file system.
 101  */
 102 STATIC struct xfs_qm *
 103 xfs_Gqm_init(void)
 104 {
 105         xfs_dqhash_t    *udqhash, *gdqhash;
 106         xfs_qm_t        *xqm;
 107         size_t          hsize;
 108         uint            i;
 109
 110         /*
 111          * Initialize the dquot hash tables.
 112          */
 113         udqhash = kmem_zalloc_greedy(&hsize,
 114                                      XFS_QM_HASHSIZE_LOW * sizeof(xfs_dqhash_t),
 115                                      XFS_QM_HASHSIZE_HIGH * sizeof(xfs_dqhash_t));
 116         if (!udqhash)
 117                 goto out;
 118
 119         gdqhash = kmem_zalloc_large(hsize);
 120         if (!gdqhash)
 121                 goto out_free_udqhash;
 122
 123         hsize /= sizeof(xfs_dqhash_t);
 124         ndquot = hsize << 8;
 125
 126         xqm = kmem_zalloc(sizeof(xfs_qm_t), KM_SLEEP);
 127         xqm->qm_dqhashmask = hsize - 1;
 128         xqm->qm_usr_dqhtable = udqhash;
 129         xqm->qm_grp_dqhtable = gdqhash;
 130         ASSERT(xqm->qm_usr_dqhtable != NULL);
 131         ASSERT(xqm->qm_grp_dqhtable != NULL);
 132
 133         for (i = 0; i < hsize; i++) {
 134                 xfs_qm_list_init(&(xqm->qm_usr_dqhtable[i]), "uxdqh", i);
 135                 xfs_qm_list_init(&(xqm->qm_grp_dqhtable[i]), "gxdqh", i);
 136         }
 137
 138         /*
 139          * Freelist of all dquots of all file systems
 140          */
 141         INIT_LIST_HEAD(&xqm->qm_dqfrlist);
 142         xqm->qm_dqfrlist_cnt = 0;
 143         mutex_init(&xqm->qm_dqfrlist_lock);
 144
 145         /*
 146          * dquot zone. we register our own low-memory callback.
 147          */
 148         if (!qm_dqzone) {
 149                 xqm->qm_dqzone = kmem_zone_init(sizeof(xfs_dquot_t),
 150                                                 "xfs_dquots");
 151                 qm_dqzone = xqm->qm_dqzone;
 152         } else
 153                 xqm->qm_dqzone = qm_dqzone;
 154
 155         register_shrinker(&xfs_qm_shaker);
 156
 157         /*
 158          * The t_dqinfo portion of transactions.
 159          */
 160         if (!qm_dqtrxzone) {
 161                 xqm->qm_dqtrxzone = kmem_zone_init(sizeof(xfs_dquot_acct_t),
 162                                                    "xfs_dqtrx");
 163                 qm_dqtrxzone = xqm->qm_dqtrxzone;
 164         } else
 165                 xqm->qm_dqtrxzone = qm_dqtrxzone;
 166
 167         atomic_set(&xqm->qm_totaldquots, 0);
 168         xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
 169         xqm->qm_nrefs = 0;
 170 #ifdef DEBUG
 171         mutex_init(&qcheck_lock);
 172 #endif
 173         return xqm;
 174
 175  out_free_udqhash:
 176         kmem_free_large(udqhash);
 177  out:
 178         return NULL;
 179 }
 180
 181 /*
 182  * Destroy the global quota manager when its reference count goes to zero.
 183  */
 184 STATIC void
 185 xfs_qm_destroy(
 186         struct xfs_qm   *xqm)
 187 {
 188         struct xfs_dquot *dqp, *n;
 189         int             hsize, i;
 190
 191         ASSERT(xqm != NULL);
 192         ASSERT(xqm->qm_nrefs == 0);
 193         unregister_shrinker(&xfs_qm_shaker);
 194         hsize = xqm->qm_dqhashmask + 1;
 195         for (i = 0; i < hsize; i++) {
 196                 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
 197                 xfs_qm_list_destroy(&(xqm->qm_grp_dqhtable[i]));
 198         }
 199         kmem_free_large(xqm->qm_usr_dqhtable);
 200         kmem_free_large(xqm->qm_grp_dqhtable);
 201         xqm->qm_usr_dqhtable = NULL;
 202         xqm->qm_grp_dqhtable = NULL;
 203         xqm->qm_dqhashmask = 0;
 204
 205         /* frlist cleanup */
 206         mutex_lock(&xqm->qm_dqfrlist_lock);
 207         list_for_each_entry_safe(dqp, n, &xqm->qm_dqfrlist, q_freelist) {
 208                 xfs_dqlock(dqp);
 209 #ifdef QUOTADEBUG
 210                 cmn_err(CE_DEBUG, "FREELIST destroy 0x%p", dqp);
 211 #endif
 212                 list_del_init(&dqp->q_freelist);
 213                 xfs_Gqm->qm_dqfrlist_cnt--;
 214                 xfs_dqunlock(dqp);
 215                 xfs_qm_dqdestroy(dqp);
 216         }
 217         mutex_unlock(&xqm->qm_dqfrlist_lock);
 218         mutex_destroy(&xqm->qm_dqfrlist_lock);
 219 #ifdef DEBUG
 220         mutex_destroy(&qcheck_lock);
 221 #endif
 222         kmem_free(xqm);
 223 }
 224
 225 /*
 226  * Called at mount time to let XQM know that another file system is
 227  * starting quotas. This isn't crucial information as the individual mount
 228  * structures are pretty independent, but it helps the XQM keep a
 229  * global view of what's going on.
 230  */
 231 /* ARGSUSED */
 232 STATIC int
 233 xfs_qm_hold_quotafs_ref(
 234         struct xfs_mount *mp)
 235 {
 236         /*
 237          * Need to lock the xfs_Gqm structure for things like this. For example,
 238          * the structure could disappear between the entry to this routine and
 239          * a HOLD operation if not locked.
 240          */
 241         mutex_lock(&xfs_Gqm_lock);
 242
 243         if (!xfs_Gqm) {
 244                 xfs_Gqm = xfs_Gqm_init();
 245                 if (!xfs_Gqm) {
 246                         mutex_unlock(&xfs_Gqm_lock);
 247                         return ENOMEM;
 248                 }
 249         }
 250
 251         /*
 252          * We can keep a list of all filesystems with quotas mounted for
 253          * debugging and statistical purposes, but ...
 254          * Just take a reference and get out.
 255          */
 256         xfs_Gqm->qm_nrefs++;
 257         mutex_unlock(&xfs_Gqm_lock);
 258
 259         return 0;
 260 }
 261
 262
 263 /*
 264  * Release the reference that a filesystem took at mount time,
 265  * so that we know when we need to destroy the entire quota manager.
 266  */
 267 /* ARGSUSED */
 268 STATIC void
 269 xfs_qm_rele_quotafs_ref(
 270         struct xfs_mount *mp)
 271 {
 272         xfs_dquot_t     *dqp, *n;
 273
 274         ASSERT(xfs_Gqm);
 275         ASSERT(xfs_Gqm->qm_nrefs > 0);
 276
 277         /*
 278          * Go thru the freelist and destroy all inactive dquots.
 279          */
 280         mutex_lock(&xfs_Gqm->qm_dqfrlist_lock);
 281
 282         list_for_each_entry_safe(dqp, n, &xfs_Gqm->qm_dqfrlist, q_freelist) {
 283                 xfs_dqlock(dqp);
 284                 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
 285                         ASSERT(dqp->q_mount == NULL);
 286                         ASSERT(! XFS_DQ_IS_DIRTY(dqp));
 287                         ASSERT(list_empty(&dqp->q_hashlist));
 288                         ASSERT(list_empty(&dqp->q_mplist));
 289                         list_del_init(&dqp->q_freelist);
 290                         xfs_Gqm->qm_dqfrlist_cnt--;
 291                         xfs_dqunlock(dqp);
 292                         xfs_qm_dqdestroy(dqp);
 293                 } else {
 294                         xfs_dqunlock(dqp);
 295                 }
 296         }
 297         mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
 298
 299         /*
 300          * Destroy the entire XQM. If somebody mounts with quotaon, this'll
 301          * be restarted.
 302          */
 303         mutex_lock(&xfs_Gqm_lock);
 304         if (--xfs_Gqm->qm_nrefs == 0) {
 305                 xfs_qm_destroy(xfs_Gqm);
 306                 xfs_Gqm = NULL;
 307         }
 308         mutex_unlock(&xfs_Gqm_lock);
 309 }
 310
 311 /*
 312  * Just destroy the quotainfo structure.
 313  */
 314 void
 315 xfs_qm_unmount(
 316         struct xfs_mount        *mp)
 317 {
 318         if (mp->m_quotainfo) {
 319                 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
 320                 xfs_qm_destroy_quotainfo(mp);
 321         }
 322 }
 323
 324
 325 /*
 326  * This is called from xfs_mountfs to start quotas and initialize all
 327  * necessary data structures like quotainfo.  This is also responsible for
 328  * running a quotacheck as necessary.  We are guaranteed that the superblock
 329  * is consistently read in at this point.
 330  *
 331  * If we fail here, the mount will continue with quota turned off. We don't
 332  * need to inidicate success or failure at all.
 333  */
 334 void
 335 xfs_qm_mount_quotas(
 336         xfs_mount_t     *mp)
 337 {
 338         int             error = 0;
 339         uint            sbf;
 340
 341         /*
 342          * If quotas on realtime volumes is not supported, we disable
 343          * quotas immediately.
 344          */
 345         if (mp->m_sb.sb_rextents) {
 346                 cmn_err(CE_NOTE,
 347                         "Cannot turn on quotas for realtime filesystem %s",
 348                         mp->m_fsname);
 349                 mp->m_qflags = 0;
 350                 goto write_changes;
 351         }
 352
 353         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 354
 355         /*
 356          * Allocate the quotainfo structure inside the mount struct, and
 357          * create quotainode(s), and change/rev superblock if necessary.
 358          */
 359         error = xfs_qm_init_quotainfo(mp);
 360         if (error) {
 361                 /*
 362                  * We must turn off quotas.
 363                  */
 364                 ASSERT(mp->m_quotainfo == NULL);
 365                 mp->m_qflags = 0;
 366                 goto write_changes;
 367         }
 368         /*
 369          * If any of the quotas are not consistent, do a quotacheck.
 370          */
 371         if (XFS_QM_NEED_QUOTACHECK(mp)) {
 372                 error = xfs_qm_quotacheck(mp);
 373                 if (error) {
 374                         /* Quotacheck failed and disabled quotas. */
 375                         return;
 376                 }
 377         }
 378         /*
 379          * If one type of quotas is off, then it will lose its
 380          * quotachecked status, since we won't be doing accounting for
 381          * that type anymore.
 382          */
 383         if (!XFS_IS_UQUOTA_ON(mp))
 384                 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
 385         if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
 386                 mp->m_qflags &= ~XFS_OQUOTA_CHKD;
 387
 388  write_changes:
 389         /*
 390          * We actually don't have to acquire the m_sb_lock at all.
 391          * This can only be called from mount, and that's single threaded. XXX
 392          */
 393         spin_lock(&mp->m_sb_lock);
 394         sbf = mp->m_sb.sb_qflags;
 395         mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
 396         spin_unlock(&mp->m_sb_lock);
 397
 398         if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
 399                 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) {
 400                         /*
 401                          * We could only have been turning quotas off.
 402                          * We aren't in very good shape actually because
 403                          * the incore structures are convinced that quotas are
 404                          * off, but the on disk superblock doesn't know that !
 405                          */
 406                         ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
 407                         xfs_fs_cmn_err(CE_ALERT, mp,
 408                                 "XFS mount_quotas: Superblock update failed!");
 409                 }
 410         }
 411
 412         if (error) {
 413                 xfs_fs_cmn_err(CE_WARN, mp,
 414                         "Failed to initialize disk quotas.");
 415                 return;
 416         }
 417
 418 #ifdef QUOTADEBUG
 419         if (XFS_IS_QUOTA_ON(mp))
 420                 xfs_qm_internalqcheck(mp);
 421 #endif
 422 }
 423
 424 /*
 425  * Called from the vfsops layer.
 426  */
 427 void
 428 xfs_qm_unmount_quotas(
 429         xfs_mount_t     *mp)
 430 {
 431         /*
 432          * Release the dquots that root inode, et al might be holding,
 433          * before we flush quotas and blow away the quotainfo structure.
 434          */
 435         ASSERT(mp->m_rootip);
 436         xfs_qm_dqdetach(mp->m_rootip);
 437         if (mp->m_rbmip)
 438                 xfs_qm_dqdetach(mp->m_rbmip);
 439         if (mp->m_rsumip)
 440                 xfs_qm_dqdetach(mp->m_rsumip);
 441
 442         /*
 443          * Release the quota inodes.
 444          */
 445         if (mp->m_quotainfo) {
 446                 if (mp->m_quotainfo->qi_uquotaip) {
 447                         IRELE(mp->m_quotainfo->qi_uquotaip);
 448                         mp->m_quotainfo->qi_uquotaip = NULL;
 449                 }
 450                 if (mp->m_quotainfo->qi_gquotaip) {
 451                         IRELE(mp->m_quotainfo->qi_gquotaip);
 452                         mp->m_quotainfo->qi_gquotaip = NULL;
 453                 }
 454         }
 455 }
 456
 457 /*
 458  * Flush all dquots of the given file system to disk. The dquots are
 459  * _not_ purged from memory here, just their data written to disk.
 460  */
 461 STATIC int
 462 xfs_qm_dqflush_all(
 463         struct xfs_mount        *mp,
 464         int                     sync_mode)
 465 {
 466         struct xfs_quotainfo    *q = mp->m_quotainfo;
 467         int                     recl;
 468         struct xfs_dquot        *dqp;
 469         int                     niters;
 470         int                     error;
 471
 472         if (!q)
 473                 return 0;
 474         niters = 0;
 475 again:
 476         mutex_lock(&q->qi_dqlist_lock);
 477         list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
 478                 xfs_dqlock(dqp);
 479                 if (! XFS_DQ_IS_DIRTY(dqp)) {
 480                         xfs_dqunlock(dqp);
 481                         continue;
 482                 }
 483
 484                 /* XXX a sentinel would be better */
 485                 recl = q->qi_dqreclaims;
 486                 if (!xfs_dqflock_nowait(dqp)) {
 487                         /*
 488                          * If we can't grab the flush lock then check
 489                          * to see if the dquot has been flushed delayed
 490                          * write.  If so, grab its buffer and send it
 491                          * out immediately.  We'll be able to acquire
 492                          * the flush lock when the I/O completes.
 493                          */
 494                         xfs_qm_dqflock_pushbuf_wait(dqp);
 495                 }
 496                 /*
 497                  * Let go of the mplist lock. We don't want to hold it
 498                  * across a disk write.
 499                  */
 500                 mutex_unlock(&q->qi_dqlist_lock);
 501                 error = xfs_qm_dqflush(dqp, sync_mode);
 502                 xfs_dqunlock(dqp);
 503                 if (error)
 504                         return error;
 505
 506                 mutex_lock(&q->qi_dqlist_lock);
 507                 if (recl != q->qi_dqreclaims) {
 508                         mutex_unlock(&q->qi_dqlist_lock);
 509                         /* XXX restart limit */
 510                         goto again;
 511                 }
 512         }
 513
 514         mutex_unlock(&q->qi_dqlist_lock);
 515         /* return ! busy */
 516         return 0;
 517 }
 518 /*
 519  * Release the group dquot pointers the user dquots may be
 520  * carrying around as a hint. mplist is locked on entry and exit.
 521  */
 522 STATIC void
 523 xfs_qm_detach_gdquots(
 524         struct xfs_mount        *mp)
 525 {
 526         struct xfs_quotainfo    *q = mp->m_quotainfo;
 527         struct xfs_dquot        *dqp, *gdqp;
 528         int                     nrecl;
 529
 530  again:
 531         ASSERT(mutex_is_locked(&q->qi_dqlist_lock));
 532         list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
 533                 xfs_dqlock(dqp);
 534                 if ((gdqp = dqp->q_gdquot)) {
 535                         xfs_dqlock(gdqp);
 536                         dqp->q_gdquot = NULL;
 537                 }
 538                 xfs_dqunlock(dqp);
 539
 540                 if (gdqp) {
 541                         /*
 542                          * Can't hold the mplist lock across a dqput.
 543                          * XXXmust convert to marker based iterations here.
 544                          */
 545                         nrecl = q->qi_dqreclaims;
 546                         mutex_unlock(&q->qi_dqlist_lock);
 547                         xfs_qm_dqput(gdqp);
 548
 549                         mutex_lock(&q->qi_dqlist_lock);
 550                         if (nrecl != q->qi_dqreclaims)
 551                                 goto again;
 552                 }
 553         }
 554 }
 555
 556 /*
 557  * Go through all the incore dquots of this file system and take them
 558  * off the mplist and hashlist, if the dquot type matches the dqtype
 559  * parameter. This is used when turning off quota accounting for
 560  * users and/or groups, as well as when the filesystem is unmounting.
 561  */
 562 STATIC int
 563 xfs_qm_dqpurge_int(
 564         struct xfs_mount        *mp,
 565         uint                    flags)
 566 {
 567         struct xfs_quotainfo    *q = mp->m_quotainfo;
 568         struct xfs_dquot        *dqp, *n;
 569         uint                    dqtype;
 570         int                     nrecl;
 571         int                     nmisses;
 572
 573         if (!q)
 574                 return 0;
 575
 576         dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;
 577         dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;
 578         dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;
 579
 580         mutex_lock(&q->qi_dqlist_lock);
 581
 582         /*
 583          * In the first pass through all incore dquots of this filesystem,
 584          * we release the group dquot pointers the user dquots may be
 585          * carrying around as a hint. We need to do this irrespective of
 586          * what's being turned off.
 587          */
 588         xfs_qm_detach_gdquots(mp);
 589
 590       again:
 591         nmisses = 0;
 592         ASSERT(mutex_is_locked(&q->qi_dqlist_lock));
 593         /*
 594          * Try to get rid of all of the unwanted dquots. The idea is to
 595          * get them off mplist and hashlist, but leave them on freelist.
 596          */
 597         list_for_each_entry_safe(dqp, n, &q->qi_dqlist, q_mplist) {
 598                 /*
 599                  * It's OK to look at the type without taking dqlock here.
 600                  * We're holding the mplist lock here, and that's needed for
 601                  * a dqreclaim.
 602                  */
 603                 if ((dqp->dq_flags & dqtype) == 0)
 604                         continue;
 605
 606                 if (!mutex_trylock(&dqp->q_hash->qh_lock)) {
 607                         nrecl = q->qi_dqreclaims;
 608                         mutex_unlock(&q->qi_dqlist_lock);
 609                         mutex_lock(&dqp->q_hash->qh_lock);
 610                         mutex_lock(&q->qi_dqlist_lock);
 611
 612                         /*
 613                          * XXXTheoretically, we can get into a very long
 614                          * ping pong game here.
 615                          * No one can be adding dquots to the mplist at
 616                          * this point, but somebody might be taking things off.
 617                          */
 618                         if (nrecl != q->qi_dqreclaims) {
 619                                 mutex_unlock(&dqp->q_hash->qh_lock);
 620                                 goto again;
 621                         }
 622                 }
 623
 624                 /*
 625                  * Take the dquot off the mplist and hashlist. It may remain on
 626                  * freelist in INACTIVE state.
 627                  */
 628                 nmisses += xfs_qm_dqpurge(dqp);
 629         }
 630         mutex_unlock(&q->qi_dqlist_lock);
 631         return nmisses;
 632 }
 633
 634 int
 635 xfs_qm_dqpurge_all(
 636         xfs_mount_t     *mp,
 637         uint            flags)
 638 {
 639         int             ndquots;
 640
 641         /*
 642          * Purge the dquot cache.
 643          * None of the dquots should really be busy at this point.
 644          */
 645         if (mp->m_quotainfo) {
 646                 while ((ndquots = xfs_qm_dqpurge_int(mp, flags))) {
 647                         delay(ndquots * 10);
 648                 }
 649         }
 650         return 0;
 651 }
 652
 653 STATIC int
 654 xfs_qm_dqattach_one(
 655         xfs_inode_t     *ip,
 656         xfs_dqid_t      id,
 657         uint            type,
 658         uint            doalloc,
 659         xfs_dquot_t     *udqhint, /* hint */
 660         xfs_dquot_t     **IO_idqpp)
 661 {
 662         xfs_dquot_t     *dqp;
 663         int             error;
 664
 665         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 666         error = 0;
 667
 668         /*
 669          * See if we already have it in the inode itself. IO_idqpp is
 670          * &i_udquot or &i_gdquot. This made the code look weird, but
 671          * made the logic a lot simpler.
 672          */
 673         dqp = *IO_idqpp;
 674         if (dqp) {
 675                 trace_xfs_dqattach_found(dqp);
 676                 return 0;
 677         }
 678
 679         /*
 680          * udqhint is the i_udquot field in inode, and is non-NULL only
 681          * when the type arg is group/project. Its purpose is to save a
 682          * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside
 683          * the user dquot.
 684          */
 685         if (udqhint) {
 686                 ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ);
 687                 xfs_dqlock(udqhint);
 688
 689                 /*
 690                  * No need to take dqlock to look at the id.
 691                  *
 692                  * The ID can't change until it gets reclaimed, and it won't
 693                  * be reclaimed as long as we have a ref from inode and we
 694                  * hold the ilock.
 695                  */
 696                 dqp = udqhint->q_gdquot;
 697                 if (dqp && be32_to_cpu(dqp->q_core.d_id) == id) {
 698                         xfs_dqlock(dqp);
 699                         XFS_DQHOLD(dqp);
 700                         ASSERT(*IO_idqpp == NULL);
 701                         *IO_idqpp = dqp;
 702
 703                         xfs_dqunlock(dqp);
 704                         xfs_dqunlock(udqhint);
 705                         return 0;
 706                 }
 707
 708                 /*
 709                  * We can't hold a dquot lock when we call the dqget code.
 710                  * We'll deadlock in no time, because of (not conforming to)
 711                  * lock ordering - the inodelock comes before any dquot lock,
 712                  * and we may drop and reacquire the ilock in xfs_qm_dqget().
 713                  */
 714                 xfs_dqunlock(udqhint);
 715         }
 716
 717         /*
 718          * Find the dquot from somewhere. This bumps the
 719          * reference count of dquot and returns it locked.
 720          * This can return ENOENT if dquot didn't exist on
 721          * disk and we didn't ask it to allocate;
 722          * ESRCH if quotas got turned off suddenly.
 723          */
 724         error = xfs_qm_dqget(ip->i_mount, ip, id, type, XFS_QMOPT_DOWARN, &dqp);
 725         if (error)
 726                 return error;
 727
 728         trace_xfs_dqattach_get(dqp);
 729
 730         /*
 731          * dqget may have dropped and re-acquired the ilock, but it guarantees
 732          * that the dquot returned is the one that should go in the inode.
 733          */
 734         *IO_idqpp = dqp;
 735         xfs_dqunlock(dqp);
 736         return 0;
 737 }
 738
 739
 740 /*
 741  * Given a udquot and gdquot, attach a ptr to the group dquot in the
 742  * udquot as a hint for future lookups. The idea sounds simple, but the
 743  * execution isn't, because the udquot might have a group dquot attached
 744  * already and getting rid of that gets us into lock ordering constraints.
 745  * The process is complicated more by the fact that the dquots may or may not
 746  * be locked on entry.
 747  */
 748 STATIC void
 749 xfs_qm_dqattach_grouphint(
 750         xfs_dquot_t     *udq,
 751         xfs_dquot_t     *gdq)
 752 {
 753         xfs_dquot_t     *tmp;
 754
 755         xfs_dqlock(udq);
 756
 757         if ((tmp = udq->q_gdquot)) {
 758                 if (tmp == gdq) {
 759                         xfs_dqunlock(udq);
 760                         return;
 761                 }
 762
 763                 udq->q_gdquot = NULL;
 764                 /*
 765                  * We can't keep any dqlocks when calling dqrele,
 766                  * because the freelist lock comes before dqlocks.
 767                  */
 768                 xfs_dqunlock(udq);
 769                 /*
 770                  * we took a hard reference once upon a time in dqget,
 771                  * so give it back when the udquot no longer points at it
 772                  * dqput() does the unlocking of the dquot.
 773                  */
 774                 xfs_qm_dqrele(tmp);
 775
 776                 xfs_dqlock(udq);
 777                 xfs_dqlock(gdq);
 778
 779         } else {
 780                 ASSERT(XFS_DQ_IS_LOCKED(udq));
 781                 xfs_dqlock(gdq);
 782         }
 783
 784         ASSERT(XFS_DQ_IS_LOCKED(udq));
 785         ASSERT(XFS_DQ_IS_LOCKED(gdq));
 786         /*
 787          * Somebody could have attached a gdquot here,
 788          * when we dropped the uqlock. If so, just do nothing.
 789          */
 790         if (udq->q_gdquot == NULL) {
 791                 XFS_DQHOLD(gdq);
 792                 udq->q_gdquot = gdq;
 793         }
 794
 795         xfs_dqunlock(gdq);
 796         xfs_dqunlock(udq);
 797 }
 798
 799
 800 /*
 801  * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
 802  * into account.
 803  * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
 804  * Inode may get unlocked and relocked in here, and the caller must deal with
 805  * the consequences.
 806  */
 807 int
 808 xfs_qm_dqattach_locked(
 809         xfs_inode_t     *ip,
 810         uint            flags)
 811 {
 812         xfs_mount_t     *mp = ip->i_mount;
 813         uint            nquotas = 0;
 814         int             error = 0;
 815
 816         if (!XFS_IS_QUOTA_RUNNING(mp) ||
 817             !XFS_IS_QUOTA_ON(mp) ||
 818             !XFS_NOT_DQATTACHED(mp, ip) ||
 819             ip->i_ino == mp->m_sb.sb_uquotino ||
 820             ip->i_ino == mp->m_sb.sb_gquotino)
 821                 return 0;
 822
 823         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 824
 825         if (XFS_IS_UQUOTA_ON(mp)) {
 826                 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
 827                                                 flags & XFS_QMOPT_DQALLOC,
 828                                                 NULL, &ip->i_udquot);
 829                 if (error)
 830                         goto done;
 831                 nquotas++;
 832         }
 833
 834         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 835         if (XFS_IS_OQUOTA_ON(mp)) {
 836                 error = XFS_IS_GQUOTA_ON(mp) ?
 837                         xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
 838                                                 flags & XFS_QMOPT_DQALLOC,
 839                                                 ip->i_udquot, &ip->i_gdquot) :
 840                         xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
 841                                                 flags & XFS_QMOPT_DQALLOC,
 842                                                 ip->i_udquot, &ip->i_gdquot);
 843                 /*
 844                  * Don't worry about the udquot that we may have
 845                  * attached above. It'll get detached, if not already.
 846                  */
 847                 if (error)
 848                         goto done;
 849                 nquotas++;
 850         }
 851
 852         /*
 853          * Attach this group quota to the user quota as a hint.
 854          * This WON'T, in general, result in a thrash.
 855          */
 856         if (nquotas == 2) {
 857                 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 858                 ASSERT(ip->i_udquot);
 859                 ASSERT(ip->i_gdquot);
 860
 861                 /*
 862                  * We may or may not have the i_udquot locked at this point,
 863                  * but this check is OK since we don't depend on the i_gdquot to
 864                  * be accurate 100% all the time. It is just a hint, and this
 865                  * will succeed in general.
 866                  */
 867                 if (ip->i_udquot->q_gdquot == ip->i_gdquot)
 868                         goto done;
 869                 /*
 870                  * Attach i_gdquot to the gdquot hint inside the i_udquot.
 871                  */
 872                 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot);
 873         }
 874
 875  done:
 876 #ifdef QUOTADEBUG
 877         if (! error) {
 878                 if (XFS_IS_UQUOTA_ON(mp))
 879                         ASSERT(ip->i_udquot);
 880                 if (XFS_IS_OQUOTA_ON(mp))
 881                         ASSERT(ip->i_gdquot);
 882         }
 883         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 884 #endif
 885         return error;
 886 }
 887
 888 int
 889 xfs_qm_dqattach(
 890         struct xfs_inode        *ip,
 891         uint                    flags)
 892 {
 893         int                     error;
 894
 895         xfs_ilock(ip, XFS_ILOCK_EXCL);
 896         error = xfs_qm_dqattach_locked(ip, flags);
 897         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 898
 899         return error;
 900 }
 901
 902 /*
 903  * Release dquots (and their references) if any.
 904  * The inode should be locked EXCL except when this's called by
 905  * xfs_ireclaim.
 906  */
 907 void
 908 xfs_qm_dqdetach(
 909         xfs_inode_t     *ip)
 910 {
 911         if (!(ip->i_udquot || ip->i_gdquot))
 912                 return;
 913
 914         trace_xfs_dquot_dqdetach(ip);
 915
 916         ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
 917         ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
 918         if (ip->i_udquot) {
 919                 xfs_qm_dqrele(ip->i_udquot);
 920                 ip->i_udquot = NULL;
 921         }
 922         if (ip->i_gdquot) {
 923                 xfs_qm_dqrele(ip->i_gdquot);
 924                 ip->i_gdquot = NULL;
 925         }
 926 }
 927
 928 int
 929 xfs_qm_sync(
 930         struct xfs_mount        *mp,
 931         int                     flags)
 932 {
 933         struct xfs_quotainfo    *q = mp->m_quotainfo;
 934         int                     recl, restarts;
 935         struct xfs_dquot        *dqp;
 936         int                     error;
 937
 938         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
 939                 return 0;
 940
 941         restarts = 0;
 942
 943   again:
 944         mutex_lock(&q->qi_dqlist_lock);
 945         /*
 946          * dqpurge_all() also takes the mplist lock and iterate thru all dquots
 947          * in quotaoff. However, if the QUOTA_ACTIVE bits are not cleared
 948          * when we have the mplist lock, we know that dquots will be consistent
 949          * as long as we have it locked.
 950          */
 951         if (!XFS_IS_QUOTA_ON(mp)) {
 952                 mutex_unlock(&q->qi_dqlist_lock);
 953                 return 0;
 954         }
 955         ASSERT(mutex_is_locked(&q->qi_dqlist_lock));
 956         list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {
 957                 /*
 958                  * If this is vfs_sync calling, then skip the dquots that
 959                  * don't 'seem' to be dirty. ie. don't acquire dqlock.
 960                  * This is very similar to what xfs_sync does with inodes.
 961                  */
 962                 if (flags & SYNC_TRYLOCK) {
 963                         if (!XFS_DQ_IS_DIRTY(dqp))
 964                                 continue;
 965                         if (!xfs_qm_dqlock_nowait(dqp))
 966                                 continue;
 967                 } else {
 968                         xfs_dqlock(dqp);
 969                 }
 970
 971                 /*
 972                  * Now, find out for sure if this dquot is dirty or not.
 973                  */
 974                 if (! XFS_DQ_IS_DIRTY(dqp)) {
 975                         xfs_dqunlock(dqp);
 976                         continue;
 977                 }
 978
 979                 /* XXX a sentinel would be better */
 980                 recl = q->qi_dqreclaims;
 981                 if (!xfs_dqflock_nowait(dqp)) {
 982                         if (flags & SYNC_TRYLOCK) {
 983                                 xfs_dqunlock(dqp);
 984                                 continue;
 985                         }
 986                         /*
 987                          * If we can't grab the flush lock then if the caller
 988                          * really wanted us to give this our best shot, so
 989                          * see if we can give a push to the buffer before we wait
 990                          * on the flush lock. At this point, we know that
 991                          * even though the dquot is being flushed,
 992                          * it has (new) dirty data.
 993                          */
 994                         xfs_qm_dqflock_pushbuf_wait(dqp);
 995                 }
 996                 /*
 997                  * Let go of the mplist lock. We don't want to hold it
 998                  * across a disk write
 999                  */
1000                 mutex_unlock(&q->qi_dqlist_lock);
1001                 error = xfs_qm_dqflush(dqp, flags);
1002                 xfs_dqunlock(dqp);
1003                 if (error && XFS_FORCED_SHUTDOWN(mp))
1004                         return 0;       /* Need to prevent umount failure */
1005                 else if (error)
1006                         return error;
1007
1008                 mutex_lock(&q->qi_dqlist_lock);
1009                 if (recl != q->qi_dqreclaims) {
1010                         if (++restarts >= XFS_QM_SYNC_MAX_RESTARTS)
1011                                 break;
1012
1013                         mutex_unlock(&q->qi_dqlist_lock);
1014                         goto again;
1015                 }
1016         }
1017
1018         mutex_unlock(&q->qi_dqlist_lock);
1019         return 0;
1020 }
1021
1022 /*
1023  * The hash chains and the mplist use the same xfs_dqhash structure as
1024  * their list head, but we can take the mplist qh_lock and one of the
1025  * hash qh_locks at the same time without any problem as they aren't
1026  * related.
1027  */
1028 static struct lock_class_key xfs_quota_mplist_class;
1029
1030 /*
1031  * This initializes all the quota information that's kept in the
1032  * mount structure
1033  */
1034 STATIC int
1035 xfs_qm_init_quotainfo(
1036         xfs_mount_t     *mp)
1037 {
1038         xfs_quotainfo_t *qinf;
1039         int             error;
1040         xfs_dquot_t     *dqp;
1041
1042         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1043
1044         /*
1045          * Tell XQM that we exist as soon as possible.
1046          */
1047         if ((error = xfs_qm_hold_quotafs_ref(mp))) {
1048                 return error;
1049         }
1050
1051         qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP);
1052
1053         /*
1054          * See if quotainodes are setup, and if not, allocate them,
1055          * and change the superblock accordingly.
1056          */
1057         if ((error = xfs_qm_init_quotainos(mp))) {
1058                 kmem_free(qinf);
1059                 mp->m_quotainfo = NULL;
1060                 return error;
1061         }
1062
1063         INIT_LIST_HEAD(&qinf->qi_dqlist);
1064         mutex_init(&qinf->qi_dqlist_lock);
1065         lockdep_set_class(&qinf->qi_dqlist_lock, &xfs_quota_mplist_class);
1066
1067         qinf->qi_dqreclaims = 0;
1068
1069         /* mutex used to serialize quotaoffs */
1070         mutex_init(&qinf->qi_quotaofflock);
1071
1072         /* Precalc some constants */
1073         qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1074         ASSERT(qinf->qi_dqchunklen);
1075         qinf->qi_dqperchunk = BBTOB(qinf->qi_dqchunklen);
1076         do_div(qinf->qi_dqperchunk, sizeof(xfs_dqblk_t));
1077
1078         mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
1079
1080         /*
1081          * We try to get the limits from the superuser's limits fields.
1082          * This is quite hacky, but it is standard quota practice.
1083          * We look at the USR dquot with id == 0 first, but if user quotas
1084          * are not enabled we goto the GRP dquot with id == 0.
1085          * We don't really care to keep separate default limits for user
1086          * and group quotas, at least not at this point.
1087          */
1088         error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)0,
1089                              XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
1090                              (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
1091                                 XFS_DQ_PROJ),
1092                              XFS_QMOPT_DQSUSER|XFS_QMOPT_DOWARN,
1093                              &dqp);
1094         if (! error) {
1095                 xfs_disk_dquot_t        *ddqp = &dqp->q_core;
1096
1097                 /*
1098                  * The warnings and timers set the grace period given to
1099                  * a user or group before he or she can not perform any
1100                  * more writing. If it is zero, a default is used.
1101                  */
1102                 qinf->qi_btimelimit = ddqp->d_btimer ?
1103                         be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;
1104                 qinf->qi_itimelimit = ddqp->d_itimer ?
1105                         be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;
1106                 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?
1107                         be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;
1108                 qinf->qi_bwarnlimit = ddqp->d_bwarns ?
1109                         be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;
1110                 qinf->qi_iwarnlimit = ddqp->d_iwarns ?
1111                         be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;
1112                 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?
1113                         be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;
1114                 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
1115                 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
1116                 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
1117                 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
1118                 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
1119                 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
1120
1121                 /*
1122                  * We sent the XFS_QMOPT_DQSUSER flag to dqget because
1123                  * we don't want this dquot cached. We haven't done a
1124                  * quotacheck yet, and quotacheck doesn't like incore dquots.
1125                  */
1126                 xfs_qm_dqdestroy(dqp);
1127         } else {
1128                 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
1129                 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
1130                 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
1131                 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
1132                 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
1133                 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;
1134         }
1135
1136         return 0;
1137 }
1138
1139
1140 /*
1141  * Gets called when unmounting a filesystem or when all quotas get
1142  * turned off.
1143  * This purges the quota inodes, destroys locks and frees itself.
1144  */
1145 void
1146 xfs_qm_destroy_quotainfo(
1147         xfs_mount_t     *mp)
1148 {
1149         xfs_quotainfo_t *qi;
1150
1151         qi = mp->m_quotainfo;
1152         ASSERT(qi != NULL);
1153         ASSERT(xfs_Gqm != NULL);
1154
1155         /*
1156          * Release the reference that XQM kept, so that we know
1157          * when the XQM structure should be freed. We cannot assume
1158          * that xfs_Gqm is non-null after this point.
1159          */
1160         xfs_qm_rele_quotafs_ref(mp);
1161
1162         ASSERT(list_empty(&qi->qi_dqlist));
1163         mutex_destroy(&qi->qi_dqlist_lock);
1164
1165         if (qi->qi_uquotaip) {
1166                 IRELE(qi->qi_uquotaip);
1167                 qi->qi_uquotaip = NULL; /* paranoia */
1168         }
1169         if (qi->qi_gquotaip) {
1170                 IRELE(qi->qi_gquotaip);
1171                 qi->qi_gquotaip = NULL;
1172         }
1173         mutex_destroy(&qi->qi_quotaofflock);
1174         kmem_free(qi);
1175         mp->m_quotainfo = NULL;
1176 }
1177
1178
1179
1180 /* ------------------- PRIVATE STATIC FUNCTIONS ----------------------- */
1181
1182 /* ARGSUSED */
1183 STATIC void
1184 xfs_qm_list_init(
1185         xfs_dqlist_t    *list,
1186         char            *str,
1187         int             n)
1188 {
1189         mutex_init(&list->qh_lock);
1190         INIT_LIST_HEAD(&list->qh_list);
1191         list->qh_version = 0;
1192         list->qh_nelems = 0;
1193 }
1194
1195 STATIC void
1196 xfs_qm_list_destroy(
1197         xfs_dqlist_t    *list)
1198 {
1199         mutex_destroy(&(list->qh_lock));
1200 }
1201
1202
1203 /*
1204  * Stripped down version of dqattach. This doesn't attach, or even look at the
1205  * dquots attached to the inode. The rationale is that there won't be any
1206  * attached at the time this is called from quotacheck.
1207  */
1208 STATIC int
1209 xfs_qm_dqget_noattach(
1210         xfs_inode_t     *ip,
1211         xfs_dquot_t     **O_udqpp,
1212         xfs_dquot_t     **O_gdqpp)
1213 {
1214         int             error;
1215         xfs_mount_t     *mp;
1216         xfs_dquot_t     *udqp, *gdqp;
1217
1218         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
1219         mp = ip->i_mount;
1220         udqp = NULL;
1221         gdqp = NULL;
1222
1223         if (XFS_IS_UQUOTA_ON(mp)) {
1224                 ASSERT(ip->i_udquot == NULL);
1225                 /*
1226                  * We want the dquot allocated if it doesn't exist.
1227                  */
1228                 if ((error = xfs_qm_dqget(mp, ip, ip->i_d.di_uid, XFS_DQ_USER,
1229                                          XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN,
1230                                          &udqp))) {
1231                         /*
1232                          * Shouldn't be able to turn off quotas here.
1233                          */
1234                         ASSERT(error != ESRCH);
1235                         ASSERT(error != ENOENT);
1236                         return error;
1237                 }
1238                 ASSERT(udqp);
1239         }
1240
1241         if (XFS_IS_OQUOTA_ON(mp)) {
1242                 ASSERT(ip->i_gdquot == NULL);
1243                 if (udqp)
1244                         xfs_dqunlock(udqp);
1245                 error = XFS_IS_GQUOTA_ON(mp) ?
1246                                 xfs_qm_dqget(mp, ip,
1247                                              ip->i_d.di_gid, XFS_DQ_GROUP,
1248                                              XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1249                                              &gdqp) :
1250                                 xfs_qm_dqget(mp, ip,
1251                                              ip->i_d.di_projid, XFS_DQ_PROJ,
1252                                              XFS_QMOPT_DQALLOC|XFS_QMOPT_DOWARN,
1253                                              &gdqp);
1254                 if (error) {
1255                         if (udqp)
1256                                 xfs_qm_dqrele(udqp);
1257                         ASSERT(error != ESRCH);
1258                         ASSERT(error != ENOENT);
1259                         return error;
1260                 }
1261                 ASSERT(gdqp);
1262
1263                 /* Reacquire the locks in the right order */
1264                 if (udqp) {
1265                         if (! xfs_qm_dqlock_nowait(udqp)) {
1266                                 xfs_dqunlock(gdqp);
1267                                 xfs_dqlock(udqp);
1268                                 xfs_dqlock(gdqp);
1269                         }
1270                 }
1271         }
1272
1273         *O_udqpp = udqp;
1274         *O_gdqpp = gdqp;
1275
1276 #ifdef QUOTADEBUG
1277         if (udqp) ASSERT(XFS_DQ_IS_LOCKED(udqp));
1278         if (gdqp) ASSERT(XFS_DQ_IS_LOCKED(gdqp));
1279 #endif
1280         return 0;
1281 }
1282
1283 /*
1284  * Create an inode and return with a reference already taken, but unlocked
1285  * This is how we create quota inodes
1286  */
1287 STATIC int
1288 xfs_qm_qino_alloc(
1289         xfs_mount_t     *mp,
1290         xfs_inode_t     **ip,
1291         __int64_t       sbfields,
1292         uint            flags)
1293 {
1294         xfs_trans_t     *tp;
1295         int             error;
1296         int             committed;
1297
1298         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE);
1299         if ((error = xfs_trans_reserve(tp,
1300                                       XFS_QM_QINOCREATE_SPACE_RES(mp),
1301                                       XFS_CREATE_LOG_RES(mp), 0,
1302                                       XFS_TRANS_PERM_LOG_RES,
1303                                       XFS_CREATE_LOG_COUNT))) {
1304                 xfs_trans_cancel(tp, 0);
1305                 return error;
1306         }
1307
1308         if ((error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0,
1309                                    &xfs_zerocr, 0, 1, ip, &committed))) {
1310                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
1311                                  XFS_TRANS_ABORT);
1312                 return error;
1313         }
1314
1315         /*
1316          * Keep an extra reference to this quota inode. This inode is
1317          * locked exclusively and joined to the transaction already.
1318          */
1319         ASSERT(xfs_isilocked(*ip, XFS_ILOCK_EXCL));
1320         IHOLD(*ip);
1321
1322         /*
1323          * Make the changes in the superblock, and log those too.
1324          * sbfields arg may contain fields other than *QUOTINO;
1325          * VERSIONNUM for example.
1326          */
1327         spin_lock(&mp->m_sb_lock);
1328         if (flags & XFS_QMOPT_SBVERSION) {
1329                 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
1330                 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1331                                    XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
1332                        (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1333                         XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
1334
1335                 xfs_sb_version_addquota(&mp->m_sb);
1336                 mp->m_sb.sb_uquotino = NULLFSINO;
1337                 mp->m_sb.sb_gquotino = NULLFSINO;
1338
1339                 /* qflags will get updated _after_ quotacheck */
1340                 mp->m_sb.sb_qflags = 0;
1341         }
1342         if (flags & XFS_QMOPT_UQUOTA)
1343                 mp->m_sb.sb_uquotino = (*ip)->i_ino;
1344         else
1345                 mp->m_sb.sb_gquotino = (*ip)->i_ino;
1346         spin_unlock(&mp->m_sb_lock);
1347         xfs_mod_sb(tp, sbfields);
1348
1349         if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) {
1350                 xfs_fs_cmn_err(CE_ALERT, mp, "XFS qino_alloc failed!");
1351                 return error;
1352         }
1353         return 0;
1354 }
1355
1356
1357 STATIC void
1358 xfs_qm_reset_dqcounts(
1359         xfs_mount_t     *mp,
1360         xfs_buf_t       *bp,
1361         xfs_dqid_t      id,
1362         uint            type)
1363 {
1364         xfs_disk_dquot_t        *ddq;
1365         int                     j;
1366
1367         trace_xfs_reset_dqcounts(bp, _RET_IP_);
1368
1369         /*
1370          * Reset all counters and timers. They'll be
1371          * started afresh by xfs_qm_quotacheck.
1372          */
1373 #ifdef DEBUG
1374         j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
1375         do_div(j, sizeof(xfs_dqblk_t));
1376         ASSERT(mp->m_quotainfo->qi_dqperchunk == j);
1377 #endif
1378         ddq = (xfs_disk_dquot_t *)XFS_BUF_PTR(bp);
1379         for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {
1380                 /*
1381                  * Do a sanity check, and if needed, repair the dqblk. Don't
1382                  * output any warnings because it's perfectly possible to
1383                  * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
1384                  */
1385                 (void) xfs_qm_dqcheck(ddq, id+j, type, XFS_QMOPT_DQREPAIR,
1386                                       "xfs_quotacheck");
1387                 ddq->d_bcount = 0;
1388                 ddq->d_icount = 0;
1389                 ddq->d_rtbcount = 0;
1390                 ddq->d_btimer = 0;
1391                 ddq->d_itimer = 0;
1392                 ddq->d_rtbtimer = 0;
1393                 ddq->d_bwarns = 0;
1394                 ddq->d_iwarns = 0;
1395                 ddq->d_rtbwarns = 0;
1396                 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);
1397         }
1398 }
1399
1400 STATIC int
1401 xfs_qm_dqiter_bufs(
1402         xfs_mount_t     *mp,
1403         xfs_dqid_t      firstid,
1404         xfs_fsblock_t   bno,
1405         xfs_filblks_t   blkcnt,
1406         uint            flags)
1407 {
1408         xfs_buf_t       *bp;
1409         int             error;
1410         int             notcommitted;
1411         int             incr;
1412         int             type;
1413
1414         ASSERT(blkcnt > 0);
1415         notcommitted = 0;
1416         incr = (blkcnt > XFS_QM_MAX_DQCLUSTER_LOGSZ) ?
1417                 XFS_QM_MAX_DQCLUSTER_LOGSZ : blkcnt;
1418         type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
1419                 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
1420         error = 0;
1421
1422         /*
1423          * Blkcnt arg can be a very big number, and might even be
1424          * larger than the log itself. So, we have to break it up into
1425          * manageable-sized transactions.
1426          * Note that we don't start a permanent transaction here; we might
1427          * not be able to get a log reservation for the whole thing up front,
1428          * and we don't really care to either, because we just discard
1429          * everything if we were to crash in the middle of this loop.
1430          */
1431         while (blkcnt--) {
1432                 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
1433                               XFS_FSB_TO_DADDR(mp, bno),
1434                               mp->m_quotainfo->qi_dqchunklen, 0, &bp);
1435                 if (error)
1436                         break;
1437
1438                 xfs_qm_reset_dqcounts(mp, bp, firstid, type);
1439                 xfs_bdwrite(mp, bp);
1440                 /*
1441                  * goto the next block.
1442                  */
1443                 bno++;
1444                 firstid += mp->m_quotainfo->qi_dqperchunk;
1445         }
1446         return error;
1447 }
1448
1449 /*
1450  * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a
1451  * caller supplied function for every chunk of dquots that we find.
1452  */
1453 STATIC int
1454 xfs_qm_dqiterate(
1455         xfs_mount_t     *mp,
1456         xfs_inode_t     *qip,
1457         uint            flags)
1458 {
1459         xfs_bmbt_irec_t         *map;
1460         int                     i, nmaps;       /* number of map entries */
1461         int                     error;          /* return value */
1462         xfs_fileoff_t           lblkno;
1463         xfs_filblks_t           maxlblkcnt;
1464         xfs_dqid_t              firstid;
1465         xfs_fsblock_t           rablkno;
1466         xfs_filblks_t           rablkcnt;
1467
1468         error = 0;
1469         /*
1470          * This looks racy, but we can't keep an inode lock across a
1471          * trans_reserve. But, this gets called during quotacheck, and that
1472          * happens only at mount time which is single threaded.
1473          */
1474         if (qip->i_d.di_nblocks == 0)
1475                 return 0;
1476
1477         map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP);
1478
1479         lblkno = 0;
1480         maxlblkcnt = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1481         do {
1482                 nmaps = XFS_DQITER_MAP_SIZE;
1483                 /*
1484                  * We aren't changing the inode itself. Just changing
1485                  * some of its data. No new blocks are added here, and
1486                  * the inode is never added to the transaction.
1487                  */
1488                 xfs_ilock(qip, XFS_ILOCK_SHARED);
1489                 error = xfs_bmapi(NULL, qip, lblkno,
1490                                   maxlblkcnt - lblkno,
1491                                   XFS_BMAPI_METADATA,
1492                                   NULL,
1493                                   0, map, &nmaps, NULL);
1494                 xfs_iunlock(qip, XFS_ILOCK_SHARED);
1495                 if (error)
1496                         break;
1497
1498                 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
1499                 for (i = 0; i < nmaps; i++) {
1500                         ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
1501                         ASSERT(map[i].br_blockcount);
1502
1503
1504                         lblkno += map[i].br_blockcount;
1505
1506                         if (map[i].br_startblock == HOLESTARTBLOCK)
1507                                 continue;
1508
1509                         firstid = (xfs_dqid_t) map[i].br_startoff *
1510                                 mp->m_quotainfo->qi_dqperchunk;
1511                         /*
1512                          * Do a read-ahead on the next extent.
1513                          */
1514                         if ((i+1 < nmaps) &&
1515                             (map[i+1].br_startblock != HOLESTARTBLOCK)) {
1516                                 rablkcnt =  map[i+1].br_blockcount;
1517                                 rablkno = map[i+1].br_startblock;
1518                                 while (rablkcnt--) {
1519                                         xfs_baread(mp->m_ddev_targp,
1520                                                XFS_FSB_TO_DADDR(mp, rablkno),
1521                                                mp->m_quotainfo->qi_dqchunklen);
1522                                         rablkno++;
1523                                 }
1524                         }
1525                         /*
1526                          * Iterate thru all the blks in the extent and
1527                          * reset the counters of all the dquots inside them.
1528                          */
1529                         if ((error = xfs_qm_dqiter_bufs(mp,
1530                                                        firstid,
1531                                                        map[i].br_startblock,
1532                                                        map[i].br_blockcount,
1533                                                        flags))) {
1534                                 break;
1535                         }
1536                 }
1537
1538                 if (error)
1539                         break;
1540         } while (nmaps > 0);
1541
1542         kmem_free(map);
1543
1544         return error;
1545 }
1546
1547 /*
1548  * Called by dqusage_adjust in doing a quotacheck.
1549  * Given the inode, and a dquot (either USR or GRP, doesn't matter),
1550  * this updates its incore copy as well as the buffer copy. This is
1551  * so that once the quotacheck is done, we can just log all the buffers,
1552  * as opposed to logging numerous updates to individual dquots.
1553  */
1554 STATIC void
1555 xfs_qm_quotacheck_dqadjust(
1556         xfs_dquot_t             *dqp,
1557         xfs_qcnt_t              nblks,
1558         xfs_qcnt_t              rtblks)
1559 {
1560         ASSERT(XFS_DQ_IS_LOCKED(dqp));
1561
1562         trace_xfs_dqadjust(dqp);
1563
1564         /*
1565          * Adjust the inode count and the block count to reflect this inode's
1566          * resource usage.
1567          */
1568         be64_add_cpu(&dqp->q_core.d_icount, 1);
1569         dqp->q_res_icount++;
1570         if (nblks) {
1571                 be64_add_cpu(&dqp->q_core.d_bcount, nblks);
1572                 dqp->q_res_bcount += nblks;
1573         }
1574         if (rtblks) {
1575                 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
1576                 dqp->q_res_rtbcount += rtblks;
1577         }
1578
1579         /*
1580          * Set default limits, adjust timers (since we changed usages)
1581          *
1582          * There are no timers for the default values set in the root dquot.
1583          */
1584         if (dqp->q_core.d_id) {
1585                 xfs_qm_adjust_dqlimits(dqp->q_mount, &dqp->q_core);
1586                 xfs_qm_adjust_dqtimers(dqp->q_mount, &dqp->q_core);
1587         }
1588
1589         dqp->dq_flags |= XFS_DQ_DIRTY;
1590 }
1591
1592 STATIC int
1593 xfs_qm_get_rtblks(
1594         xfs_inode_t     *ip,
1595         xfs_qcnt_t      *O_rtblks)
1596 {
1597         xfs_filblks_t   rtblks;                 /* total rt blks */
1598         xfs_extnum_t    idx;                    /* extent record index */
1599         xfs_ifork_t     *ifp;                   /* inode fork pointer */
1600         xfs_extnum_t    nextents;               /* number of extent entries */
1601         int             error;
1602
1603         ASSERT(XFS_IS_REALTIME_INODE(ip));
1604         ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);
1605         if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1606                 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK)))
1607                         return error;
1608         }
1609         rtblks = 0;
1610         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
1611         for (idx = 0; idx < nextents; idx++)
1612                 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx));
1613         *O_rtblks = (xfs_qcnt_t)rtblks;
1614         return 0;
1615 }
1616
1617 /*
1618  * callback routine supplied to bulkstat(). Given an inumber, find its
1619  * dquots and update them to account for resources taken by that inode.
1620  */
1621 /* ARGSUSED */
1622 STATIC int
1623 xfs_qm_dqusage_adjust(
1624         xfs_mount_t     *mp,            /* mount point for filesystem */
1625         xfs_ino_t       ino,            /* inode number to get data for */
1626         void            __user *buffer, /* not used */
1627         int             ubsize,         /* not used */
1628         int             *ubused,        /* not used */
1629         int             *res)           /* result code value */
1630 {
1631         xfs_inode_t     *ip;
1632         xfs_dquot_t     *udqp, *gdqp;
1633         xfs_qcnt_t      nblks, rtblks;
1634         int             error;
1635
1636         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1637
1638         /*
1639          * rootino must have its resources accounted for, not so with the quota
1640          * inodes.
1641          */
1642         if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1643                 *res = BULKSTAT_RV_NOTHING;
1644                 return XFS_ERROR(EINVAL);
1645         }
1646
1647         /*
1648          * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget
1649          * interface expects the inode to be exclusively locked because that's
1650          * the case in all other instances. It's OK that we do this because
1651          * quotacheck is done only at mount time.
1652          */
1653         if ((error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip))) {
1654                 *res = BULKSTAT_RV_NOTHING;
1655                 return error;
1656         }
1657
1658         /*
1659          * Obtain the locked dquots. In case of an error (eg. allocation
1660          * fails for ENOSPC), we return the negative of the error number
1661          * to bulkstat, so that it can get propagated to quotacheck() and
1662          * making us disable quotas for the file system.
1663          */
1664         if ((error = xfs_qm_dqget_noattach(ip, &udqp, &gdqp))) {
1665                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1666                 IRELE(ip);
1667                 *res = BULKSTAT_RV_GIVEUP;
1668                 return error;
1669         }
1670
1671         rtblks = 0;
1672         if (! XFS_IS_REALTIME_INODE(ip)) {
1673                 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks;
1674         } else {
1675                 /*
1676                  * Walk thru the extent list and count the realtime blocks.
1677                  */
1678                 if ((error = xfs_qm_get_rtblks(ip, &rtblks))) {
1679                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1680                         IRELE(ip);
1681                         if (udqp)
1682                                 xfs_qm_dqput(udqp);
1683                         if (gdqp)
1684                                 xfs_qm_dqput(gdqp);
1685                         *res = BULKSTAT_RV_GIVEUP;
1686                         return error;
1687                 }
1688                 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
1689         }
1690         ASSERT(ip->i_delayed_blks == 0);
1691
1692         /*
1693          * We can't release the inode while holding its dquot locks.
1694          * The inode can go into inactive and might try to acquire the dquotlocks.
1695          * So, just unlock here and do a vn_rele at the end.
1696          */
1697         xfs_iunlock(ip, XFS_ILOCK_EXCL);
1698
1699         /*
1700          * Add the (disk blocks and inode) resources occupied by this
1701          * inode to its dquots. We do this adjustment in the incore dquot,
1702          * and also copy the changes to its buffer.
1703          * We don't care about putting these changes in a transaction
1704          * envelope because if we crash in the middle of a 'quotacheck'
1705          * we have to start from the beginning anyway.
1706          * Once we're done, we'll log all the dquot bufs.
1707          *
1708          * The *QUOTA_ON checks below may look pretty racy, but quotachecks
1709          * and quotaoffs don't race. (Quotachecks happen at mount time only).
1710          */
1711         if (XFS_IS_UQUOTA_ON(mp)) {
1712                 ASSERT(udqp);
1713                 xfs_qm_quotacheck_dqadjust(udqp, nblks, rtblks);
1714                 xfs_qm_dqput(udqp);
1715         }
1716         if (XFS_IS_OQUOTA_ON(mp)) {
1717                 ASSERT(gdqp);
1718                 xfs_qm_quotacheck_dqadjust(gdqp, nblks, rtblks);
1719                 xfs_qm_dqput(gdqp);
1720         }
1721         /*
1722          * Now release the inode. This will send it to 'inactive', and
1723          * possibly even free blocks.
1724          */
1725         IRELE(ip);
1726
1727         /*
1728          * Goto next inode.
1729          */
1730         *res = BULKSTAT_RV_DIDONE;
1731         return 0;
1732 }
1733
1734 /*
1735  * Walk thru all the filesystem inodes and construct a consistent view
1736  * of the disk quota world. If the quotacheck fails, disable quotas.
1737  */
1738 int
1739 xfs_qm_quotacheck(
1740         xfs_mount_t     *mp)
1741 {
1742         int             done, count, error;
1743         xfs_ino_t       lastino;
1744         size_t          structsz;
1745         xfs_inode_t     *uip, *gip;
1746         uint            flags;
1747
1748         count = INT_MAX;
1749         structsz = 1;
1750         lastino = 0;
1751         flags = 0;
1752
1753         ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip);
1754         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1755
1756         /*
1757          * There should be no cached dquots. The (simplistic) quotacheck
1758          * algorithm doesn't like that.
1759          */
1760         ASSERT(list_empty(&mp->m_quotainfo->qi_dqlist));
1761
1762         cmn_err(CE_NOTE, "XFS quotacheck %s: Please wait.", mp->m_fsname);
1763
1764         /*
1765          * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
1766          * their counters to zero. We need a clean slate.
1767          * We don't log our changes till later.
1768          */
1769         uip = mp->m_quotainfo->qi_uquotaip;
1770         if (uip) {
1771                 error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA);
1772                 if (error)
1773                         goto error_return;
1774                 flags |= XFS_UQUOTA_CHKD;
1775         }
1776
1777         gip = mp->m_quotainfo->qi_gquotaip;
1778         if (gip) {
1779                 error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?
1780                                         XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1781                 if (error)
1782                         goto error_return;
1783                 flags |= XFS_OQUOTA_CHKD;
1784         }
1785
1786         do {
1787                 /*
1788                  * Iterate thru all the inodes in the file system,
1789                  * adjusting the corresponding dquot counters in core.
1790                  */
1791                 error = xfs_bulkstat(mp, &lastino, &count,
1792                                      xfs_qm_dqusage_adjust,
1793                                      structsz, NULL, &done);
1794                 if (error)
1795                         break;
1796
1797         } while (!done);
1798
1799         /*
1800          * We've made all the changes that we need to make incore.
1801          * Flush them down to disk buffers if everything was updated
1802          * successfully.
1803          */
1804         if (!error)
1805                 error = xfs_qm_dqflush_all(mp, 0);
1806
1807         /*
1808          * We can get this error if we couldn't do a dquot allocation inside
1809          * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
1810          * dirty dquots that might be cached, we just want to get rid of them
1811          * and turn quotaoff. The dquots won't be attached to any of the inodes
1812          * at this point (because we intentionally didn't in dqget_noattach).
1813          */
1814         if (error) {
1815                 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
1816                 goto error_return;
1817         }
1818
1819         /*
1820          * We didn't log anything, because if we crashed, we'll have to
1821          * start the quotacheck from scratch anyway. However, we must make
1822          * sure that our dquot changes are secure before we put the
1823          * quotacheck'd stamp on the superblock. So, here we do a synchronous
1824          * flush.
1825          */
1826         XFS_bflush(mp->m_ddev_targp);
1827
1828         /*
1829          * If one type of quotas is off, then it will lose its
1830          * quotachecked status, since we won't be doing accounting for
1831          * that type anymore.
1832          */
1833         mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
1834         mp->m_qflags |= flags;
1835
1836         xfs_qm_dquot_list_print(mp);
1837
1838  error_return:
1839         if (error) {
1840                 cmn_err(CE_WARN, "XFS quotacheck %s: Unsuccessful (Error %d): "
1841                         "Disabling quotas.",
1842                         mp->m_fsname, error);
1843                 /*
1844                  * We must turn off quotas.
1845                  */
1846                 ASSERT(mp->m_quotainfo != NULL);
1847                 ASSERT(xfs_Gqm != NULL);
1848                 xfs_qm_destroy_quotainfo(mp);
1849                 if (xfs_mount_reset_sbqflags(mp)) {
1850                         cmn_err(CE_WARN, "XFS quotacheck %s: "
1851                                 "Failed to reset quota flags.", mp->m_fsname);
1852                 }
1853         } else {
1854                 cmn_err(CE_NOTE, "XFS quotacheck %s: Done.", mp->m_fsname);
1855         }
1856         return (error);
1857 }
1858
1859 /*
1860  * This is called after the superblock has been read in and we're ready to
1861  * iget the quota inodes.
1862  */
1863 STATIC int
1864 xfs_qm_init_quotainos(
1865         xfs_mount_t     *mp)
1866 {
1867         xfs_inode_t     *uip, *gip;
1868         int             error;
1869         __int64_t       sbflags;
1870         uint            flags;
1871
1872         ASSERT(mp->m_quotainfo);
1873         uip = gip = NULL;
1874         sbflags = 0;
1875         flags = 0;
1876
1877         /*
1878          * Get the uquota and gquota inodes
1879          */
1880         if (xfs_sb_version_hasquota(&mp->m_sb)) {
1881                 if (XFS_IS_UQUOTA_ON(mp) &&
1882                     mp->m_sb.sb_uquotino != NULLFSINO) {
1883                         ASSERT(mp->m_sb.sb_uquotino > 0);
1884                         if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
1885                                              0, 0, &uip)))
1886                                 return XFS_ERROR(error);
1887                 }
1888                 if (XFS_IS_OQUOTA_ON(mp) &&
1889                     mp->m_sb.sb_gquotino != NULLFSINO) {
1890                         ASSERT(mp->m_sb.sb_gquotino > 0);
1891                         if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
1892                                              0, 0, &gip))) {
1893                                 if (uip)
1894                                         IRELE(uip);
1895                                 return XFS_ERROR(error);
1896                         }
1897                 }
1898         } else {
1899                 flags |= XFS_QMOPT_SBVERSION;
1900                 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
1901                             XFS_SB_GQUOTINO | XFS_SB_QFLAGS);
1902         }
1903
1904         /*
1905          * Create the two inodes, if they don't exist already. The changes
1906          * made above will get added to a transaction and logged in one of
1907          * the qino_alloc calls below.  If the device is readonly,
1908          * temporarily switch to read-write to do this.
1909          */
1910         if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1911                 if ((error = xfs_qm_qino_alloc(mp, &uip,
1912                                               sbflags | XFS_SB_UQUOTINO,
1913                                               flags | XFS_QMOPT_UQUOTA)))
1914                         return XFS_ERROR(error);
1915
1916                 flags &= ~XFS_QMOPT_SBVERSION;
1917         }
1918         if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) {
1919                 flags |= (XFS_IS_GQUOTA_ON(mp) ?
1920                                 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
1921                 error = xfs_qm_qino_alloc(mp, &gip,
1922                                           sbflags | XFS_SB_GQUOTINO, flags);
1923                 if (error) {
1924                         if (uip)
1925                                 IRELE(uip);
1926
1927                         return XFS_ERROR(error);
1928                 }
1929         }
1930
1931         mp->m_quotainfo->qi_uquotaip = uip;
1932         mp->m_quotainfo->qi_gquotaip = gip;
1933
1934         return 0;
1935 }
1936
1937
1938
1939 /*
1940  * Just pop the least recently used dquot off the freelist and
1941  * recycle it. The returned dquot is locked.
1942  */
1943 STATIC xfs_dquot_t *
1944 xfs_qm_dqreclaim_one(void)
1945 {
1946         xfs_dquot_t     *dqpout;
1947         xfs_dquot_t     *dqp;
1948         int             restarts;
1949
1950         restarts = 0;
1951         dqpout = NULL;
1952
1953         /* lockorder: hashchainlock, freelistlock, mplistlock, dqlock, dqflock */
1954 startagain:
1955         mutex_lock(&xfs_Gqm->qm_dqfrlist_lock);
1956
1957         list_for_each_entry(dqp, &xfs_Gqm->qm_dqfrlist, q_freelist) {
1958                 struct xfs_mount *mp = dqp->q_mount;
1959                 xfs_dqlock(dqp);
1960
1961                 /*
1962                  * We are racing with dqlookup here. Naturally we don't
1963                  * want to reclaim a dquot that lookup wants. We release the
1964                  * freelist lock and start over, so that lookup will grab
1965                  * both the dquot and the freelistlock.
1966                  */
1967                 if (dqp->dq_flags & XFS_DQ_WANT) {
1968                         ASSERT(! (dqp->dq_flags & XFS_DQ_INACTIVE));
1969
1970                         trace_xfs_dqreclaim_want(dqp);
1971
1972                         xfs_dqunlock(dqp);
1973                         mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
1974                         if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
1975                                 return NULL;
1976                         XQM_STATS_INC(xqmstats.xs_qm_dqwants);
1977                         goto startagain;
1978                 }
1979
1980                 /*
1981                  * If the dquot is inactive, we are assured that it is
1982                  * not on the mplist or the hashlist, and that makes our
1983                  * life easier.
1984                  */
1985                 if (dqp->dq_flags & XFS_DQ_INACTIVE) {
1986                         ASSERT(mp == NULL);
1987                         ASSERT(! XFS_DQ_IS_DIRTY(dqp));
1988                         ASSERT(list_empty(&dqp->q_hashlist));
1989                         ASSERT(list_empty(&dqp->q_mplist));
1990                         list_del_init(&dqp->q_freelist);
1991                         xfs_Gqm->qm_dqfrlist_cnt--;
1992                         xfs_dqunlock(dqp);
1993                         dqpout = dqp;
1994                         XQM_STATS_INC(xqmstats.xs_qm_dqinact_reclaims);
1995                         break;
1996                 }
1997
1998                 ASSERT(dqp->q_hash);
1999                 ASSERT(!list_empty(&dqp->q_mplist));
2000
2001                 /*
2002                  * Try to grab the flush lock. If this dquot is in the process of
2003                  * getting flushed to disk, we don't want to reclaim it.
2004                  */
2005                 if (!xfs_dqflock_nowait(dqp)) {
2006                         xfs_dqunlock(dqp);
2007                         continue;
2008                 }
2009
2010                 /*
2011                  * We have the flush lock so we know that this is not in the
2012                  * process of being flushed. So, if this is dirty, flush it
2013                  * DELWRI so that we don't get a freelist infested with
2014                  * dirty dquots.
2015                  */
2016                 if (XFS_DQ_IS_DIRTY(dqp)) {
2017                         int     error;
2018
2019                         trace_xfs_dqreclaim_dirty(dqp);
2020
2021                         /*
2022                          * We flush it delayed write, so don't bother
2023                          * releasing the freelist lock.
2024                          */
2025                         error = xfs_qm_dqflush(dqp, 0);
2026                         if (error) {
2027                                 xfs_fs_cmn_err(CE_WARN, mp,
2028                         "xfs_qm_dqreclaim: dquot %p flush failed", dqp);
2029                         }
2030                         xfs_dqunlock(dqp); /* dqflush unlocks dqflock */
2031                         continue;
2032                 }
2033
2034                 /*
2035                  * We're trying to get the hashlock out of order. This races
2036                  * with dqlookup; so, we giveup and goto the next dquot if
2037                  * we couldn't get the hashlock. This way, we won't starve
2038                  * a dqlookup process that holds the hashlock that is
2039                  * waiting for the freelist lock.
2040                  */
2041                 if (!mutex_trylock(&dqp->q_hash->qh_lock)) {
2042                         restarts++;
2043                         goto dqfunlock;
2044                 }
2045
2046                 /*
2047                  * This races with dquot allocation code as well as dqflush_all
2048                  * and reclaim code. So, if we failed to grab the mplist lock,
2049                  * giveup everything and start over.
2050                  */
2051                 if (!mutex_trylock(&mp->m_quotainfo->qi_dqlist_lock)) {
2052                         restarts++;
2053                         mutex_unlock(&dqp->q_hash->qh_lock);
2054                         xfs_dqfunlock(dqp);
2055                         xfs_dqunlock(dqp);
2056                         mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
2057                         if (restarts++ >= XFS_QM_RECLAIM_MAX_RESTARTS)
2058                                 return NULL;
2059                         goto startagain;
2060                 }
2061
2062                 ASSERT(dqp->q_nrefs == 0);
2063                 list_del_init(&dqp->q_mplist);
2064                 mp->m_quotainfo->qi_dquots--;
2065                 mp->m_quotainfo->qi_dqreclaims++;
2066                 list_del_init(&dqp->q_hashlist);
2067                 dqp->q_hash->qh_version++;
2068                 list_del_init(&dqp->q_freelist);
2069                 xfs_Gqm->qm_dqfrlist_cnt--;
2070                 dqpout = dqp;
2071                 mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);
2072                 mutex_unlock(&dqp->q_hash->qh_lock);
2073 dqfunlock:
2074                 xfs_dqfunlock(dqp);
2075                 xfs_dqunlock(dqp);
2076                 if (dqpout)
2077                         break;
2078                 if (restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
2079                         return NULL;
2080         }
2081         mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock);
2082         return dqpout;
2083 }
2084
2085 /*
2086  * Traverse the freelist of dquots and attempt to reclaim a maximum of
2087  * 'howmany' dquots. This operation races with dqlookup(), and attempts to
2088  * favor the lookup function ...
2089  */
2090 STATIC int
2091 xfs_qm_shake_freelist(
2092         int     howmany)
2093 {
2094         int             nreclaimed = 0;
2095         xfs_dquot_t     *dqp;
2096
2097         if (howmany <= 0)
2098                 return 0;
2099
2100         while (nreclaimed < howmany) {
2101                 dqp = xfs_qm_dqreclaim_one();
2102                 if (!dqp)
2103                         return nreclaimed;
2104                 xfs_qm_dqdestroy(dqp);
2105                 nreclaimed++;
2106         }
2107         return nreclaimed;
2108 }
2109
2110 /*
2111  * The kmem_shake interface is invoked when memory is running low.
2112  */
2113 /* ARGSUSED */
2114 STATIC int
2115 xfs_qm_shake(
2116         struct shrinker *shrink,
2117         int             nr_to_scan,
2118         gfp_t           gfp_mask)
2119 {
2120         int     ndqused, nfree, n;
2121
2122         if (!kmem_shake_allow(gfp_mask))
2123                 return 0;
2124         if (!xfs_Gqm)
2125                 return 0;
2126
2127         nfree = xfs_Gqm->qm_dqfrlist_cnt; /* free dquots */
2128         /* incore dquots in all f/s's */
2129         ndqused = atomic_read(&xfs_Gqm->qm_totaldquots) - nfree;
2130
2131         ASSERT(ndqused >= 0);
2132
2133         if (nfree <= ndqused && nfree < ndquot)
2134                 return 0;
2135
2136         ndqused *= xfs_Gqm->qm_dqfree_ratio;    /* target # of free dquots */
2137         n = nfree - ndqused - ndquot;           /* # over target */
2138
2139         return xfs_qm_shake_freelist(MAX(nfree, n));
2140 }
2141
2142
2143 /*------------------------------------------------------------------*/
2144
2145 /*
2146  * Return a new incore dquot. Depending on the number of
2147  * dquots in the system, we either allocate a new one on the kernel heap,
2148  * or reclaim a free one.
2149  * Return value is B_TRUE if we allocated a new dquot, B_FALSE if we managed
2150  * to reclaim an existing one from the freelist.
2151  */
2152 boolean_t
2153 xfs_qm_dqalloc_incore(
2154         xfs_dquot_t **O_dqpp)
2155 {
2156         xfs_dquot_t     *dqp;
2157
2158         /*
2159          * Check against high water mark to see if we want to pop
2160          * a nincompoop dquot off the freelist.
2161          */
2162         if (atomic_read(&xfs_Gqm->qm_totaldquots) >= ndquot) {
2163                 /*
2164                  * Try to recycle a dquot from the freelist.
2165                  */
2166                 if ((dqp = xfs_qm_dqreclaim_one())) {
2167                         XQM_STATS_INC(xqmstats.xs_qm_dqreclaims);
2168                         /*
2169                          * Just zero the core here. The rest will get
2170                          * reinitialized by caller. XXX we shouldn't even
2171                          * do this zero ...
2172                          */
2173                         memset(&dqp->q_core, 0, sizeof(dqp->q_core));
2174                         *O_dqpp = dqp;
2175                         return B_FALSE;
2176                 }
2177                 XQM_STATS_INC(xqmstats.xs_qm_dqreclaim_misses);
2178         }
2179
2180         /*
2181          * Allocate a brand new dquot on the kernel heap and return it
2182          * to the caller to initialize.
2183          */
2184         ASSERT(xfs_Gqm->qm_dqzone != NULL);
2185         *O_dqpp = kmem_zone_zalloc(xfs_Gqm->qm_dqzone, KM_SLEEP);
2186         atomic_inc(&xfs_Gqm->qm_totaldquots);
2187
2188         return B_TRUE;
2189 }
2190
2191
2192 /*
2193  * Start a transaction and write the incore superblock changes to
2194  * disk. flags parameter indicates which fields have changed.
2195  */
2196 int
2197 xfs_qm_write_sb_changes(
2198         xfs_mount_t     *mp,
2199         __int64_t       flags)
2200 {
2201         xfs_trans_t     *tp;
2202         int             error;
2203
2204 #ifdef QUOTADEBUG
2205         cmn_err(CE_NOTE, "Writing superblock quota changes :%s", mp->m_fsname);
2206 #endif
2207         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
2208         if ((error = xfs_trans_reserve(tp, 0,
2209                                       mp->m_sb.sb_sectsize + 128, 0,
2210                                       0,
2211                                       XFS_DEFAULT_LOG_COUNT))) {
2212                 xfs_trans_cancel(tp, 0);
2213                 return error;
2214         }
2215
2216         xfs_mod_sb(tp, flags);
2217         error = xfs_trans_commit(tp, 0);
2218
2219         return error;
2220 }
2221
2222
2223 /* --------------- utility functions for vnodeops ---------------- */
2224
2225
2226 /*
2227  * Given an inode, a uid and gid (from cred_t) make sure that we have
2228  * allocated relevant dquot(s) on disk, and that we won't exceed inode
2229  * quotas by creating this file.
2230  * This also attaches dquot(s) to the given inode after locking it,
2231  * and returns the dquots corresponding to the uid and/or gid.
2232  *
2233  * in   : inode (unlocked)
2234  * out  : udquot, gdquot with references taken and unlocked
2235  */
2236 int
2237 xfs_qm_vop_dqalloc(
2238         struct xfs_inode        *ip,
2239         uid_t                   uid,
2240         gid_t                   gid,
2241         prid_t                  prid,
2242         uint                    flags,
2243         struct xfs_dquot        **O_udqpp,
2244         struct xfs_dquot        **O_gdqpp)
2245 {
2246         struct xfs_mount        *mp = ip->i_mount;
2247         struct xfs_dquot        *uq, *gq;
2248         int                     error;
2249         uint                    lockflags;
2250
2251         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
2252                 return 0;
2253
2254         lockflags = XFS_ILOCK_EXCL;
2255         xfs_ilock(ip, lockflags);
2256
2257         if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
2258                 gid = ip->i_d.di_gid;
2259
2260         /*
2261          * Attach the dquot(s) to this inode, doing a dquot allocation
2262          * if necessary. The dquot(s) will not be locked.
2263          */
2264         if (XFS_NOT_DQATTACHED(mp, ip)) {
2265                 error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);
2266                 if (error) {
2267                         xfs_iunlock(ip, lockflags);
2268                         return error;
2269                 }
2270         }
2271
2272         uq = gq = NULL;
2273         if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
2274                 if (ip->i_d.di_uid != uid) {
2275                         /*
2276                          * What we need is the dquot that has this uid, and
2277                          * if we send the inode to dqget, the uid of the inode
2278                          * takes priority over what's sent in the uid argument.
2279                          * We must unlock inode here before calling dqget if
2280                          * we're not sending the inode, because otherwise
2281                          * we'll deadlock by doing trans_reserve while
2282                          * holding ilock.
2283                          */
2284                         xfs_iunlock(ip, lockflags);
2285                         if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
2286                                                  XFS_DQ_USER,
2287                                                  XFS_QMOPT_DQALLOC |
2288                                                  XFS_QMOPT_DOWARN,
2289                                                  &uq))) {
2290                                 ASSERT(error != ENOENT);
2291                                 return error;
2292                         }
2293                         /*
2294                          * Get the ilock in the right order.
2295                          */
2296                         xfs_dqunlock(uq);
2297                         lockflags = XFS_ILOCK_SHARED;
2298                         xfs_ilock(ip, lockflags);
2299                 } else {
2300                         /*
2301                          * Take an extra reference, because we'll return
2302                          * this to caller
2303                          */
2304                         ASSERT(ip->i_udquot);
2305                         uq = ip->i_udquot;
2306                         xfs_dqlock(uq);
2307                         XFS_DQHOLD(uq);
2308                         xfs_dqunlock(uq);
2309                 }
2310         }
2311         if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
2312                 if (ip->i_d.di_gid != gid) {
2313                         xfs_iunlock(ip, lockflags);
2314                         if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
2315                                                  XFS_DQ_GROUP,
2316                                                  XFS_QMOPT_DQALLOC |
2317                                                  XFS_QMOPT_DOWARN,
2318                                                  &gq))) {
2319                                 if (uq)
2320                                         xfs_qm_dqrele(uq);
2321                                 ASSERT(error != ENOENT);
2322                                 return error;
2323                         }
2324                         xfs_dqunlock(gq);
2325                         lockflags = XFS_ILOCK_SHARED;
2326                         xfs_ilock(ip, lockflags);
2327                 } else {
2328                         ASSERT(ip->i_gdquot);
2329                         gq = ip->i_gdquot;
2330                         xfs_dqlock(gq);
2331                         XFS_DQHOLD(gq);
2332                         xfs_dqunlock(gq);
2333                 }
2334         } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
2335                 if (ip->i_d.di_projid != prid) {
2336                         xfs_iunlock(ip, lockflags);
2337                         if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
2338                                                  XFS_DQ_PROJ,
2339                                                  XFS_QMOPT_DQALLOC |
2340                                                  XFS_QMOPT_DOWARN,
2341                                                  &gq))) {
2342                                 if (uq)
2343                                         xfs_qm_dqrele(uq);
2344                                 ASSERT(error != ENOENT);
2345                                 return (error);
2346                         }
2347                         xfs_dqunlock(gq);
2348                         lockflags = XFS_ILOCK_SHARED;
2349                         xfs_ilock(ip, lockflags);
2350                 } else {
2351                         ASSERT(ip->i_gdquot);
2352                         gq = ip->i_gdquot;
2353                         xfs_dqlock(gq);
2354                         XFS_DQHOLD(gq);
2355                         xfs_dqunlock(gq);
2356                 }
2357         }
2358         if (uq)
2359                 trace_xfs_dquot_dqalloc(ip);
2360
2361         xfs_iunlock(ip, lockflags);
2362         if (O_udqpp)
2363                 *O_udqpp = uq;
2364         else if (uq)
2365                 xfs_qm_dqrele(uq);
2366         if (O_gdqpp)
2367                 *O_gdqpp = gq;
2368         else if (gq)
2369                 xfs_qm_dqrele(gq);
2370         return 0;
2371 }
2372
2373 /*
2374  * Actually transfer ownership, and do dquot modifications.
2375  * These were already reserved.
2376  */
2377 xfs_dquot_t *
2378 xfs_qm_vop_chown(
2379         xfs_trans_t     *tp,
2380         xfs_inode_t     *ip,
2381         xfs_dquot_t     **IO_olddq,
2382         xfs_dquot_t     *newdq)
2383 {
2384         xfs_dquot_t     *prevdq;
2385         uint            bfield = XFS_IS_REALTIME_INODE(ip) ?
2386                                  XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
2387
2388
2389         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2390         ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
2391
2392         /* old dquot */
2393         prevdq = *IO_olddq;
2394         ASSERT(prevdq);
2395         ASSERT(prevdq != newdq);
2396
2397         xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
2398         xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
2399
2400         /* the sparkling new dquot */
2401         xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
2402         xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
2403
2404         /*
2405          * Take an extra reference, because the inode
2406          * is going to keep this dquot pointer even
2407          * after the trans_commit.
2408          */
2409         xfs_dqlock(newdq);
2410         XFS_DQHOLD(newdq);
2411         xfs_dqunlock(newdq);
2412         *IO_olddq = newdq;
2413
2414         return prevdq;
2415 }
2416
2417 /*
2418  * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
2419  */
2420 int
2421 xfs_qm_vop_chown_reserve(
2422         xfs_trans_t     *tp,
2423         xfs_inode_t     *ip,
2424         xfs_dquot_t     *udqp,
2425         xfs_dquot_t     *gdqp,
2426         uint            flags)
2427 {
2428         xfs_mount_t     *mp = ip->i_mount;
2429         uint            delblks, blkflags, prjflags = 0;
2430         xfs_dquot_t     *unresudq, *unresgdq, *delblksudq, *delblksgdq;
2431         int             error;
2432
2433
2434         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
2435         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2436
2437         delblks = ip->i_delayed_blks;
2438         delblksudq = delblksgdq = unresudq = unresgdq = NULL;
2439         blkflags = XFS_IS_REALTIME_INODE(ip) ?
2440                         XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
2441
2442         if (XFS_IS_UQUOTA_ON(mp) && udqp &&
2443             ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
2444                 delblksudq = udqp;
2445                 /*
2446                  * If there are delayed allocation blocks, then we have to
2447                  * unreserve those from the old dquot, and add them to the
2448                  * new dquot.
2449                  */
2450                 if (delblks) {
2451                         ASSERT(ip->i_udquot);
2452                         unresudq = ip->i_udquot;
2453                 }
2454         }
2455         if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
2456                 if (XFS_IS_PQUOTA_ON(ip->i_mount) &&
2457                      ip->i_d.di_projid != be32_to_cpu(gdqp->q_core.d_id))
2458                         prjflags = XFS_QMOPT_ENOSPC;
2459
2460                 if (prjflags ||
2461                     (XFS_IS_GQUOTA_ON(ip->i_mount) &&
2462                      ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
2463                         delblksgdq = gdqp;
2464                         if (delblks) {
2465                                 ASSERT(ip->i_gdquot);
2466                                 unresgdq = ip->i_gdquot;
2467                         }
2468                 }
2469         }
2470
2471         if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
2472                                 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
2473                                 flags | blkflags | prjflags)))
2474                 return (error);
2475
2476         /*
2477          * Do the delayed blks reservations/unreservations now. Since, these
2478          * are done without the help of a transaction, if a reservation fails
2479          * its previous reservations won't be automatically undone by trans
2480          * code. So, we have to do it manually here.
2481          */
2482         if (delblks) {
2483                 /*
2484                  * Do the reservations first. Unreservation can't fail.
2485                  */
2486                 ASSERT(delblksudq || delblksgdq);
2487                 ASSERT(unresudq || unresgdq);
2488                 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2489                                 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
2490                                 flags | blkflags | prjflags)))
2491                         return (error);
2492                 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
2493                                 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
2494                                 blkflags);
2495         }
2496
2497         return (0);
2498 }
2499
2500 int
2501 xfs_qm_vop_rename_dqattach(
2502         struct xfs_inode        **i_tab)
2503 {
2504         struct xfs_mount        *mp = i_tab[0]->i_mount;
2505         int                     i;
2506
2507         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
2508                 return 0;
2509
2510         for (i = 0; (i < 4 && i_tab[i]); i++) {
2511                 struct xfs_inode        *ip = i_tab[i];
2512                 int                     error;
2513
2514                 /*
2515                  * Watch out for duplicate entries in the table.
2516                  */
2517                 if (i == 0 || ip != i_tab[i-1]) {
2518                         if (XFS_NOT_DQATTACHED(mp, ip)) {
2519                                 error = xfs_qm_dqattach(ip, 0);
2520                                 if (error)
2521                                         return error;
2522                         }
2523                 }
2524         }
2525         return 0;
2526 }
2527
2528 void
2529 xfs_qm_vop_create_dqattach(
2530         struct xfs_trans        *tp,
2531         struct xfs_inode        *ip,
2532         struct xfs_dquot        *udqp,
2533         struct xfs_dquot        *gdqp)
2534 {
2535         struct xfs_mount        *mp = tp->t_mountp;
2536
2537         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
2538                 return;
2539
2540         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
2541         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
2542
2543         if (udqp) {
2544                 xfs_dqlock(udqp);
2545                 XFS_DQHOLD(udqp);
2546                 xfs_dqunlock(udqp);
2547                 ASSERT(ip->i_udquot == NULL);
2548                 ip->i_udquot = udqp;
2549                 ASSERT(XFS_IS_UQUOTA_ON(mp));
2550                 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
2551                 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
2552         }
2553         if (gdqp) {
2554                 xfs_dqlock(gdqp);
2555                 XFS_DQHOLD(gdqp);
2556                 xfs_dqunlock(gdqp);
2557                 ASSERT(ip->i_gdquot == NULL);
2558                 ip->i_gdquot = gdqp;
2559                 ASSERT(XFS_IS_OQUOTA_ON(mp));
2560                 ASSERT((XFS_IS_GQUOTA_ON(mp) ?
2561                         ip->i_d.di_gid : ip->i_d.di_projid) ==
2562                                 be32_to_cpu(gdqp->q_core.d_id));
2563                 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
2564         }
2565 }
2566