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