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