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