fs/xfs/quota/xfs_qm_syscalls.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
  19 #include <linux/capability.h>
  20
  21 #include "xfs.h"
  22 #include "xfs_fs.h"
  23 #include "xfs_bit.h"
  24 #include "xfs_log.h"
  25 #include "xfs_inum.h"
  26 #include "xfs_trans.h"
  27 #include "xfs_sb.h"
  28 #include "xfs_ag.h"
  29 #include "xfs_dir2.h"
  30 #include "xfs_alloc.h"
  31 #include "xfs_dmapi.h"
  32 #include "xfs_quota.h"
  33 #include "xfs_mount.h"
  34 #include "xfs_bmap_btree.h"
  35 #include "xfs_alloc_btree.h"
  36 #include "xfs_ialloc_btree.h"
  37 #include "xfs_dir2_sf.h"
  38 #include "xfs_attr_sf.h"
  39 #include "xfs_dinode.h"
  40 #include "xfs_inode.h"
  41 #include "xfs_ialloc.h"
  42 #include "xfs_itable.h"
  43 #include "xfs_bmap.h"
  44 #include "xfs_btree.h"
  45 #include "xfs_rtalloc.h"
  46 #include "xfs_error.h"
  47 #include "xfs_rw.h"
  48 #include "xfs_attr.h"
  49 #include "xfs_buf_item.h"
  50 #include "xfs_utils.h"
  51 #include "xfs_qm.h"
  52 #include "xfs_trace.h"
  53
  54 #ifdef DEBUG
  55 # define qdprintk(s, args...)   cmn_err(CE_DEBUG, s, ## args)
  56 #else
  57 # define qdprintk(s, args...)   do { } while (0)
  58 #endif
  59
  60 STATIC int      xfs_qm_log_quotaoff(xfs_mount_t *, xfs_qoff_logitem_t **, uint);
  61 STATIC int      xfs_qm_log_quotaoff_end(xfs_mount_t *, xfs_qoff_logitem_t *,
  62                                         uint);
  63 STATIC uint     xfs_qm_export_flags(uint);
  64 STATIC uint     xfs_qm_export_qtype_flags(uint);
  65 STATIC void     xfs_qm_export_dquot(xfs_mount_t *, xfs_disk_dquot_t *,
  66                                         fs_disk_quota_t *);
  67
  68
  69 /*
  70  * Turn off quota accounting and/or enforcement for all udquots and/or
  71  * gdquots. Called only at unmount time.
  72  *
  73  * This assumes that there are no dquots of this file system cached
  74  * incore, and modifies the ondisk dquot directly. Therefore, for example,
  75  * it is an error to call this twice, without purging the cache.
  76  */
  77 int
  78 xfs_qm_scall_quotaoff(
  79         xfs_mount_t             *mp,
  80         uint                    flags)
  81 {
  82         struct xfs_quotainfo    *q = mp->m_quotainfo;
  83         uint                    dqtype;
  84         int                     error;
  85         uint                    inactivate_flags;
  86         xfs_qoff_logitem_t      *qoffstart;
  87         int                     nculprits;
  88
  89         /*
  90          * No file system can have quotas enabled on disk but not in core.
  91          * Note that quota utilities (like quotaoff) _expect_
  92          * errno == EEXIST here.
  93          */
  94         if ((mp->m_qflags & flags) == 0)
  95                 return XFS_ERROR(EEXIST);
  96         error = 0;
  97
  98         flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
  99
 100         /*
 101          * We don't want to deal with two quotaoffs messing up each other,
 102          * so we're going to serialize it. quotaoff isn't exactly a performance
 103          * critical thing.
 104          * If quotaoff, then we must be dealing with the root filesystem.
 105          */
 106         ASSERT(q);
 107         mutex_lock(&q->qi_quotaofflock);
 108
 109         /*
 110          * If we're just turning off quota enforcement, change mp and go.
 111          */
 112         if ((flags & XFS_ALL_QUOTA_ACCT) == 0) {
 113                 mp->m_qflags &= ~(flags);
 114
 115                 spin_lock(&mp->m_sb_lock);
 116                 mp->m_sb.sb_qflags = mp->m_qflags;
 117                 spin_unlock(&mp->m_sb_lock);
 118                 mutex_unlock(&q->qi_quotaofflock);
 119
 120                 /* XXX what to do if error ? Revert back to old vals incore ? */
 121                 error = xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS);
 122                 return (error);
 123         }
 124
 125         dqtype = 0;
 126         inactivate_flags = 0;
 127         /*
 128          * If accounting is off, we must turn enforcement off, clear the
 129          * quota 'CHKD' certificate to make it known that we have to
 130          * do a quotacheck the next time this quota is turned on.
 131          */
 132         if (flags & XFS_UQUOTA_ACCT) {
 133                 dqtype |= XFS_QMOPT_UQUOTA;
 134                 flags |= (XFS_UQUOTA_CHKD | XFS_UQUOTA_ENFD);
 135                 inactivate_flags |= XFS_UQUOTA_ACTIVE;
 136         }
 137         if (flags & XFS_GQUOTA_ACCT) {
 138                 dqtype |= XFS_QMOPT_GQUOTA;
 139                 flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
 140                 inactivate_flags |= XFS_GQUOTA_ACTIVE;
 141         } else if (flags & XFS_PQUOTA_ACCT) {
 142                 dqtype |= XFS_QMOPT_PQUOTA;
 143                 flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
 144                 inactivate_flags |= XFS_PQUOTA_ACTIVE;
 145         }
 146
 147         /*
 148          * Nothing to do?  Don't complain. This happens when we're just
 149          * turning off quota enforcement.
 150          */
 151         if ((mp->m_qflags & flags) == 0)
 152                 goto out_unlock;
 153
 154         /*
 155          * Write the LI_QUOTAOFF log record, and do SB changes atomically,
 156          * and synchronously. If we fail to write, we should abort the
 157          * operation as it cannot be recovered safely if we crash.
 158          */
 159         error = xfs_qm_log_quotaoff(mp, &qoffstart, flags);
 160         if (error)
 161                 goto out_unlock;
 162
 163         /*
 164          * Next we clear the XFS_MOUNT_*DQ_ACTIVE bit(s) in the mount struct
 165          * to take care of the race between dqget and quotaoff. We don't take
 166          * any special locks to reset these bits. All processes need to check
 167          * these bits *after* taking inode lock(s) to see if the particular
 168          * quota type is in the process of being turned off. If *ACTIVE, it is
 169          * guaranteed that all dquot structures and all quotainode ptrs will all
 170          * stay valid as long as that inode is kept locked.
 171          *
 172          * There is no turning back after this.
 173          */
 174         mp->m_qflags &= ~inactivate_flags;
 175
 176         /*
 177          * Give back all the dquot reference(s) held by inodes.
 178          * Here we go thru every single incore inode in this file system, and
 179          * do a dqrele on the i_udquot/i_gdquot that it may have.
 180          * Essentially, as long as somebody has an inode locked, this guarantees
 181          * that quotas will not be turned off. This is handy because in a
 182          * transaction once we lock the inode(s) and check for quotaon, we can
 183          * depend on the quota inodes (and other things) being valid as long as
 184          * we keep the lock(s).
 185          */
 186         xfs_qm_dqrele_all_inodes(mp, flags);
 187
 188         /*
 189          * Next we make the changes in the quota flag in the mount struct.
 190          * This isn't protected by a particular lock directly, because we
 191          * don't want to take a mrlock everytime we depend on quotas being on.
 192          */
 193         mp->m_qflags &= ~(flags);
 194
 195         /*
 196          * Go through all the dquots of this file system and purge them,
 197          * according to what was turned off. We may not be able to get rid
 198          * of all dquots, because dquots can have temporary references that
 199          * are not attached to inodes. eg. xfs_setattr, xfs_create.
 200          * So, if we couldn't purge all the dquots from the filesystem,
 201          * we can't get rid of the incore data structures.
 202          */
 203         while ((nculprits = xfs_qm_dqpurge_all(mp, dqtype)))
 204                 delay(10 * nculprits);
 205
 206         /*
 207          * Transactions that had started before ACTIVE state bit was cleared
 208          * could have logged many dquots, so they'd have higher LSNs than
 209          * the first QUOTAOFF log record does. If we happen to crash when
 210          * the tail of the log has gone past the QUOTAOFF record, but
 211          * before the last dquot modification, those dquots __will__
 212          * recover, and that's not good.
 213          *
 214          * So, we have QUOTAOFF start and end logitems; the start
 215          * logitem won't get overwritten until the end logitem appears...
 216          */
 217         error = xfs_qm_log_quotaoff_end(mp, qoffstart, flags);
 218         if (error) {
 219                 /* We're screwed now. Shutdown is the only option. */
 220                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 221                 goto out_unlock;
 222         }
 223
 224         /*
 225          * If quotas is completely disabled, close shop.
 226          */
 227         if (((flags & XFS_MOUNT_QUOTA_ALL) == XFS_MOUNT_QUOTA_SET1) ||
 228             ((flags & XFS_MOUNT_QUOTA_ALL) == XFS_MOUNT_QUOTA_SET2)) {
 229                 mutex_unlock(&q->qi_quotaofflock);
 230                 xfs_qm_destroy_quotainfo(mp);
 231                 return (0);
 232         }
 233
 234         /*
 235          * Release our quotainode references if we don't need them anymore.
 236          */
 237         if ((dqtype & XFS_QMOPT_UQUOTA) && q->qi_uquotaip) {
 238                 IRELE(q->qi_uquotaip);
 239                 q->qi_uquotaip = NULL;
 240         }
 241         if ((dqtype & (XFS_QMOPT_GQUOTA|XFS_QMOPT_PQUOTA)) && q->qi_gquotaip) {
 242                 IRELE(q->qi_gquotaip);
 243                 q->qi_gquotaip = NULL;
 244         }
 245
 246 out_unlock:
 247         mutex_unlock(&q->qi_quotaofflock);
 248         return error;
 249 }
 250
 251 int
 252 xfs_qm_scall_trunc_qfiles(
 253         xfs_mount_t     *mp,
 254         uint            flags)
 255 {
 256         int             error = 0, error2 = 0;
 257         xfs_inode_t     *qip;
 258
 259         if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0) {
 260                 qdprintk("qtrunc flags=%x m_qflags=%x\n", flags, mp->m_qflags);
 261                 return XFS_ERROR(EINVAL);
 262         }
 263
 264         if ((flags & XFS_DQ_USER) && mp->m_sb.sb_uquotino != NULLFSINO) {
 265                 error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino, 0, 0, &qip);
 266                 if (!error) {
 267                         error = xfs_truncate_file(mp, qip);
 268                         IRELE(qip);
 269                 }
 270         }
 271
 272         if ((flags & (XFS_DQ_GROUP|XFS_DQ_PROJ)) &&
 273             mp->m_sb.sb_gquotino != NULLFSINO) {
 274                 error2 = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino, 0, 0, &qip);
 275                 if (!error2) {
 276                         error2 = xfs_truncate_file(mp, qip);
 277                         IRELE(qip);
 278                 }
 279         }
 280
 281         return error ? error : error2;
 282 }
 283
 284
 285 /*
 286  * Switch on (a given) quota enforcement for a filesystem.  This takes
 287  * effect immediately.
 288  * (Switching on quota accounting must be done at mount time.)
 289  */
 290 int
 291 xfs_qm_scall_quotaon(
 292         xfs_mount_t     *mp,
 293         uint            flags)
 294 {
 295         int             error;
 296         uint            qf;
 297         uint            accflags;
 298         __int64_t       sbflags;
 299
 300         flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
 301         /*
 302          * Switching on quota accounting must be done at mount time.
 303          */
 304         accflags = flags & XFS_ALL_QUOTA_ACCT;
 305         flags &= ~(XFS_ALL_QUOTA_ACCT);
 306
 307         sbflags = 0;
 308
 309         if (flags == 0) {
 310                 qdprintk("quotaon: zero flags, m_qflags=%x\n", mp->m_qflags);
 311                 return XFS_ERROR(EINVAL);
 312         }
 313
 314         /* No fs can turn on quotas with a delayed effect */
 315         ASSERT((flags & XFS_ALL_QUOTA_ACCT) == 0);
 316
 317         /*
 318          * Can't enforce without accounting. We check the superblock
 319          * qflags here instead of m_qflags because rootfs can have
 320          * quota acct on ondisk without m_qflags' knowing.
 321          */
 322         if (((flags & XFS_UQUOTA_ACCT) == 0 &&
 323             (mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
 324             (flags & XFS_UQUOTA_ENFD))
 325             ||
 326             ((flags & XFS_PQUOTA_ACCT) == 0 &&
 327             (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
 328             (flags & XFS_GQUOTA_ACCT) == 0 &&
 329             (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
 330             (flags & XFS_OQUOTA_ENFD))) {
 331                 qdprintk("Can't enforce without acct, flags=%x sbflags=%x\n",
 332                         flags, mp->m_sb.sb_qflags);
 333                 return XFS_ERROR(EINVAL);
 334         }
 335         /*
 336          * If everything's upto-date incore, then don't waste time.
 337          */
 338         if ((mp->m_qflags & flags) == flags)
 339                 return XFS_ERROR(EEXIST);
 340
 341         /*
 342          * Change sb_qflags on disk but not incore mp->qflags
 343          * if this is the root filesystem.
 344          */
 345         spin_lock(&mp->m_sb_lock);
 346         qf = mp->m_sb.sb_qflags;
 347         mp->m_sb.sb_qflags = qf | flags;
 348         spin_unlock(&mp->m_sb_lock);
 349
 350         /*
 351          * There's nothing to change if it's the same.
 352          */
 353         if ((qf & flags) == flags && sbflags == 0)
 354                 return XFS_ERROR(EEXIST);
 355         sbflags |= XFS_SB_QFLAGS;
 356
 357         if ((error = xfs_qm_write_sb_changes(mp, sbflags)))
 358                 return (error);
 359         /*
 360          * If we aren't trying to switch on quota enforcement, we are done.
 361          */
 362         if  (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) !=
 363              (mp->m_qflags & XFS_UQUOTA_ACCT)) ||
 364              ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) !=
 365              (mp->m_qflags & XFS_PQUOTA_ACCT)) ||
 366              ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) !=
 367              (mp->m_qflags & XFS_GQUOTA_ACCT)) ||
 368             (flags & XFS_ALL_QUOTA_ENFD) == 0)
 369                 return (0);
 370
 371         if (! XFS_IS_QUOTA_RUNNING(mp))
 372                 return XFS_ERROR(ESRCH);
 373
 374         /*
 375          * Switch on quota enforcement in core.
 376          */
 377         mutex_lock(&mp->m_quotainfo->qi_quotaofflock);
 378         mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD);
 379         mutex_unlock(&mp->m_quotainfo->qi_quotaofflock);
 380
 381         return (0);
 382 }
 383
 384
 385 /*
 386  * Return quota status information, such as uquota-off, enforcements, etc.
 387  */
 388 int
 389 xfs_qm_scall_getqstat(
 390         struct xfs_mount        *mp,
 391         struct fs_quota_stat    *out)
 392 {
 393         struct xfs_quotainfo    *q = mp->m_quotainfo;
 394         struct xfs_inode        *uip, *gip;
 395         boolean_t               tempuqip, tempgqip;
 396
 397         uip = gip = NULL;
 398         tempuqip = tempgqip = B_FALSE;
 399         memset(out, 0, sizeof(fs_quota_stat_t));
 400
 401         out->qs_version = FS_QSTAT_VERSION;
 402         if (!xfs_sb_version_hasquota(&mp->m_sb)) {
 403                 out->qs_uquota.qfs_ino = NULLFSINO;
 404                 out->qs_gquota.qfs_ino = NULLFSINO;
 405                 return (0);
 406         }
 407         out->qs_flags = (__uint16_t) xfs_qm_export_flags(mp->m_qflags &
 408                                                         (XFS_ALL_QUOTA_ACCT|
 409                                                          XFS_ALL_QUOTA_ENFD));
 410         out->qs_pad = 0;
 411         out->qs_uquota.qfs_ino = mp->m_sb.sb_uquotino;
 412         out->qs_gquota.qfs_ino = mp->m_sb.sb_gquotino;
 413
 414         if (q) {
 415                 uip = q->qi_uquotaip;
 416                 gip = q->qi_gquotaip;
 417         }
 418         if (!uip && mp->m_sb.sb_uquotino != NULLFSINO) {
 419                 if (xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
 420                                         0, 0, &uip) == 0)
 421                         tempuqip = B_TRUE;
 422         }
 423         if (!gip && mp->m_sb.sb_gquotino != NULLFSINO) {
 424                 if (xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
 425                                         0, 0, &gip) == 0)
 426                         tempgqip = B_TRUE;
 427         }
 428         if (uip) {
 429                 out->qs_uquota.qfs_nblks = uip->i_d.di_nblocks;
 430                 out->qs_uquota.qfs_nextents = uip->i_d.di_nextents;
 431                 if (tempuqip)
 432                         IRELE(uip);
 433         }
 434         if (gip) {
 435                 out->qs_gquota.qfs_nblks = gip->i_d.di_nblocks;
 436                 out->qs_gquota.qfs_nextents = gip->i_d.di_nextents;
 437                 if (tempgqip)
 438                         IRELE(gip);
 439         }
 440         if (q) {
 441                 out->qs_incoredqs = q->qi_dquots;
 442                 out->qs_btimelimit = q->qi_btimelimit;
 443                 out->qs_itimelimit = q->qi_itimelimit;
 444                 out->qs_rtbtimelimit = q->qi_rtbtimelimit;
 445                 out->qs_bwarnlimit = q->qi_bwarnlimit;
 446                 out->qs_iwarnlimit = q->qi_iwarnlimit;
 447         }
 448         return 0;
 449 }
 450
 451 #define XFS_DQ_MASK \
 452         (FS_DQ_LIMIT_MASK | FS_DQ_TIMER_MASK | FS_DQ_WARNS_MASK)
 453
 454 /*
 455  * Adjust quota limits, and start/stop timers accordingly.
 456  */
 457 int
 458 xfs_qm_scall_setqlim(
 459         xfs_mount_t             *mp,
 460         xfs_dqid_t              id,
 461         uint                    type,
 462         fs_disk_quota_t         *newlim)
 463 {
 464         struct xfs_quotainfo    *q = mp->m_quotainfo;
 465         xfs_disk_dquot_t        *ddq;
 466         xfs_dquot_t             *dqp;
 467         xfs_trans_t             *tp;
 468         int                     error;
 469         xfs_qcnt_t              hard, soft;
 470
 471         if (newlim->d_fieldmask & ~XFS_DQ_MASK)
 472                 return EINVAL;
 473         if ((newlim->d_fieldmask & XFS_DQ_MASK) == 0)
 474                 return 0;
 475
 476         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SETQLIM);
 477         if ((error = xfs_trans_reserve(tp, 0, sizeof(xfs_disk_dquot_t) + 128,
 478                                       0, 0, XFS_DEFAULT_LOG_COUNT))) {
 479                 xfs_trans_cancel(tp, 0);
 480                 return (error);
 481         }
 482
 483         /*
 484          * We don't want to race with a quotaoff so take the quotaoff lock.
 485          * (We don't hold an inode lock, so there's nothing else to stop
 486          * a quotaoff from happening). (XXXThis doesn't currently happen
 487          * because we take the vfslock before calling xfs_qm_sysent).
 488          */
 489         mutex_lock(&q->qi_quotaofflock);
 490
 491         /*
 492          * Get the dquot (locked), and join it to the transaction.
 493          * Allocate the dquot if this doesn't exist.
 494          */
 495         if ((error = xfs_qm_dqget(mp, NULL, id, type, XFS_QMOPT_DQALLOC, &dqp))) {
 496                 xfs_trans_cancel(tp, XFS_TRANS_ABORT);
 497                 ASSERT(error != ENOENT);
 498                 goto out_unlock;
 499         }
 500         xfs_trans_dqjoin(tp, dqp);
 501         ddq = &dqp->q_core;
 502
 503         /*
 504          * Make sure that hardlimits are >= soft limits before changing.
 505          */
 506         hard = (newlim->d_fieldmask & FS_DQ_BHARD) ?
 507                 (xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_blk_hardlimit) :
 508                         be64_to_cpu(ddq->d_blk_hardlimit);
 509         soft = (newlim->d_fieldmask & FS_DQ_BSOFT) ?
 510                 (xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_blk_softlimit) :
 511                         be64_to_cpu(ddq->d_blk_softlimit);
 512         if (hard == 0 || hard >= soft) {
 513                 ddq->d_blk_hardlimit = cpu_to_be64(hard);
 514                 ddq->d_blk_softlimit = cpu_to_be64(soft);
 515                 if (id == 0) {
 516                         q->qi_bhardlimit = hard;
 517                         q->qi_bsoftlimit = soft;
 518                 }
 519         } else {
 520                 qdprintk("blkhard %Ld < blksoft %Ld\n", hard, soft);
 521         }
 522         hard = (newlim->d_fieldmask & FS_DQ_RTBHARD) ?
 523                 (xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_rtb_hardlimit) :
 524                         be64_to_cpu(ddq->d_rtb_hardlimit);
 525         soft = (newlim->d_fieldmask & FS_DQ_RTBSOFT) ?
 526                 (xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_rtb_softlimit) :
 527                         be64_to_cpu(ddq->d_rtb_softlimit);
 528         if (hard == 0 || hard >= soft) {
 529                 ddq->d_rtb_hardlimit = cpu_to_be64(hard);
 530                 ddq->d_rtb_softlimit = cpu_to_be64(soft);
 531                 if (id == 0) {
 532                         q->qi_rtbhardlimit = hard;
 533                         q->qi_rtbsoftlimit = soft;
 534                 }
 535         } else {
 536                 qdprintk("rtbhard %Ld < rtbsoft %Ld\n", hard, soft);
 537         }
 538
 539         hard = (newlim->d_fieldmask & FS_DQ_IHARD) ?
 540                 (xfs_qcnt_t) newlim->d_ino_hardlimit :
 541                         be64_to_cpu(ddq->d_ino_hardlimit);
 542         soft = (newlim->d_fieldmask & FS_DQ_ISOFT) ?
 543                 (xfs_qcnt_t) newlim->d_ino_softlimit :
 544                         be64_to_cpu(ddq->d_ino_softlimit);
 545         if (hard == 0 || hard >= soft) {
 546                 ddq->d_ino_hardlimit = cpu_to_be64(hard);
 547                 ddq->d_ino_softlimit = cpu_to_be64(soft);
 548                 if (id == 0) {
 549                         q->qi_ihardlimit = hard;
 550                         q->qi_isoftlimit = soft;
 551                 }
 552         } else {
 553                 qdprintk("ihard %Ld < isoft %Ld\n", hard, soft);
 554         }
 555
 556         /*
 557          * Update warnings counter(s) if requested
 558          */
 559         if (newlim->d_fieldmask & FS_DQ_BWARNS)
 560                 ddq->d_bwarns = cpu_to_be16(newlim->d_bwarns);
 561         if (newlim->d_fieldmask & FS_DQ_IWARNS)
 562                 ddq->d_iwarns = cpu_to_be16(newlim->d_iwarns);
 563         if (newlim->d_fieldmask & FS_DQ_RTBWARNS)
 564                 ddq->d_rtbwarns = cpu_to_be16(newlim->d_rtbwarns);
 565
 566         if (id == 0) {
 567                 /*
 568                  * Timelimits for the super user set the relative time
 569                  * the other users can be over quota for this file system.
 570                  * If it is zero a default is used.  Ditto for the default
 571                  * soft and hard limit values (already done, above), and
 572                  * for warnings.
 573                  */
 574                 if (newlim->d_fieldmask & FS_DQ_BTIMER) {
 575                         q->qi_btimelimit = newlim->d_btimer;
 576                         ddq->d_btimer = cpu_to_be32(newlim->d_btimer);
 577                 }
 578                 if (newlim->d_fieldmask & FS_DQ_ITIMER) {
 579                         q->qi_itimelimit = newlim->d_itimer;
 580                         ddq->d_itimer = cpu_to_be32(newlim->d_itimer);
 581                 }
 582                 if (newlim->d_fieldmask & FS_DQ_RTBTIMER) {
 583                         q->qi_rtbtimelimit = newlim->d_rtbtimer;
 584                         ddq->d_rtbtimer = cpu_to_be32(newlim->d_rtbtimer);
 585                 }
 586                 if (newlim->d_fieldmask & FS_DQ_BWARNS)
 587                         q->qi_bwarnlimit = newlim->d_bwarns;
 588                 if (newlim->d_fieldmask & FS_DQ_IWARNS)
 589                         q->qi_iwarnlimit = newlim->d_iwarns;
 590                 if (newlim->d_fieldmask & FS_DQ_RTBWARNS)
 591                         q->qi_rtbwarnlimit = newlim->d_rtbwarns;
 592         } else {
 593                 /*
 594                  * If the user is now over quota, start the timelimit.
 595                  * The user will not be 'warned'.
 596                  * Note that we keep the timers ticking, whether enforcement
 597                  * is on or off. We don't really want to bother with iterating
 598                  * over all ondisk dquots and turning the timers on/off.
 599                  */
 600                 xfs_qm_adjust_dqtimers(mp, ddq);
 601         }
 602         dqp->dq_flags |= XFS_DQ_DIRTY;
 603         xfs_trans_log_dquot(tp, dqp);
 604
 605         error = xfs_trans_commit(tp, 0);
 606         xfs_qm_dqprint(dqp);
 607         xfs_qm_dqrele(dqp);
 608
 609  out_unlock:
 610         mutex_unlock(&q->qi_quotaofflock);
 611         return error;
 612 }
 613
 614 int
 615 xfs_qm_scall_getquota(
 616         xfs_mount_t     *mp,
 617         xfs_dqid_t      id,
 618         uint            type,
 619         fs_disk_quota_t *out)
 620 {
 621         xfs_dquot_t     *dqp;
 622         int             error;
 623
 624         /*
 625          * Try to get the dquot. We don't want it allocated on disk, so
 626          * we aren't passing the XFS_QMOPT_DOALLOC flag. If it doesn't
 627          * exist, we'll get ENOENT back.
 628          */
 629         if ((error = xfs_qm_dqget(mp, NULL, id, type, 0, &dqp))) {
 630                 return (error);
 631         }
 632
 633         /*
 634          * If everything's NULL, this dquot doesn't quite exist as far as
 635          * our utility programs are concerned.
 636          */
 637         if (XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
 638                 xfs_qm_dqput(dqp);
 639                 return XFS_ERROR(ENOENT);
 640         }
 641         /* xfs_qm_dqprint(dqp); */
 642         /*
 643          * Convert the disk dquot to the exportable format
 644          */
 645         xfs_qm_export_dquot(mp, &dqp->q_core, out);
 646         xfs_qm_dqput(dqp);
 647         return (error ? XFS_ERROR(EFAULT) : 0);
 648 }
 649
 650
 651 STATIC int
 652 xfs_qm_log_quotaoff_end(
 653         xfs_mount_t             *mp,
 654         xfs_qoff_logitem_t      *startqoff,
 655         uint                    flags)
 656 {
 657         xfs_trans_t             *tp;
 658         int                     error;
 659         xfs_qoff_logitem_t      *qoffi;
 660
 661         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF_END);
 662
 663         if ((error = xfs_trans_reserve(tp, 0, sizeof(xfs_qoff_logitem_t) * 2,
 664                                       0, 0, XFS_DEFAULT_LOG_COUNT))) {
 665                 xfs_trans_cancel(tp, 0);
 666                 return (error);
 667         }
 668
 669         qoffi = xfs_trans_get_qoff_item(tp, startqoff,
 670                                         flags & XFS_ALL_QUOTA_ACCT);
 671         xfs_trans_log_quotaoff_item(tp, qoffi);
 672
 673         /*
 674          * We have to make sure that the transaction is secure on disk before we
 675          * return and actually stop quota accounting. So, make it synchronous.
 676          * We don't care about quotoff's performance.
 677          */
 678         xfs_trans_set_sync(tp);
 679         error = xfs_trans_commit(tp, 0);
 680         return (error);
 681 }
 682
 683
 684 STATIC int
 685 xfs_qm_log_quotaoff(
 686         xfs_mount_t            *mp,
 687         xfs_qoff_logitem_t     **qoffstartp,
 688         uint                   flags)
 689 {
 690         xfs_trans_t            *tp;
 691         int                     error;
 692         xfs_qoff_logitem_t     *qoffi=NULL;
 693         uint                    oldsbqflag=0;
 694
 695         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF);
 696         if ((error = xfs_trans_reserve(tp, 0,
 697                                       sizeof(xfs_qoff_logitem_t) * 2 +
 698                                       mp->m_sb.sb_sectsize + 128,
 699                                       0,
 700                                       0,
 701                                       XFS_DEFAULT_LOG_COUNT))) {
 702                 goto error0;
 703         }
 704
 705         qoffi = xfs_trans_get_qoff_item(tp, NULL, flags & XFS_ALL_QUOTA_ACCT);
 706         xfs_trans_log_quotaoff_item(tp, qoffi);
 707
 708         spin_lock(&mp->m_sb_lock);
 709         oldsbqflag = mp->m_sb.sb_qflags;
 710         mp->m_sb.sb_qflags = (mp->m_qflags & ~(flags)) & XFS_MOUNT_QUOTA_ALL;
 711         spin_unlock(&mp->m_sb_lock);
 712
 713         xfs_mod_sb(tp, XFS_SB_QFLAGS);
 714
 715         /*
 716          * We have to make sure that the transaction is secure on disk before we
 717          * return and actually stop quota accounting. So, make it synchronous.
 718          * We don't care about quotoff's performance.
 719          */
 720         xfs_trans_set_sync(tp);
 721         error = xfs_trans_commit(tp, 0);
 722
 723 error0:
 724         if (error) {
 725                 xfs_trans_cancel(tp, 0);
 726                 /*
 727                  * No one else is modifying sb_qflags, so this is OK.
 728                  * We still hold the quotaofflock.
 729                  */
 730                 spin_lock(&mp->m_sb_lock);
 731                 mp->m_sb.sb_qflags = oldsbqflag;
 732                 spin_unlock(&mp->m_sb_lock);
 733         }
 734         *qoffstartp = qoffi;
 735         return (error);
 736 }
 737
 738
 739 /*
 740  * Translate an internal style on-disk-dquot to the exportable format.
 741  * The main differences are that the counters/limits are all in Basic
 742  * Blocks (BBs) instead of the internal FSBs, and all on-disk data has
 743  * to be converted to the native endianness.
 744  */
 745 STATIC void
 746 xfs_qm_export_dquot(
 747         xfs_mount_t             *mp,
 748         xfs_disk_dquot_t        *src,
 749         struct fs_disk_quota    *dst)
 750 {
 751         memset(dst, 0, sizeof(*dst));
 752         dst->d_version = FS_DQUOT_VERSION;  /* different from src->d_version */
 753         dst->d_flags = xfs_qm_export_qtype_flags(src->d_flags);
 754         dst->d_id = be32_to_cpu(src->d_id);
 755         dst->d_blk_hardlimit =
 756                 XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_blk_hardlimit));
 757         dst->d_blk_softlimit =
 758                 XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_blk_softlimit));
 759         dst->d_ino_hardlimit = be64_to_cpu(src->d_ino_hardlimit);
 760         dst->d_ino_softlimit = be64_to_cpu(src->d_ino_softlimit);
 761         dst->d_bcount = XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_bcount));
 762         dst->d_icount = be64_to_cpu(src->d_icount);
 763         dst->d_btimer = be32_to_cpu(src->d_btimer);
 764         dst->d_itimer = be32_to_cpu(src->d_itimer);
 765         dst->d_iwarns = be16_to_cpu(src->d_iwarns);
 766         dst->d_bwarns = be16_to_cpu(src->d_bwarns);
 767         dst->d_rtb_hardlimit =
 768                 XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_rtb_hardlimit));
 769         dst->d_rtb_softlimit =
 770                 XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_rtb_softlimit));
 771         dst->d_rtbcount = XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_rtbcount));
 772         dst->d_rtbtimer = be32_to_cpu(src->d_rtbtimer);
 773         dst->d_rtbwarns = be16_to_cpu(src->d_rtbwarns);
 774
 775         /*
 776          * Internally, we don't reset all the timers when quota enforcement
 777          * gets turned off. No need to confuse the user level code,
 778          * so return zeroes in that case.
 779          */
 780         if ((!XFS_IS_UQUOTA_ENFORCED(mp) && src->d_flags == XFS_DQ_USER) ||
 781             (!XFS_IS_OQUOTA_ENFORCED(mp) &&
 782                         (src->d_flags & (XFS_DQ_PROJ | XFS_DQ_GROUP)))) {
 783                 dst->d_btimer = 0;
 784                 dst->d_itimer = 0;
 785                 dst->d_rtbtimer = 0;
 786         }
 787
 788 #ifdef DEBUG
 789         if (((XFS_IS_UQUOTA_ENFORCED(mp) && dst->d_flags == XFS_USER_QUOTA) ||
 790              (XFS_IS_OQUOTA_ENFORCED(mp) &&
 791                         (dst->d_flags & (XFS_PROJ_QUOTA | XFS_GROUP_QUOTA)))) &&
 792             dst->d_id != 0) {
 793                 if (((int) dst->d_bcount >= (int) dst->d_blk_softlimit) &&
 794                     (dst->d_blk_softlimit > 0)) {
 795                         ASSERT(dst->d_btimer != 0);
 796                 }
 797                 if (((int) dst->d_icount >= (int) dst->d_ino_softlimit) &&
 798                     (dst->d_ino_softlimit > 0)) {
 799                         ASSERT(dst->d_itimer != 0);
 800                 }
 801         }
 802 #endif
 803 }
 804
 805 STATIC uint
 806 xfs_qm_export_qtype_flags(
 807         uint flags)
 808 {
 809         /*
 810          * Can't be more than one, or none.
 811          */
 812         ASSERT((flags & (XFS_PROJ_QUOTA | XFS_USER_QUOTA)) !=
 813                 (XFS_PROJ_QUOTA | XFS_USER_QUOTA));
 814         ASSERT((flags & (XFS_PROJ_QUOTA | XFS_GROUP_QUOTA)) !=
 815                 (XFS_PROJ_QUOTA | XFS_GROUP_QUOTA));
 816         ASSERT((flags & (XFS_USER_QUOTA | XFS_GROUP_QUOTA)) !=
 817                 (XFS_USER_QUOTA | XFS_GROUP_QUOTA));
 818         ASSERT((flags & (XFS_PROJ_QUOTA|XFS_USER_QUOTA|XFS_GROUP_QUOTA)) != 0);
 819
 820         return (flags & XFS_DQ_USER) ?
 821                 XFS_USER_QUOTA : (flags & XFS_DQ_PROJ) ?
 822                         XFS_PROJ_QUOTA : XFS_GROUP_QUOTA;
 823 }
 824
 825 STATIC uint
 826 xfs_qm_export_flags(
 827         uint flags)
 828 {
 829         uint uflags;
 830
 831         uflags = 0;
 832         if (flags & XFS_UQUOTA_ACCT)
 833                 uflags |= XFS_QUOTA_UDQ_ACCT;
 834         if (flags & XFS_PQUOTA_ACCT)
 835                 uflags |= XFS_QUOTA_PDQ_ACCT;
 836         if (flags & XFS_GQUOTA_ACCT)
 837                 uflags |= XFS_QUOTA_GDQ_ACCT;
 838         if (flags & XFS_UQUOTA_ENFD)
 839                 uflags |= XFS_QUOTA_UDQ_ENFD;
 840         if (flags & (XFS_OQUOTA_ENFD)) {
 841                 uflags |= (flags & XFS_GQUOTA_ACCT) ?
 842                         XFS_QUOTA_GDQ_ENFD : XFS_QUOTA_PDQ_ENFD;
 843         }
 844         return (uflags);
 845 }
 846
 847
 848 STATIC int
 849 xfs_dqrele_inode(
 850         struct xfs_inode        *ip,
 851         struct xfs_perag        *pag,
 852         int                     flags)
 853 {
 854         int                     error;
 855
 856         /* skip quota inodes */
 857         if (ip == ip->i_mount->m_quotainfo->qi_uquotaip ||
 858             ip == ip->i_mount->m_quotainfo->qi_gquotaip) {
 859                 ASSERT(ip->i_udquot == NULL);
 860                 ASSERT(ip->i_gdquot == NULL);
 861                 read_unlock(&pag->pag_ici_lock);
 862                 return 0;
 863         }
 864
 865         error = xfs_sync_inode_valid(ip, pag);
 866         if (error)
 867                 return error;
 868
 869         xfs_ilock(ip, XFS_ILOCK_EXCL);
 870         if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) {
 871                 xfs_qm_dqrele(ip->i_udquot);
 872                 ip->i_udquot = NULL;
 873         }
 874         if (flags & (XFS_PQUOTA_ACCT|XFS_GQUOTA_ACCT) && ip->i_gdquot) {
 875                 xfs_qm_dqrele(ip->i_gdquot);
 876                 ip->i_gdquot = NULL;
 877         }
 878         xfs_iput(ip, XFS_ILOCK_EXCL);
 879
 880         return 0;
 881 }
 882
 883
 884 /*
 885  * Go thru all the inodes in the file system, releasing their dquots.
 886  *
 887  * Note that the mount structure gets modified to indicate that quotas are off
 888  * AFTER this, in the case of quotaoff.
 889  */
 890 void
 891 xfs_qm_dqrele_all_inodes(
 892         struct xfs_mount *mp,
 893         uint             flags)
 894 {
 895         ASSERT(mp->m_quotainfo);
 896         xfs_inode_ag_iterator(mp, xfs_dqrele_inode, flags,
 897                                 XFS_ICI_NO_TAG, 0, NULL);
 898 }
 899
 900 /*------------------------------------------------------------------------*/
 901 #ifdef DEBUG
 902 /*
 903  * This contains all the test functions for XFS disk quotas.
 904  * Currently it does a quota accounting check. ie. it walks through
 905  * all inodes in the file system, calculating the dquot accounting fields,
 906  * and prints out any inconsistencies.
 907  */
 908 xfs_dqhash_t *qmtest_udqtab;
 909 xfs_dqhash_t *qmtest_gdqtab;
 910 int           qmtest_hashmask;
 911 int           qmtest_nfails;
 912 struct mutex  qcheck_lock;
 913
 914 #define DQTEST_HASHVAL(mp, id) (((__psunsigned_t)(mp) + \
 915                                  (__psunsigned_t)(id)) & \
 916                                 (qmtest_hashmask - 1))
 917
 918 #define DQTEST_HASH(mp, id, type)   ((type & XFS_DQ_USER) ? \
 919                                      (qmtest_udqtab + \
 920                                       DQTEST_HASHVAL(mp, id)) : \
 921                                      (qmtest_gdqtab + \
 922                                       DQTEST_HASHVAL(mp, id)))
 923
 924 #define DQTEST_LIST_PRINT(l, NXT, title) \
 925 { \
 926           xfs_dqtest_t  *dqp; int i = 0;\
 927           cmn_err(CE_DEBUG, "%s (#%d)", title, (int) (l)->qh_nelems); \
 928           for (dqp = (xfs_dqtest_t *)(l)->qh_next; dqp != NULL; \
 929                dqp = (xfs_dqtest_t *)dqp->NXT) { \
 930                 cmn_err(CE_DEBUG, "  %d. \"%d (%s)\"  bcnt = %d, icnt = %d", \
 931                          ++i, dqp->d_id, DQFLAGTO_TYPESTR(dqp),      \
 932                          dqp->d_bcount, dqp->d_icount); } \
 933 }
 934
 935 typedef struct dqtest {
 936         uint             dq_flags;      /* various flags (XFS_DQ_*) */
 937         struct list_head q_hashlist;
 938         xfs_dqhash_t    *q_hash;        /* the hashchain header */
 939         xfs_mount_t     *q_mount;       /* filesystem this relates to */
 940         xfs_dqid_t      d_id;           /* user id or group id */
 941         xfs_qcnt_t      d_bcount;       /* # disk blocks owned by the user */
 942         xfs_qcnt_t      d_icount;       /* # inodes owned by the user */
 943 } xfs_dqtest_t;
 944
 945 STATIC void
 946 xfs_qm_hashinsert(xfs_dqhash_t *h, xfs_dqtest_t *dqp)
 947 {
 948         list_add(&dqp->q_hashlist, &h->qh_list);
 949         h->qh_version++;
 950         h->qh_nelems++;
 951 }
 952 STATIC void
 953 xfs_qm_dqtest_print(
 954         xfs_dqtest_t    *d)
 955 {
 956         cmn_err(CE_DEBUG, "-----------DQTEST DQUOT----------------");
 957         cmn_err(CE_DEBUG, "---- dquot ID = %d", d->d_id);
 958         cmn_err(CE_DEBUG, "---- fs       = 0x%p", d->q_mount);
 959         cmn_err(CE_DEBUG, "---- bcount   = %Lu (0x%x)",
 960                 d->d_bcount, (int)d->d_bcount);
 961         cmn_err(CE_DEBUG, "---- icount   = %Lu (0x%x)",
 962                 d->d_icount, (int)d->d_icount);
 963         cmn_err(CE_DEBUG, "---------------------------");
 964 }
 965
 966 STATIC void
 967 xfs_qm_dqtest_failed(
 968         xfs_dqtest_t    *d,
 969         xfs_dquot_t     *dqp,
 970         char            *reason,
 971         xfs_qcnt_t      a,
 972         xfs_qcnt_t      b,
 973         int             error)
 974 {
 975         qmtest_nfails++;
 976         if (error)
 977                 cmn_err(CE_DEBUG, "quotacheck failed id=%d, err=%d\nreason: %s",
 978                        d->d_id, error, reason);
 979         else
 980                 cmn_err(CE_DEBUG, "quotacheck failed id=%d (%s) [%d != %d]",
 981                        d->d_id, reason, (int)a, (int)b);
 982         xfs_qm_dqtest_print(d);
 983         if (dqp)
 984                 xfs_qm_dqprint(dqp);
 985 }
 986
 987 STATIC int
 988 xfs_dqtest_cmp2(
 989         xfs_dqtest_t    *d,
 990         xfs_dquot_t     *dqp)
 991 {
 992         int err = 0;
 993         if (be64_to_cpu(dqp->q_core.d_icount) != d->d_icount) {
 994                 xfs_qm_dqtest_failed(d, dqp, "icount mismatch",
 995                         be64_to_cpu(dqp->q_core.d_icount),
 996                         d->d_icount, 0);
 997                 err++;
 998         }
 999         if (be64_to_cpu(dqp->q_core.d_bcount) != d->d_bcount) {
1000                 xfs_qm_dqtest_failed(d, dqp, "bcount mismatch",
1001                         be64_to_cpu(dqp->q_core.d_bcount),
1002                         d->d_bcount, 0);
1003                 err++;
1004         }
1005         if (dqp->q_core.d_blk_softlimit &&
1006             be64_to_cpu(dqp->q_core.d_bcount) >=
1007             be64_to_cpu(dqp->q_core.d_blk_softlimit)) {
1008                 if (!dqp->q_core.d_btimer && dqp->q_core.d_id) {
1009                         cmn_err(CE_DEBUG,
1010                                 "%d [%s] [0x%p] BLK TIMER NOT STARTED",
1011                                 d->d_id, DQFLAGTO_TYPESTR(d), d->q_mount);
1012                         err++;
1013                 }
1014         }
1015         if (dqp->q_core.d_ino_softlimit &&
1016             be64_to_cpu(dqp->q_core.d_icount) >=
1017             be64_to_cpu(dqp->q_core.d_ino_softlimit)) {
1018                 if (!dqp->q_core.d_itimer && dqp->q_core.d_id) {
1019                         cmn_err(CE_DEBUG,
1020                                 "%d [%s] [0x%p] INO TIMER NOT STARTED",
1021                                 d->d_id, DQFLAGTO_TYPESTR(d), d->q_mount);
1022                         err++;
1023                 }
1024         }
1025 #ifdef QUOTADEBUG
1026         if (!err) {
1027                 cmn_err(CE_DEBUG, "%d [%s] [0x%p] qchecked",
1028                         d->d_id, DQFLAGTO_TYPESTR(d), d->q_mount);
1029         }
1030 #endif
1031         return (err);
1032 }
1033
1034 STATIC void
1035 xfs_dqtest_cmp(
1036         xfs_dqtest_t    *d)
1037 {
1038         xfs_dquot_t     *dqp;
1039         int             error;
1040
1041         /* xfs_qm_dqtest_print(d); */
1042         if ((error = xfs_qm_dqget(d->q_mount, NULL, d->d_id, d->dq_flags, 0,
1043                                  &dqp))) {
1044                 xfs_qm_dqtest_failed(d, NULL, "dqget failed", 0, 0, error);
1045                 return;
1046         }
1047         xfs_dqtest_cmp2(d, dqp);
1048         xfs_qm_dqput(dqp);
1049 }
1050
1051 STATIC int
1052 xfs_qm_internalqcheck_dqget(
1053         xfs_mount_t     *mp,
1054         xfs_dqid_t      id,
1055         uint            type,
1056         xfs_dqtest_t    **O_dq)
1057 {
1058         xfs_dqtest_t    *d;
1059         xfs_dqhash_t    *h;
1060
1061         h = DQTEST_HASH(mp, id, type);
1062         list_for_each_entry(d, &h->qh_list, q_hashlist) {
1063                 if (d->d_id == id && mp == d->q_mount) {
1064                         *O_dq = d;
1065                         return (0);
1066                 }
1067         }
1068         d = kmem_zalloc(sizeof(xfs_dqtest_t), KM_SLEEP);
1069         d->dq_flags = type;
1070         d->d_id = id;
1071         d->q_mount = mp;
1072         d->q_hash = h;
1073         INIT_LIST_HEAD(&d->q_hashlist);
1074         xfs_qm_hashinsert(h, d);
1075         *O_dq = d;
1076         return (0);
1077 }
1078
1079 STATIC void
1080 xfs_qm_internalqcheck_get_dquots(
1081         xfs_mount_t     *mp,
1082         xfs_dqid_t      uid,
1083         xfs_dqid_t      projid,
1084         xfs_dqid_t      gid,
1085         xfs_dqtest_t    **ud,
1086         xfs_dqtest_t    **gd)
1087 {
1088         if (XFS_IS_UQUOTA_ON(mp))
1089                 xfs_qm_internalqcheck_dqget(mp, uid, XFS_DQ_USER, ud);
1090         if (XFS_IS_GQUOTA_ON(mp))
1091                 xfs_qm_internalqcheck_dqget(mp, gid, XFS_DQ_GROUP, gd);
1092         else if (XFS_IS_PQUOTA_ON(mp))
1093                 xfs_qm_internalqcheck_dqget(mp, projid, XFS_DQ_PROJ, gd);
1094 }
1095
1096
1097 STATIC void
1098 xfs_qm_internalqcheck_dqadjust(
1099         xfs_inode_t             *ip,
1100         xfs_dqtest_t            *d)
1101 {
1102         d->d_icount++;
1103         d->d_bcount += (xfs_qcnt_t)ip->i_d.di_nblocks;
1104 }
1105
1106 STATIC int
1107 xfs_qm_internalqcheck_adjust(
1108         xfs_mount_t     *mp,            /* mount point for filesystem */
1109         xfs_ino_t       ino,            /* inode number to get data for */
1110         void            __user *buffer, /* not used */
1111         int             ubsize,         /* not used */
1112         int             *ubused,        /* not used */
1113         int             *res)           /* bulkstat result code */
1114 {
1115         xfs_inode_t             *ip;
1116         xfs_dqtest_t            *ud, *gd;
1117         uint                    lock_flags;
1118         boolean_t               ipreleased;
1119         int                     error;
1120
1121         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1122
1123         if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
1124                 *res = BULKSTAT_RV_NOTHING;
1125                 qdprintk("internalqcheck: ino=%llu, uqino=%llu, gqino=%llu\n",
1126                         (unsigned long long) ino,
1127                         (unsigned long long) mp->m_sb.sb_uquotino,
1128                         (unsigned long long) mp->m_sb.sb_gquotino);
1129                 return XFS_ERROR(EINVAL);
1130         }
1131         ipreleased = B_FALSE;
1132  again:
1133         lock_flags = XFS_ILOCK_SHARED;
1134         if ((error = xfs_iget(mp, NULL, ino, 0, lock_flags, &ip))) {
1135                 *res = BULKSTAT_RV_NOTHING;
1136                 return (error);
1137         }
1138
1139         /*
1140          * This inode can have blocks after eof which can get released
1141          * when we send it to inactive. Since we don't check the dquot
1142          * until the after all our calculations are done, we must get rid
1143          * of those now.
1144          */
1145         if (! ipreleased) {
1146                 xfs_iput(ip, lock_flags);
1147                 ipreleased = B_TRUE;
1148                 goto again;
1149         }
1150         xfs_qm_internalqcheck_get_dquots(mp,
1151                                         (xfs_dqid_t) ip->i_d.di_uid,
1152                                         (xfs_dqid_t) ip->i_d.di_projid,
1153                                         (xfs_dqid_t) ip->i_d.di_gid,
1154                                         &ud, &gd);
1155         if (XFS_IS_UQUOTA_ON(mp)) {
1156                 ASSERT(ud);
1157                 xfs_qm_internalqcheck_dqadjust(ip, ud);
1158         }
1159         if (XFS_IS_OQUOTA_ON(mp)) {
1160                 ASSERT(gd);
1161                 xfs_qm_internalqcheck_dqadjust(ip, gd);
1162         }
1163         xfs_iput(ip, lock_flags);
1164         *res = BULKSTAT_RV_DIDONE;
1165         return (0);
1166 }
1167
1168
1169 /* PRIVATE, debugging */
1170 int
1171 xfs_qm_internalqcheck(
1172         xfs_mount_t     *mp)
1173 {
1174         xfs_ino_t       lastino;
1175         int             done, count;
1176         int             i;
1177         int             error;
1178
1179         lastino = 0;
1180         qmtest_hashmask = 32;
1181         count = 5;
1182         done = 0;
1183         qmtest_nfails = 0;
1184
1185         if (! XFS_IS_QUOTA_ON(mp))
1186                 return XFS_ERROR(ESRCH);
1187
1188         xfs_log_force(mp, XFS_LOG_SYNC);
1189         XFS_bflush(mp->m_ddev_targp);
1190         xfs_log_force(mp, XFS_LOG_SYNC);
1191         XFS_bflush(mp->m_ddev_targp);
1192
1193         mutex_lock(&qcheck_lock);
1194         /* There should be absolutely no quota activity while this
1195            is going on. */
1196         qmtest_udqtab = kmem_zalloc(qmtest_hashmask *
1197                                     sizeof(xfs_dqhash_t), KM_SLEEP);
1198         qmtest_gdqtab = kmem_zalloc(qmtest_hashmask *
1199                                     sizeof(xfs_dqhash_t), KM_SLEEP);
1200         do {
1201                 /*
1202                  * Iterate thru all the inodes in the file system,
1203                  * adjusting the corresponding dquot counters
1204                  */
1205                 error = xfs_bulkstat(mp, &lastino, &count,
1206                                  xfs_qm_internalqcheck_adjust,
1207                                  0, NULL, &done);
1208                 if (error) {
1209                         cmn_err(CE_DEBUG, "Bulkstat returned error 0x%x", error);
1210                         break;
1211                 }
1212         } while (!done);
1213
1214         cmn_err(CE_DEBUG, "Checking results against system dquots");
1215         for (i = 0; i < qmtest_hashmask; i++) {
1216                 xfs_dqtest_t    *d, *n;
1217                 xfs_dqhash_t    *h;
1218
1219                 h = &qmtest_udqtab[i];
1220                 list_for_each_entry_safe(d, n, &h->qh_list, q_hashlist) {
1221                         xfs_dqtest_cmp(d);
1222                         kmem_free(d);
1223                 }
1224                 h = &qmtest_gdqtab[i];
1225                 list_for_each_entry_safe(d, n, &h->qh_list, q_hashlist) {
1226                         xfs_dqtest_cmp(d);
1227                         kmem_free(d);
1228                 }
1229         }
1230
1231         if (qmtest_nfails) {
1232                 cmn_err(CE_DEBUG, "******** quotacheck failed  ********");
1233                 cmn_err(CE_DEBUG, "failures = %d", qmtest_nfails);
1234         } else {
1235                 cmn_err(CE_DEBUG, "******** quotacheck successful! ********");
1236         }
1237         kmem_free(qmtest_udqtab);
1238         kmem_free(qmtest_gdqtab);
1239         mutex_unlock(&qcheck_lock);
1240         return (qmtest_nfails);
1241 }
1242
1243 #endif /* DEBUG */