1/* 2 * Copyright (c) 2000-2003 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_bmap.h" 32#include "xfs_rtalloc.h" 33#include "xfs_error.h" 34#include "xfs_itable.h" 35#include "xfs_attr.h" 36#include "xfs_buf_item.h" 37#include "xfs_trans_space.h" 38#include "xfs_trans_priv.h" 39#include "xfs_qm.h" 40#include "xfs_trace.h" 41 42 43/* 44 LOCK ORDER 45 46 inode lock (ilock) 47 dquot hash-chain lock (hashlock) 48 xqm dquot freelist lock (freelistlock 49 mount's dquot list lock (mplistlock) 50 user dquot lock - lock ordering among dquots is based on the uid or gid 51 group dquot lock - similar to udquots. Between the two dquots, the udquot 52 has to be locked first. 53 pin lock - the dquot lock must be held to take this lock. 54 flush lock - ditto. 55*/ 56 57#ifdef DEBUG 58xfs_buftarg_t *xfs_dqerror_target; 59int xfs_do_dqerror; 60int xfs_dqreq_num; 61int xfs_dqerror_mod = 33; 62#endif 63 64static struct lock_class_key xfs_dquot_other_class; 65 66/* 67 * Allocate and initialize a dquot. We don't always allocate fresh memory; 68 * we try to reclaim a free dquot if the number of incore dquots are above 69 * a threshold. 70 * The only field inside the core that gets initialized at this point 71 * is the d_id field. The idea is to fill in the entire q_core 72 * when we read in the on disk dquot. 73 */ 74STATIC xfs_dquot_t * 75xfs_qm_dqinit( 76 xfs_mount_t *mp, 77 xfs_dqid_t id, 78 uint type) 79{ 80 xfs_dquot_t *dqp; 81 boolean_t brandnewdquot; 82 83 brandnewdquot = xfs_qm_dqalloc_incore(&dqp); 84 dqp->dq_flags = type; 85 dqp->q_core.d_id = cpu_to_be32(id); 86 dqp->q_mount = mp; 87 88 /* 89 * No need to re-initialize these if this is a reclaimed dquot. 90 */ 91 if (brandnewdquot) { 92 INIT_LIST_HEAD(&dqp->q_freelist); 93 mutex_init(&dqp->q_qlock); 94 init_waitqueue_head(&dqp->q_pinwait); 95 96 /* 97 * Because we want to use a counting completion, complete 98 * the flush completion once to allow a single access to 99 * the flush completion without blocking. 100 */ 101 init_completion(&dqp->q_flush); 102 complete(&dqp->q_flush); 103 104 trace_xfs_dqinit(dqp); 105 } else { 106 /* 107 * Only the q_core portion was zeroed in dqreclaim_one(). 108 * So, we need to reset others. 109 */ 110 dqp->q_nrefs = 0; 111 dqp->q_blkno = 0; 112 INIT_LIST_HEAD(&dqp->q_mplist); 113 INIT_LIST_HEAD(&dqp->q_hashlist); 114 dqp->q_bufoffset = 0; 115 dqp->q_fileoffset = 0; 116 dqp->q_transp = NULL; 117 dqp->q_gdquot = NULL; 118 dqp->q_res_bcount = 0; 119 dqp->q_res_icount = 0; 120 dqp->q_res_rtbcount = 0; 121 atomic_set(&dqp->q_pincount, 0); 122 dqp->q_hash = NULL; 123 ASSERT(list_empty(&dqp->q_freelist)); 124 125 trace_xfs_dqreuse(dqp); 126 } 127 128 /* 129 * In either case we need to make sure group quotas have a different 130 * lock class than user quotas, to make sure lockdep knows we can 131 * locks of one of each at the same time. 132 */ 133 if (!(type & XFS_DQ_USER)) 134 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_other_class); 135 136 /* 137 * log item gets initialized later 138 */ 139 return (dqp); 140} 141 142/* 143 * This is called to free all the memory associated with a dquot 144 */ 145void 146xfs_qm_dqdestroy( 147 xfs_dquot_t *dqp) 148{ 149 ASSERT(list_empty(&dqp->q_freelist)); 150 151 mutex_destroy(&dqp->q_qlock); 152 sv_destroy(&dqp->q_pinwait); 153 kmem_zone_free(xfs_Gqm->qm_dqzone, dqp); 154 155 atomic_dec(&xfs_Gqm->qm_totaldquots); 156} 157 158/* 159 * This is what a 'fresh' dquot inside a dquot chunk looks like on disk. 160 */ 161STATIC void 162xfs_qm_dqinit_core( 163 xfs_dqid_t id, 164 uint type, 165 xfs_dqblk_t *d) 166{ 167 /* 168 * Caller has zero'd the entire dquot 'chunk' already. 169 */ 170 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC); 171 d->dd_diskdq.d_version = XFS_DQUOT_VERSION; 172 d->dd_diskdq.d_id = cpu_to_be32(id); 173 d->dd_diskdq.d_flags = type; 174} 175 176/* 177 * If default limits are in force, push them into the dquot now. 178 * We overwrite the dquot limits only if they are zero and this 179 * is not the root dquot. 180 */ 181void 182xfs_qm_adjust_dqlimits( 183 xfs_mount_t *mp, 184 xfs_disk_dquot_t *d) 185{ 186 xfs_quotainfo_t *q = mp->m_quotainfo; 187 188 ASSERT(d->d_id); 189 190 if (q->qi_bsoftlimit && !d->d_blk_softlimit) 191 d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit); 192 if (q->qi_bhardlimit && !d->d_blk_hardlimit) 193 d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit); 194 if (q->qi_isoftlimit && !d->d_ino_softlimit) 195 d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit); 196 if (q->qi_ihardlimit && !d->d_ino_hardlimit) 197 d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit); 198 if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit) 199 d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit); 200 if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit) 201 d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit); 202} 203 204/* 205 * Check the limits and timers of a dquot and start or reset timers 206 * if necessary. 207 * This gets called even when quota enforcement is OFF, which makes our 208 * life a little less complicated. (We just don't reject any quota 209 * reservations in that case, when enforcement is off). 210 * We also return 0 as the values of the timers in Q_GETQUOTA calls, when 211 * enforcement's off. 212 * In contrast, warnings are a little different in that they don't 213 * 'automatically' get started when limits get exceeded. They do 214 * get reset to zero, however, when we find the count to be under 215 * the soft limit (they are only ever set non-zero via userspace). 216 */ 217void 218xfs_qm_adjust_dqtimers( 219 xfs_mount_t *mp, 220 xfs_disk_dquot_t *d) 221{ 222 ASSERT(d->d_id); 223 224#ifdef QUOTADEBUG 225 if (d->d_blk_hardlimit) 226 ASSERT(be64_to_cpu(d->d_blk_softlimit) <= 227 be64_to_cpu(d->d_blk_hardlimit)); 228 if (d->d_ino_hardlimit) 229 ASSERT(be64_to_cpu(d->d_ino_softlimit) <= 230 be64_to_cpu(d->d_ino_hardlimit)); 231 if (d->d_rtb_hardlimit) 232 ASSERT(be64_to_cpu(d->d_rtb_softlimit) <= 233 be64_to_cpu(d->d_rtb_hardlimit)); 234#endif 235 if (!d->d_btimer) { 236 if ((d->d_blk_softlimit && 237 (be64_to_cpu(d->d_bcount) >= 238 be64_to_cpu(d->d_blk_softlimit))) || 239 (d->d_blk_hardlimit && 240 (be64_to_cpu(d->d_bcount) >= 241 be64_to_cpu(d->d_blk_hardlimit)))) { 242 d->d_btimer = cpu_to_be32(get_seconds() + 243 mp->m_quotainfo->qi_btimelimit); 244 } else { 245 d->d_bwarns = 0; 246 } 247 } else { 248 if ((!d->d_blk_softlimit || 249 (be64_to_cpu(d->d_bcount) < 250 be64_to_cpu(d->d_blk_softlimit))) && 251 (!d->d_blk_hardlimit || 252 (be64_to_cpu(d->d_bcount) < 253 be64_to_cpu(d->d_blk_hardlimit)))) { 254 d->d_btimer = 0; 255 } 256 } 257 258 if (!d->d_itimer) { 259 if ((d->d_ino_softlimit && 260 (be64_to_cpu(d->d_icount) >= 261 be64_to_cpu(d->d_ino_softlimit))) || 262 (d->d_ino_hardlimit && 263 (be64_to_cpu(d->d_icount) >= 264 be64_to_cpu(d->d_ino_hardlimit)))) { 265 d->d_itimer = cpu_to_be32(get_seconds() + 266 mp->m_quotainfo->qi_itimelimit); 267 } else { 268 d->d_iwarns = 0; 269 } 270 } else { 271 if ((!d->d_ino_softlimit || 272 (be64_to_cpu(d->d_icount) < 273 be64_to_cpu(d->d_ino_softlimit))) && 274 (!d->d_ino_hardlimit || 275 (be64_to_cpu(d->d_icount) < 276 be64_to_cpu(d->d_ino_hardlimit)))) { 277 d->d_itimer = 0; 278 } 279 } 280 281 if (!d->d_rtbtimer) { 282 if ((d->d_rtb_softlimit && 283 (be64_to_cpu(d->d_rtbcount) >= 284 be64_to_cpu(d->d_rtb_softlimit))) || 285 (d->d_rtb_hardlimit && 286 (be64_to_cpu(d->d_rtbcount) >= 287 be64_to_cpu(d->d_rtb_hardlimit)))) { 288 d->d_rtbtimer = cpu_to_be32(get_seconds() + 289 mp->m_quotainfo->qi_rtbtimelimit); 290 } else { 291 d->d_rtbwarns = 0; 292 } 293 } else { 294 if ((!d->d_rtb_softlimit || 295 (be64_to_cpu(d->d_rtbcount) < 296 be64_to_cpu(d->d_rtb_softlimit))) && 297 (!d->d_rtb_hardlimit || 298 (be64_to_cpu(d->d_rtbcount) < 299 be64_to_cpu(d->d_rtb_hardlimit)))) { 300 d->d_rtbtimer = 0; 301 } 302 } 303} 304 305/* 306 * initialize a buffer full of dquots and log the whole thing 307 */ 308STATIC void 309xfs_qm_init_dquot_blk( 310 xfs_trans_t *tp, 311 xfs_mount_t *mp, 312 xfs_dqid_t id, 313 uint type, 314 xfs_buf_t *bp) 315{ 316 struct xfs_quotainfo *q = mp->m_quotainfo; 317 xfs_dqblk_t *d; 318 int curid, i; 319 320 ASSERT(tp); 321 ASSERT(XFS_BUF_ISBUSY(bp)); 322 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); 323 324 d = (xfs_dqblk_t *)XFS_BUF_PTR(bp); 325 326 /* 327 * ID of the first dquot in the block - id's are zero based. 328 */ 329 curid = id - (id % q->qi_dqperchunk); 330 ASSERT(curid >= 0); 331 memset(d, 0, BBTOB(q->qi_dqchunklen)); 332 for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) 333 xfs_qm_dqinit_core(curid, type, d); 334 xfs_trans_dquot_buf(tp, bp, 335 (type & XFS_DQ_USER ? XFS_BLF_UDQUOT_BUF : 336 ((type & XFS_DQ_PROJ) ? XFS_BLF_PDQUOT_BUF : 337 XFS_BLF_GDQUOT_BUF))); 338 xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1); 339} 340 341 342 343/* 344 * Allocate a block and fill it with dquots. 345 * This is called when the bmapi finds a hole. 346 */ 347STATIC int 348xfs_qm_dqalloc( 349 xfs_trans_t **tpp, 350 xfs_mount_t *mp, 351 xfs_dquot_t *dqp, 352 xfs_inode_t *quotip, 353 xfs_fileoff_t offset_fsb, 354 xfs_buf_t **O_bpp) 355{ 356 xfs_fsblock_t firstblock; 357 xfs_bmap_free_t flist; 358 xfs_bmbt_irec_t map; 359 int nmaps, error, committed; 360 xfs_buf_t *bp; 361 xfs_trans_t *tp = *tpp; 362 363 ASSERT(tp != NULL); 364 365 trace_xfs_dqalloc(dqp); 366 367 /* 368 * Initialize the bmap freelist prior to calling bmapi code. 369 */ 370 xfs_bmap_init(&flist, &firstblock); 371 xfs_ilock(quotip, XFS_ILOCK_EXCL); 372 /* 373 * Return if this type of quotas is turned off while we didn't 374 * have an inode lock 375 */ 376 if (XFS_IS_THIS_QUOTA_OFF(dqp)) { 377 xfs_iunlock(quotip, XFS_ILOCK_EXCL); 378 return (ESRCH); 379 } 380 381 xfs_trans_ijoin_ref(tp, quotip, XFS_ILOCK_EXCL); 382 nmaps = 1; 383 if ((error = xfs_bmapi(tp, quotip, 384 offset_fsb, XFS_DQUOT_CLUSTER_SIZE_FSB, 385 XFS_BMAPI_METADATA | XFS_BMAPI_WRITE, 386 &firstblock, 387 XFS_QM_DQALLOC_SPACE_RES(mp), 388 &map, &nmaps, &flist))) { 389 goto error0; 390 } 391 ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB); 392 ASSERT(nmaps == 1); 393 ASSERT((map.br_startblock != DELAYSTARTBLOCK) && 394 (map.br_startblock != HOLESTARTBLOCK)); 395 396 /* 397 * Keep track of the blkno to save a lookup later 398 */ 399 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock); 400 401 /* now we can just get the buffer (there's nothing to read yet) */ 402 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, 403 dqp->q_blkno, 404 mp->m_quotainfo->qi_dqchunklen, 405 0); 406 if (!bp || (error = XFS_BUF_GETERROR(bp))) 407 goto error1; 408 /* 409 * Make a chunk of dquots out of this buffer and log 410 * the entire thing. 411 */ 412 xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id), 413 dqp->dq_flags & XFS_DQ_ALLTYPES, bp); 414 415 /* 416 * xfs_bmap_finish() may commit the current transaction and 417 * start a second transaction if the freelist is not empty. 418 * 419 * Since we still want to modify this buffer, we need to 420 * ensure that the buffer is not released on commit of 421 * the first transaction and ensure the buffer is added to the 422 * second transaction. 423 * 424 * If there is only one transaction then don't stop the buffer 425 * from being released when it commits later on. 426 */ 427 428 xfs_trans_bhold(tp, bp); 429 430 if ((error = xfs_bmap_finish(tpp, &flist, &committed))) { 431 goto error1; 432 } 433 434 if (committed) { 435 tp = *tpp; 436 xfs_trans_bjoin(tp, bp); 437 } else { 438 xfs_trans_bhold_release(tp, bp); 439 } 440 441 *O_bpp = bp; 442 return 0; 443 444 error1: 445 xfs_bmap_cancel(&flist); 446 error0: 447 xfs_iunlock(quotip, XFS_ILOCK_EXCL); 448 449 return (error); 450} 451 452/* 453 * Maps a dquot to the buffer containing its on-disk version. 454 * This returns a ptr to the buffer containing the on-disk dquot 455 * in the bpp param, and a ptr to the on-disk dquot within that buffer 456 */ 457STATIC int 458xfs_qm_dqtobp( 459 xfs_trans_t **tpp, 460 xfs_dquot_t *dqp, 461 xfs_disk_dquot_t **O_ddpp, 462 xfs_buf_t **O_bpp, 463 uint flags) 464{ 465 xfs_bmbt_irec_t map; 466 int nmaps, error; 467 xfs_buf_t *bp; 468 xfs_inode_t *quotip; 469 xfs_mount_t *mp; 470 xfs_disk_dquot_t *ddq; 471 xfs_dqid_t id; 472 boolean_t newdquot; 473 xfs_trans_t *tp = (tpp ? *tpp : NULL); 474 475 mp = dqp->q_mount; 476 id = be32_to_cpu(dqp->q_core.d_id); 477 nmaps = 1; 478 newdquot = B_FALSE; 479 480 /* 481 * If we don't know where the dquot lives, find out. 482 */ 483 if (dqp->q_blkno == (xfs_daddr_t) 0) { 484 /* We use the id as an index */ 485 dqp->q_fileoffset = (xfs_fileoff_t)id / 486 mp->m_quotainfo->qi_dqperchunk; 487 nmaps = 1; 488 quotip = XFS_DQ_TO_QIP(dqp); 489 xfs_ilock(quotip, XFS_ILOCK_SHARED); 490 /* 491 * Return if this type of quotas is turned off while we didn't 492 * have an inode lock 493 */ 494 if (XFS_IS_THIS_QUOTA_OFF(dqp)) { 495 xfs_iunlock(quotip, XFS_ILOCK_SHARED); 496 return (ESRCH); 497 } 498 /* 499 * Find the block map; no allocations yet 500 */ 501 error = xfs_bmapi(NULL, quotip, dqp->q_fileoffset, 502 XFS_DQUOT_CLUSTER_SIZE_FSB, 503 XFS_BMAPI_METADATA, 504 NULL, 0, &map, &nmaps, NULL); 505 506 xfs_iunlock(quotip, XFS_ILOCK_SHARED); 507 if (error) 508 return (error); 509 ASSERT(nmaps == 1); 510 ASSERT(map.br_blockcount == 1); 511 512 /* 513 * offset of dquot in the (fixed sized) dquot chunk. 514 */ 515 dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) * 516 sizeof(xfs_dqblk_t); 517 if (map.br_startblock == HOLESTARTBLOCK) { 518 /* 519 * We don't allocate unless we're asked to 520 */ 521 if (!(flags & XFS_QMOPT_DQALLOC)) 522 return (ENOENT); 523 524 ASSERT(tp); 525 if ((error = xfs_qm_dqalloc(tpp, mp, dqp, quotip, 526 dqp->q_fileoffset, &bp))) 527 return (error); 528 tp = *tpp; 529 newdquot = B_TRUE; 530 } else { 531 /* 532 * store the blkno etc so that we don't have to do the 533 * mapping all the time 534 */ 535 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock); 536 } 537 } 538 ASSERT(dqp->q_blkno != DELAYSTARTBLOCK); 539 ASSERT(dqp->q_blkno != HOLESTARTBLOCK); 540 541 /* 542 * Read in the buffer, unless we've just done the allocation 543 * (in which case we already have the buf). 544 */ 545 if (!newdquot) { 546 trace_xfs_dqtobp_read(dqp); 547 548 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, 549 dqp->q_blkno, 550 mp->m_quotainfo->qi_dqchunklen, 551 0, &bp); 552 if (error || !bp) 553 return XFS_ERROR(error); 554 } 555 ASSERT(XFS_BUF_ISBUSY(bp)); 556 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); 557 558 /* 559 * calculate the location of the dquot inside the buffer. 560 */ 561 ddq = (xfs_disk_dquot_t *)((char *)XFS_BUF_PTR(bp) + dqp->q_bufoffset); 562 563 /* 564 * A simple sanity check in case we got a corrupted dquot... 565 */ 566 if (xfs_qm_dqcheck(ddq, id, dqp->dq_flags & XFS_DQ_ALLTYPES, 567 flags & (XFS_QMOPT_DQREPAIR|XFS_QMOPT_DOWARN), 568 "dqtobp")) { 569 if (!(flags & XFS_QMOPT_DQREPAIR)) { 570 xfs_trans_brelse(tp, bp); 571 return XFS_ERROR(EIO); 572 } 573 XFS_BUF_BUSY(bp); /* We dirtied this */ 574 } 575 576 *O_bpp = bp; 577 *O_ddpp = ddq; 578 579 return (0); 580} 581 582 583/* 584 * Read in the ondisk dquot using dqtobp() then copy it to an incore version, 585 * and release the buffer immediately. 586 * 587 */ 588/* ARGSUSED */ 589STATIC int 590xfs_qm_dqread( 591 xfs_trans_t **tpp, 592 xfs_dqid_t id, 593 xfs_dquot_t *dqp, /* dquot to get filled in */ 594 uint flags) 595{ 596 xfs_disk_dquot_t *ddqp; 597 xfs_buf_t *bp; 598 int error; 599 xfs_trans_t *tp; 600 601 ASSERT(tpp); 602 603 trace_xfs_dqread(dqp); 604 605 /* 606 * get a pointer to the on-disk dquot and the buffer containing it 607 * dqp already knows its own type (GROUP/USER). 608 */ 609 if ((error = xfs_qm_dqtobp(tpp, dqp, &ddqp, &bp, flags))) { 610 return (error); 611 } 612 tp = *tpp; 613 614 /* copy everything from disk dquot to the incore dquot */ 615 memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t)); 616 ASSERT(be32_to_cpu(dqp->q_core.d_id) == id); 617 xfs_qm_dquot_logitem_init(dqp); 618 619 /* 620 * Reservation counters are defined as reservation plus current usage 621 * to avoid having to add everytime. 622 */ 623 dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount); 624 dqp->q_res_icount = be64_to_cpu(ddqp->d_icount); 625 dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount); 626 627 /* Mark the buf so that this will stay incore a little longer */ 628 XFS_BUF_SET_VTYPE_REF(bp, B_FS_DQUOT, XFS_DQUOT_REF); 629 630 /* 631 * We got the buffer with a xfs_trans_read_buf() (in dqtobp()) 632 * So we need to release with xfs_trans_brelse(). 633 * The strategy here is identical to that of inodes; we lock 634 * the dquot in xfs_qm_dqget() before making it accessible to 635 * others. This is because dquots, like inodes, need a good level of 636 * concurrency, and we don't want to take locks on the entire buffers 637 * for dquot accesses. 638 * Note also that the dquot buffer may even be dirty at this point, if 639 * this particular dquot was repaired. We still aren't afraid to 640 * brelse it because we have the changes incore. 641 */ 642 ASSERT(XFS_BUF_ISBUSY(bp)); 643 ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); 644 xfs_trans_brelse(tp, bp); 645 646 return (error); 647} 648 649 650/* 651 * allocate an incore dquot from the kernel heap, 652 * and fill its core with quota information kept on disk. 653 * If XFS_QMOPT_DQALLOC is set, it'll allocate a dquot on disk 654 * if it wasn't already allocated. 655 */ 656STATIC int 657xfs_qm_idtodq( 658 xfs_mount_t *mp, 659 xfs_dqid_t id, /* gid or uid, depending on type */ 660 uint type, /* UDQUOT or GDQUOT */ 661 uint flags, /* DQALLOC, DQREPAIR */ 662 xfs_dquot_t **O_dqpp)/* OUT : incore dquot, not locked */ 663{ 664 xfs_dquot_t *dqp; 665 int error; 666 xfs_trans_t *tp; 667 int cancelflags=0; 668 669 dqp = xfs_qm_dqinit(mp, id, type); 670 tp = NULL; 671 if (flags & XFS_QMOPT_DQALLOC) { 672 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC); 673 error = xfs_trans_reserve(tp, XFS_QM_DQALLOC_SPACE_RES(mp), 674 XFS_WRITE_LOG_RES(mp) + 675 BBTOB(mp->m_quotainfo->qi_dqchunklen) - 1 + 676 128, 677 0, 678 XFS_TRANS_PERM_LOG_RES, 679 XFS_WRITE_LOG_COUNT); 680 if (error) { 681 cancelflags = 0; 682 goto error0; 683 } 684 cancelflags = XFS_TRANS_RELEASE_LOG_RES; 685 } 686 687 /* 688 * Read it from disk; xfs_dqread() takes care of 689 * all the necessary initialization of dquot's fields (locks, etc) 690 */ 691 if ((error = xfs_qm_dqread(&tp, id, dqp, flags))) { 692 /* 693 * This can happen if quotas got turned off (ESRCH), 694 * or if the dquot didn't exist on disk and we ask to 695 * allocate (ENOENT). 696 */ 697 trace_xfs_dqread_fail(dqp); 698 cancelflags |= XFS_TRANS_ABORT; 699 goto error0; 700 } 701 if (tp) { 702 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) 703 goto error1; 704 } 705 706 *O_dqpp = dqp; 707 return (0); 708 709 error0: 710 ASSERT(error); 711 if (tp) 712 xfs_trans_cancel(tp, cancelflags); 713 error1: 714 xfs_qm_dqdestroy(dqp); 715 *O_dqpp = NULL; 716 return (error); 717} 718 719/* 720 * Lookup a dquot in the incore dquot hashtable. We keep two separate 721 * hashtables for user and group dquots; and, these are global tables 722 * inside the XQM, not per-filesystem tables. 723 * The hash chain must be locked by caller, and it is left locked 724 * on return. Returning dquot is locked. 725 */ 726STATIC int 727xfs_qm_dqlookup( 728 xfs_mount_t *mp, 729 xfs_dqid_t id, 730 xfs_dqhash_t *qh, 731 xfs_dquot_t **O_dqpp) 732{ 733 xfs_dquot_t *dqp; 734 uint flist_locked; 735 736 ASSERT(mutex_is_locked(&qh->qh_lock)); 737 738 flist_locked = B_FALSE; 739 740 /* 741 * Traverse the hashchain looking for a match 742 */ 743 list_for_each_entry(dqp, &qh->qh_list, q_hashlist) { 744 /* 745 * We already have the hashlock. We don't need the 746 * dqlock to look at the id field of the dquot, since the 747 * id can't be modified without the hashlock anyway. 748 */ 749 if (be32_to_cpu(dqp->q_core.d_id) == id && dqp->q_mount == mp) { 750 trace_xfs_dqlookup_found(dqp); 751 752 /* 753 * All in core dquots must be on the dqlist of mp 754 */ 755 ASSERT(!list_empty(&dqp->q_mplist)); 756 757 xfs_dqlock(dqp); 758 if (dqp->q_nrefs == 0) { 759 ASSERT(!list_empty(&dqp->q_freelist)); 760 if (!mutex_trylock(&xfs_Gqm->qm_dqfrlist_lock)) { 761 trace_xfs_dqlookup_want(dqp); 762 763 /* 764 * We may have raced with dqreclaim_one() 765 * (and lost). So, flag that we don't 766 * want the dquot to be reclaimed. 767 */ 768 dqp->dq_flags |= XFS_DQ_WANT; 769 xfs_dqunlock(dqp); 770 mutex_lock(&xfs_Gqm->qm_dqfrlist_lock); 771 xfs_dqlock(dqp); 772 dqp->dq_flags &= ~(XFS_DQ_WANT); 773 } 774 flist_locked = B_TRUE; 775 } 776 777 /* 778 * id couldn't have changed; we had the hashlock all 779 * along 780 */ 781 ASSERT(be32_to_cpu(dqp->q_core.d_id) == id); 782 783 if (flist_locked) { 784 if (dqp->q_nrefs != 0) { 785 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock); 786 flist_locked = B_FALSE; 787 } else { 788 /* take it off the freelist */ 789 trace_xfs_dqlookup_freelist(dqp); 790 list_del_init(&dqp->q_freelist); 791 xfs_Gqm->qm_dqfrlist_cnt--; 792 } 793 } 794 795 XFS_DQHOLD(dqp); 796 797 if (flist_locked) 798 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock); 799 /* 800 * move the dquot to the front of the hashchain 801 */ 802 ASSERT(mutex_is_locked(&qh->qh_lock)); 803 list_move(&dqp->q_hashlist, &qh->qh_list); 804 trace_xfs_dqlookup_done(dqp); 805 *O_dqpp = dqp; 806 return 0; 807 } 808 } 809 810 *O_dqpp = NULL; 811 ASSERT(mutex_is_locked(&qh->qh_lock)); 812 return (1); 813} 814 815/* 816 * Given the file system, inode OR id, and type (UDQUOT/GDQUOT), return a 817 * a locked dquot, doing an allocation (if requested) as needed. 818 * When both an inode and an id are given, the inode's id takes precedence. 819 * That is, if the id changes while we don't hold the ilock inside this 820 * function, the new dquot is returned, not necessarily the one requested 821 * in the id argument. 822 */ 823int 824xfs_qm_dqget( 825 xfs_mount_t *mp, 826 xfs_inode_t *ip, /* locked inode (optional) */ 827 xfs_dqid_t id, /* uid/projid/gid depending on type */ 828 uint type, /* XFS_DQ_USER/XFS_DQ_PROJ/XFS_DQ_GROUP */ 829 uint flags, /* DQALLOC, DQSUSER, DQREPAIR, DOWARN */ 830 xfs_dquot_t **O_dqpp) /* OUT : locked incore dquot */ 831{ 832 xfs_dquot_t *dqp; 833 xfs_dqhash_t *h; 834 uint version; 835 int error; 836 837 ASSERT(XFS_IS_QUOTA_RUNNING(mp)); 838 if ((! XFS_IS_UQUOTA_ON(mp) && type == XFS_DQ_USER) || 839 (! XFS_IS_PQUOTA_ON(mp) && type == XFS_DQ_PROJ) || 840 (! XFS_IS_GQUOTA_ON(mp) && type == XFS_DQ_GROUP)) { 841 return (ESRCH); 842 } 843 h = XFS_DQ_HASH(mp, id, type); 844 845#ifdef DEBUG 846 if (xfs_do_dqerror) { 847 if ((xfs_dqerror_target == mp->m_ddev_targp) && 848 (xfs_dqreq_num++ % xfs_dqerror_mod) == 0) { 849 cmn_err(CE_DEBUG, "Returning error in dqget"); 850 return (EIO); 851 } 852 } 853#endif 854 855 again: 856 857#ifdef DEBUG 858 ASSERT(type == XFS_DQ_USER || 859 type == XFS_DQ_PROJ || 860 type == XFS_DQ_GROUP); 861 if (ip) { 862 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 863 if (type == XFS_DQ_USER) 864 ASSERT(ip->i_udquot == NULL); 865 else 866 ASSERT(ip->i_gdquot == NULL); 867 } 868#endif 869 mutex_lock(&h->qh_lock); 870 871 /* 872 * Look in the cache (hashtable). 873 * The chain is kept locked during lookup. 874 */ 875 if (xfs_qm_dqlookup(mp, id, h, O_dqpp) == 0) { 876 XQM_STATS_INC(xqmstats.xs_qm_dqcachehits); 877 /* 878 * The dquot was found, moved to the front of the chain, 879 * taken off the freelist if it was on it, and locked 880 * at this point. Just unlock the hashchain and return. 881 */ 882 ASSERT(*O_dqpp); 883 ASSERT(XFS_DQ_IS_LOCKED(*O_dqpp)); 884 mutex_unlock(&h->qh_lock); 885 trace_xfs_dqget_hit(*O_dqpp); 886 return (0); /* success */ 887 } 888 XQM_STATS_INC(xqmstats.xs_qm_dqcachemisses); 889 890 /* 891 * Dquot cache miss. We don't want to keep the inode lock across 892 * a (potential) disk read. Also we don't want to deal with the lock 893 * ordering between quotainode and this inode. OTOH, dropping the inode 894 * lock here means dealing with a chown that can happen before 895 * we re-acquire the lock. 896 */ 897 if (ip) 898 xfs_iunlock(ip, XFS_ILOCK_EXCL); 899 /* 900 * Save the hashchain version stamp, and unlock the chain, so that 901 * we don't keep the lock across a disk read 902 */ 903 version = h->qh_version; 904 mutex_unlock(&h->qh_lock); 905 906 /* 907 * Allocate the dquot on the kernel heap, and read the ondisk 908 * portion off the disk. Also, do all the necessary initialization 909 * This can return ENOENT if dquot didn't exist on disk and we didn't 910 * ask it to allocate; ESRCH if quotas got turned off suddenly. 911 */ 912 if ((error = xfs_qm_idtodq(mp, id, type, 913 flags & (XFS_QMOPT_DQALLOC|XFS_QMOPT_DQREPAIR| 914 XFS_QMOPT_DOWARN), 915 &dqp))) { 916 if (ip) 917 xfs_ilock(ip, XFS_ILOCK_EXCL); 918 return (error); 919 } 920 921 /* 922 * See if this is mount code calling to look at the overall quota limits 923 * which are stored in the id == 0 user or group's dquot. 924 * Since we may not have done a quotacheck by this point, just return 925 * the dquot without attaching it to any hashtables, lists, etc, or even 926 * taking a reference. 927 * The caller must dqdestroy this once done. 928 */ 929 if (flags & XFS_QMOPT_DQSUSER) { 930 ASSERT(id == 0); 931 ASSERT(! ip); 932 goto dqret; 933 } 934 935 /* 936 * Dquot lock comes after hashlock in the lock ordering 937 */ 938 if (ip) { 939 xfs_ilock(ip, XFS_ILOCK_EXCL); 940 941 /* 942 * A dquot could be attached to this inode by now, since 943 * we had dropped the ilock. 944 */ 945 if (type == XFS_DQ_USER) { 946 if (!XFS_IS_UQUOTA_ON(mp)) { 947 /* inode stays locked on return */ 948 xfs_qm_dqdestroy(dqp); 949 return XFS_ERROR(ESRCH); 950 } 951 if (ip->i_udquot) { 952 xfs_qm_dqdestroy(dqp); 953 dqp = ip->i_udquot; 954 xfs_dqlock(dqp); 955 goto dqret; 956 } 957 } else { 958 if (!XFS_IS_OQUOTA_ON(mp)) { 959 /* inode stays locked on return */ 960 xfs_qm_dqdestroy(dqp); 961 return XFS_ERROR(ESRCH); 962 } 963 if (ip->i_gdquot) { 964 xfs_qm_dqdestroy(dqp); 965 dqp = ip->i_gdquot; 966 xfs_dqlock(dqp); 967 goto dqret; 968 } 969 } 970 } 971 972 /* 973 * Hashlock comes after ilock in lock order 974 */ 975 mutex_lock(&h->qh_lock); 976 if (version != h->qh_version) { 977 xfs_dquot_t *tmpdqp; 978 /* 979 * Now, see if somebody else put the dquot in the 980 * hashtable before us. This can happen because we didn't 981 * keep the hashchain lock. We don't have to worry about 982 * lock order between the two dquots here since dqp isn't 983 * on any findable lists yet. 984 */ 985 if (xfs_qm_dqlookup(mp, id, h, &tmpdqp) == 0) { 986 /* 987 * Duplicate found. Just throw away the new dquot 988 * and start over. 989 */ 990 xfs_qm_dqput(tmpdqp); 991 mutex_unlock(&h->qh_lock); 992 xfs_qm_dqdestroy(dqp); 993 XQM_STATS_INC(xqmstats.xs_qm_dquot_dups); 994 goto again; 995 } 996 } 997 998 /* 999 * Put the dquot at the beginning of the hash-chain and mp's list 1000 * LOCK ORDER: hashlock, freelistlock, mplistlock, udqlock, gdqlock .. 1001 */ 1002 ASSERT(mutex_is_locked(&h->qh_lock)); 1003 dqp->q_hash = h; 1004 list_add(&dqp->q_hashlist, &h->qh_list); 1005 h->qh_version++; 1006 1007 /* 1008 * Attach this dquot to this filesystem's list of all dquots, 1009 * kept inside the mount structure in m_quotainfo field 1010 */ 1011 mutex_lock(&mp->m_quotainfo->qi_dqlist_lock); 1012 1013 /* 1014 * We return a locked dquot to the caller, with a reference taken 1015 */ 1016 xfs_dqlock(dqp); 1017 dqp->q_nrefs = 1; 1018 1019 list_add(&dqp->q_mplist, &mp->m_quotainfo->qi_dqlist); 1020 mp->m_quotainfo->qi_dquots++; 1021 mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock); 1022 mutex_unlock(&h->qh_lock); 1023 dqret: 1024 ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL)); 1025 trace_xfs_dqget_miss(dqp); 1026 *O_dqpp = dqp; 1027 return (0); 1028} 1029 1030 1031/* 1032 * Release a reference to the dquot (decrement ref-count) 1033 * and unlock it. If there is a group quota attached to this 1034 * dquot, carefully release that too without tripping over 1035 * deadlocks'n'stuff. 1036 */ 1037void 1038xfs_qm_dqput( 1039 xfs_dquot_t *dqp) 1040{ 1041 xfs_dquot_t *gdqp; 1042 1043 ASSERT(dqp->q_nrefs > 0); 1044 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 1045 1046 trace_xfs_dqput(dqp); 1047 1048 if (dqp->q_nrefs != 1) { 1049 dqp->q_nrefs--; 1050 xfs_dqunlock(dqp); 1051 return; 1052 } 1053 1054 /* 1055 * drop the dqlock and acquire the freelist and dqlock 1056 * in the right order; but try to get it out-of-order first 1057 */ 1058 if (!mutex_trylock(&xfs_Gqm->qm_dqfrlist_lock)) { 1059 trace_xfs_dqput_wait(dqp); 1060 xfs_dqunlock(dqp); 1061 mutex_lock(&xfs_Gqm->qm_dqfrlist_lock); 1062 xfs_dqlock(dqp); 1063 } 1064 1065 while (1) { 1066 gdqp = NULL; 1067 1068 /* We can't depend on nrefs being == 1 here */ 1069 if (--dqp->q_nrefs == 0) { 1070 trace_xfs_dqput_free(dqp); 1071 1072 list_add_tail(&dqp->q_freelist, &xfs_Gqm->qm_dqfrlist); 1073 xfs_Gqm->qm_dqfrlist_cnt++; 1074 1075 /* 1076 * If we just added a udquot to the freelist, then 1077 * we want to release the gdquot reference that 1078 * it (probably) has. Otherwise it'll keep the 1079 * gdquot from getting reclaimed. 1080 */ 1081 if ((gdqp = dqp->q_gdquot)) { 1082 /* 1083 * Avoid a recursive dqput call 1084 */ 1085 xfs_dqlock(gdqp); 1086 dqp->q_gdquot = NULL; 1087 } 1088 } 1089 xfs_dqunlock(dqp); 1090 1091 /* 1092 * If we had a group quota inside the user quota as a hint, 1093 * release it now. 1094 */ 1095 if (! gdqp) 1096 break; 1097 dqp = gdqp; 1098 } 1099 mutex_unlock(&xfs_Gqm->qm_dqfrlist_lock); 1100} 1101 1102/* 1103 * Release a dquot. Flush it if dirty, then dqput() it. 1104 * dquot must not be locked. 1105 */ 1106void 1107xfs_qm_dqrele( 1108 xfs_dquot_t *dqp) 1109{ 1110 if (!dqp) 1111 return; 1112 1113 trace_xfs_dqrele(dqp); 1114 1115 xfs_dqlock(dqp); 1116 /* 1117 * We don't care to flush it if the dquot is dirty here. 1118 * That will create stutters that we want to avoid. 1119 * Instead we do a delayed write when we try to reclaim 1120 * a dirty dquot. Also xfs_sync will take part of the burden... 1121 */ 1122 xfs_qm_dqput(dqp); 1123} 1124 1125/* 1126 * This is the dquot flushing I/O completion routine. It is called 1127 * from interrupt level when the buffer containing the dquot is 1128 * flushed to disk. It is responsible for removing the dquot logitem 1129 * from the AIL if it has not been re-logged, and unlocking the dquot's 1130 * flush lock. This behavior is very similar to that of inodes.. 1131 */ 1132STATIC void 1133xfs_qm_dqflush_done( 1134 struct xfs_buf *bp, 1135 struct xfs_log_item *lip) 1136{ 1137 xfs_dq_logitem_t *qip = (struct xfs_dq_logitem *)lip; 1138 xfs_dquot_t *dqp = qip->qli_dquot; 1139 struct xfs_ail *ailp = lip->li_ailp; 1140 1141 /* 1142 * We only want to pull the item from the AIL if its 1143 * location in the log has not changed since we started the flush. 1144 * Thus, we only bother if the dquot's lsn has 1145 * not changed. First we check the lsn outside the lock 1146 * since it's cheaper, and then we recheck while 1147 * holding the lock before removing the dquot from the AIL. 1148 */ 1149 if ((lip->li_flags & XFS_LI_IN_AIL) && 1150 lip->li_lsn == qip->qli_flush_lsn) { 1151 1152 /* xfs_trans_ail_delete() drops the AIL lock. */ 1153 spin_lock(&ailp->xa_lock); 1154 if (lip->li_lsn == qip->qli_flush_lsn) 1155 xfs_trans_ail_delete(ailp, lip); 1156 else 1157 spin_unlock(&ailp->xa_lock); 1158 } 1159 1160 /* 1161 * Release the dq's flush lock since we're done with it. 1162 */ 1163 xfs_dqfunlock(dqp); 1164} 1165 1166/* 1167 * Write a modified dquot to disk. 1168 * The dquot must be locked and the flush lock too taken by caller. 1169 * The flush lock will not be unlocked until the dquot reaches the disk, 1170 * but the dquot is free to be unlocked and modified by the caller 1171 * in the interim. Dquot is still locked on return. This behavior is 1172 * identical to that of inodes. 1173 */ 1174int 1175xfs_qm_dqflush( 1176 xfs_dquot_t *dqp, 1177 uint flags) 1178{ 1179 xfs_mount_t *mp; 1180 xfs_buf_t *bp; 1181 xfs_disk_dquot_t *ddqp; 1182 int error; 1183 1184 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 1185 ASSERT(!completion_done(&dqp->q_flush)); 1186 trace_xfs_dqflush(dqp); 1187 1188 /* 1189 * If not dirty, or it's pinned and we are not supposed to 1190 * block, nada. 1191 */ 1192 if (!XFS_DQ_IS_DIRTY(dqp) || 1193 (!(flags & SYNC_WAIT) && atomic_read(&dqp->q_pincount) > 0)) { 1194 xfs_dqfunlock(dqp); 1195 return 0; 1196 } 1197 xfs_qm_dqunpin_wait(dqp); 1198 1199 /* 1200 * This may have been unpinned because the filesystem is shutting 1201 * down forcibly. If that's the case we must not write this dquot 1202 * to disk, because the log record didn't make it to disk! 1203 */ 1204 if (XFS_FORCED_SHUTDOWN(dqp->q_mount)) { 1205 dqp->dq_flags &= ~(XFS_DQ_DIRTY); 1206 xfs_dqfunlock(dqp); 1207 return XFS_ERROR(EIO); 1208 } 1209 1210 /* 1211 * Get the buffer containing the on-disk dquot 1212 * We don't need a transaction envelope because we know that the 1213 * the ondisk-dquot has already been allocated for. 1214 */ 1215 if ((error = xfs_qm_dqtobp(NULL, dqp, &ddqp, &bp, XFS_QMOPT_DOWARN))) { 1216 ASSERT(error != ENOENT); 1217 /* 1218 * Quotas could have gotten turned off (ESRCH) 1219 */ 1220 xfs_dqfunlock(dqp); 1221 return (error); 1222 } 1223 1224 if (xfs_qm_dqcheck(&dqp->q_core, be32_to_cpu(ddqp->d_id), 1225 0, XFS_QMOPT_DOWARN, "dqflush (incore copy)")) { 1226 xfs_force_shutdown(dqp->q_mount, SHUTDOWN_CORRUPT_INCORE); 1227 return XFS_ERROR(EIO); 1228 } 1229 1230 /* This is the only portion of data that needs to persist */ 1231 memcpy(ddqp, &(dqp->q_core), sizeof(xfs_disk_dquot_t)); 1232 1233 /* 1234 * Clear the dirty field and remember the flush lsn for later use. 1235 */ 1236 dqp->dq_flags &= ~(XFS_DQ_DIRTY); 1237 mp = dqp->q_mount; 1238 1239 xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn, 1240 &dqp->q_logitem.qli_item.li_lsn); 1241 1242 /* 1243 * Attach an iodone routine so that we can remove this dquot from the 1244 * AIL and release the flush lock once the dquot is synced to disk. 1245 */ 1246 xfs_buf_attach_iodone(bp, xfs_qm_dqflush_done, 1247 &dqp->q_logitem.qli_item); 1248 1249 /* 1250 * If the buffer is pinned then push on the log so we won't 1251 * get stuck waiting in the write for too long. 1252 */ 1253 if (XFS_BUF_ISPINNED(bp)) { 1254 trace_xfs_dqflush_force(dqp); 1255 xfs_log_force(mp, 0); 1256 } 1257 1258 if (flags & SYNC_WAIT) 1259 error = xfs_bwrite(mp, bp); 1260 else 1261 xfs_bdwrite(mp, bp); 1262 1263 trace_xfs_dqflush_done(dqp); 1264 1265 /* 1266 * dqp is still locked, but caller is free to unlock it now. 1267 */ 1268 return error; 1269 1270} 1271 1272int 1273xfs_qm_dqlock_nowait( 1274 xfs_dquot_t *dqp) 1275{ 1276 return mutex_trylock(&dqp->q_qlock); 1277} 1278 1279void 1280xfs_dqlock( 1281 xfs_dquot_t *dqp) 1282{ 1283 mutex_lock(&dqp->q_qlock); 1284} 1285 1286void 1287xfs_dqunlock( 1288 xfs_dquot_t *dqp) 1289{ 1290 mutex_unlock(&(dqp->q_qlock)); 1291 if (dqp->q_logitem.qli_dquot == dqp) { 1292 /* Once was dqp->q_mount, but might just have been cleared */ 1293 xfs_trans_unlocked_item(dqp->q_logitem.qli_item.li_ailp, 1294 (xfs_log_item_t*)&(dqp->q_logitem)); 1295 } 1296} 1297 1298 1299void 1300xfs_dqunlock_nonotify( 1301 xfs_dquot_t *dqp) 1302{ 1303 mutex_unlock(&(dqp->q_qlock)); 1304} 1305 1306/* 1307 * Lock two xfs_dquot structures. 1308 * 1309 * To avoid deadlocks we always lock the quota structure with 1310 * the lowerd id first. 1311 */ 1312void 1313xfs_dqlock2( 1314 xfs_dquot_t *d1, 1315 xfs_dquot_t *d2) 1316{ 1317 if (d1 && d2) { 1318 ASSERT(d1 != d2); 1319 if (be32_to_cpu(d1->q_core.d_id) > 1320 be32_to_cpu(d2->q_core.d_id)) { 1321 mutex_lock(&d2->q_qlock); 1322 mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED); 1323 } else { 1324 mutex_lock(&d1->q_qlock); 1325 mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED); 1326 } 1327 } else if (d1) { 1328 mutex_lock(&d1->q_qlock); 1329 } else if (d2) { 1330 mutex_lock(&d2->q_qlock); 1331 } 1332} 1333 1334 1335/* 1336 * Take a dquot out of the mount's dqlist as well as the hashlist. 1337 * This is called via unmount as well as quotaoff, and the purge 1338 * will always succeed unless there are soft (temp) references 1339 * outstanding. 1340 * 1341 * This returns 0 if it was purged, 1 if it wasn't. It's not an error code 1342 * that we're returning! XXXsup - not cool. 1343 */ 1344/* ARGSUSED */ 1345int 1346xfs_qm_dqpurge( 1347 xfs_dquot_t *dqp) 1348{ 1349 xfs_dqhash_t *qh = dqp->q_hash; 1350 xfs_mount_t *mp = dqp->q_mount; 1351 1352 ASSERT(mutex_is_locked(&mp->m_quotainfo->qi_dqlist_lock)); 1353 ASSERT(mutex_is_locked(&dqp->q_hash->qh_lock)); 1354 1355 xfs_dqlock(dqp); 1356 /* 1357 * We really can't afford to purge a dquot that is 1358 * referenced, because these are hard refs. 1359 * It shouldn't happen in general because we went thru _all_ inodes in 1360 * dqrele_all_inodes before calling this and didn't let the mountlock go. 1361 * However it is possible that we have dquots with temporary 1362 * references that are not attached to an inode. e.g. see xfs_setattr(). 1363 */ 1364 if (dqp->q_nrefs != 0) { 1365 xfs_dqunlock(dqp); 1366 mutex_unlock(&dqp->q_hash->qh_lock); 1367 return (1); 1368 } 1369 1370 ASSERT(!list_empty(&dqp->q_freelist)); 1371 1372 /* 1373 * If we're turning off quotas, we have to make sure that, for 1374 * example, we don't delete quota disk blocks while dquots are 1375 * in the process of getting written to those disk blocks. 1376 * This dquot might well be on AIL, and we can't leave it there 1377 * if we're turning off quotas. Basically, we need this flush 1378 * lock, and are willing to block on it. 1379 */ 1380 if (!xfs_dqflock_nowait(dqp)) { 1381 /* 1382 * Block on the flush lock after nudging dquot buffer, 1383 * if it is incore. 1384 */ 1385 xfs_qm_dqflock_pushbuf_wait(dqp); 1386 } 1387 1388 /* 1389 * XXXIf we're turning this type of quotas off, we don't care 1390 * about the dirty metadata sitting in this dquot. OTOH, if 1391 * we're unmounting, we do care, so we flush it and wait. 1392 */ 1393 if (XFS_DQ_IS_DIRTY(dqp)) { 1394 int error; 1395 1396 /* dqflush unlocks dqflock */ 1397 /* 1398 * Given that dqpurge is a very rare occurrence, it is OK 1399 * that we're holding the hashlist and mplist locks 1400 * across the disk write. But, ... XXXsup 1401 * 1402 * We don't care about getting disk errors here. We need 1403 * to purge this dquot anyway, so we go ahead regardless. 1404 */ 1405 error = xfs_qm_dqflush(dqp, SYNC_WAIT); 1406 if (error) 1407 xfs_fs_cmn_err(CE_WARN, mp, 1408 "xfs_qm_dqpurge: dquot %p flush failed", dqp); 1409 xfs_dqflock(dqp); 1410 } 1411 ASSERT(atomic_read(&dqp->q_pincount) == 0); 1412 ASSERT(XFS_FORCED_SHUTDOWN(mp) || 1413 !(dqp->q_logitem.qli_item.li_flags & XFS_LI_IN_AIL)); 1414 1415 list_del_init(&dqp->q_hashlist); 1416 qh->qh_version++; 1417 list_del_init(&dqp->q_mplist); 1418 mp->m_quotainfo->qi_dqreclaims++; 1419 mp->m_quotainfo->qi_dquots--; 1420 ASSERT(!list_empty(&dqp->q_freelist)); 1421 1422 dqp->q_mount = NULL; 1423 dqp->q_hash = NULL; 1424 dqp->dq_flags = XFS_DQ_INACTIVE; 1425 memset(&dqp->q_core, 0, sizeof(dqp->q_core)); 1426 xfs_dqfunlock(dqp); 1427 xfs_dqunlock(dqp); 1428 mutex_unlock(&qh->qh_lock); 1429 return (0); 1430} 1431 1432 1433#ifdef QUOTADEBUG 1434void 1435xfs_qm_dqprint(xfs_dquot_t *dqp) 1436{ 1437 cmn_err(CE_DEBUG, "-----------KERNEL DQUOT----------------"); 1438 cmn_err(CE_DEBUG, "---- dquotID = %d", 1439 (int)be32_to_cpu(dqp->q_core.d_id)); 1440 cmn_err(CE_DEBUG, "---- type = %s", DQFLAGTO_TYPESTR(dqp)); 1441 cmn_err(CE_DEBUG, "---- fs = 0x%p", dqp->q_mount); 1442 cmn_err(CE_DEBUG, "---- blkno = 0x%x", (int) dqp->q_blkno); 1443 cmn_err(CE_DEBUG, "---- boffset = 0x%x", (int) dqp->q_bufoffset); 1444 cmn_err(CE_DEBUG, "---- blkhlimit = %Lu (0x%x)", 1445 be64_to_cpu(dqp->q_core.d_blk_hardlimit), 1446 (int)be64_to_cpu(dqp->q_core.d_blk_hardlimit)); 1447 cmn_err(CE_DEBUG, "---- blkslimit = %Lu (0x%x)", 1448 be64_to_cpu(dqp->q_core.d_blk_softlimit), 1449 (int)be64_to_cpu(dqp->q_core.d_blk_softlimit)); 1450 cmn_err(CE_DEBUG, "---- inohlimit = %Lu (0x%x)", 1451 be64_to_cpu(dqp->q_core.d_ino_hardlimit), 1452 (int)be64_to_cpu(dqp->q_core.d_ino_hardlimit)); 1453 cmn_err(CE_DEBUG, "---- inoslimit = %Lu (0x%x)", 1454 be64_to_cpu(dqp->q_core.d_ino_softlimit), 1455 (int)be64_to_cpu(dqp->q_core.d_ino_softlimit)); 1456 cmn_err(CE_DEBUG, "---- bcount = %Lu (0x%x)", 1457 be64_to_cpu(dqp->q_core.d_bcount), 1458 (int)be64_to_cpu(dqp->q_core.d_bcount)); 1459 cmn_err(CE_DEBUG, "---- icount = %Lu (0x%x)", 1460 be64_to_cpu(dqp->q_core.d_icount), 1461 (int)be64_to_cpu(dqp->q_core.d_icount)); 1462 cmn_err(CE_DEBUG, "---- btimer = %d", 1463 (int)be32_to_cpu(dqp->q_core.d_btimer)); 1464 cmn_err(CE_DEBUG, "---- itimer = %d", 1465 (int)be32_to_cpu(dqp->q_core.d_itimer)); 1466 cmn_err(CE_DEBUG, "---------------------------"); 1467} 1468#endif 1469 1470/* 1471 * Give the buffer a little push if it is incore and 1472 * wait on the flush lock. 1473 */ 1474void 1475xfs_qm_dqflock_pushbuf_wait( 1476 xfs_dquot_t *dqp) 1477{ 1478 xfs_mount_t *mp = dqp->q_mount; 1479 xfs_buf_t *bp; 1480 1481 /* 1482 * Check to see if the dquot has been flushed delayed 1483 * write. If so, grab its buffer and send it 1484 * out immediately. We'll be able to acquire 1485 * the flush lock when the I/O completes. 1486 */ 1487 bp = xfs_incore(mp->m_ddev_targp, dqp->q_blkno, 1488 mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK); 1489 if (!bp) 1490 goto out_lock; 1491 1492 if (XFS_BUF_ISDELAYWRITE(bp)) { 1493 if (XFS_BUF_ISPINNED(bp)) 1494 xfs_log_force(mp, 0); 1495 xfs_buf_delwri_promote(bp); 1496 wake_up_process(bp->b_target->bt_task); 1497 } 1498 xfs_buf_relse(bp); 1499out_lock: 1500 xfs_dqflock(dqp); 1501} 1502