fs/xfs/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_shared.h"
  24 #include "xfs_format.h"
  25 #include "xfs_log_format.h"
  26 #include "xfs_trans_resv.h"
  27 #include "xfs_bit.h"
  28 #include "xfs_sb.h"
  29 #include "xfs_mount.h"
  30 #include "xfs_inode.h"
  31 #include "xfs_trans.h"
  32 #include "xfs_error.h"
  33 #include "xfs_quota.h"
  34 #include "xfs_qm.h"
  35 #include "xfs_trace.h"
  36 #include "xfs_icache.h"
  37
  38 STATIC int      xfs_qm_log_quotaoff(xfs_mount_t *, xfs_qoff_logitem_t **, uint);
  39 STATIC int      xfs_qm_log_quotaoff_end(xfs_mount_t *, xfs_qoff_logitem_t *,
  40                                         uint);
  41 STATIC uint     xfs_qm_export_flags(uint);
  42
  43 /*
  44  * Turn off quota accounting and/or enforcement for all udquots and/or
  45  * gdquots. Called only at unmount time.
  46  *
  47  * This assumes that there are no dquots of this file system cached
  48  * incore, and modifies the ondisk dquot directly. Therefore, for example,
  49  * it is an error to call this twice, without purging the cache.
  50  */
  51 int
  52 xfs_qm_scall_quotaoff(
  53         xfs_mount_t             *mp,
  54         uint                    flags)
  55 {
  56         struct xfs_quotainfo    *q = mp->m_quotainfo;
  57         uint                    dqtype;
  58         int                     error;
  59         uint                    inactivate_flags;
  60         xfs_qoff_logitem_t      *qoffstart;
  61
  62         /*
  63          * No file system can have quotas enabled on disk but not in core.
  64          * Note that quota utilities (like quotaoff) _expect_
  65          * errno == -EEXIST here.
  66          */
  67         if ((mp->m_qflags & flags) == 0)
  68                 return -EEXIST;
  69         error = 0;
  70
  71         flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
  72
  73         /*
  74          * We don't want to deal with two quotaoffs messing up each other,
  75          * so we're going to serialize it. quotaoff isn't exactly a performance
  76          * critical thing.
  77          * If quotaoff, then we must be dealing with the root filesystem.
  78          */
  79         ASSERT(q);
  80         mutex_lock(&q->qi_quotaofflock);
  81
  82         /*
  83          * If we're just turning off quota enforcement, change mp and go.
  84          */
  85         if ((flags & XFS_ALL_QUOTA_ACCT) == 0) {
  86                 mp->m_qflags &= ~(flags);
  87
  88                 spin_lock(&mp->m_sb_lock);
  89                 mp->m_sb.sb_qflags = mp->m_qflags;
  90                 spin_unlock(&mp->m_sb_lock);
  91                 mutex_unlock(&q->qi_quotaofflock);
  92
  93                 /* XXX what to do if error ? Revert back to old vals incore ? */
  94                 return xfs_sync_sb(mp, false);
  95         }
  96
  97         dqtype = 0;
  98         inactivate_flags = 0;
  99         /*
 100          * If accounting is off, we must turn enforcement off, clear the
 101          * quota 'CHKD' certificate to make it known that we have to
 102          * do a quotacheck the next time this quota is turned on.
 103          */
 104         if (flags & XFS_UQUOTA_ACCT) {
 105                 dqtype |= XFS_QMOPT_UQUOTA;
 106                 flags |= (XFS_UQUOTA_CHKD | XFS_UQUOTA_ENFD);
 107                 inactivate_flags |= XFS_UQUOTA_ACTIVE;
 108         }
 109         if (flags & XFS_GQUOTA_ACCT) {
 110                 dqtype |= XFS_QMOPT_GQUOTA;
 111                 flags |= (XFS_GQUOTA_CHKD | XFS_GQUOTA_ENFD);
 112                 inactivate_flags |= XFS_GQUOTA_ACTIVE;
 113         }
 114         if (flags & XFS_PQUOTA_ACCT) {
 115                 dqtype |= XFS_QMOPT_PQUOTA;
 116                 flags |= (XFS_PQUOTA_CHKD | XFS_PQUOTA_ENFD);
 117                 inactivate_flags |= XFS_PQUOTA_ACTIVE;
 118         }
 119
 120         /*
 121          * Nothing to do?  Don't complain. This happens when we're just
 122          * turning off quota enforcement.
 123          */
 124         if ((mp->m_qflags & flags) == 0)
 125                 goto out_unlock;
 126
 127         /*
 128          * Write the LI_QUOTAOFF log record, and do SB changes atomically,
 129          * and synchronously. If we fail to write, we should abort the
 130          * operation as it cannot be recovered safely if we crash.
 131          */
 132         error = xfs_qm_log_quotaoff(mp, &qoffstart, flags);
 133         if (error)
 134                 goto out_unlock;
 135
 136         /*
 137          * Next we clear the XFS_MOUNT_*DQ_ACTIVE bit(s) in the mount struct
 138          * to take care of the race between dqget and quotaoff. We don't take
 139          * any special locks to reset these bits. All processes need to check
 140          * these bits *after* taking inode lock(s) to see if the particular
 141          * quota type is in the process of being turned off. If *ACTIVE, it is
 142          * guaranteed that all dquot structures and all quotainode ptrs will all
 143          * stay valid as long as that inode is kept locked.
 144          *
 145          * There is no turning back after this.
 146          */
 147         mp->m_qflags &= ~inactivate_flags;
 148
 149         /*
 150          * Give back all the dquot reference(s) held by inodes.
 151          * Here we go thru every single incore inode in this file system, and
 152          * do a dqrele on the i_udquot/i_gdquot that it may have.
 153          * Essentially, as long as somebody has an inode locked, this guarantees
 154          * that quotas will not be turned off. This is handy because in a
 155          * transaction once we lock the inode(s) and check for quotaon, we can
 156          * depend on the quota inodes (and other things) being valid as long as
 157          * we keep the lock(s).
 158          */
 159         xfs_qm_dqrele_all_inodes(mp, flags);
 160
 161         /*
 162          * Next we make the changes in the quota flag in the mount struct.
 163          * This isn't protected by a particular lock directly, because we
 164          * don't want to take a mrlock every time we depend on quotas being on.
 165          */
 166         mp->m_qflags &= ~flags;
 167
 168         /*
 169          * Go through all the dquots of this file system and purge them,
 170          * according to what was turned off.
 171          */
 172         xfs_qm_dqpurge_all(mp, dqtype);
 173
 174         /*
 175          * Transactions that had started before ACTIVE state bit was cleared
 176          * could have logged many dquots, so they'd have higher LSNs than
 177          * the first QUOTAOFF log record does. If we happen to crash when
 178          * the tail of the log has gone past the QUOTAOFF record, but
 179          * before the last dquot modification, those dquots __will__
 180          * recover, and that's not good.
 181          *
 182          * So, we have QUOTAOFF start and end logitems; the start
 183          * logitem won't get overwritten until the end logitem appears...
 184          */
 185         error = xfs_qm_log_quotaoff_end(mp, qoffstart, flags);
 186         if (error) {
 187                 /* We're screwed now. Shutdown is the only option. */
 188                 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 189                 goto out_unlock;
 190         }
 191
 192         /*
 193          * If all quotas are completely turned off, close shop.
 194          */
 195         if (mp->m_qflags == 0) {
 196                 mutex_unlock(&q->qi_quotaofflock);
 197                 xfs_qm_destroy_quotainfo(mp);
 198                 return 0;
 199         }
 200
 201         /*
 202          * Release our quotainode references if we don't need them anymore.
 203          */
 204         if ((dqtype & XFS_QMOPT_UQUOTA) && q->qi_uquotaip) {
 205                 IRELE(q->qi_uquotaip);
 206                 q->qi_uquotaip = NULL;
 207         }
 208         if ((dqtype & XFS_QMOPT_GQUOTA) && q->qi_gquotaip) {
 209                 IRELE(q->qi_gquotaip);
 210                 q->qi_gquotaip = NULL;
 211         }
 212         if ((dqtype & XFS_QMOPT_PQUOTA) && q->qi_pquotaip) {
 213                 IRELE(q->qi_pquotaip);
 214                 q->qi_pquotaip = NULL;
 215         }
 216
 217 out_unlock:
 218         mutex_unlock(&q->qi_quotaofflock);
 219         return error;
 220 }
 221
 222 STATIC int
 223 xfs_qm_scall_trunc_qfile(
 224         struct xfs_mount        *mp,
 225         xfs_ino_t               ino)
 226 {
 227         struct xfs_inode        *ip;
 228         struct xfs_trans        *tp;
 229         int                     error;
 230
 231         if (ino == NULLFSINO)
 232                 return 0;
 233
 234         error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
 235         if (error)
 236                 return error;
 237
 238         xfs_ilock(ip, XFS_IOLOCK_EXCL);
 239
 240         tp = xfs_trans_alloc(mp, XFS_TRANS_TRUNCATE_FILE);
 241         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
 242         if (error) {
 243                 xfs_trans_cancel(tp, 0);
 244                 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
 245                 goto out_put;
 246         }
 247
 248         xfs_ilock(ip, XFS_ILOCK_EXCL);
 249         xfs_trans_ijoin(tp, ip, 0);
 250
 251         ip->i_d.di_size = 0;
 252         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
 253
 254         error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
 255         if (error) {
 256                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
 257                                      XFS_TRANS_ABORT);
 258                 goto out_unlock;
 259         }
 260
 261         ASSERT(ip->i_d.di_nextents == 0);
 262
 263         xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 264         error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
 265
 266 out_unlock:
 267         xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
 268 out_put:
 269         IRELE(ip);
 270         return error;
 271 }
 272
 273 int
 274 xfs_qm_scall_trunc_qfiles(
 275         xfs_mount_t     *mp,
 276         uint            flags)
 277 {
 278         int             error = -EINVAL;
 279
 280         if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0 ||
 281             (flags & ~XFS_DQ_ALLTYPES)) {
 282                 xfs_debug(mp, "%s: flags=%x m_qflags=%x",
 283                         __func__, flags, mp->m_qflags);
 284                 return -EINVAL;
 285         }
 286
 287         if (flags & XFS_DQ_USER) {
 288                 error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_uquotino);
 289                 if (error)
 290                         return error;
 291         }
 292         if (flags & XFS_DQ_GROUP) {
 293                 error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_gquotino);
 294                 if (error)
 295                         return error;
 296         }
 297         if (flags & XFS_DQ_PROJ)
 298                 error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_pquotino);
 299
 300         return error;
 301 }
 302
 303 /*
 304  * Switch on (a given) quota enforcement for a filesystem.  This takes
 305  * effect immediately.
 306  * (Switching on quota accounting must be done at mount time.)
 307  */
 308 int
 309 xfs_qm_scall_quotaon(
 310         xfs_mount_t     *mp,
 311         uint            flags)
 312 {
 313         int             error;
 314         uint            qf;
 315
 316         flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
 317         /*
 318          * Switching on quota accounting must be done at mount time.
 319          */
 320         flags &= ~(XFS_ALL_QUOTA_ACCT);
 321
 322         if (flags == 0) {
 323                 xfs_debug(mp, "%s: zero flags, m_qflags=%x",
 324                         __func__, mp->m_qflags);
 325                 return -EINVAL;
 326         }
 327
 328         /*
 329          * Can't enforce without accounting. We check the superblock
 330          * qflags here instead of m_qflags because rootfs can have
 331          * quota acct on ondisk without m_qflags' knowing.
 332          */
 333         if (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
 334              (flags & XFS_UQUOTA_ENFD)) ||
 335             ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
 336              (flags & XFS_GQUOTA_ENFD)) ||
 337             ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
 338              (flags & XFS_PQUOTA_ENFD))) {
 339                 xfs_debug(mp,
 340                         "%s: Can't enforce without acct, flags=%x sbflags=%x",
 341                         __func__, flags, mp->m_sb.sb_qflags);
 342                 return -EINVAL;
 343         }
 344         /*
 345          * If everything's up to-date incore, then don't waste time.
 346          */
 347         if ((mp->m_qflags & flags) == flags)
 348                 return -EEXIST;
 349
 350         /*
 351          * Change sb_qflags on disk but not incore mp->qflags
 352          * if this is the root filesystem.
 353          */
 354         spin_lock(&mp->m_sb_lock);
 355         qf = mp->m_sb.sb_qflags;
 356         mp->m_sb.sb_qflags = qf | flags;
 357         spin_unlock(&mp->m_sb_lock);
 358
 359         /*
 360          * There's nothing to change if it's the same.
 361          */
 362         if ((qf & flags) == flags)
 363                 return -EEXIST;
 364
 365         error = xfs_sync_sb(mp, false);
 366         if (error)
 367                 return error;
 368         /*
 369          * If we aren't trying to switch on quota enforcement, we are done.
 370          */
 371         if  (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) !=
 372              (mp->m_qflags & XFS_UQUOTA_ACCT)) ||
 373              ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) !=
 374              (mp->m_qflags & XFS_PQUOTA_ACCT)) ||
 375              ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) !=
 376              (mp->m_qflags & XFS_GQUOTA_ACCT)))
 377                 return 0;
 378
 379         if (! XFS_IS_QUOTA_RUNNING(mp))
 380                 return -ESRCH;
 381
 382         /*
 383          * Switch on quota enforcement in core.
 384          */
 385         mutex_lock(&mp->m_quotainfo->qi_quotaofflock);
 386         mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD);
 387         mutex_unlock(&mp->m_quotainfo->qi_quotaofflock);
 388
 389         return 0;
 390 }
 391
 392
 393 /*
 394  * Return quota status information, such as uquota-off, enforcements, etc.
 395  * for Q_XGETQSTAT command.
 396  */
 397 int
 398 xfs_qm_scall_getqstat(
 399         struct xfs_mount        *mp,
 400         struct fs_quota_stat    *out)
 401 {
 402         struct xfs_quotainfo    *q = mp->m_quotainfo;
 403         struct xfs_inode        *uip = NULL;
 404         struct xfs_inode        *gip = NULL;
 405         struct xfs_inode        *pip = NULL;
 406         bool                    tempuqip = false;
 407         bool                    tempgqip = false;
 408         bool                    temppqip = false;
 409
 410         memset(out, 0, sizeof(fs_quota_stat_t));
 411
 412         out->qs_version = FS_QSTAT_VERSION;
 413         out->qs_flags = (__uint16_t) xfs_qm_export_flags(mp->m_qflags &
 414                                                         (XFS_ALL_QUOTA_ACCT|
 415                                                          XFS_ALL_QUOTA_ENFD));
 416         uip = q->qi_uquotaip;
 417         gip = q->qi_gquotaip;
 418         pip = q->qi_pquotaip;
 419         if (!uip && mp->m_sb.sb_uquotino != NULLFSINO) {
 420                 if (xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
 421                                         0, 0, &uip) == 0)
 422                         tempuqip = true;
 423         }
 424         if (!gip && mp->m_sb.sb_gquotino != NULLFSINO) {
 425                 if (xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
 426                                         0, 0, &gip) == 0)
 427                         tempgqip = true;
 428         }
 429         /*
 430          * Q_XGETQSTAT doesn't have room for both group and project quotas.
 431          * So, allow the project quota values to be copied out only if
 432          * there is no group quota information available.
 433          */
 434         if (!gip) {
 435                 if (!pip && mp->m_sb.sb_pquotino != NULLFSINO) {
 436                         if (xfs_iget(mp, NULL, mp->m_sb.sb_pquotino,
 437                                                 0, 0, &pip) == 0)
 438                                 temppqip = true;
 439                 }
 440         } else
 441                 pip = NULL;
 442         if (uip) {
 443                 out->qs_uquota.qfs_ino = mp->m_sb.sb_uquotino;
 444                 out->qs_uquota.qfs_nblks = uip->i_d.di_nblocks;
 445                 out->qs_uquota.qfs_nextents = uip->i_d.di_nextents;
 446                 if (tempuqip)
 447                         IRELE(uip);
 448         }
 449
 450         if (gip) {
 451                 out->qs_gquota.qfs_ino = mp->m_sb.sb_gquotino;
 452                 out->qs_gquota.qfs_nblks = gip->i_d.di_nblocks;
 453                 out->qs_gquota.qfs_nextents = gip->i_d.di_nextents;
 454                 if (tempgqip)
 455                         IRELE(gip);
 456         }
 457         if (pip) {
 458                 out->qs_gquota.qfs_ino = mp->m_sb.sb_gquotino;
 459                 out->qs_gquota.qfs_nblks = pip->i_d.di_nblocks;
 460                 out->qs_gquota.qfs_nextents = pip->i_d.di_nextents;
 461                 if (temppqip)
 462                         IRELE(pip);
 463         }
 464         out->qs_incoredqs = q->qi_dquots;
 465         out->qs_btimelimit = q->qi_btimelimit;
 466         out->qs_itimelimit = q->qi_itimelimit;
 467         out->qs_rtbtimelimit = q->qi_rtbtimelimit;
 468         out->qs_bwarnlimit = q->qi_bwarnlimit;
 469         out->qs_iwarnlimit = q->qi_iwarnlimit;
 470
 471         return 0;
 472 }
 473
 474 /*
 475  * Return quota status information, such as uquota-off, enforcements, etc.
 476  * for Q_XGETQSTATV command, to support separate project quota field.
 477  */
 478 int
 479 xfs_qm_scall_getqstatv(
 480         struct xfs_mount        *mp,
 481         struct fs_quota_statv   *out)
 482 {
 483         struct xfs_quotainfo    *q = mp->m_quotainfo;
 484         struct xfs_inode        *uip = NULL;
 485         struct xfs_inode        *gip = NULL;
 486         struct xfs_inode        *pip = NULL;
 487         bool                    tempuqip = false;
 488         bool                    tempgqip = false;
 489         bool                    temppqip = false;
 490
 491         out->qs_flags = (__uint16_t) xfs_qm_export_flags(mp->m_qflags &
 492                                                         (XFS_ALL_QUOTA_ACCT|
 493                                                          XFS_ALL_QUOTA_ENFD));
 494         out->qs_uquota.qfs_ino = mp->m_sb.sb_uquotino;
 495         out->qs_gquota.qfs_ino = mp->m_sb.sb_gquotino;
 496         out->qs_pquota.qfs_ino = mp->m_sb.sb_pquotino;
 497
 498         uip = q->qi_uquotaip;
 499         gip = q->qi_gquotaip;
 500         pip = q->qi_pquotaip;
 501         if (!uip && mp->m_sb.sb_uquotino != NULLFSINO) {
 502                 if (xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
 503                                         0, 0, &uip) == 0)
 504                         tempuqip = true;
 505         }
 506         if (!gip && mp->m_sb.sb_gquotino != NULLFSINO) {
 507                 if (xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
 508                                         0, 0, &gip) == 0)
 509                         tempgqip = true;
 510         }
 511         if (!pip && mp->m_sb.sb_pquotino != NULLFSINO) {
 512                 if (xfs_iget(mp, NULL, mp->m_sb.sb_pquotino,
 513                                         0, 0, &pip) == 0)
 514                         temppqip = true;
 515         }
 516         if (uip) {
 517                 out->qs_uquota.qfs_nblks = uip->i_d.di_nblocks;
 518                 out->qs_uquota.qfs_nextents = uip->i_d.di_nextents;
 519                 if (tempuqip)
 520                         IRELE(uip);
 521         }
 522
 523         if (gip) {
 524                 out->qs_gquota.qfs_nblks = gip->i_d.di_nblocks;
 525                 out->qs_gquota.qfs_nextents = gip->i_d.di_nextents;
 526                 if (tempgqip)
 527                         IRELE(gip);
 528         }
 529         if (pip) {
 530                 out->qs_pquota.qfs_nblks = pip->i_d.di_nblocks;
 531                 out->qs_pquota.qfs_nextents = pip->i_d.di_nextents;
 532                 if (temppqip)
 533                         IRELE(pip);
 534         }
 535         out->qs_incoredqs = q->qi_dquots;
 536         out->qs_btimelimit = q->qi_btimelimit;
 537         out->qs_itimelimit = q->qi_itimelimit;
 538         out->qs_rtbtimelimit = q->qi_rtbtimelimit;
 539         out->qs_bwarnlimit = q->qi_bwarnlimit;
 540         out->qs_iwarnlimit = q->qi_iwarnlimit;
 541
 542         return 0;
 543 }
 544
 545 #define XFS_QC_MASK \
 546         (QC_LIMIT_MASK | QC_TIMER_MASK | QC_WARNS_MASK)
 547
 548 /*
 549  * Adjust quota limits, and start/stop timers accordingly.
 550  */
 551 int
 552 xfs_qm_scall_setqlim(
 553         struct xfs_mount        *mp,
 554         xfs_dqid_t              id,
 555         uint                    type,
 556         struct qc_dqblk         *newlim)
 557 {
 558         struct xfs_quotainfo    *q = mp->m_quotainfo;
 559         struct xfs_disk_dquot   *ddq;
 560         struct xfs_dquot        *dqp;
 561         struct xfs_trans        *tp;
 562         int                     error;
 563         xfs_qcnt_t              hard, soft;
 564
 565         if (newlim->d_fieldmask & ~XFS_QC_MASK)
 566                 return -EINVAL;
 567         if ((newlim->d_fieldmask & XFS_QC_MASK) == 0)
 568                 return 0;
 569
 570         /*
 571          * We don't want to race with a quotaoff so take the quotaoff lock.
 572          * We don't hold an inode lock, so there's nothing else to stop
 573          * a quotaoff from happening.
 574          */
 575         mutex_lock(&q->qi_quotaofflock);
 576
 577         /*
 578          * Get the dquot (locked) before we start, as we need to do a
 579          * transaction to allocate it if it doesn't exist. Once we have the
 580          * dquot, unlock it so we can start the next transaction safely. We hold
 581          * a reference to the dquot, so it's safe to do this unlock/lock without
 582          * it being reclaimed in the mean time.
 583          */
 584         error = xfs_qm_dqget(mp, NULL, id, type, XFS_QMOPT_DQALLOC, &dqp);
 585         if (error) {
 586                 ASSERT(error != -ENOENT);
 587                 goto out_unlock;
 588         }
 589         xfs_dqunlock(dqp);
 590
 591         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SETQLIM);
 592         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_setqlim, 0, 0);
 593         if (error) {
 594                 xfs_trans_cancel(tp, 0);
 595                 goto out_rele;
 596         }
 597
 598         xfs_dqlock(dqp);
 599         xfs_trans_dqjoin(tp, dqp);
 600         ddq = &dqp->q_core;
 601
 602         /*
 603          * Make sure that hardlimits are >= soft limits before changing.
 604          */
 605         hard = (newlim->d_fieldmask & QC_SPC_HARD) ?
 606                 (xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_hardlimit) :
 607                         be64_to_cpu(ddq->d_blk_hardlimit);
 608         soft = (newlim->d_fieldmask & QC_SPC_SOFT) ?
 609                 (xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_softlimit) :
 610                         be64_to_cpu(ddq->d_blk_softlimit);
 611         if (hard == 0 || hard >= soft) {
 612                 ddq->d_blk_hardlimit = cpu_to_be64(hard);
 613                 ddq->d_blk_softlimit = cpu_to_be64(soft);
 614                 xfs_dquot_set_prealloc_limits(dqp);
 615                 if (id == 0) {
 616                         q->qi_bhardlimit = hard;
 617                         q->qi_bsoftlimit = soft;
 618                 }
 619         } else {
 620                 xfs_debug(mp, "blkhard %Ld < blksoft %Ld", hard, soft);
 621         }
 622         hard = (newlim->d_fieldmask & QC_RT_SPC_HARD) ?
 623                 (xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_hardlimit) :
 624                         be64_to_cpu(ddq->d_rtb_hardlimit);
 625         soft = (newlim->d_fieldmask & QC_RT_SPC_SOFT) ?
 626                 (xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_softlimit) :
 627                         be64_to_cpu(ddq->d_rtb_softlimit);
 628         if (hard == 0 || hard >= soft) {
 629                 ddq->d_rtb_hardlimit = cpu_to_be64(hard);
 630                 ddq->d_rtb_softlimit = cpu_to_be64(soft);
 631                 if (id == 0) {
 632                         q->qi_rtbhardlimit = hard;
 633                         q->qi_rtbsoftlimit = soft;
 634                 }
 635         } else {
 636                 xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld", hard, soft);
 637         }
 638
 639         hard = (newlim->d_fieldmask & QC_INO_HARD) ?
 640                 (xfs_qcnt_t) newlim->d_ino_hardlimit :
 641                         be64_to_cpu(ddq->d_ino_hardlimit);
 642         soft = (newlim->d_fieldmask & QC_INO_SOFT) ?
 643                 (xfs_qcnt_t) newlim->d_ino_softlimit :
 644                         be64_to_cpu(ddq->d_ino_softlimit);
 645         if (hard == 0 || hard >= soft) {
 646                 ddq->d_ino_hardlimit = cpu_to_be64(hard);
 647                 ddq->d_ino_softlimit = cpu_to_be64(soft);
 648                 if (id == 0) {
 649                         q->qi_ihardlimit = hard;
 650                         q->qi_isoftlimit = soft;
 651                 }
 652         } else {
 653                 xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft);
 654         }
 655
 656         /*
 657          * Update warnings counter(s) if requested
 658          */
 659         if (newlim->d_fieldmask & QC_SPC_WARNS)
 660                 ddq->d_bwarns = cpu_to_be16(newlim->d_spc_warns);
 661         if (newlim->d_fieldmask & QC_INO_WARNS)
 662                 ddq->d_iwarns = cpu_to_be16(newlim->d_ino_warns);
 663         if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
 664                 ddq->d_rtbwarns = cpu_to_be16(newlim->d_rt_spc_warns);
 665
 666         if (id == 0) {
 667                 /*
 668                  * Timelimits for the super user set the relative time
 669                  * the other users can be over quota for this file system.
 670                  * If it is zero a default is used.  Ditto for the default
 671                  * soft and hard limit values (already done, above), and
 672                  * for warnings.
 673                  */
 674                 if (newlim->d_fieldmask & QC_SPC_TIMER) {
 675                         q->qi_btimelimit = newlim->d_spc_timer;
 676                         ddq->d_btimer = cpu_to_be32(newlim->d_spc_timer);
 677                 }
 678                 if (newlim->d_fieldmask & QC_INO_TIMER) {
 679                         q->qi_itimelimit = newlim->d_ino_timer;
 680                         ddq->d_itimer = cpu_to_be32(newlim->d_ino_timer);
 681                 }
 682                 if (newlim->d_fieldmask & QC_RT_SPC_TIMER) {
 683                         q->qi_rtbtimelimit = newlim->d_rt_spc_timer;
 684                         ddq->d_rtbtimer = cpu_to_be32(newlim->d_rt_spc_timer);
 685                 }
 686                 if (newlim->d_fieldmask & QC_SPC_WARNS)
 687                         q->qi_bwarnlimit = newlim->d_spc_warns;
 688                 if (newlim->d_fieldmask & QC_INO_WARNS)
 689                         q->qi_iwarnlimit = newlim->d_ino_warns;
 690                 if (newlim->d_fieldmask & QC_RT_SPC_WARNS)
 691                         q->qi_rtbwarnlimit = newlim->d_rt_spc_warns;
 692         } else {
 693                 /*
 694                  * If the user is now over quota, start the timelimit.
 695                  * The user will not be 'warned'.
 696                  * Note that we keep the timers ticking, whether enforcement
 697                  * is on or off. We don't really want to bother with iterating
 698                  * over all ondisk dquots and turning the timers on/off.
 699                  */
 700                 xfs_qm_adjust_dqtimers(mp, ddq);
 701         }
 702         dqp->dq_flags |= XFS_DQ_DIRTY;
 703         xfs_trans_log_dquot(tp, dqp);
 704
 705         error = xfs_trans_commit(tp, 0);
 706
 707 out_rele:
 708         xfs_qm_dqrele(dqp);
 709 out_unlock:
 710         mutex_unlock(&q->qi_quotaofflock);
 711         return error;
 712 }
 713
 714 STATIC int
 715 xfs_qm_log_quotaoff_end(
 716         xfs_mount_t             *mp,
 717         xfs_qoff_logitem_t      *startqoff,
 718         uint                    flags)
 719 {
 720         xfs_trans_t             *tp;
 721         int                     error;
 722         xfs_qoff_logitem_t      *qoffi;
 723
 724         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF_END);
 725
 726         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_equotaoff, 0, 0);
 727         if (error) {
 728                 xfs_trans_cancel(tp, 0);
 729                 return error;
 730         }
 731
 732         qoffi = xfs_trans_get_qoff_item(tp, startqoff,
 733                                         flags & XFS_ALL_QUOTA_ACCT);
 734         xfs_trans_log_quotaoff_item(tp, qoffi);
 735
 736         /*
 737          * We have to make sure that the transaction is secure on disk before we
 738          * return and actually stop quota accounting. So, make it synchronous.
 739          * We don't care about quotoff's performance.
 740          */
 741         xfs_trans_set_sync(tp);
 742         error = xfs_trans_commit(tp, 0);
 743         return error;
 744 }
 745
 746
 747 STATIC int
 748 xfs_qm_log_quotaoff(
 749         xfs_mount_t            *mp,
 750         xfs_qoff_logitem_t     **qoffstartp,
 751         uint                   flags)
 752 {
 753         xfs_trans_t            *tp;
 754         int                     error;
 755         xfs_qoff_logitem_t     *qoffi;
 756
 757         *qoffstartp = NULL;
 758
 759         tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF);
 760         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_qm_quotaoff, 0, 0);
 761         if (error) {
 762                 xfs_trans_cancel(tp, 0);
 763                 goto out;
 764         }
 765
 766         qoffi = xfs_trans_get_qoff_item(tp, NULL, flags & XFS_ALL_QUOTA_ACCT);
 767         xfs_trans_log_quotaoff_item(tp, qoffi);
 768
 769         spin_lock(&mp->m_sb_lock);
 770         mp->m_sb.sb_qflags = (mp->m_qflags & ~(flags)) & XFS_MOUNT_QUOTA_ALL;
 771         spin_unlock(&mp->m_sb_lock);
 772
 773         xfs_log_sb(tp);
 774
 775         /*
 776          * We have to make sure that the transaction is secure on disk before we
 777          * return and actually stop quota accounting. So, make it synchronous.
 778          * We don't care about quotoff's performance.
 779          */
 780         xfs_trans_set_sync(tp);
 781         error = xfs_trans_commit(tp, 0);
 782         if (error)
 783                 goto out;
 784
 785         *qoffstartp = qoffi;
 786 out:
 787         return error;
 788 }
 789
 790
 791 int
 792 xfs_qm_scall_getquota(
 793         struct xfs_mount        *mp,
 794         xfs_dqid_t              id,
 795         uint                    type,
 796         struct qc_dqblk         *dst)
 797 {
 798         struct xfs_dquot        *dqp;
 799         int                     error;
 800
 801         /*
 802          * Try to get the dquot. We don't want it allocated on disk, so
 803          * we aren't passing the XFS_QMOPT_DOALLOC flag. If it doesn't
 804          * exist, we'll get ENOENT back.
 805          */
 806         error = xfs_qm_dqget(mp, NULL, id, type, 0, &dqp);
 807         if (error)
 808                 return error;
 809
 810         /*
 811          * If everything's NULL, this dquot doesn't quite exist as far as
 812          * our utility programs are concerned.
 813          */
 814         if (XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
 815                 error = -ENOENT;
 816                 goto out_put;
 817         }
 818
 819         memset(dst, 0, sizeof(*dst));
 820         dst->d_spc_hardlimit =
 821                 XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_blk_hardlimit));
 822         dst->d_spc_softlimit =
 823                 XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_blk_softlimit));
 824         dst->d_ino_hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
 825         dst->d_ino_softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);
 826         dst->d_space = XFS_FSB_TO_B(mp, dqp->q_res_bcount);
 827         dst->d_ino_count = dqp->q_res_icount;
 828         dst->d_spc_timer = be32_to_cpu(dqp->q_core.d_btimer);
 829         dst->d_ino_timer = be32_to_cpu(dqp->q_core.d_itimer);
 830         dst->d_ino_warns = be16_to_cpu(dqp->q_core.d_iwarns);
 831         dst->d_spc_warns = be16_to_cpu(dqp->q_core.d_bwarns);
 832         dst->d_rt_spc_hardlimit =
 833                 XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_hardlimit));
 834         dst->d_rt_spc_softlimit =
 835                 XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_softlimit));
 836         dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_res_rtbcount);
 837         dst->d_rt_spc_timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
 838         dst->d_rt_spc_warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
 839
 840         /*
 841          * Internally, we don't reset all the timers when quota enforcement
 842          * gets turned off. No need to confuse the user level code,
 843          * so return zeroes in that case.
 844          */
 845         if ((!XFS_IS_UQUOTA_ENFORCED(mp) &&
 846              dqp->q_core.d_flags == XFS_DQ_USER) ||
 847             (!XFS_IS_GQUOTA_ENFORCED(mp) &&
 848              dqp->q_core.d_flags == XFS_DQ_GROUP) ||
 849             (!XFS_IS_PQUOTA_ENFORCED(mp) &&
 850              dqp->q_core.d_flags == XFS_DQ_PROJ)) {
 851                 dst->d_spc_timer = 0;
 852                 dst->d_ino_timer = 0;
 853                 dst->d_rt_spc_timer = 0;
 854         }
 855
 856 #ifdef DEBUG
 857         if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQ_USER) ||
 858              (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQ_GROUP) ||
 859              (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQ_PROJ)) &&
 860             id != 0) {
 861                 if ((dst->d_space > dst->d_spc_softlimit) &&
 862                     (dst->d_spc_softlimit > 0)) {
 863                         ASSERT(dst->d_spc_timer != 0);
 864                 }
 865                 if ((dst->d_ino_count > dst->d_ino_softlimit) &&
 866                     (dst->d_ino_softlimit > 0)) {
 867                         ASSERT(dst->d_ino_timer != 0);
 868                 }
 869         }
 870 #endif
 871 out_put:
 872         xfs_qm_dqput(dqp);
 873         return error;
 874 }
 875
 876 STATIC uint
 877 xfs_qm_export_flags(
 878         uint flags)
 879 {
 880         uint uflags;
 881
 882         uflags = 0;
 883         if (flags & XFS_UQUOTA_ACCT)
 884                 uflags |= FS_QUOTA_UDQ_ACCT;
 885         if (flags & XFS_GQUOTA_ACCT)
 886                 uflags |= FS_QUOTA_GDQ_ACCT;
 887         if (flags & XFS_PQUOTA_ACCT)
 888                 uflags |= FS_QUOTA_PDQ_ACCT;
 889         if (flags & XFS_UQUOTA_ENFD)
 890                 uflags |= FS_QUOTA_UDQ_ENFD;
 891         if (flags & XFS_GQUOTA_ENFD)
 892                 uflags |= FS_QUOTA_GDQ_ENFD;
 893         if (flags & XFS_PQUOTA_ENFD)
 894                 uflags |= FS_QUOTA_PDQ_ENFD;
 895         return uflags;
 896 }
 897
 898
 899 STATIC int
 900 xfs_dqrele_inode(
 901         struct xfs_inode        *ip,
 902         int                     flags,
 903         void                    *args)
 904 {
 905         /* skip quota inodes */
 906         if (ip == ip->i_mount->m_quotainfo->qi_uquotaip ||
 907             ip == ip->i_mount->m_quotainfo->qi_gquotaip ||
 908             ip == ip->i_mount->m_quotainfo->qi_pquotaip) {
 909                 ASSERT(ip->i_udquot == NULL);
 910                 ASSERT(ip->i_gdquot == NULL);
 911                 ASSERT(ip->i_pdquot == NULL);
 912                 return 0;
 913         }
 914
 915         xfs_ilock(ip, XFS_ILOCK_EXCL);
 916         if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) {
 917                 xfs_qm_dqrele(ip->i_udquot);
 918                 ip->i_udquot = NULL;
 919         }
 920         if ((flags & XFS_GQUOTA_ACCT) && ip->i_gdquot) {
 921                 xfs_qm_dqrele(ip->i_gdquot);
 922                 ip->i_gdquot = NULL;
 923         }
 924         if ((flags & XFS_PQUOTA_ACCT) && ip->i_pdquot) {
 925                 xfs_qm_dqrele(ip->i_pdquot);
 926                 ip->i_pdquot = NULL;
 927         }
 928         xfs_iunlock(ip, XFS_ILOCK_EXCL);
 929         return 0;
 930 }
 931
 932
 933 /*
 934  * Go thru all the inodes in the file system, releasing their dquots.
 935  *
 936  * Note that the mount structure gets modified to indicate that quotas are off
 937  * AFTER this, in the case of quotaoff.
 938  */
 939 void
 940 xfs_qm_dqrele_all_inodes(
 941         struct xfs_mount *mp,
 942         uint             flags)
 943 {
 944         ASSERT(mp->m_quotainfo);
 945         xfs_inode_ag_iterator(mp, xfs_dqrele_inode, flags, NULL);
 946 }