1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2003 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 #include "xfs.h" 7 #include "xfs_fs.h" 8 #include "xfs_format.h" 9 #include "xfs_log_format.h" 10 #include "xfs_shared.h" 11 #include "xfs_trans_resv.h" 12 #include "xfs_bit.h" 13 #include "xfs_mount.h" 14 #include "xfs_defer.h" 15 #include "xfs_inode.h" 16 #include "xfs_bmap.h" 17 #include "xfs_quota.h" 18 #include "xfs_trans.h" 19 #include "xfs_buf_item.h" 20 #include "xfs_trans_space.h" 21 #include "xfs_trans_priv.h" 22 #include "xfs_qm.h" 23 #include "xfs_trace.h" 24 #include "xfs_log.h" 25 #include "xfs_bmap_btree.h" 26 #include "xfs_error.h" 27 28 /* 29 * Lock order: 30 * 31 * ip->i_lock 32 * qi->qi_tree_lock 33 * dquot->q_qlock (xfs_dqlock() and friends) 34 * dquot->q_flush (xfs_dqflock() and friends) 35 * qi->qi_lru_lock 36 * 37 * If two dquots need to be locked the order is user before group/project, 38 * otherwise by the lowest id first, see xfs_dqlock2. 39 */ 40 41 struct kmem_zone *xfs_qm_dqtrxzone; 42 static struct kmem_zone *xfs_qm_dqzone; 43 44 static struct lock_class_key xfs_dquot_group_class; 45 static struct lock_class_key xfs_dquot_project_class; 46 47 /* 48 * This is called to free all the memory associated with a dquot 49 */ 50 void 51 xfs_qm_dqdestroy( 52 struct xfs_dquot *dqp) 53 { 54 ASSERT(list_empty(&dqp->q_lru)); 55 56 kmem_free(dqp->q_logitem.qli_item.li_lv_shadow); 57 mutex_destroy(&dqp->q_qlock); 58 59 XFS_STATS_DEC(dqp->q_mount, xs_qm_dquot); 60 kmem_cache_free(xfs_qm_dqzone, dqp); 61 } 62 63 /* 64 * If default limits are in force, push them into the dquot now. 65 * We overwrite the dquot limits only if they are zero and this 66 * is not the root dquot. 67 */ 68 void 69 xfs_qm_adjust_dqlimits( 70 struct xfs_dquot *dq) 71 { 72 struct xfs_mount *mp = dq->q_mount; 73 struct xfs_quotainfo *q = mp->m_quotainfo; 74 struct xfs_def_quota *defq; 75 int prealloc = 0; 76 77 ASSERT(dq->q_id); 78 defq = xfs_get_defquota(q, xfs_dquot_type(dq)); 79 80 if (!dq->q_blk.softlimit) { 81 dq->q_blk.softlimit = defq->blk.soft; 82 prealloc = 1; 83 } 84 if (!dq->q_blk.hardlimit) { 85 dq->q_blk.hardlimit = defq->blk.hard; 86 prealloc = 1; 87 } 88 if (!dq->q_ino.softlimit) 89 dq->q_ino.softlimit = defq->ino.soft; 90 if (!dq->q_ino.hardlimit) 91 dq->q_ino.hardlimit = defq->ino.hard; 92 if (!dq->q_rtb.softlimit) 93 dq->q_rtb.softlimit = defq->rtb.soft; 94 if (!dq->q_rtb.hardlimit) 95 dq->q_rtb.hardlimit = defq->rtb.hard; 96 97 if (prealloc) 98 xfs_dquot_set_prealloc_limits(dq); 99 } 100 101 /* 102 * Determine if this quota counter is over either limit and set the quota 103 * timers as appropriate. 104 */ 105 static inline void 106 xfs_qm_adjust_res_timer( 107 struct xfs_dquot_res *res, 108 struct xfs_quota_limits *qlim) 109 { 110 ASSERT(res->hardlimit == 0 || res->softlimit <= res->hardlimit); 111 112 if ((res->softlimit && res->count > res->softlimit) || 113 (res->hardlimit && res->count > res->hardlimit)) { 114 if (res->timer == 0) 115 res->timer = ktime_get_real_seconds() + qlim->time; 116 } else { 117 if (res->timer == 0) 118 res->warnings = 0; 119 else 120 res->timer = 0; 121 } 122 } 123 124 /* 125 * Check the limits and timers of a dquot and start or reset timers 126 * if necessary. 127 * This gets called even when quota enforcement is OFF, which makes our 128 * life a little less complicated. (We just don't reject any quota 129 * reservations in that case, when enforcement is off). 130 * We also return 0 as the values of the timers in Q_GETQUOTA calls, when 131 * enforcement's off. 132 * In contrast, warnings are a little different in that they don't 133 * 'automatically' get started when limits get exceeded. They do 134 * get reset to zero, however, when we find the count to be under 135 * the soft limit (they are only ever set non-zero via userspace). 136 */ 137 void 138 xfs_qm_adjust_dqtimers( 139 struct xfs_dquot *dq) 140 { 141 struct xfs_mount *mp = dq->q_mount; 142 struct xfs_quotainfo *qi = mp->m_quotainfo; 143 struct xfs_def_quota *defq; 144 145 ASSERT(dq->q_id); 146 defq = xfs_get_defquota(qi, xfs_dquot_type(dq)); 147 148 xfs_qm_adjust_res_timer(&dq->q_blk, &defq->blk); 149 xfs_qm_adjust_res_timer(&dq->q_ino, &defq->ino); 150 xfs_qm_adjust_res_timer(&dq->q_rtb, &defq->rtb); 151 } 152 153 /* 154 * initialize a buffer full of dquots and log the whole thing 155 */ 156 STATIC void 157 xfs_qm_init_dquot_blk( 158 struct xfs_trans *tp, 159 struct xfs_mount *mp, 160 xfs_dqid_t id, 161 xfs_dqtype_t type, 162 struct xfs_buf *bp) 163 { 164 struct xfs_quotainfo *q = mp->m_quotainfo; 165 struct xfs_dqblk *d; 166 xfs_dqid_t curid; 167 unsigned int qflag; 168 unsigned int blftype; 169 int i; 170 171 ASSERT(tp); 172 ASSERT(xfs_buf_islocked(bp)); 173 174 switch (type) { 175 case XFS_DQTYPE_USER: 176 qflag = XFS_UQUOTA_CHKD; 177 blftype = XFS_BLF_UDQUOT_BUF; 178 break; 179 case XFS_DQTYPE_PROJ: 180 qflag = XFS_PQUOTA_CHKD; 181 blftype = XFS_BLF_PDQUOT_BUF; 182 break; 183 case XFS_DQTYPE_GROUP: 184 qflag = XFS_GQUOTA_CHKD; 185 blftype = XFS_BLF_GDQUOT_BUF; 186 break; 187 default: 188 ASSERT(0); 189 return; 190 } 191 192 d = bp->b_addr; 193 194 /* 195 * ID of the first dquot in the block - id's are zero based. 196 */ 197 curid = id - (id % q->qi_dqperchunk); 198 memset(d, 0, BBTOB(q->qi_dqchunklen)); 199 for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++) { 200 d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC); 201 d->dd_diskdq.d_version = XFS_DQUOT_VERSION; 202 d->dd_diskdq.d_id = cpu_to_be32(curid); 203 d->dd_diskdq.d_type = type; 204 if (xfs_sb_version_hascrc(&mp->m_sb)) { 205 uuid_copy(&d->dd_uuid, &mp->m_sb.sb_meta_uuid); 206 xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk), 207 XFS_DQUOT_CRC_OFF); 208 } 209 } 210 211 xfs_trans_dquot_buf(tp, bp, blftype); 212 213 /* 214 * quotacheck uses delayed writes to update all the dquots on disk in an 215 * efficient manner instead of logging the individual dquot changes as 216 * they are made. However if we log the buffer allocated here and crash 217 * after quotacheck while the logged initialisation is still in the 218 * active region of the log, log recovery can replay the dquot buffer 219 * initialisation over the top of the checked dquots and corrupt quota 220 * accounting. 221 * 222 * To avoid this problem, quotacheck cannot log the initialised buffer. 223 * We must still dirty the buffer and write it back before the 224 * allocation transaction clears the log. Therefore, mark the buffer as 225 * ordered instead of logging it directly. This is safe for quotacheck 226 * because it detects and repairs allocated but initialized dquot blocks 227 * in the quota inodes. 228 */ 229 if (!(mp->m_qflags & qflag)) 230 xfs_trans_ordered_buf(tp, bp); 231 else 232 xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1); 233 } 234 235 /* 236 * Initialize the dynamic speculative preallocation thresholds. The lo/hi 237 * watermarks correspond to the soft and hard limits by default. If a soft limit 238 * is not specified, we use 95% of the hard limit. 239 */ 240 void 241 xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp) 242 { 243 uint64_t space; 244 245 dqp->q_prealloc_hi_wmark = dqp->q_blk.hardlimit; 246 dqp->q_prealloc_lo_wmark = dqp->q_blk.softlimit; 247 if (!dqp->q_prealloc_lo_wmark) { 248 dqp->q_prealloc_lo_wmark = dqp->q_prealloc_hi_wmark; 249 do_div(dqp->q_prealloc_lo_wmark, 100); 250 dqp->q_prealloc_lo_wmark *= 95; 251 } 252 253 space = dqp->q_prealloc_hi_wmark; 254 255 do_div(space, 100); 256 dqp->q_low_space[XFS_QLOWSP_1_PCNT] = space; 257 dqp->q_low_space[XFS_QLOWSP_3_PCNT] = space * 3; 258 dqp->q_low_space[XFS_QLOWSP_5_PCNT] = space * 5; 259 } 260 261 /* 262 * Ensure that the given in-core dquot has a buffer on disk backing it, and 263 * return the buffer locked and held. This is called when the bmapi finds a 264 * hole. 265 */ 266 STATIC int 267 xfs_dquot_disk_alloc( 268 struct xfs_trans **tpp, 269 struct xfs_dquot *dqp, 270 struct xfs_buf **bpp) 271 { 272 struct xfs_bmbt_irec map; 273 struct xfs_trans *tp = *tpp; 274 struct xfs_mount *mp = tp->t_mountp; 275 struct xfs_buf *bp; 276 xfs_dqtype_t qtype = xfs_dquot_type(dqp); 277 struct xfs_inode *quotip = xfs_quota_inode(mp, qtype); 278 int nmaps = 1; 279 int error; 280 281 trace_xfs_dqalloc(dqp); 282 283 xfs_ilock(quotip, XFS_ILOCK_EXCL); 284 if (!xfs_this_quota_on(dqp->q_mount, qtype)) { 285 /* 286 * Return if this type of quotas is turned off while we didn't 287 * have an inode lock 288 */ 289 xfs_iunlock(quotip, XFS_ILOCK_EXCL); 290 return -ESRCH; 291 } 292 293 /* Create the block mapping. */ 294 xfs_trans_ijoin(tp, quotip, XFS_ILOCK_EXCL); 295 error = xfs_bmapi_write(tp, quotip, dqp->q_fileoffset, 296 XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA, 0, &map, 297 &nmaps); 298 if (error) 299 return error; 300 ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB); 301 ASSERT(nmaps == 1); 302 ASSERT((map.br_startblock != DELAYSTARTBLOCK) && 303 (map.br_startblock != HOLESTARTBLOCK)); 304 305 /* 306 * Keep track of the blkno to save a lookup later 307 */ 308 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock); 309 310 /* now we can just get the buffer (there's nothing to read yet) */ 311 error = xfs_trans_get_buf(tp, mp->m_ddev_targp, dqp->q_blkno, 312 mp->m_quotainfo->qi_dqchunklen, 0, &bp); 313 if (error) 314 return error; 315 bp->b_ops = &xfs_dquot_buf_ops; 316 317 /* 318 * Make a chunk of dquots out of this buffer and log 319 * the entire thing. 320 */ 321 xfs_qm_init_dquot_blk(tp, mp, dqp->q_id, qtype, bp); 322 xfs_buf_set_ref(bp, XFS_DQUOT_REF); 323 324 /* 325 * Hold the buffer and join it to the dfops so that we'll still own 326 * the buffer when we return to the caller. The buffer disposal on 327 * error must be paid attention to very carefully, as it has been 328 * broken since commit efa092f3d4c6 "[XFS] Fixes a bug in the quota 329 * code when allocating a new dquot record" in 2005, and the later 330 * conversion to xfs_defer_ops in commit 310a75a3c6c747 failed to keep 331 * the buffer locked across the _defer_finish call. We can now do 332 * this correctly with xfs_defer_bjoin. 333 * 334 * Above, we allocated a disk block for the dquot information and used 335 * get_buf to initialize the dquot. If the _defer_finish fails, the old 336 * transaction is gone but the new buffer is not joined or held to any 337 * transaction, so we must _buf_relse it. 338 * 339 * If everything succeeds, the caller of this function is returned a 340 * buffer that is locked and held to the transaction. The caller 341 * is responsible for unlocking any buffer passed back, either 342 * manually or by committing the transaction. On error, the buffer is 343 * released and not passed back. 344 */ 345 xfs_trans_bhold(tp, bp); 346 error = xfs_defer_finish(tpp); 347 if (error) { 348 xfs_trans_bhold_release(*tpp, bp); 349 xfs_trans_brelse(*tpp, bp); 350 return error; 351 } 352 *bpp = bp; 353 return 0; 354 } 355 356 /* 357 * Read in the in-core dquot's on-disk metadata and return the buffer. 358 * Returns ENOENT to signal a hole. 359 */ 360 STATIC int 361 xfs_dquot_disk_read( 362 struct xfs_mount *mp, 363 struct xfs_dquot *dqp, 364 struct xfs_buf **bpp) 365 { 366 struct xfs_bmbt_irec map; 367 struct xfs_buf *bp; 368 xfs_dqtype_t qtype = xfs_dquot_type(dqp); 369 struct xfs_inode *quotip = xfs_quota_inode(mp, qtype); 370 uint lock_mode; 371 int nmaps = 1; 372 int error; 373 374 lock_mode = xfs_ilock_data_map_shared(quotip); 375 if (!xfs_this_quota_on(mp, qtype)) { 376 /* 377 * Return if this type of quotas is turned off while we 378 * didn't have the quota inode lock. 379 */ 380 xfs_iunlock(quotip, lock_mode); 381 return -ESRCH; 382 } 383 384 /* 385 * Find the block map; no allocations yet 386 */ 387 error = xfs_bmapi_read(quotip, dqp->q_fileoffset, 388 XFS_DQUOT_CLUSTER_SIZE_FSB, &map, &nmaps, 0); 389 xfs_iunlock(quotip, lock_mode); 390 if (error) 391 return error; 392 393 ASSERT(nmaps == 1); 394 ASSERT(map.br_blockcount >= 1); 395 ASSERT(map.br_startblock != DELAYSTARTBLOCK); 396 if (map.br_startblock == HOLESTARTBLOCK) 397 return -ENOENT; 398 399 trace_xfs_dqtobp_read(dqp); 400 401 /* 402 * store the blkno etc so that we don't have to do the 403 * mapping all the time 404 */ 405 dqp->q_blkno = XFS_FSB_TO_DADDR(mp, map.br_startblock); 406 407 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno, 408 mp->m_quotainfo->qi_dqchunklen, 0, &bp, 409 &xfs_dquot_buf_ops); 410 if (error) { 411 ASSERT(bp == NULL); 412 return error; 413 } 414 415 ASSERT(xfs_buf_islocked(bp)); 416 xfs_buf_set_ref(bp, XFS_DQUOT_REF); 417 *bpp = bp; 418 419 return 0; 420 } 421 422 /* Allocate and initialize everything we need for an incore dquot. */ 423 STATIC struct xfs_dquot * 424 xfs_dquot_alloc( 425 struct xfs_mount *mp, 426 xfs_dqid_t id, 427 xfs_dqtype_t type) 428 { 429 struct xfs_dquot *dqp; 430 431 dqp = kmem_cache_zalloc(xfs_qm_dqzone, GFP_KERNEL | __GFP_NOFAIL); 432 433 dqp->q_type = type; 434 dqp->q_id = id; 435 dqp->q_mount = mp; 436 INIT_LIST_HEAD(&dqp->q_lru); 437 mutex_init(&dqp->q_qlock); 438 init_waitqueue_head(&dqp->q_pinwait); 439 dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk; 440 /* 441 * Offset of dquot in the (fixed sized) dquot chunk. 442 */ 443 dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) * 444 sizeof(xfs_dqblk_t); 445 446 /* 447 * Because we want to use a counting completion, complete 448 * the flush completion once to allow a single access to 449 * the flush completion without blocking. 450 */ 451 init_completion(&dqp->q_flush); 452 complete(&dqp->q_flush); 453 454 /* 455 * Make sure group quotas have a different lock class than user 456 * quotas. 457 */ 458 switch (type) { 459 case XFS_DQTYPE_USER: 460 /* uses the default lock class */ 461 break; 462 case XFS_DQTYPE_GROUP: 463 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_group_class); 464 break; 465 case XFS_DQTYPE_PROJ: 466 lockdep_set_class(&dqp->q_qlock, &xfs_dquot_project_class); 467 break; 468 default: 469 ASSERT(0); 470 break; 471 } 472 473 xfs_qm_dquot_logitem_init(dqp); 474 475 XFS_STATS_INC(mp, xs_qm_dquot); 476 return dqp; 477 } 478 479 /* Copy the in-core quota fields in from the on-disk buffer. */ 480 STATIC int 481 xfs_dquot_from_disk( 482 struct xfs_dquot *dqp, 483 struct xfs_buf *bp) 484 { 485 struct xfs_disk_dquot *ddqp = bp->b_addr + dqp->q_bufoffset; 486 487 /* 488 * Ensure that we got the type and ID we were looking for. 489 * Everything else was checked by the dquot buffer verifier. 490 */ 491 if ((ddqp->d_type & XFS_DQTYPE_REC_MASK) != xfs_dquot_type(dqp) || 492 be32_to_cpu(ddqp->d_id) != dqp->q_id) { 493 xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR, 494 "Metadata corruption detected at %pS, quota %u", 495 __this_address, dqp->q_id); 496 xfs_alert(bp->b_mount, "Unmount and run xfs_repair"); 497 return -EFSCORRUPTED; 498 } 499 500 /* copy everything from disk dquot to the incore dquot */ 501 dqp->q_type = ddqp->d_type; 502 dqp->q_blk.hardlimit = be64_to_cpu(ddqp->d_blk_hardlimit); 503 dqp->q_blk.softlimit = be64_to_cpu(ddqp->d_blk_softlimit); 504 dqp->q_ino.hardlimit = be64_to_cpu(ddqp->d_ino_hardlimit); 505 dqp->q_ino.softlimit = be64_to_cpu(ddqp->d_ino_softlimit); 506 dqp->q_rtb.hardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit); 507 dqp->q_rtb.softlimit = be64_to_cpu(ddqp->d_rtb_softlimit); 508 509 dqp->q_blk.count = be64_to_cpu(ddqp->d_bcount); 510 dqp->q_ino.count = be64_to_cpu(ddqp->d_icount); 511 dqp->q_rtb.count = be64_to_cpu(ddqp->d_rtbcount); 512 513 dqp->q_blk.warnings = be16_to_cpu(ddqp->d_bwarns); 514 dqp->q_ino.warnings = be16_to_cpu(ddqp->d_iwarns); 515 dqp->q_rtb.warnings = be16_to_cpu(ddqp->d_rtbwarns); 516 517 dqp->q_blk.timer = be32_to_cpu(ddqp->d_btimer); 518 dqp->q_ino.timer = be32_to_cpu(ddqp->d_itimer); 519 dqp->q_rtb.timer = be32_to_cpu(ddqp->d_rtbtimer); 520 521 /* 522 * Reservation counters are defined as reservation plus current usage 523 * to avoid having to add every time. 524 */ 525 dqp->q_blk.reserved = dqp->q_blk.count; 526 dqp->q_ino.reserved = dqp->q_ino.count; 527 dqp->q_rtb.reserved = dqp->q_rtb.count; 528 529 /* initialize the dquot speculative prealloc thresholds */ 530 xfs_dquot_set_prealloc_limits(dqp); 531 return 0; 532 } 533 534 /* Copy the in-core quota fields into the on-disk buffer. */ 535 void 536 xfs_dquot_to_disk( 537 struct xfs_disk_dquot *ddqp, 538 struct xfs_dquot *dqp) 539 { 540 ddqp->d_magic = cpu_to_be16(XFS_DQUOT_MAGIC); 541 ddqp->d_version = XFS_DQUOT_VERSION; 542 ddqp->d_type = dqp->q_type; 543 ddqp->d_id = cpu_to_be32(dqp->q_id); 544 ddqp->d_pad0 = 0; 545 ddqp->d_pad = 0; 546 547 ddqp->d_blk_hardlimit = cpu_to_be64(dqp->q_blk.hardlimit); 548 ddqp->d_blk_softlimit = cpu_to_be64(dqp->q_blk.softlimit); 549 ddqp->d_ino_hardlimit = cpu_to_be64(dqp->q_ino.hardlimit); 550 ddqp->d_ino_softlimit = cpu_to_be64(dqp->q_ino.softlimit); 551 ddqp->d_rtb_hardlimit = cpu_to_be64(dqp->q_rtb.hardlimit); 552 ddqp->d_rtb_softlimit = cpu_to_be64(dqp->q_rtb.softlimit); 553 554 ddqp->d_bcount = cpu_to_be64(dqp->q_blk.count); 555 ddqp->d_icount = cpu_to_be64(dqp->q_ino.count); 556 ddqp->d_rtbcount = cpu_to_be64(dqp->q_rtb.count); 557 558 ddqp->d_bwarns = cpu_to_be16(dqp->q_blk.warnings); 559 ddqp->d_iwarns = cpu_to_be16(dqp->q_ino.warnings); 560 ddqp->d_rtbwarns = cpu_to_be16(dqp->q_rtb.warnings); 561 562 ddqp->d_btimer = cpu_to_be32(dqp->q_blk.timer); 563 ddqp->d_itimer = cpu_to_be32(dqp->q_ino.timer); 564 ddqp->d_rtbtimer = cpu_to_be32(dqp->q_rtb.timer); 565 } 566 567 /* Allocate and initialize the dquot buffer for this in-core dquot. */ 568 static int 569 xfs_qm_dqread_alloc( 570 struct xfs_mount *mp, 571 struct xfs_dquot *dqp, 572 struct xfs_buf **bpp) 573 { 574 struct xfs_trans *tp; 575 int error; 576 577 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_dqalloc, 578 XFS_QM_DQALLOC_SPACE_RES(mp), 0, 0, &tp); 579 if (error) 580 goto err; 581 582 error = xfs_dquot_disk_alloc(&tp, dqp, bpp); 583 if (error) 584 goto err_cancel; 585 586 error = xfs_trans_commit(tp); 587 if (error) { 588 /* 589 * Buffer was held to the transaction, so we have to unlock it 590 * manually here because we're not passing it back. 591 */ 592 xfs_buf_relse(*bpp); 593 *bpp = NULL; 594 goto err; 595 } 596 return 0; 597 598 err_cancel: 599 xfs_trans_cancel(tp); 600 err: 601 return error; 602 } 603 604 /* 605 * Read in the ondisk dquot using dqtobp() then copy it to an incore version, 606 * and release the buffer immediately. If @can_alloc is true, fill any 607 * holes in the on-disk metadata. 608 */ 609 static int 610 xfs_qm_dqread( 611 struct xfs_mount *mp, 612 xfs_dqid_t id, 613 xfs_dqtype_t type, 614 bool can_alloc, 615 struct xfs_dquot **dqpp) 616 { 617 struct xfs_dquot *dqp; 618 struct xfs_buf *bp; 619 int error; 620 621 dqp = xfs_dquot_alloc(mp, id, type); 622 trace_xfs_dqread(dqp); 623 624 /* Try to read the buffer, allocating if necessary. */ 625 error = xfs_dquot_disk_read(mp, dqp, &bp); 626 if (error == -ENOENT && can_alloc) 627 error = xfs_qm_dqread_alloc(mp, dqp, &bp); 628 if (error) 629 goto err; 630 631 /* 632 * At this point we should have a clean locked buffer. Copy the data 633 * to the incore dquot and release the buffer since the incore dquot 634 * has its own locking protocol so we needn't tie up the buffer any 635 * further. 636 */ 637 ASSERT(xfs_buf_islocked(bp)); 638 error = xfs_dquot_from_disk(dqp, bp); 639 xfs_buf_relse(bp); 640 if (error) 641 goto err; 642 643 *dqpp = dqp; 644 return error; 645 646 err: 647 trace_xfs_dqread_fail(dqp); 648 xfs_qm_dqdestroy(dqp); 649 *dqpp = NULL; 650 return error; 651 } 652 653 /* 654 * Advance to the next id in the current chunk, or if at the 655 * end of the chunk, skip ahead to first id in next allocated chunk 656 * using the SEEK_DATA interface. 657 */ 658 static int 659 xfs_dq_get_next_id( 660 struct xfs_mount *mp, 661 xfs_dqtype_t type, 662 xfs_dqid_t *id) 663 { 664 struct xfs_inode *quotip = xfs_quota_inode(mp, type); 665 xfs_dqid_t next_id = *id + 1; /* simple advance */ 666 uint lock_flags; 667 struct xfs_bmbt_irec got; 668 struct xfs_iext_cursor cur; 669 xfs_fsblock_t start; 670 int error = 0; 671 672 /* If we'd wrap past the max ID, stop */ 673 if (next_id < *id) 674 return -ENOENT; 675 676 /* If new ID is within the current chunk, advancing it sufficed */ 677 if (next_id % mp->m_quotainfo->qi_dqperchunk) { 678 *id = next_id; 679 return 0; 680 } 681 682 /* Nope, next_id is now past the current chunk, so find the next one */ 683 start = (xfs_fsblock_t)next_id / mp->m_quotainfo->qi_dqperchunk; 684 685 lock_flags = xfs_ilock_data_map_shared(quotip); 686 if (!(quotip->i_df.if_flags & XFS_IFEXTENTS)) { 687 error = xfs_iread_extents(NULL, quotip, XFS_DATA_FORK); 688 if (error) 689 return error; 690 } 691 692 if (xfs_iext_lookup_extent(quotip, "ip->i_df, start, &cur, &got)) { 693 /* contiguous chunk, bump startoff for the id calculation */ 694 if (got.br_startoff < start) 695 got.br_startoff = start; 696 *id = got.br_startoff * mp->m_quotainfo->qi_dqperchunk; 697 } else { 698 error = -ENOENT; 699 } 700 701 xfs_iunlock(quotip, lock_flags); 702 703 return error; 704 } 705 706 /* 707 * Look up the dquot in the in-core cache. If found, the dquot is returned 708 * locked and ready to go. 709 */ 710 static struct xfs_dquot * 711 xfs_qm_dqget_cache_lookup( 712 struct xfs_mount *mp, 713 struct xfs_quotainfo *qi, 714 struct radix_tree_root *tree, 715 xfs_dqid_t id) 716 { 717 struct xfs_dquot *dqp; 718 719 restart: 720 mutex_lock(&qi->qi_tree_lock); 721 dqp = radix_tree_lookup(tree, id); 722 if (!dqp) { 723 mutex_unlock(&qi->qi_tree_lock); 724 XFS_STATS_INC(mp, xs_qm_dqcachemisses); 725 return NULL; 726 } 727 728 xfs_dqlock(dqp); 729 if (dqp->q_flags & XFS_DQFLAG_FREEING) { 730 xfs_dqunlock(dqp); 731 mutex_unlock(&qi->qi_tree_lock); 732 trace_xfs_dqget_freeing(dqp); 733 delay(1); 734 goto restart; 735 } 736 737 dqp->q_nrefs++; 738 mutex_unlock(&qi->qi_tree_lock); 739 740 trace_xfs_dqget_hit(dqp); 741 XFS_STATS_INC(mp, xs_qm_dqcachehits); 742 return dqp; 743 } 744 745 /* 746 * Try to insert a new dquot into the in-core cache. If an error occurs the 747 * caller should throw away the dquot and start over. Otherwise, the dquot 748 * is returned locked (and held by the cache) as if there had been a cache 749 * hit. 750 */ 751 static int 752 xfs_qm_dqget_cache_insert( 753 struct xfs_mount *mp, 754 struct xfs_quotainfo *qi, 755 struct radix_tree_root *tree, 756 xfs_dqid_t id, 757 struct xfs_dquot *dqp) 758 { 759 int error; 760 761 mutex_lock(&qi->qi_tree_lock); 762 error = radix_tree_insert(tree, id, dqp); 763 if (unlikely(error)) { 764 /* Duplicate found! Caller must try again. */ 765 WARN_ON(error != -EEXIST); 766 mutex_unlock(&qi->qi_tree_lock); 767 trace_xfs_dqget_dup(dqp); 768 return error; 769 } 770 771 /* Return a locked dquot to the caller, with a reference taken. */ 772 xfs_dqlock(dqp); 773 dqp->q_nrefs = 1; 774 775 qi->qi_dquots++; 776 mutex_unlock(&qi->qi_tree_lock); 777 778 return 0; 779 } 780 781 /* Check our input parameters. */ 782 static int 783 xfs_qm_dqget_checks( 784 struct xfs_mount *mp, 785 xfs_dqtype_t type) 786 { 787 if (WARN_ON_ONCE(!XFS_IS_QUOTA_RUNNING(mp))) 788 return -ESRCH; 789 790 switch (type) { 791 case XFS_DQTYPE_USER: 792 if (!XFS_IS_UQUOTA_ON(mp)) 793 return -ESRCH; 794 return 0; 795 case XFS_DQTYPE_GROUP: 796 if (!XFS_IS_GQUOTA_ON(mp)) 797 return -ESRCH; 798 return 0; 799 case XFS_DQTYPE_PROJ: 800 if (!XFS_IS_PQUOTA_ON(mp)) 801 return -ESRCH; 802 return 0; 803 default: 804 WARN_ON_ONCE(0); 805 return -EINVAL; 806 } 807 } 808 809 /* 810 * Given the file system, id, and type (UDQUOT/GDQUOT), return a locked 811 * dquot, doing an allocation (if requested) as needed. 812 */ 813 int 814 xfs_qm_dqget( 815 struct xfs_mount *mp, 816 xfs_dqid_t id, 817 xfs_dqtype_t type, 818 bool can_alloc, 819 struct xfs_dquot **O_dqpp) 820 { 821 struct xfs_quotainfo *qi = mp->m_quotainfo; 822 struct radix_tree_root *tree = xfs_dquot_tree(qi, type); 823 struct xfs_dquot *dqp; 824 int error; 825 826 error = xfs_qm_dqget_checks(mp, type); 827 if (error) 828 return error; 829 830 restart: 831 dqp = xfs_qm_dqget_cache_lookup(mp, qi, tree, id); 832 if (dqp) { 833 *O_dqpp = dqp; 834 return 0; 835 } 836 837 error = xfs_qm_dqread(mp, id, type, can_alloc, &dqp); 838 if (error) 839 return error; 840 841 error = xfs_qm_dqget_cache_insert(mp, qi, tree, id, dqp); 842 if (error) { 843 /* 844 * Duplicate found. Just throw away the new dquot and start 845 * over. 846 */ 847 xfs_qm_dqdestroy(dqp); 848 XFS_STATS_INC(mp, xs_qm_dquot_dups); 849 goto restart; 850 } 851 852 trace_xfs_dqget_miss(dqp); 853 *O_dqpp = dqp; 854 return 0; 855 } 856 857 /* 858 * Given a dquot id and type, read and initialize a dquot from the on-disk 859 * metadata. This function is only for use during quota initialization so 860 * it ignores the dquot cache assuming that the dquot shrinker isn't set up. 861 * The caller is responsible for _qm_dqdestroy'ing the returned dquot. 862 */ 863 int 864 xfs_qm_dqget_uncached( 865 struct xfs_mount *mp, 866 xfs_dqid_t id, 867 xfs_dqtype_t type, 868 struct xfs_dquot **dqpp) 869 { 870 int error; 871 872 error = xfs_qm_dqget_checks(mp, type); 873 if (error) 874 return error; 875 876 return xfs_qm_dqread(mp, id, type, 0, dqpp); 877 } 878 879 /* Return the quota id for a given inode and type. */ 880 xfs_dqid_t 881 xfs_qm_id_for_quotatype( 882 struct xfs_inode *ip, 883 xfs_dqtype_t type) 884 { 885 switch (type) { 886 case XFS_DQTYPE_USER: 887 return i_uid_read(VFS_I(ip)); 888 case XFS_DQTYPE_GROUP: 889 return i_gid_read(VFS_I(ip)); 890 case XFS_DQTYPE_PROJ: 891 return ip->i_d.di_projid; 892 } 893 ASSERT(0); 894 return 0; 895 } 896 897 /* 898 * Return the dquot for a given inode and type. If @can_alloc is true, then 899 * allocate blocks if needed. The inode's ILOCK must be held and it must not 900 * have already had an inode attached. 901 */ 902 int 903 xfs_qm_dqget_inode( 904 struct xfs_inode *ip, 905 xfs_dqtype_t type, 906 bool can_alloc, 907 struct xfs_dquot **O_dqpp) 908 { 909 struct xfs_mount *mp = ip->i_mount; 910 struct xfs_quotainfo *qi = mp->m_quotainfo; 911 struct radix_tree_root *tree = xfs_dquot_tree(qi, type); 912 struct xfs_dquot *dqp; 913 xfs_dqid_t id; 914 int error; 915 916 error = xfs_qm_dqget_checks(mp, type); 917 if (error) 918 return error; 919 920 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 921 ASSERT(xfs_inode_dquot(ip, type) == NULL); 922 923 id = xfs_qm_id_for_quotatype(ip, type); 924 925 restart: 926 dqp = xfs_qm_dqget_cache_lookup(mp, qi, tree, id); 927 if (dqp) { 928 *O_dqpp = dqp; 929 return 0; 930 } 931 932 /* 933 * Dquot cache miss. We don't want to keep the inode lock across 934 * a (potential) disk read. Also we don't want to deal with the lock 935 * ordering between quotainode and this inode. OTOH, dropping the inode 936 * lock here means dealing with a chown that can happen before 937 * we re-acquire the lock. 938 */ 939 xfs_iunlock(ip, XFS_ILOCK_EXCL); 940 error = xfs_qm_dqread(mp, id, type, can_alloc, &dqp); 941 xfs_ilock(ip, XFS_ILOCK_EXCL); 942 if (error) 943 return error; 944 945 /* 946 * A dquot could be attached to this inode by now, since we had 947 * dropped the ilock. 948 */ 949 if (xfs_this_quota_on(mp, type)) { 950 struct xfs_dquot *dqp1; 951 952 dqp1 = xfs_inode_dquot(ip, type); 953 if (dqp1) { 954 xfs_qm_dqdestroy(dqp); 955 dqp = dqp1; 956 xfs_dqlock(dqp); 957 goto dqret; 958 } 959 } else { 960 /* inode stays locked on return */ 961 xfs_qm_dqdestroy(dqp); 962 return -ESRCH; 963 } 964 965 error = xfs_qm_dqget_cache_insert(mp, qi, tree, id, dqp); 966 if (error) { 967 /* 968 * Duplicate found. Just throw away the new dquot and start 969 * over. 970 */ 971 xfs_qm_dqdestroy(dqp); 972 XFS_STATS_INC(mp, xs_qm_dquot_dups); 973 goto restart; 974 } 975 976 dqret: 977 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 978 trace_xfs_dqget_miss(dqp); 979 *O_dqpp = dqp; 980 return 0; 981 } 982 983 /* 984 * Starting at @id and progressing upwards, look for an initialized incore 985 * dquot, lock it, and return it. 986 */ 987 int 988 xfs_qm_dqget_next( 989 struct xfs_mount *mp, 990 xfs_dqid_t id, 991 xfs_dqtype_t type, 992 struct xfs_dquot **dqpp) 993 { 994 struct xfs_dquot *dqp; 995 int error = 0; 996 997 *dqpp = NULL; 998 for (; !error; error = xfs_dq_get_next_id(mp, type, &id)) { 999 error = xfs_qm_dqget(mp, id, type, false, &dqp); 1000 if (error == -ENOENT) 1001 continue; 1002 else if (error != 0) 1003 break; 1004 1005 if (!XFS_IS_DQUOT_UNINITIALIZED(dqp)) { 1006 *dqpp = dqp; 1007 return 0; 1008 } 1009 1010 xfs_qm_dqput(dqp); 1011 } 1012 1013 return error; 1014 } 1015 1016 /* 1017 * Release a reference to the dquot (decrement ref-count) and unlock it. 1018 * 1019 * If there is a group quota attached to this dquot, carefully release that 1020 * too without tripping over deadlocks'n'stuff. 1021 */ 1022 void 1023 xfs_qm_dqput( 1024 struct xfs_dquot *dqp) 1025 { 1026 ASSERT(dqp->q_nrefs > 0); 1027 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 1028 1029 trace_xfs_dqput(dqp); 1030 1031 if (--dqp->q_nrefs == 0) { 1032 struct xfs_quotainfo *qi = dqp->q_mount->m_quotainfo; 1033 trace_xfs_dqput_free(dqp); 1034 1035 if (list_lru_add(&qi->qi_lru, &dqp->q_lru)) 1036 XFS_STATS_INC(dqp->q_mount, xs_qm_dquot_unused); 1037 } 1038 xfs_dqunlock(dqp); 1039 } 1040 1041 /* 1042 * Release a dquot. Flush it if dirty, then dqput() it. 1043 * dquot must not be locked. 1044 */ 1045 void 1046 xfs_qm_dqrele( 1047 struct xfs_dquot *dqp) 1048 { 1049 if (!dqp) 1050 return; 1051 1052 trace_xfs_dqrele(dqp); 1053 1054 xfs_dqlock(dqp); 1055 /* 1056 * We don't care to flush it if the dquot is dirty here. 1057 * That will create stutters that we want to avoid. 1058 * Instead we do a delayed write when we try to reclaim 1059 * a dirty dquot. Also xfs_sync will take part of the burden... 1060 */ 1061 xfs_qm_dqput(dqp); 1062 } 1063 1064 /* 1065 * This is the dquot flushing I/O completion routine. It is called 1066 * from interrupt level when the buffer containing the dquot is 1067 * flushed to disk. It is responsible for removing the dquot logitem 1068 * from the AIL if it has not been re-logged, and unlocking the dquot's 1069 * flush lock. This behavior is very similar to that of inodes.. 1070 */ 1071 static void 1072 xfs_qm_dqflush_done( 1073 struct xfs_log_item *lip) 1074 { 1075 struct xfs_dq_logitem *qip = (struct xfs_dq_logitem *)lip; 1076 struct xfs_dquot *dqp = qip->qli_dquot; 1077 struct xfs_ail *ailp = lip->li_ailp; 1078 xfs_lsn_t tail_lsn; 1079 1080 /* 1081 * We only want to pull the item from the AIL if its 1082 * location in the log has not changed since we started the flush. 1083 * Thus, we only bother if the dquot's lsn has 1084 * not changed. First we check the lsn outside the lock 1085 * since it's cheaper, and then we recheck while 1086 * holding the lock before removing the dquot from the AIL. 1087 */ 1088 if (test_bit(XFS_LI_IN_AIL, &lip->li_flags) && 1089 ((lip->li_lsn == qip->qli_flush_lsn) || 1090 test_bit(XFS_LI_FAILED, &lip->li_flags))) { 1091 1092 spin_lock(&ailp->ail_lock); 1093 xfs_clear_li_failed(lip); 1094 if (lip->li_lsn == qip->qli_flush_lsn) { 1095 /* xfs_ail_update_finish() drops the AIL lock */ 1096 tail_lsn = xfs_ail_delete_one(ailp, lip); 1097 xfs_ail_update_finish(ailp, tail_lsn); 1098 } else { 1099 spin_unlock(&ailp->ail_lock); 1100 } 1101 } 1102 1103 /* 1104 * Release the dq's flush lock since we're done with it. 1105 */ 1106 xfs_dqfunlock(dqp); 1107 } 1108 1109 void 1110 xfs_dquot_done( 1111 struct xfs_buf *bp) 1112 { 1113 struct xfs_log_item *lip, *n; 1114 1115 list_for_each_entry_safe(lip, n, &bp->b_li_list, li_bio_list) { 1116 list_del_init(&lip->li_bio_list); 1117 xfs_qm_dqflush_done(lip); 1118 } 1119 } 1120 1121 /* Check incore dquot for errors before we flush. */ 1122 static xfs_failaddr_t 1123 xfs_qm_dqflush_check( 1124 struct xfs_dquot *dqp) 1125 { 1126 xfs_dqtype_t type = xfs_dquot_type(dqp); 1127 1128 if (type != XFS_DQTYPE_USER && 1129 type != XFS_DQTYPE_GROUP && 1130 type != XFS_DQTYPE_PROJ) 1131 return __this_address; 1132 1133 if (dqp->q_id == 0) 1134 return NULL; 1135 1136 if (dqp->q_blk.softlimit && dqp->q_blk.count > dqp->q_blk.softlimit && 1137 !dqp->q_blk.timer) 1138 return __this_address; 1139 1140 if (dqp->q_ino.softlimit && dqp->q_ino.count > dqp->q_ino.softlimit && 1141 !dqp->q_ino.timer) 1142 return __this_address; 1143 1144 if (dqp->q_rtb.softlimit && dqp->q_rtb.count > dqp->q_rtb.softlimit && 1145 !dqp->q_rtb.timer) 1146 return __this_address; 1147 1148 return NULL; 1149 } 1150 1151 /* 1152 * Write a modified dquot to disk. 1153 * The dquot must be locked and the flush lock too taken by caller. 1154 * The flush lock will not be unlocked until the dquot reaches the disk, 1155 * but the dquot is free to be unlocked and modified by the caller 1156 * in the interim. Dquot is still locked on return. This behavior is 1157 * identical to that of inodes. 1158 */ 1159 int 1160 xfs_qm_dqflush( 1161 struct xfs_dquot *dqp, 1162 struct xfs_buf **bpp) 1163 { 1164 struct xfs_mount *mp = dqp->q_mount; 1165 struct xfs_log_item *lip = &dqp->q_logitem.qli_item; 1166 struct xfs_buf *bp; 1167 struct xfs_dqblk *dqblk; 1168 xfs_failaddr_t fa; 1169 int error; 1170 1171 ASSERT(XFS_DQ_IS_LOCKED(dqp)); 1172 ASSERT(!completion_done(&dqp->q_flush)); 1173 1174 trace_xfs_dqflush(dqp); 1175 1176 *bpp = NULL; 1177 1178 xfs_qm_dqunpin_wait(dqp); 1179 1180 /* 1181 * Get the buffer containing the on-disk dquot 1182 */ 1183 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno, 1184 mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK, 1185 &bp, &xfs_dquot_buf_ops); 1186 if (error == -EAGAIN) 1187 goto out_unlock; 1188 if (error) 1189 goto out_abort; 1190 1191 fa = xfs_qm_dqflush_check(dqp); 1192 if (fa) { 1193 xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS", 1194 dqp->q_id, fa); 1195 xfs_buf_relse(bp); 1196 error = -EFSCORRUPTED; 1197 goto out_abort; 1198 } 1199 1200 /* Flush the incore dquot to the ondisk buffer. */ 1201 dqblk = bp->b_addr + dqp->q_bufoffset; 1202 xfs_dquot_to_disk(&dqblk->dd_diskdq, dqp); 1203 1204 /* 1205 * Clear the dirty field and remember the flush lsn for later use. 1206 */ 1207 dqp->q_flags &= ~XFS_DQFLAG_DIRTY; 1208 1209 xfs_trans_ail_copy_lsn(mp->m_ail, &dqp->q_logitem.qli_flush_lsn, 1210 &dqp->q_logitem.qli_item.li_lsn); 1211 1212 /* 1213 * copy the lsn into the on-disk dquot now while we have the in memory 1214 * dquot here. This can't be done later in the write verifier as we 1215 * can't get access to the log item at that point in time. 1216 * 1217 * We also calculate the CRC here so that the on-disk dquot in the 1218 * buffer always has a valid CRC. This ensures there is no possibility 1219 * of a dquot without an up-to-date CRC getting to disk. 1220 */ 1221 if (xfs_sb_version_hascrc(&mp->m_sb)) { 1222 dqblk->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn); 1223 xfs_update_cksum((char *)dqblk, sizeof(struct xfs_dqblk), 1224 XFS_DQUOT_CRC_OFF); 1225 } 1226 1227 /* 1228 * Attach the dquot to the buffer so that we can remove this dquot from 1229 * the AIL and release the flush lock once the dquot is synced to disk. 1230 */ 1231 bp->b_flags |= _XBF_DQUOTS; 1232 list_add_tail(&dqp->q_logitem.qli_item.li_bio_list, &bp->b_li_list); 1233 1234 /* 1235 * If the buffer is pinned then push on the log so we won't 1236 * get stuck waiting in the write for too long. 1237 */ 1238 if (xfs_buf_ispinned(bp)) { 1239 trace_xfs_dqflush_force(dqp); 1240 xfs_log_force(mp, 0); 1241 } 1242 1243 trace_xfs_dqflush_done(dqp); 1244 *bpp = bp; 1245 return 0; 1246 1247 out_abort: 1248 dqp->q_flags &= ~XFS_DQFLAG_DIRTY; 1249 xfs_trans_ail_delete(lip, 0); 1250 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 1251 out_unlock: 1252 xfs_dqfunlock(dqp); 1253 return error; 1254 } 1255 1256 /* 1257 * Lock two xfs_dquot structures. 1258 * 1259 * To avoid deadlocks we always lock the quota structure with 1260 * the lowerd id first. 1261 */ 1262 void 1263 xfs_dqlock2( 1264 struct xfs_dquot *d1, 1265 struct xfs_dquot *d2) 1266 { 1267 if (d1 && d2) { 1268 ASSERT(d1 != d2); 1269 if (d1->q_id > d2->q_id) { 1270 mutex_lock(&d2->q_qlock); 1271 mutex_lock_nested(&d1->q_qlock, XFS_QLOCK_NESTED); 1272 } else { 1273 mutex_lock(&d1->q_qlock); 1274 mutex_lock_nested(&d2->q_qlock, XFS_QLOCK_NESTED); 1275 } 1276 } else if (d1) { 1277 mutex_lock(&d1->q_qlock); 1278 } else if (d2) { 1279 mutex_lock(&d2->q_qlock); 1280 } 1281 } 1282 1283 int __init 1284 xfs_qm_init(void) 1285 { 1286 xfs_qm_dqzone = kmem_cache_create("xfs_dquot", 1287 sizeof(struct xfs_dquot), 1288 0, 0, NULL); 1289 if (!xfs_qm_dqzone) 1290 goto out; 1291 1292 xfs_qm_dqtrxzone = kmem_cache_create("xfs_dqtrx", 1293 sizeof(struct xfs_dquot_acct), 1294 0, 0, NULL); 1295 if (!xfs_qm_dqtrxzone) 1296 goto out_free_dqzone; 1297 1298 return 0; 1299 1300 out_free_dqzone: 1301 kmem_cache_destroy(xfs_qm_dqzone); 1302 out: 1303 return -ENOMEM; 1304 } 1305 1306 void 1307 xfs_qm_exit(void) 1308 { 1309 kmem_cache_destroy(xfs_qm_dqtrxzone); 1310 kmem_cache_destroy(xfs_qm_dqzone); 1311 } 1312 1313 /* 1314 * Iterate every dquot of a particular type. The caller must ensure that the 1315 * particular quota type is active. iter_fn can return negative error codes, 1316 * or -ECANCELED to indicate that it wants to stop iterating. 1317 */ 1318 int 1319 xfs_qm_dqiterate( 1320 struct xfs_mount *mp, 1321 xfs_dqtype_t type, 1322 xfs_qm_dqiterate_fn iter_fn, 1323 void *priv) 1324 { 1325 struct xfs_dquot *dq; 1326 xfs_dqid_t id = 0; 1327 int error; 1328 1329 do { 1330 error = xfs_qm_dqget_next(mp, id, type, &dq); 1331 if (error == -ENOENT) 1332 return 0; 1333 if (error) 1334 return error; 1335 1336 error = iter_fn(dq, type, priv); 1337 id = dq->q_id; 1338 xfs_qm_dqput(dq); 1339 } while (error == 0 && id != 0); 1340 1341 return error; 1342 } 1343