fs/xfs/quota/xfs_qm.c

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