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         enum quota_type qtype;
 576
 577         if (dqp->dq_flags & XFS_DQ_PROJ)
 578                 qtype = PRJQUOTA;
 579         else if (dqp->dq_flags & XFS_DQ_USER)
 580                 qtype = USRQUOTA;
 581         else
 582                 qtype = GRPQUOTA;
 583
 584         quota_send_warning(make_kqid(&init_user_ns, qtype,
 585                                      be32_to_cpu(dqp->q_core.d_id)),
 586                            mp->m_super->s_dev, type);
 587 }
 588
 589 /*
 590  * This reserves disk blocks and inodes against a dquot.
 591  * Flags indicate if the dquot is to be locked here and also
 592  * if the blk reservation is for RT or regular blocks.
 593  * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check.
 594  */
 595 STATIC int
 596 xfs_trans_dqresv(
 597         xfs_trans_t     *tp,
 598         xfs_mount_t     *mp,
 599         xfs_dquot_t     *dqp,
 600         long            nblks,
 601         long            ninos,
 602         uint            flags)
 603 {
 604         xfs_qcnt_t      hardlimit;
 605         xfs_qcnt_t      softlimit;
 606         time_t          timer;
 607         xfs_qwarncnt_t  warns;
 608         xfs_qwarncnt_t  warnlimit;
 609         xfs_qcnt_t      total_count;
 610         xfs_qcnt_t      *resbcountp;
 611         xfs_quotainfo_t *q = mp->m_quotainfo;
 612
 613
 614         xfs_dqlock(dqp);
 615
 616         if (flags & XFS_TRANS_DQ_RES_BLKS) {
 617                 hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);
 618                 if (!hardlimit)
 619                         hardlimit = q->qi_bhardlimit;
 620                 softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit);
 621                 if (!softlimit)
 622                         softlimit = q->qi_bsoftlimit;
 623                 timer = be32_to_cpu(dqp->q_core.d_btimer);
 624                 warns = be16_to_cpu(dqp->q_core.d_bwarns);
 625                 warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit;
 626                 resbcountp = &dqp->q_res_bcount;
 627         } else {
 628                 ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);
 629                 hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);
 630                 if (!hardlimit)
 631                         hardlimit = q->qi_rtbhardlimit;
 632                 softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit);
 633                 if (!softlimit)
 634                         softlimit = q->qi_rtbsoftlimit;
 635                 timer = be32_to_cpu(dqp->q_core.d_rtbtimer);
 636                 warns = be16_to_cpu(dqp->q_core.d_rtbwarns);
 637                 warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit;
 638                 resbcountp = &dqp->q_res_rtbcount;
 639         }
 640
 641         if ((flags & XFS_QMOPT_FORCE_RES) == 0 &&
 642             dqp->q_core.d_id &&
 643             ((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) ||
 644              (XFS_IS_GQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISGDQ(dqp)) ||
 645              (XFS_IS_PQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISPDQ(dqp)))) {
 646                 if (nblks > 0) {
 647                         /*
 648                          * dquot is locked already. See if we'd go over the
 649                          * hardlimit or exceed the timelimit if we allocate
 650                          * nblks.
 651                          */
 652                         total_count = *resbcountp + nblks;
 653                         if (hardlimit && total_count > hardlimit) {
 654                                 xfs_quota_warn(mp, dqp, QUOTA_NL_BHARDWARN);
 655                                 goto error_return;
 656                         }
 657                         if (softlimit && total_count > softlimit) {
 658                                 if ((timer != 0 && get_seconds() > timer) ||
 659                                     (warns != 0 && warns >= warnlimit)) {
 660                                         xfs_quota_warn(mp, dqp,
 661                                                        QUOTA_NL_BSOFTLONGWARN);
 662                                         goto error_return;
 663                                 }
 664
 665                                 xfs_quota_warn(mp, dqp, QUOTA_NL_BSOFTWARN);
 666                         }
 667                 }
 668                 if (ninos > 0) {
 669                         total_count = be64_to_cpu(dqp->q_core.d_icount) + ninos;
 670                         timer = be32_to_cpu(dqp->q_core.d_itimer);
 671                         warns = be16_to_cpu(dqp->q_core.d_iwarns);
 672                         warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit;
 673                         hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);
 674                         if (!hardlimit)
 675                                 hardlimit = q->qi_ihardlimit;
 676                         softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);
 677                         if (!softlimit)
 678                                 softlimit = q->qi_isoftlimit;
 679
 680                         if (hardlimit && total_count > hardlimit) {
 681                                 xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN);
 682                                 goto error_return;
 683                         }
 684                         if (softlimit && total_count > softlimit) {
 685                                 if  ((timer != 0 && get_seconds() > timer) ||
 686                                      (warns != 0 && warns >= warnlimit)) {
 687                                         xfs_quota_warn(mp, dqp,
 688                                                        QUOTA_NL_ISOFTLONGWARN);
 689                                         goto error_return;
 690                                 }
 691                                 xfs_quota_warn(mp, dqp, QUOTA_NL_ISOFTWARN);
 692                         }
 693                 }
 694         }
 695
 696         /*
 697          * Change the reservation, but not the actual usage.
 698          * Note that q_res_bcount = q_core.d_bcount + resv
 699          */
 700         (*resbcountp) += (xfs_qcnt_t)nblks;
 701         if (ninos != 0)
 702                 dqp->q_res_icount += (xfs_qcnt_t)ninos;
 703
 704         /*
 705          * note the reservation amt in the trans struct too,
 706          * so that the transaction knows how much was reserved by
 707          * it against this particular dquot.
 708          * We don't do this when we are reserving for a delayed allocation,
 709          * because we don't have the luxury of a transaction envelope then.
 710          */
 711         if (tp) {
 712                 ASSERT(tp->t_dqinfo);
 713                 ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
 714                 if (nblks != 0)
 715                         xfs_trans_mod_dquot(tp, dqp,
 716                                             flags & XFS_QMOPT_RESBLK_MASK,
 717                                             nblks);
 718                 if (ninos != 0)
 719                         xfs_trans_mod_dquot(tp, dqp,
 720                                             XFS_TRANS_DQ_RES_INOS,
 721                                             ninos);
 722         }
 723         ASSERT(dqp->q_res_bcount >= be64_to_cpu(dqp->q_core.d_bcount));
 724         ASSERT(dqp->q_res_rtbcount >= be64_to_cpu(dqp->q_core.d_rtbcount));
 725         ASSERT(dqp->q_res_icount >= be64_to_cpu(dqp->q_core.d_icount));
 726
 727         xfs_dqunlock(dqp);
 728         return 0;
 729
 730 error_return:
 731         xfs_dqunlock(dqp);
 732         if (flags & XFS_QMOPT_ENOSPC)
 733                 return -ENOSPC;
 734         return -EDQUOT;
 735 }
 736
 737
 738 /*
 739  * Given dquot(s), make disk block and/or inode reservations against them.
 740  * The fact that this does the reservation against user, group and
 741  * project quotas is important, because this follows a all-or-nothing
 742  * approach.
 743  *
 744  * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown.
 745  *         XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT.  Used by pquota.
 746  *         XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks
 747  *         XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks
 748  * dquots are unlocked on return, if they were not locked by caller.
 749  */
 750 int
 751 xfs_trans_reserve_quota_bydquots(
 752         struct xfs_trans        *tp,
 753         struct xfs_mount        *mp,
 754         struct xfs_dquot        *udqp,
 755         struct xfs_dquot        *gdqp,
 756         struct xfs_dquot        *pdqp,
 757         long                    nblks,
 758         long                    ninos,
 759         uint                    flags)
 760 {
 761         int             error;
 762
 763         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
 764                 return 0;
 765
 766         if (tp && tp->t_dqinfo == NULL)
 767                 xfs_trans_alloc_dqinfo(tp);
 768
 769         ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
 770
 771         if (udqp) {
 772                 error = xfs_trans_dqresv(tp, mp, udqp, nblks, ninos,
 773                                         (flags & ~XFS_QMOPT_ENOSPC));
 774                 if (error)
 775                         return error;
 776         }
 777
 778         if (gdqp) {
 779                 error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags);
 780                 if (error)
 781                         goto unwind_usr;
 782         }
 783
 784         if (pdqp) {
 785                 error = xfs_trans_dqresv(tp, mp, pdqp, nblks, ninos, flags);
 786                 if (error)
 787                         goto unwind_grp;
 788         }
 789
 790         /*
 791          * Didn't change anything critical, so, no need to log
 792          */
 793         return 0;
 794
 795 unwind_grp:
 796         flags |= XFS_QMOPT_FORCE_RES;
 797         if (gdqp)
 798                 xfs_trans_dqresv(tp, mp, gdqp, -nblks, -ninos, flags);
 799 unwind_usr:
 800         flags |= XFS_QMOPT_FORCE_RES;
 801         if (udqp)
 802                 xfs_trans_dqresv(tp, mp, udqp, -nblks, -ninos, flags);
 803         return error;
 804 }
 805
 806
 807 /*
 808  * Lock the dquot and change the reservation if we can.
 809  * This doesn't change the actual usage, just the reservation.
 810  * The inode sent in is locked.
 811  */
 812 int
 813 xfs_trans_reserve_quota_nblks(
 814         struct xfs_trans        *tp,
 815         struct xfs_inode        *ip,
 816         long                    nblks,
 817         long                    ninos,
 818         uint                    flags)
 819 {
 820         struct xfs_mount        *mp = ip->i_mount;
 821
 822         if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
 823                 return 0;
 824         if (XFS_IS_PQUOTA_ON(mp))
 825                 flags |= XFS_QMOPT_ENOSPC;
 826
 827         ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino));
 828
 829         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 830         ASSERT((flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
 831                                 XFS_TRANS_DQ_RES_RTBLKS ||
 832                (flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
 833                                 XFS_TRANS_DQ_RES_BLKS);
 834
 835         /*
 836          * Reserve nblks against these dquots, with trans as the mediator.
 837          */
 838         return xfs_trans_reserve_quota_bydquots(tp, mp,
 839                                                 ip->i_udquot, ip->i_gdquot,
 840                                                 ip->i_pdquot,
 841                                                 nblks, ninos, flags);
 842 }
 843
 844 /*
 845  * This routine is called to allocate a quotaoff log item.
 846  */
 847 xfs_qoff_logitem_t *
 848 xfs_trans_get_qoff_item(
 849         xfs_trans_t             *tp,
 850         xfs_qoff_logitem_t      *startqoff,
 851         uint                    flags)
 852 {
 853         xfs_qoff_logitem_t      *q;
 854
 855         ASSERT(tp != NULL);
 856
 857         q = xfs_qm_qoff_logitem_init(tp->t_mountp, startqoff, flags);
 858         ASSERT(q != NULL);
 859
 860         /*
 861          * Get a log_item_desc to point at the new item.
 862          */
 863         xfs_trans_add_item(tp, &q->qql_item);
 864         return q;
 865 }
 866
 867
 868 /*
 869  * This is called to mark the quotaoff logitem as needing
 870  * to be logged when the transaction is committed.  The logitem must
 871  * already be associated with the given transaction.
 872  */
 873 void
 874 xfs_trans_log_quotaoff_item(
 875         xfs_trans_t             *tp,
 876         xfs_qoff_logitem_t      *qlp)
 877 {
 878         tp->t_flags |= XFS_TRANS_DIRTY;
 879         qlp->qql_item.li_desc->lid_flags |= XFS_LID_DIRTY;
 880 }
 881
 882 STATIC void
 883 xfs_trans_alloc_dqinfo(
 884         xfs_trans_t     *tp)
 885 {
 886         tp->t_dqinfo = kmem_zone_zalloc(xfs_qm_dqtrxzone, KM_SLEEP);
 887 }
 888
 889 void
 890 xfs_trans_free_dqinfo(
 891         xfs_trans_t     *tp)
 892 {
 893         if (!tp->t_dqinfo)
 894                 return;
 895         kmem_zone_free(xfs_qm_dqtrxzone, tp->t_dqinfo);
 896         tp->t_dqinfo = NULL;
 897 }