fs/xfs/xfs_qm.c

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