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