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_sb.h" 25 #include "xfs_ag.h" 26 #include "xfs_mount.h" 27 #include "xfs_inode.h" 28 #include "xfs_error.h" 29 #include "xfs_trans.h" 30 #include "xfs_trans_priv.h" 31 #include "xfs_quota.h" 32 #include "xfs_qm.h" 33 34 STATIC void xfs_trans_alloc_dqinfo(xfs_trans_t *); 35 36 /* 37 * Add the locked dquot to the transaction. 38 * The dquot must be locked, and it cannot be associated with any 39 * transaction. 40 */ 41 void 42 xfs_trans_dqjoin( 43 xfs_trans_t *tp, 44 xfs_dquot_t *dqp) 45 { 46 ASSERT(dqp->q_transp != tp); 47 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 48 ASSERT(dqp->q_logitem.qli_dquot == dqp); 49 50 /* 51 * Get a log_item_desc to point at the new item. 52 */ 53 xfs_trans_add_item(tp, &dqp->q_logitem.qli_item); 54 55 /* 56 * Initialize d_transp so we can later determine if this dquot is 57 * associated with this transaction. 58 */ 59 dqp->q_transp = tp; 60 } 61 62 63 /* 64 * This is called to mark the dquot as needing 65 * to be logged when the transaction is committed. The dquot must 66 * already be associated with the given transaction. 67 * Note that it marks the entire transaction as dirty. In the ordinary 68 * case, this gets called via xfs_trans_commit, after the transaction 69 * is already dirty. However, there's nothing stop this from getting 70 * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY 71 * flag. 72 */ 73 void 74 xfs_trans_log_dquot( 75 xfs_trans_t *tp, 76 xfs_dquot_t *dqp) 77 { 78 ASSERT(dqp->q_transp == tp); 79 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 80 81 tp->t_flags |= XFS_TRANS_DIRTY; 82 dqp->q_logitem.qli_item.li_desc->lid_flags |= XFS_LID_DIRTY; 83 } 84 85 /* 86 * Carry forward whatever is left of the quota blk reservation to 87 * the spanky new transaction 88 */ 89 void 90 xfs_trans_dup_dqinfo( 91 xfs_trans_t *otp, 92 xfs_trans_t *ntp) 93 { 94 xfs_dqtrx_t *oq, *nq; 95 int i,j; 96 xfs_dqtrx_t *oqa, *nqa; 97 98 if (!otp->t_dqinfo) 99 return; 100 101 xfs_trans_alloc_dqinfo(ntp); 102 103 /* 104 * Because the quota blk reservation is carried forward, 105 * it is also necessary to carry forward the DQ_DIRTY flag. 106 */ 107 if(otp->t_flags & XFS_TRANS_DQ_DIRTY) 108 ntp->t_flags |= XFS_TRANS_DQ_DIRTY; 109 110 for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) { 111 oqa = otp->t_dqinfo->dqs[j]; 112 nqa = ntp->t_dqinfo->dqs[j]; 113 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) { 114 if (oqa[i].qt_dquot == NULL) 115 break; 116 oq = &oqa[i]; 117 nq = &nqa[i]; 118 119 nq->qt_dquot = oq->qt_dquot; 120 nq->qt_bcount_delta = nq->qt_icount_delta = 0; 121 nq->qt_rtbcount_delta = 0; 122 123 /* 124 * Transfer whatever is left of the reservations. 125 */ 126 nq->qt_blk_res = oq->qt_blk_res - oq->qt_blk_res_used; 127 oq->qt_blk_res = oq->qt_blk_res_used; 128 129 nq->qt_rtblk_res = oq->qt_rtblk_res - 130 oq->qt_rtblk_res_used; 131 oq->qt_rtblk_res = oq->qt_rtblk_res_used; 132 133 nq->qt_ino_res = oq->qt_ino_res - oq->qt_ino_res_used; 134 oq->qt_ino_res = oq->qt_ino_res_used; 135 136 } 137 } 138 } 139 140 /* 141 * Wrap around mod_dquot to account for both user and group quotas. 142 */ 143 void 144 xfs_trans_mod_dquot_byino( 145 xfs_trans_t *tp, 146 xfs_inode_t *ip, 147 uint field, 148 long delta) 149 { 150 xfs_mount_t *mp = tp->t_mountp; 151 152 if (!XFS_IS_QUOTA_RUNNING(mp) || 153 !XFS_IS_QUOTA_ON(mp) || 154 xfs_is_quota_inode(&mp->m_sb, ip->i_ino)) 155 return; 156 157 if (tp->t_dqinfo == NULL) 158 xfs_trans_alloc_dqinfo(tp); 159 160 if (XFS_IS_UQUOTA_ON(mp) && ip->i_udquot) 161 (void) xfs_trans_mod_dquot(tp, ip->i_udquot, field, delta); 162 if (XFS_IS_GQUOTA_ON(mp) && ip->i_gdquot) 163 (void) xfs_trans_mod_dquot(tp, ip->i_gdquot, field, delta); 164 if (XFS_IS_PQUOTA_ON(mp) && ip->i_pdquot) 165 (void) xfs_trans_mod_dquot(tp, ip->i_pdquot, field, delta); 166 } 167 168 STATIC struct xfs_dqtrx * 169 xfs_trans_get_dqtrx( 170 struct xfs_trans *tp, 171 struct xfs_dquot *dqp) 172 { 173 int i; 174 struct xfs_dqtrx *qa; 175 176 if (XFS_QM_ISUDQ(dqp)) 177 qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_USR]; 178 else if (XFS_QM_ISGDQ(dqp)) 179 qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_GRP]; 180 else if (XFS_QM_ISPDQ(dqp)) 181 qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_PRJ]; 182 else 183 return NULL; 184 185 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) { 186 if (qa[i].qt_dquot == NULL || 187 qa[i].qt_dquot == dqp) 188 return &qa[i]; 189 } 190 191 return NULL; 192 } 193 194 /* 195 * Make the changes in the transaction structure. 196 * The moral equivalent to xfs_trans_mod_sb(). 197 * We don't touch any fields in the dquot, so we don't care 198 * if it's locked or not (most of the time it won't be). 199 */ 200 void 201 xfs_trans_mod_dquot( 202 xfs_trans_t *tp, 203 xfs_dquot_t *dqp, 204 uint field, 205 long delta) 206 { 207 xfs_dqtrx_t *qtrx; 208 209 ASSERT(tp); 210 ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp)); 211 qtrx = NULL; 212 213 if (tp->t_dqinfo == NULL) 214 xfs_trans_alloc_dqinfo(tp); 215 /* 216 * Find either the first free slot or the slot that belongs 217 * to this dquot. 218 */ 219 qtrx = xfs_trans_get_dqtrx(tp, dqp); 220 ASSERT(qtrx); 221 if (qtrx->qt_dquot == NULL) 222 qtrx->qt_dquot = dqp; 223 224 switch (field) { 225 226 /* 227 * regular disk blk reservation 228 */ 229 case XFS_TRANS_DQ_RES_BLKS: 230 qtrx->qt_blk_res += (ulong)delta; 231 break; 232 233 /* 234 * inode reservation 235 */ 236 case XFS_TRANS_DQ_RES_INOS: 237 qtrx->qt_ino_res += (ulong)delta; 238 break; 239 240 /* 241 * disk blocks used. 242 */ 243 case XFS_TRANS_DQ_BCOUNT: 244 if (qtrx->qt_blk_res && delta > 0) { 245 qtrx->qt_blk_res_used += (ulong)delta; 246 ASSERT(qtrx->qt_blk_res >= qtrx->qt_blk_res_used); 247 } 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 if (qtrx->qt_blk_res != qtrx->qt_blk_res_used) { 429 if (qtrx->qt_blk_res > 430 qtrx->qt_blk_res_used) 431 dqp->q_res_bcount -= (xfs_qcnt_t) 432 (qtrx->qt_blk_res - 433 qtrx->qt_blk_res_used); 434 else 435 dqp->q_res_bcount -= (xfs_qcnt_t) 436 (qtrx->qt_blk_res_used - 437 qtrx->qt_blk_res); 438 } 439 } else { 440 /* 441 * These blks were never reserved, either inside 442 * a transaction or outside one (in a delayed 443 * allocation). Also, this isn't always a 444 * negative number since we sometimes 445 * deliberately skip quota reservations. 446 */ 447 if (qtrx->qt_bcount_delta) { 448 dqp->q_res_bcount += 449 (xfs_qcnt_t)qtrx->qt_bcount_delta; 450 } 451 } 452 /* 453 * Adjust the RT reservation. 454 */ 455 if (qtrx->qt_rtblk_res != 0) { 456 if (qtrx->qt_rtblk_res != qtrx->qt_rtblk_res_used) { 457 if (qtrx->qt_rtblk_res > 458 qtrx->qt_rtblk_res_used) 459 dqp->q_res_rtbcount -= (xfs_qcnt_t) 460 (qtrx->qt_rtblk_res - 461 qtrx->qt_rtblk_res_used); 462 else 463 dqp->q_res_rtbcount -= (xfs_qcnt_t) 464 (qtrx->qt_rtblk_res_used - 465 qtrx->qt_rtblk_res); 466 } 467 } else { 468 if (qtrx->qt_rtbcount_delta) 469 dqp->q_res_rtbcount += 470 (xfs_qcnt_t)qtrx->qt_rtbcount_delta; 471 } 472 473 /* 474 * Adjust the inode reservation. 475 */ 476 if (qtrx->qt_ino_res != 0) { 477 ASSERT(qtrx->qt_ino_res >= 478 qtrx->qt_ino_res_used); 479 if (qtrx->qt_ino_res > qtrx->qt_ino_res_used) 480 dqp->q_res_icount -= (xfs_qcnt_t) 481 (qtrx->qt_ino_res - 482 qtrx->qt_ino_res_used); 483 } else { 484 if (qtrx->qt_icount_delta) 485 dqp->q_res_icount += 486 (xfs_qcnt_t)qtrx->qt_icount_delta; 487 } 488 489 ASSERT(dqp->q_res_bcount >= 490 be64_to_cpu(dqp->q_core.d_bcount)); 491 ASSERT(dqp->q_res_icount >= 492 be64_to_cpu(dqp->q_core.d_icount)); 493 ASSERT(dqp->q_res_rtbcount >= 494 be64_to_cpu(dqp->q_core.d_rtbcount)); 495 } 496 } 497 } 498 499 /* 500 * Release the reservations, and adjust the dquots accordingly. 501 * This is called only when the transaction is being aborted. If by 502 * any chance we have done dquot modifications incore (ie. deltas) already, 503 * we simply throw those away, since that's the expected behavior 504 * when a transaction is curtailed without a commit. 505 */ 506 void 507 xfs_trans_unreserve_and_mod_dquots( 508 xfs_trans_t *tp) 509 { 510 int i, j; 511 xfs_dquot_t *dqp; 512 xfs_dqtrx_t *qtrx, *qa; 513 bool locked; 514 515 if (!tp->t_dqinfo || !(tp->t_flags & XFS_TRANS_DQ_DIRTY)) 516 return; 517 518 for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) { 519 qa = tp->t_dqinfo->dqs[j]; 520 521 for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) { 522 qtrx = &qa[i]; 523 /* 524 * We assume that the array of dquots is filled 525 * sequentially, not sparsely. 526 */ 527 if ((dqp = qtrx->qt_dquot) == NULL) 528 break; 529 /* 530 * Unreserve the original reservation. We don't care 531 * about the number of blocks used field, or deltas. 532 * Also we don't bother to zero the fields. 533 */ 534 locked = false; 535 if (qtrx->qt_blk_res) { 536 xfs_dqlock(dqp); 537 locked = true; 538 dqp->q_res_bcount -= 539 (xfs_qcnt_t)qtrx->qt_blk_res; 540 } 541 if (qtrx->qt_ino_res) { 542 if (!locked) { 543 xfs_dqlock(dqp); 544 locked = true; 545 } 546 dqp->q_res_icount -= 547 (xfs_qcnt_t)qtrx->qt_ino_res; 548 } 549 550 if (qtrx->qt_rtblk_res) { 551 if (!locked) { 552 xfs_dqlock(dqp); 553 locked = true; 554 } 555 dqp->q_res_rtbcount -= 556 (xfs_qcnt_t)qtrx->qt_rtblk_res; 557 } 558 if (locked) 559 xfs_dqunlock(dqp); 560 561 } 562 } 563 } 564 565 STATIC void 566 xfs_quota_warn( 567 struct xfs_mount *mp, 568 struct xfs_dquot *dqp, 569 int type) 570 { 571 /* no warnings for project quotas - we just return ENOSPC later */ 572 if (dqp->dq_flags & XFS_DQ_PROJ) 573 return; 574 quota_send_warning(make_kqid(&init_user_ns, 575 (dqp->dq_flags & XFS_DQ_USER) ? 576 USRQUOTA : GRPQUOTA, 577 be32_to_cpu(dqp->q_core.d_id)), 578 mp->m_super->s_dev, type); 579 } 580 581 /* 582 * This reserves disk blocks and inodes against a dquot. 583 * Flags indicate if the dquot is to be locked here and also 584 * if the blk reservation is for RT or regular blocks. 585 * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check. 586 */ 587 STATIC int 588 xfs_trans_dqresv( 589 xfs_trans_t *tp, 590 xfs_mount_t *mp, 591 xfs_dquot_t *dqp, 592 long nblks, 593 long ninos, 594 uint flags) 595 { 596 xfs_qcnt_t hardlimit; 597 xfs_qcnt_t softlimit; 598 time_t timer; 599 xfs_qwarncnt_t warns; 600 xfs_qwarncnt_t warnlimit; 601 xfs_qcnt_t total_count; 602 xfs_qcnt_t *resbcountp; 603 xfs_quotainfo_t *q = mp->m_quotainfo; 604 605 606 xfs_dqlock(dqp); 607 608 if (flags & XFS_TRANS_DQ_RES_BLKS) { 609 hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit); 610 if (!hardlimit) 611 hardlimit = q->qi_bhardlimit; 612 softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit); 613 if (!softlimit) 614 softlimit = q->qi_bsoftlimit; 615 timer = be32_to_cpu(dqp->q_core.d_btimer); 616 warns = be16_to_cpu(dqp->q_core.d_bwarns); 617 warnlimit = dqp->q_mount->m_quotainfo->qi_bwarnlimit; 618 resbcountp = &dqp->q_res_bcount; 619 } else { 620 ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS); 621 hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit); 622 if (!hardlimit) 623 hardlimit = q->qi_rtbhardlimit; 624 softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit); 625 if (!softlimit) 626 softlimit = q->qi_rtbsoftlimit; 627 timer = be32_to_cpu(dqp->q_core.d_rtbtimer); 628 warns = be16_to_cpu(dqp->q_core.d_rtbwarns); 629 warnlimit = dqp->q_mount->m_quotainfo->qi_rtbwarnlimit; 630 resbcountp = &dqp->q_res_rtbcount; 631 } 632 633 if ((flags & XFS_QMOPT_FORCE_RES) == 0 && 634 dqp->q_core.d_id && 635 ((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) || 636 (XFS_IS_GQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISGDQ(dqp)) || 637 (XFS_IS_PQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISPDQ(dqp)))) { 638 if (nblks > 0) { 639 /* 640 * dquot is locked already. See if we'd go over the 641 * hardlimit or exceed the timelimit if we allocate 642 * nblks. 643 */ 644 total_count = *resbcountp + nblks; 645 if (hardlimit && total_count > hardlimit) { 646 xfs_quota_warn(mp, dqp, QUOTA_NL_BHARDWARN); 647 goto error_return; 648 } 649 if (softlimit && total_count > softlimit) { 650 if ((timer != 0 && get_seconds() > timer) || 651 (warns != 0 && warns >= warnlimit)) { 652 xfs_quota_warn(mp, dqp, 653 QUOTA_NL_BSOFTLONGWARN); 654 goto error_return; 655 } 656 657 xfs_quota_warn(mp, dqp, QUOTA_NL_BSOFTWARN); 658 } 659 } 660 if (ninos > 0) { 661 total_count = be64_to_cpu(dqp->q_core.d_icount) + ninos; 662 timer = be32_to_cpu(dqp->q_core.d_itimer); 663 warns = be16_to_cpu(dqp->q_core.d_iwarns); 664 warnlimit = dqp->q_mount->m_quotainfo->qi_iwarnlimit; 665 hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit); 666 if (!hardlimit) 667 hardlimit = q->qi_ihardlimit; 668 softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit); 669 if (!softlimit) 670 softlimit = q->qi_isoftlimit; 671 672 if (hardlimit && total_count > hardlimit) { 673 xfs_quota_warn(mp, dqp, QUOTA_NL_IHARDWARN); 674 goto error_return; 675 } 676 if (softlimit && total_count > softlimit) { 677 if ((timer != 0 && get_seconds() > timer) || 678 (warns != 0 && warns >= warnlimit)) { 679 xfs_quota_warn(mp, dqp, 680 QUOTA_NL_ISOFTLONGWARN); 681 goto error_return; 682 } 683 xfs_quota_warn(mp, dqp, QUOTA_NL_ISOFTWARN); 684 } 685 } 686 } 687 688 /* 689 * Change the reservation, but not the actual usage. 690 * Note that q_res_bcount = q_core.d_bcount + resv 691 */ 692 (*resbcountp) += (xfs_qcnt_t)nblks; 693 if (ninos != 0) 694 dqp->q_res_icount += (xfs_qcnt_t)ninos; 695 696 /* 697 * note the reservation amt in the trans struct too, 698 * so that the transaction knows how much was reserved by 699 * it against this particular dquot. 700 * We don't do this when we are reserving for a delayed allocation, 701 * because we don't have the luxury of a transaction envelope then. 702 */ 703 if (tp) { 704 ASSERT(tp->t_dqinfo); 705 ASSERT(flags & XFS_QMOPT_RESBLK_MASK); 706 if (nblks != 0) 707 xfs_trans_mod_dquot(tp, dqp, 708 flags & XFS_QMOPT_RESBLK_MASK, 709 nblks); 710 if (ninos != 0) 711 xfs_trans_mod_dquot(tp, dqp, 712 XFS_TRANS_DQ_RES_INOS, 713 ninos); 714 } 715 ASSERT(dqp->q_res_bcount >= be64_to_cpu(dqp->q_core.d_bcount)); 716 ASSERT(dqp->q_res_rtbcount >= be64_to_cpu(dqp->q_core.d_rtbcount)); 717 ASSERT(dqp->q_res_icount >= be64_to_cpu(dqp->q_core.d_icount)); 718 719 xfs_dqunlock(dqp); 720 return 0; 721 722 error_return: 723 xfs_dqunlock(dqp); 724 if (flags & XFS_QMOPT_ENOSPC) 725 return ENOSPC; 726 return EDQUOT; 727 } 728 729 730 /* 731 * Given dquot(s), make disk block and/or inode reservations against them. 732 * The fact that this does the reservation against user, group and 733 * project quotas is important, because this follows a all-or-nothing 734 * approach. 735 * 736 * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown. 737 * XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT. Used by pquota. 738 * XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks 739 * XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks 740 * dquots are unlocked on return, if they were not locked by caller. 741 */ 742 int 743 xfs_trans_reserve_quota_bydquots( 744 struct xfs_trans *tp, 745 struct xfs_mount *mp, 746 struct xfs_dquot *udqp, 747 struct xfs_dquot *gdqp, 748 struct xfs_dquot *pdqp, 749 long nblks, 750 long ninos, 751 uint flags) 752 { 753 int error; 754 755 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp)) 756 return 0; 757 758 if (tp && tp->t_dqinfo == NULL) 759 xfs_trans_alloc_dqinfo(tp); 760 761 ASSERT(flags & XFS_QMOPT_RESBLK_MASK); 762 763 if (udqp) { 764 error = xfs_trans_dqresv(tp, mp, udqp, nblks, ninos, 765 (flags & ~XFS_QMOPT_ENOSPC)); 766 if (error) 767 return error; 768 } 769 770 if (gdqp) { 771 error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags); 772 if (error) 773 goto unwind_usr; 774 } 775 776 if (pdqp) { 777 error = xfs_trans_dqresv(tp, mp, pdqp, nblks, ninos, flags); 778 if (error) 779 goto unwind_grp; 780 } 781 782 /* 783 * Didn't change anything critical, so, no need to log 784 */ 785 return 0; 786 787 unwind_grp: 788 flags |= XFS_QMOPT_FORCE_RES; 789 if (gdqp) 790 xfs_trans_dqresv(tp, mp, gdqp, -nblks, -ninos, flags); 791 unwind_usr: 792 flags |= XFS_QMOPT_FORCE_RES; 793 if (udqp) 794 xfs_trans_dqresv(tp, mp, udqp, -nblks, -ninos, flags); 795 return error; 796 } 797 798 799 /* 800 * Lock the dquot and change the reservation if we can. 801 * This doesn't change the actual usage, just the reservation. 802 * The inode sent in is locked. 803 */ 804 int 805 xfs_trans_reserve_quota_nblks( 806 struct xfs_trans *tp, 807 struct xfs_inode *ip, 808 long nblks, 809 long ninos, 810 uint flags) 811 { 812 struct xfs_mount *mp = ip->i_mount; 813 814 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp)) 815 return 0; 816 if (XFS_IS_PQUOTA_ON(mp)) 817 flags |= XFS_QMOPT_ENOSPC; 818 819 ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino)); 820 821 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 822 ASSERT((flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) == 823 XFS_TRANS_DQ_RES_RTBLKS || 824 (flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) == 825 XFS_TRANS_DQ_RES_BLKS); 826 827 /* 828 * Reserve nblks against these dquots, with trans as the mediator. 829 */ 830 return xfs_trans_reserve_quota_bydquots(tp, mp, 831 ip->i_udquot, ip->i_gdquot, 832 ip->i_pdquot, 833 nblks, ninos, flags); 834 } 835 836 /* 837 * This routine is called to allocate a quotaoff log item. 838 */ 839 xfs_qoff_logitem_t * 840 xfs_trans_get_qoff_item( 841 xfs_trans_t *tp, 842 xfs_qoff_logitem_t *startqoff, 843 uint flags) 844 { 845 xfs_qoff_logitem_t *q; 846 847 ASSERT(tp != NULL); 848 849 q = xfs_qm_qoff_logitem_init(tp->t_mountp, startqoff, flags); 850 ASSERT(q != NULL); 851 852 /* 853 * Get a log_item_desc to point at the new item. 854 */ 855 xfs_trans_add_item(tp, &q->qql_item); 856 return q; 857 } 858 859 860 /* 861 * This is called to mark the quotaoff logitem as needing 862 * to be logged when the transaction is committed. The logitem must 863 * already be associated with the given transaction. 864 */ 865 void 866 xfs_trans_log_quotaoff_item( 867 xfs_trans_t *tp, 868 xfs_qoff_logitem_t *qlp) 869 { 870 tp->t_flags |= XFS_TRANS_DIRTY; 871 qlp->qql_item.li_desc->lid_flags |= XFS_LID_DIRTY; 872 } 873 874 STATIC void 875 xfs_trans_alloc_dqinfo( 876 xfs_trans_t *tp) 877 { 878 tp->t_dqinfo = kmem_zone_zalloc(xfs_qm_dqtrxzone, KM_SLEEP); 879 } 880 881 void 882 xfs_trans_free_dqinfo( 883 xfs_trans_t *tp) 884 { 885 if (!tp->t_dqinfo) 886 return; 887 kmem_zone_free(xfs_qm_dqtrxzone, tp->t_dqinfo); 888 tp->t_dqinfo = NULL; 889 } 890