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