fs/xfs/xfs_trans_dquot.c

   1 /*
   2  * Copyright (c) 2000-2002 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_format.h"
  21 #include "xfs_log.h"
  22 #include "xfs_trans.h"
  23 #include "xfs_sb.h"
  24 #include "xfs_ag.h"
  25 #include "xfs_alloc.h"
  26 #include "xfs_quota.h"
  27 #include "xfs_mount.h"
  28 #include "xfs_bmap_btree.h"
  29 #include "xfs_inode.h"
  30 #include "xfs_itable.h"
  31 #include "xfs_bmap.h"
  32 #include "xfs_rtalloc.h"
  33 #include "xfs_error.h"
  34 #include "xfs_attr.h"
  35 #include "xfs_buf_item.h"
  36 #include "xfs_trans_priv.h"
  37 #include "xfs_qm.h"
  38
  39 STATIC void     xfs_trans_alloc_dqinfo(xfs_trans_t *);
  40
  41 /*
  42  * Add the locked dquot to the transaction.
  43  * The dquot must be locked, and it cannot be associated with any
  44  * transaction.
  45  */
  46 void
  47 xfs_trans_dqjoin(
  48         xfs_trans_t     *tp,
  49         xfs_dquot_t     *dqp)
  50 {
  51         ASSERT(dqp->q_transp != tp);
  52         ASSERT(XFS_DQ_IS_LOCKED(dqp));
  53         ASSERT(dqp->q_logitem.qli_dquot == dqp);
  54
  55         /*
  56          * Get a log_item_desc to point at the new item.
  57          */
  58         xfs_trans_add_item(tp, &dqp->q_logitem.qli_item);
  59
  60         /*
  61          * Initialize d_transp so we can later determine if this dquot is
  62          * associated with this transaction.
  63          */
  64         dqp->q_transp = tp;
  65 }
  66
  67
  68 /*
  69  * This is called to mark the dquot as needing
  70  * to be logged when the transaction is committed.  The dquot must
  71  * already be associated with the given transaction.
  72  * Note that it marks the entire transaction as dirty. In the ordinary
  73  * case, this gets called via xfs_trans_commit, after the transaction
  74  * is already dirty. However, there's nothing stop this from getting
  75  * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY
  76  * flag.
  77  */
  78 void
  79 xfs_trans_log_dquot(
  80         xfs_trans_t     *tp,
  81         xfs_dquot_t     *dqp)
  82 {
  83         ASSERT(dqp->q_transp == tp);
  84         ASSERT(XFS_DQ_IS_LOCKED(dqp));
  85
  86         tp->t_flags |= XFS_TRANS_DIRTY;
  87         dqp->q_logitem.qli_item.li_desc->lid_flags |= XFS_LID_DIRTY;
  88 }
  89
  90 /*
  91  * Carry forward whatever is left of the quota blk reservation to
  92  * the spanky new transaction
  93  */
  94 void
  95 xfs_trans_dup_dqinfo(
  96         xfs_trans_t     *otp,
  97         xfs_trans_t     *ntp)
  98 {
  99         xfs_dqtrx_t     *oq, *nq;
 100         int             i,j;
 101         xfs_dqtrx_t     *oqa, *nqa;
 102
 103         if (!otp->t_dqinfo)
 104                 return;
 105
 106         xfs_trans_alloc_dqinfo(ntp);
 107
 108         /*
 109          * Because the quota blk reservation is carried forward,
 110          * it is also necessary to carry forward the DQ_DIRTY flag.
 111          */
 112         if(otp->t_flags & XFS_TRANS_DQ_DIRTY)
 113                 ntp->t_flags |= XFS_TRANS_DQ_DIRTY;
 114
 115         for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
 116                 oqa = otp->t_dqinfo->dqs[j];
 117                 nqa = ntp->t_dqinfo->dqs[j];
 118                 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 119                         if (oqa[i].qt_dquot == NULL)
 120                                 break;
 121                         oq = &oqa[i];
 122                         nq = &nqa[i];
 123
 124                         nq->qt_dquot = oq->qt_dquot;
 125                         nq->qt_bcount_delta = nq->qt_icount_delta = 0;
 126                         nq->qt_rtbcount_delta = 0;
 127
 128                         /*
 129                          * Transfer whatever is left of the reservations.
 130                          */
 131                         nq->qt_blk_res = oq->qt_blk_res - oq->qt_blk_res_used;
 132                         oq->qt_blk_res = oq->qt_blk_res_used;
 133
 134                         nq->qt_rtblk_res = oq->qt_rtblk_res -
 135                                 oq->qt_rtblk_res_used;
 136                         oq->qt_rtblk_res = oq->qt_rtblk_res_used;
 137
 138                         nq->qt_ino_res = oq->qt_ino_res - oq->qt_ino_res_used;
 139                         oq->qt_ino_res = oq->qt_ino_res_used;
 140
 141                 }
 142         }
 143 }
 144
 145 /*
 146  * Wrap around mod_dquot to account for both user and group quotas.
 147  */
 148 void
 149 xfs_trans_mod_dquot_byino(
 150         xfs_trans_t     *tp,
 151         xfs_inode_t     *ip,
 152         uint            field,
 153         long            delta)
 154 {
 155         xfs_mount_t     *mp = tp->t_mountp;
 156
 157         if (!XFS_IS_QUOTA_RUNNING(mp) ||
 158             !XFS_IS_QUOTA_ON(mp) ||
 159             xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
 160                 return;
 161
 162         if (tp->t_dqinfo == NULL)
 163                 xfs_trans_alloc_dqinfo(tp);
 164
 165         if (XFS_IS_UQUOTA_ON(mp) && ip->i_udquot)
 166                 (void) xfs_trans_mod_dquot(tp, ip->i_udquot, field, delta);
 167         if (XFS_IS_GQUOTA_ON(mp) && ip->i_gdquot)
 168                 (void) xfs_trans_mod_dquot(tp, ip->i_gdquot, field, delta);
 169         if (XFS_IS_PQUOTA_ON(mp) && ip->i_pdquot)
 170                 (void) xfs_trans_mod_dquot(tp, ip->i_pdquot, field, delta);
 171 }
 172
 173 STATIC struct xfs_dqtrx *
 174 xfs_trans_get_dqtrx(
 175         struct xfs_trans        *tp,
 176         struct xfs_dquot        *dqp)
 177 {
 178         int                     i;
 179         struct xfs_dqtrx        *qa;
 180
 181         if (XFS_QM_ISUDQ(dqp))
 182                 qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_USR];
 183         else if (XFS_QM_ISGDQ(dqp))
 184                 qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_GRP];
 185         else if (XFS_QM_ISPDQ(dqp))
 186                 qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_PRJ];
 187         else
 188                 return NULL;
 189
 190         for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 191                 if (qa[i].qt_dquot == NULL ||
 192                     qa[i].qt_dquot == dqp)
 193                         return &qa[i];
 194         }
 195
 196         return NULL;
 197 }
 198
 199 /*
 200  * Make the changes in the transaction structure.
 201  * The moral equivalent to xfs_trans_mod_sb().
 202  * We don't touch any fields in the dquot, so we don't care
 203  * if it's locked or not (most of the time it won't be).
 204  */
 205 void
 206 xfs_trans_mod_dquot(
 207         xfs_trans_t     *tp,
 208         xfs_dquot_t     *dqp,
 209         uint            field,
 210         long            delta)
 211 {
 212         xfs_dqtrx_t     *qtrx;
 213
 214         ASSERT(tp);
 215         ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
 216         qtrx = NULL;
 217
 218         if (tp->t_dqinfo == NULL)
 219                 xfs_trans_alloc_dqinfo(tp);
 220         /*
 221          * Find either the first free slot or the slot that belongs
 222          * to this dquot.
 223          */
 224         qtrx = xfs_trans_get_dqtrx(tp, dqp);
 225         ASSERT(qtrx);
 226         if (qtrx->qt_dquot == NULL)
 227                 qtrx->qt_dquot = dqp;
 228
 229         switch (field) {
 230
 231                 /*
 232                  * regular disk blk reservation
 233                  */
 234               case XFS_TRANS_DQ_RES_BLKS:
 235                 qtrx->qt_blk_res += (ulong)delta;
 236                 break;
 237
 238                 /*
 239                  * inode reservation
 240                  */
 241               case XFS_TRANS_DQ_RES_INOS:
 242                 qtrx->qt_ino_res += (ulong)delta;
 243                 break;
 244
 245                 /*
 246                  * disk blocks used.
 247                  */
 248               case XFS_TRANS_DQ_BCOUNT:
 249                 if (qtrx->qt_blk_res && delta > 0) {
 250                         qtrx->qt_blk_res_used += (ulong)delta;
 251                         ASSERT(qtrx->qt_blk_res >= qtrx->qt_blk_res_used);
 252                 }
 253                 qtrx->qt_bcount_delta += delta;
 254                 break;
 255
 256               case XFS_TRANS_DQ_DELBCOUNT:
 257                 qtrx->qt_delbcnt_delta += delta;
 258                 break;
 259
 260                 /*
 261                  * Inode Count
 262                  */
 263               case XFS_TRANS_DQ_ICOUNT:
 264                 if (qtrx->qt_ino_res && delta > 0) {
 265                         qtrx->qt_ino_res_used += (ulong)delta;
 266                         ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used);
 267                 }
 268                 qtrx->qt_icount_delta += delta;
 269                 break;
 270
 271                 /*
 272                  * rtblk reservation
 273                  */
 274               case XFS_TRANS_DQ_RES_RTBLKS:
 275                 qtrx->qt_rtblk_res += (ulong)delta;
 276                 break;
 277
 278                 /*
 279                  * rtblk count
 280                  */
 281               case XFS_TRANS_DQ_RTBCOUNT:
 282                 if (qtrx->qt_rtblk_res && delta > 0) {
 283                         qtrx->qt_rtblk_res_used += (ulong)delta;
 284                         ASSERT(qtrx->qt_rtblk_res >= qtrx->qt_rtblk_res_used);
 285                 }
 286                 qtrx->qt_rtbcount_delta += delta;
 287                 break;
 288
 289               case XFS_TRANS_DQ_DELRTBCOUNT:
 290                 qtrx->qt_delrtb_delta += delta;
 291                 break;
 292
 293               default:
 294                 ASSERT(0);
 295         }
 296         tp->t_flags |= XFS_TRANS_DQ_DIRTY;
 297 }
 298
 299
 300 /*
 301  * Given an array of dqtrx structures, lock all the dquots associated and join
 302  * them to the transaction, provided they have been modified.  We know that the
 303  * highest number of dquots of one type - usr, grp OR prj - involved in a
 304  * transaction is 2 so we don't need to make this very generic.
 305  */
 306 STATIC void
 307 xfs_trans_dqlockedjoin(
 308         xfs_trans_t     *tp,
 309         xfs_dqtrx_t     *q)
 310 {
 311         ASSERT(q[0].qt_dquot != NULL);
 312         if (q[1].qt_dquot == NULL) {
 313                 xfs_dqlock(q[0].qt_dquot);
 314                 xfs_trans_dqjoin(tp, q[0].qt_dquot);
 315         } else {
 316                 ASSERT(XFS_QM_TRANS_MAXDQS == 2);
 317                 xfs_dqlock2(q[0].qt_dquot, q[1].qt_dquot);
 318                 xfs_trans_dqjoin(tp, q[0].qt_dquot);
 319                 xfs_trans_dqjoin(tp, q[1].qt_dquot);
 320         }
 321 }
 322
 323
 324 /*
 325  * Called by xfs_trans_commit() and similar in spirit to
 326  * xfs_trans_apply_sb_deltas().
 327  * Go thru all the dquots belonging to this transaction and modify the
 328  * INCORE dquot to reflect the actual usages.
 329  * Unreserve just the reservations done by this transaction.
 330  * dquot is still left locked at exit.
 331  */
 332 void
 333 xfs_trans_apply_dquot_deltas(
 334         struct xfs_trans        *tp)
 335 {
 336         int                     i, j;
 337         struct xfs_dquot        *dqp;
 338         struct xfs_dqtrx        *qtrx, *qa;
 339         struct xfs_disk_dquot   *d;
 340         long                    totalbdelta;
 341         long                    totalrtbdelta;
 342
 343         if (!(tp->t_flags & XFS_TRANS_DQ_DIRTY))
 344                 return;
 345
 346         ASSERT(tp->t_dqinfo);
 347         for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
 348                 qa = tp->t_dqinfo->dqs[j];
 349                 if (qa[0].qt_dquot == NULL)
 350                         continue;
 351
 352                 /*
 353                  * Lock all of the dquots and join them to the transaction.
 354                  */
 355                 xfs_trans_dqlockedjoin(tp, qa);
 356
 357                 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 358                         qtrx = &qa[i];
 359                         /*
 360                          * The array of dquots is filled
 361                          * sequentially, not sparsely.
 362                          */
 363                         if ((dqp = qtrx->qt_dquot) == NULL)
 364                                 break;
 365
 366                         ASSERT(XFS_DQ_IS_LOCKED(dqp));
 367                         ASSERT(dqp->q_transp == tp);
 368
 369                         /*
 370                          * adjust the actual number of blocks used
 371                          */
 372                         d = &dqp->q_core;
 373
 374                         /*
 375                          * The issue here is - sometimes we don't make a blkquota
 376                          * reservation intentionally to be fair to users
 377                          * (when the amount is small). On the other hand,
 378                          * delayed allocs do make reservations, but that's
 379                          * outside of a transaction, so we have no
 380                          * idea how much was really reserved.
 381                          * So, here we've accumulated delayed allocation blks and
 382                          * non-delay blks. The assumption is that the
 383                          * delayed ones are always reserved (outside of a
 384                          * transaction), and the others may or may not have
 385                          * quota reservations.
 386                          */
 387                         totalbdelta = qtrx->qt_bcount_delta +
 388                                 qtrx->qt_delbcnt_delta;
 389                         totalrtbdelta = qtrx->qt_rtbcount_delta +
 390                                 qtrx->qt_delrtb_delta;
 391 #ifdef DEBUG
 392                         if (totalbdelta < 0)
 393                                 ASSERT(be64_to_cpu(d->d_bcount) >=
 394                                        -totalbdelta);
 395
 396                         if (totalrtbdelta < 0)
 397                                 ASSERT(be64_to_cpu(d->d_rtbcount) >=
 398                                        -totalrtbdelta);
 399
 400                         if (qtrx->qt_icount_delta < 0)
 401                                 ASSERT(be64_to_cpu(d->d_icount) >=
 402                                        -qtrx->qt_icount_delta);
 403 #endif
 404                         if (totalbdelta)
 405                                 be64_add_cpu(&d->d_bcount, (xfs_qcnt_t)totalbdelta);
 406
 407                         if (qtrx->qt_icount_delta)
 408                                 be64_add_cpu(&d->d_icount, (xfs_qcnt_t)qtrx->qt_icount_delta);
 409
 410                         if (totalrtbdelta)
 411                                 be64_add_cpu(&d->d_rtbcount, (xfs_qcnt_t)totalrtbdelta);
 412
 413                         /*
 414                          * Get any default limits in use.
 415                          * Start/reset the timer(s) if needed.
 416                          */
 417                         if (d->d_id) {
 418                                 xfs_qm_adjust_dqlimits(tp->t_mountp, dqp);
 419                                 xfs_qm_adjust_dqtimers(tp->t_mountp, d);
 420                         }
 421
 422                         dqp->dq_flags |= XFS_DQ_DIRTY;
 423                         /*
 424                          * add this to the list of items to get logged
 425                          */
 426                         xfs_trans_log_dquot(tp, dqp);
 427                         /*
 428                          * Take off what's left of the original reservation.
 429                          * In case of delayed allocations, there's no
 430                          * reservation that a transaction structure knows of.
 431                          */
 432                         if (qtrx->qt_blk_res != 0) {
 433                                 if (qtrx->qt_blk_res != qtrx->qt_blk_res_used) {
 434                                         if (qtrx->qt_blk_res >
 435                                             qtrx->qt_blk_res_used)
 436                                                 dqp->q_res_bcount -= (xfs_qcnt_t)
 437                                                         (qtrx->qt_blk_res -
 438                                                          qtrx->qt_blk_res_used);
 439                                         else
 440                                                 dqp->q_res_bcount -= (xfs_qcnt_t)
 441                                                         (qtrx->qt_blk_res_used -
 442                                                          qtrx->qt_blk_res);
 443                                 }
 444                         } else {
 445                                 /*
 446                                  * These blks were never reserved, either inside
 447                                  * a transaction or outside one (in a delayed
 448                                  * allocation). Also, this isn't always a
 449                                  * negative number since we sometimes
 450                                  * deliberately skip quota reservations.
 451                                  */
 452                                 if (qtrx->qt_bcount_delta) {
 453                                         dqp->q_res_bcount +=
 454                                               (xfs_qcnt_t)qtrx->qt_bcount_delta;
 455                                 }
 456                         }
 457                         /*
 458                          * Adjust the RT reservation.
 459                          */
 460                         if (qtrx->qt_rtblk_res != 0) {
 461                                 if (qtrx->qt_rtblk_res != qtrx->qt_rtblk_res_used) {
 462                                         if (qtrx->qt_rtblk_res >
 463                                             qtrx->qt_rtblk_res_used)
 464                                                dqp->q_res_rtbcount -= (xfs_qcnt_t)
 465                                                        (qtrx->qt_rtblk_res -
 466                                                         qtrx->qt_rtblk_res_used);
 467                                         else
 468                                                dqp->q_res_rtbcount -= (xfs_qcnt_t)
 469                                                        (qtrx->qt_rtblk_res_used -
 470                                                         qtrx->qt_rtblk_res);
 471                                 }
 472                         } else {
 473                                 if (qtrx->qt_rtbcount_delta)
 474                                         dqp->q_res_rtbcount +=
 475                                             (xfs_qcnt_t)qtrx->qt_rtbcount_delta;
 476                         }
 477
 478                         /*
 479                          * Adjust the inode reservation.
 480                          */
 481                         if (qtrx->qt_ino_res != 0) {
 482                                 ASSERT(qtrx->qt_ino_res >=
 483                                        qtrx->qt_ino_res_used);
 484                                 if (qtrx->qt_ino_res > qtrx->qt_ino_res_used)
 485                                         dqp->q_res_icount -= (xfs_qcnt_t)
 486                                                 (qtrx->qt_ino_res -
 487                                                  qtrx->qt_ino_res_used);
 488                         } else {
 489                                 if (qtrx->qt_icount_delta)
 490                                         dqp->q_res_icount +=
 491                                             (xfs_qcnt_t)qtrx->qt_icount_delta;
 492                         }
 493
 494                         ASSERT(dqp->q_res_bcount >=
 495                                 be64_to_cpu(dqp->q_core.d_bcount));
 496                         ASSERT(dqp->q_res_icount >=
 497                                 be64_to_cpu(dqp->q_core.d_icount));
 498                         ASSERT(dqp->q_res_rtbcount >=
 499                                 be64_to_cpu(dqp->q_core.d_rtbcount));
 500                 }
 501         }
 502 }
 503
 504 /*
 505  * Release the reservations, and adjust the dquots accordingly.
 506  * This is called only when the transaction is being aborted. If by
 507  * any chance we have done dquot modifications incore (ie. deltas) already,
 508  * we simply throw those away, since that's the expected behavior
 509  * when a transaction is curtailed without a commit.
 510  */
 511 void
 512 xfs_trans_unreserve_and_mod_dquots(
 513         xfs_trans_t             *tp)
 514 {
 515         int                     i, j;
 516         xfs_dquot_t             *dqp;
 517         xfs_dqtrx_t             *qtrx, *qa;
 518         bool                    locked;
 519
 520         if (!tp->t_dqinfo || !(tp->t_flags & XFS_TRANS_DQ_DIRTY))
 521                 return;
 522
 523         for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
 524                 qa = tp->t_dqinfo->dqs[j];
 525
 526                 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 527                         qtrx = &qa[i];
 528                         /*
 529                          * We assume that the array of dquots is filled
 530                          * sequentially, not sparsely.
 531                          */
 532                         if ((dqp = qtrx->qt_dquot) == NULL)
 533                                 break;
 534                         /*
 535                          * Unreserve the original reservation. We don't care
 536                          * about the number of blocks used field, or deltas.
 537                          * Also we don't bother to zero the fields.
 538                          */
 539                         locked = false;
 540                         if (qtrx->qt_blk_res) {
 541                                 xfs_dqlock(dqp);
 542                                 locked = true;
 543                                 dqp->q_res_bcount -=
 544                                         (xfs_qcnt_t)qtrx->qt_blk_res;
 545                         }
 546                         if (qtrx->qt_ino_res) {
 547                                 if (!locked) {
 548                                         xfs_dqlock(dqp);
 549                                         locked = true;
 550                                 }
 551                                 dqp->q_res_icount -=
 552                                         (xfs_qcnt_t)qtrx->qt_ino_res;
 553                         }
 554
 555                         if (qtrx->qt_rtblk_res) {
 556                                 if (!locked) {
 557                                         xfs_dqlock(dqp);
 558                                         locked = true;
 559                                 }
 560                                 dqp->q_res_rtbcount -=
 561                                         (xfs_qcnt_t)qtrx->qt_rtblk_res;
 562                         }
 563                         if (locked)
 564                                 xfs_dqunlock(dqp);
 565
 566                 }
 567         }
 568 }
 569
 570 STATIC void
 571 xfs_quota_warn(
 572         struct xfs_mount        *mp,
 573         struct xfs_dquot        *dqp,
 574         int                     type)
 575 {
 576         /* no warnings for project quotas - we just return ENOSPC later */
 577         if (dqp->dq_flags & XFS_DQ_PROJ)
 578                 return;
 579         quota_send_warning(make_kqid(&init_user_ns,
 580                                      (dqp->dq_flags & XFS_DQ_USER) ?
 581                                      USRQUOTA : GRPQUOTA,
 582                                      be32_to_cpu(dqp->q_core.d_id)),
 583                            mp->m_super->s_dev, type);
 584 }
 585
 586 /*
 587  * This reserves disk blocks and inodes against a dquot.
 588  * Flags indicate if the dquot is to be locked here and also
 589  * if the blk reservation is for RT or regular blocks.
 590  * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check.
 591  */
 592 STATIC int
 593 xfs_trans_dqresv(
 594         xfs_trans_t     *tp,
 595         xfs_mount_t     *mp,
 596         xfs_dquot_t     *dqp,
 597         long            nblks,
 598         long            ninos,
 599         uint            flags)
 600 {
 601         xfs_qcnt_t      hardlimit;
 602         xfs_qcnt_t      softlimit;
 603         time_t          timer;
 604         xfs_qwarncnt_t  warns;
 605         xfs_qwarncnt_t  warnlimit;
 606         xfs_qcnt_t      total_count;
 607         xfs_qcnt_t      *resbcountp;
 608         xfs_quotainfo_t *q = mp->m_quotainfo;
 609
 610
 611         xfs_dqlock(dqp);
 612
 613         if (flags & XFS_TRANS_DQ_RES_BLKS) {
 614                 hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
 615                 if (!hardlimit)
 616                         hardlimit = q->qi_bhardlimit;
 617                 softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit);
 618                 if (!softlimit)
 619                         softlimit = q->qi_bsoftlimit;
 620                 timer = be32_to_cpu(dqp->q_core.d_btimer);
 621                 warns = be16_to_cpu(dqp->q_core.d_bwarns);
 622                 warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit;
 623                 resbcountp = &dqp->q_res_bcount;
 624         } else {
 625                 ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
 626                 hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);
 627                 if (!hardlimit)
 628                         hardlimit = q->qi_rtbhardlimit;
 629                 softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit);
 630                 if (!softlimit)
 631                         softlimit = q->qi_rtbsoftlimit;
 632                 timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
 633                 warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
 634                 warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit;
 635                 resbcountp = &dqp->q_res_rtbcount;
 636         }
 637
 638         if ((flags & XFS_QMOPT_FORCE_RES) == 0 &&
 639             dqp->q_core.d_id &&
 640             ((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) ||
 641              (XFS_IS_GQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISGDQ(dqp)) ||
 642              (XFS_IS_PQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISPDQ(dqp)))) {
 643                 if (nblks > 0) {
 644                         /*
 645                          * dquot is locked already. See if we'd go over the
 646                          * hardlimit or exceed the timelimit if we allocate
 647                          * nblks.
 648                          */
 649                         total_count = *resbcountp + nblks;
 650                         if (hardlimit && total_count > hardlimit) {
 651                                 xfs_quota_warn(mp, dqp, QUOTA_NL_BHARDWARN);
 652                                 goto error_return;
 653                         }
 654                         if (softlimit && total_count > softlimit) {
 655                                 if ((timer != 0 && get_seconds() > timer) ||
 656                                     (warns != 0 && warns >= warnlimit)) {
 657                                         xfs_quota_warn(mp, dqp,
 658                                                        QUOTA_NL_BSOFTLONGWARN);
 659                                         goto error_return;
 660                                 }
 661
 662                                 xfs_quota_warn(mp, dqp, QUOTA_NL_BSOFTWARN);
 663                         }
 664                 }
 665                 if (ninos > 0) {
 666                         total_count = be64_to_cpu(dqp->q_core.d_icount) + ninos;
 667                         timer = be32_to_cpu(dqp->q_core.d_itimer);
 668                         warns = be16_to_cpu(dqp->q_core.d_iwarns);
 669                         warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit;
 670                         hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
 671                         if (!hardlimit)
 672                                 hardlimit = q->qi_ihardlimit;
 673                         softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);
 674                         if (!softlimit)
 675                                 softlimit = q->qi_isoftlimit;
 676
 677                         if (hardlimit && total_count > hardlimit) {
 678                                 xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN);
 679                                 goto error_return;
 680                         }
 681                         if (softlimit && total_count > softlimit) {
 682                                 if  ((timer != 0 && get_seconds() > timer) ||
 683                                      (warns != 0 && warns >= warnlimit)) {
 684                                         xfs_quota_warn(mp, dqp,
 685                                                        QUOTA_NL_ISOFTLONGWARN);
 686                                         goto error_return;
 687                                 }
 688                                 xfs_quota_warn(mp, dqp, QUOTA_NL_ISOFTWARN);
 689                         }
 690                 }
 691         }
 692
 693         /*
 694          * Change the reservation, but not the actual usage.
 695          * Note that q_res_bcount = q_core.d_bcount + resv
 696          */
 697         (*resbcountp) += (xfs_qcnt_t)nblks;
 698         if (ninos != 0)
 699                 dqp->q_res_icount += (xfs_qcnt_t)ninos;
 700
 701         /*
 702          * note the reservation amt in the trans struct too,
 703          * so that the transaction knows how much was reserved by
 704          * it against this particular dquot.
 705          * We don't do this when we are reserving for a delayed allocation,
 706          * because we don't have the luxury of a transaction envelope then.
 707          */
 708         if (tp) {
 709                 ASSERT(tp->t_dqinfo);
 710                 ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
 711                 if (nblks != 0)
 712                         xfs_trans_mod_dquot(tp, dqp,
 713                                             flags & XFS_QMOPT_RESBLK_MASK,
 714                                             nblks);
 715                 if (ninos != 0)
 716                         xfs_trans_mod_dquot(tp, dqp,
 717                                             XFS_TRANS_DQ_RES_INOS,
 718                                             ninos);
 719         }
 720         ASSERT(dqp->q_res_bcount >= be64_to_cpu(dqp->q_core.d_bcount));
 721         ASSERT(dqp->q_res_rtbcount >= be64_to_cpu(dqp->q_core.d_rtbcount));
 722         ASSERT(dqp->q_res_icount >= be64_to_cpu(dqp->q_core.d_icount));
 723
 724         xfs_dqunlock(dqp);
 725         return 0;
 726
 727 error_return:
 728         xfs_dqunlock(dqp);
 729         if (flags & XFS_QMOPT_ENOSPC)
 730                 return ENOSPC;
 731         return EDQUOT;
 732 }
 733
 734
 735 /*
 736  * Given dquot(s), make disk block and/or inode reservations against them.
 737  * The fact that this does the reservation against user, group and
 738  * project quotas is important, because this follows a all-or-nothing
 739  * approach.
 740  *
 741  * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown.
 742  *         XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT.  Used by pquota.
 743  *         XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks
 744  *         XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks
 745  * dquots are unlocked on return, if they were not locked by caller.
 746  */
 747 int
 748 xfs_trans_reserve_quota_bydquots(
 749         struct xfs_trans        *tp,
 750         struct xfs_mount        *mp,
 751         struct xfs_dquot        *udqp,
 752         struct xfs_dquot        *gdqp,
 753         struct xfs_dquot        *pdqp,
 754         long                    nblks,
 755         long                    ninos,
 756         uint                    flags)
 757 {
 758         int             error;
 759
 760         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
 761                 return 0;
 762
 763         if (tp && tp->t_dqinfo == NULL)
 764                 xfs_trans_alloc_dqinfo(tp);
 765
 766         ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
 767
 768         if (udqp) {
 769                 error = xfs_trans_dqresv(tp, mp, udqp, nblks, ninos,
 770                                         (flags & ~XFS_QMOPT_ENOSPC));
 771                 if (error)
 772                         return error;
 773         }
 774
 775         if (gdqp) {
 776                 error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags);
 777                 if (error)
 778                         goto unwind_usr;
 779         }
 780
 781         if (pdqp) {
 782                 error = xfs_trans_dqresv(tp, mp, pdqp, nblks, ninos, flags);
 783                 if (error)
 784                         goto unwind_grp;
 785         }
 786
 787         /*
 788          * Didn't change anything critical, so, no need to log
 789          */
 790         return 0;
 791
 792 unwind_grp:
 793         flags |= XFS_QMOPT_FORCE_RES;
 794         if (gdqp)
 795                 xfs_trans_dqresv(tp, mp, gdqp, -nblks, -ninos, flags);
 796 unwind_usr:
 797         flags |= XFS_QMOPT_FORCE_RES;
 798         if (udqp)
 799                 xfs_trans_dqresv(tp, mp, udqp, -nblks, -ninos, flags);
 800         return error;
 801 }
 802
 803
 804 /*
 805  * Lock the dquot and change the reservation if we can.
 806  * This doesn't change the actual usage, just the reservation.
 807  * The inode sent in is locked.
 808  */
 809 int
 810 xfs_trans_reserve_quota_nblks(
 811         struct xfs_trans        *tp,
 812         struct xfs_inode        *ip,
 813         long                    nblks,
 814         long                    ninos,
 815         uint                    flags)
 816 {
 817         struct xfs_mount        *mp = ip->i_mount;
 818
 819         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
 820                 return 0;
 821         if (XFS_IS_PQUOTA_ON(mp))
 822                 flags |= XFS_QMOPT_ENOSPC;
 823
 824         ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino));
 825
 826         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 827         ASSERT((flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
 828                                 XFS_TRANS_DQ_RES_RTBLKS ||
 829                (flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
 830                                 XFS_TRANS_DQ_RES_BLKS);
 831
 832         /*
 833          * Reserve nblks against these dquots, with trans as the mediator.
 834          */
 835         return xfs_trans_reserve_quota_bydquots(tp, mp,
 836                                                 ip->i_udquot, ip->i_gdquot,
 837                                                 ip->i_pdquot,
 838                                                 nblks, ninos, flags);
 839 }
 840
 841 /*
 842  * This routine is called to allocate a quotaoff log item.
 843  */
 844 xfs_qoff_logitem_t *
 845 xfs_trans_get_qoff_item(
 846         xfs_trans_t             *tp,
 847         xfs_qoff_logitem_t      *startqoff,
 848         uint                    flags)
 849 {
 850         xfs_qoff_logitem_t      *q;
 851
 852         ASSERT(tp != NULL);
 853
 854         q = xfs_qm_qoff_logitem_init(tp->t_mountp, startqoff, flags);
 855         ASSERT(q != NULL);
 856
 857         /*
 858          * Get a log_item_desc to point at the new item.
 859          */
 860         xfs_trans_add_item(tp, &q->qql_item);
 861         return q;
 862 }
 863
 864
 865 /*
 866  * This is called to mark the quotaoff logitem as needing
 867  * to be logged when the transaction is committed.  The logitem must
 868  * already be associated with the given transaction.
 869  */
 870 void
 871 xfs_trans_log_quotaoff_item(
 872         xfs_trans_t             *tp,
 873         xfs_qoff_logitem_t      *qlp)
 874 {
 875         tp->t_flags |= XFS_TRANS_DIRTY;
 876         qlp->qql_item.li_desc->lid_flags |= XFS_LID_DIRTY;
 877 }
 878
 879 STATIC void
 880 xfs_trans_alloc_dqinfo(
 881         xfs_trans_t     *tp)
 882 {
 883         tp->t_dqinfo = kmem_zone_zalloc(xfs_qm_dqtrxzone, KM_SLEEP);
 884 }
 885
 886 void
 887 xfs_trans_free_dqinfo(
 888         xfs_trans_t     *tp)
 889 {
 890         if (!tp->t_dqinfo)
 891                 return;
 892         kmem_zone_free(xfs_qm_dqtrxzone, tp->t_dqinfo);
 893         tp->t_dqinfo = NULL;
 894 }