fs/xfs/xfs_qm.c

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