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