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