fs/xfs/quota/xfs_qm.c

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