1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2005 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 7 #include <linux/capability.h> 8 9 #include "xfs.h" 10 #include "xfs_fs.h" 11 #include "xfs_shared.h" 12 #include "xfs_format.h" 13 #include "xfs_log_format.h" 14 #include "xfs_trans_resv.h" 15 #include "xfs_bit.h" 16 #include "xfs_sb.h" 17 #include "xfs_mount.h" 18 #include "xfs_inode.h" 19 #include "xfs_trans.h" 20 #include "xfs_error.h" 21 #include "xfs_quota.h" 22 #include "xfs_qm.h" 23 #include "xfs_trace.h" 24 #include "xfs_icache.h" 25 #include "xfs_defer.h" 26 27 STATIC int xfs_qm_log_quotaoff(xfs_mount_t *, xfs_qoff_logitem_t **, uint); 28 STATIC int xfs_qm_log_quotaoff_end(xfs_mount_t *, xfs_qoff_logitem_t *, 29 uint); 30 31 /* 32 * Turn off quota accounting and/or enforcement for all udquots and/or 33 * gdquots. Called only at unmount time. 34 * 35 * This assumes that there are no dquots of this file system cached 36 * incore, and modifies the ondisk dquot directly. Therefore, for example, 37 * it is an error to call this twice, without purging the cache. 38 */ 39 int 40 xfs_qm_scall_quotaoff( 41 xfs_mount_t *mp, 42 uint flags) 43 { 44 struct xfs_quotainfo *q = mp->m_quotainfo; 45 uint dqtype; 46 int error; 47 uint inactivate_flags; 48 xfs_qoff_logitem_t *qoffstart; 49 50 /* 51 * No file system can have quotas enabled on disk but not in core. 52 * Note that quota utilities (like quotaoff) _expect_ 53 * errno == -EEXIST here. 54 */ 55 if ((mp->m_qflags & flags) == 0) 56 return -EEXIST; 57 error = 0; 58 59 flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD); 60 61 /* 62 * We don't want to deal with two quotaoffs messing up each other, 63 * so we're going to serialize it. quotaoff isn't exactly a performance 64 * critical thing. 65 * If quotaoff, then we must be dealing with the root filesystem. 66 */ 67 ASSERT(q); 68 mutex_lock(&q->qi_quotaofflock); 69 70 /* 71 * If we're just turning off quota enforcement, change mp and go. 72 */ 73 if ((flags & XFS_ALL_QUOTA_ACCT) == 0) { 74 mp->m_qflags &= ~(flags); 75 76 spin_lock(&mp->m_sb_lock); 77 mp->m_sb.sb_qflags = mp->m_qflags; 78 spin_unlock(&mp->m_sb_lock); 79 mutex_unlock(&q->qi_quotaofflock); 80 81 /* XXX what to do if error ? Revert back to old vals incore ? */ 82 return xfs_sync_sb(mp, false); 83 } 84 85 dqtype = 0; 86 inactivate_flags = 0; 87 /* 88 * If accounting is off, we must turn enforcement off, clear the 89 * quota 'CHKD' certificate to make it known that we have to 90 * do a quotacheck the next time this quota is turned on. 91 */ 92 if (flags & XFS_UQUOTA_ACCT) { 93 dqtype |= XFS_QMOPT_UQUOTA; 94 flags |= (XFS_UQUOTA_CHKD | XFS_UQUOTA_ENFD); 95 inactivate_flags |= XFS_UQUOTA_ACTIVE; 96 } 97 if (flags & XFS_GQUOTA_ACCT) { 98 dqtype |= XFS_QMOPT_GQUOTA; 99 flags |= (XFS_GQUOTA_CHKD | XFS_GQUOTA_ENFD); 100 inactivate_flags |= XFS_GQUOTA_ACTIVE; 101 } 102 if (flags & XFS_PQUOTA_ACCT) { 103 dqtype |= XFS_QMOPT_PQUOTA; 104 flags |= (XFS_PQUOTA_CHKD | XFS_PQUOTA_ENFD); 105 inactivate_flags |= XFS_PQUOTA_ACTIVE; 106 } 107 108 /* 109 * Nothing to do? Don't complain. This happens when we're just 110 * turning off quota enforcement. 111 */ 112 if ((mp->m_qflags & flags) == 0) 113 goto out_unlock; 114 115 /* 116 * Write the LI_QUOTAOFF log record, and do SB changes atomically, 117 * and synchronously. If we fail to write, we should abort the 118 * operation as it cannot be recovered safely if we crash. 119 */ 120 error = xfs_qm_log_quotaoff(mp, &qoffstart, flags); 121 if (error) 122 goto out_unlock; 123 124 /* 125 * Next we clear the XFS_MOUNT_*DQ_ACTIVE bit(s) in the mount struct 126 * to take care of the race between dqget and quotaoff. We don't take 127 * any special locks to reset these bits. All processes need to check 128 * these bits *after* taking inode lock(s) to see if the particular 129 * quota type is in the process of being turned off. If *ACTIVE, it is 130 * guaranteed that all dquot structures and all quotainode ptrs will all 131 * stay valid as long as that inode is kept locked. 132 * 133 * There is no turning back after this. 134 */ 135 mp->m_qflags &= ~inactivate_flags; 136 137 /* 138 * Give back all the dquot reference(s) held by inodes. 139 * Here we go thru every single incore inode in this file system, and 140 * do a dqrele on the i_udquot/i_gdquot that it may have. 141 * Essentially, as long as somebody has an inode locked, this guarantees 142 * that quotas will not be turned off. This is handy because in a 143 * transaction once we lock the inode(s) and check for quotaon, we can 144 * depend on the quota inodes (and other things) being valid as long as 145 * we keep the lock(s). 146 */ 147 xfs_qm_dqrele_all_inodes(mp, flags); 148 149 /* 150 * Next we make the changes in the quota flag in the mount struct. 151 * This isn't protected by a particular lock directly, because we 152 * don't want to take a mrlock every time we depend on quotas being on. 153 */ 154 mp->m_qflags &= ~flags; 155 156 /* 157 * Go through all the dquots of this file system and purge them, 158 * according to what was turned off. 159 */ 160 xfs_qm_dqpurge_all(mp, dqtype); 161 162 /* 163 * Transactions that had started before ACTIVE state bit was cleared 164 * could have logged many dquots, so they'd have higher LSNs than 165 * the first QUOTAOFF log record does. If we happen to crash when 166 * the tail of the log has gone past the QUOTAOFF record, but 167 * before the last dquot modification, those dquots __will__ 168 * recover, and that's not good. 169 * 170 * So, we have QUOTAOFF start and end logitems; the start 171 * logitem won't get overwritten until the end logitem appears... 172 */ 173 error = xfs_qm_log_quotaoff_end(mp, qoffstart, flags); 174 if (error) { 175 /* We're screwed now. Shutdown is the only option. */ 176 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 177 goto out_unlock; 178 } 179 180 /* 181 * If all quotas are completely turned off, close shop. 182 */ 183 if (mp->m_qflags == 0) { 184 mutex_unlock(&q->qi_quotaofflock); 185 xfs_qm_destroy_quotainfo(mp); 186 return 0; 187 } 188 189 /* 190 * Release our quotainode references if we don't need them anymore. 191 */ 192 if ((dqtype & XFS_QMOPT_UQUOTA) && q->qi_uquotaip) { 193 xfs_irele(q->qi_uquotaip); 194 q->qi_uquotaip = NULL; 195 } 196 if ((dqtype & XFS_QMOPT_GQUOTA) && q->qi_gquotaip) { 197 xfs_irele(q->qi_gquotaip); 198 q->qi_gquotaip = NULL; 199 } 200 if ((dqtype & XFS_QMOPT_PQUOTA) && q->qi_pquotaip) { 201 xfs_irele(q->qi_pquotaip); 202 q->qi_pquotaip = NULL; 203 } 204 205 out_unlock: 206 mutex_unlock(&q->qi_quotaofflock); 207 return error; 208 } 209 210 STATIC int 211 xfs_qm_scall_trunc_qfile( 212 struct xfs_mount *mp, 213 xfs_ino_t ino) 214 { 215 struct xfs_inode *ip; 216 struct xfs_trans *tp; 217 int error; 218 219 if (ino == NULLFSINO) 220 return 0; 221 222 error = xfs_iget(mp, NULL, ino, 0, 0, &ip); 223 if (error) 224 return error; 225 226 xfs_ilock(ip, XFS_IOLOCK_EXCL); 227 228 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp); 229 if (error) { 230 xfs_iunlock(ip, XFS_IOLOCK_EXCL); 231 goto out_put; 232 } 233 234 xfs_ilock(ip, XFS_ILOCK_EXCL); 235 xfs_trans_ijoin(tp, ip, 0); 236 237 ip->i_d.di_size = 0; 238 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE); 239 240 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0); 241 if (error) { 242 xfs_trans_cancel(tp); 243 goto out_unlock; 244 } 245 246 ASSERT(ip->i_d.di_nextents == 0); 247 248 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG); 249 error = xfs_trans_commit(tp); 250 251 out_unlock: 252 xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL); 253 out_put: 254 xfs_irele(ip); 255 return error; 256 } 257 258 int 259 xfs_qm_scall_trunc_qfiles( 260 xfs_mount_t *mp, 261 uint flags) 262 { 263 int error = -EINVAL; 264 265 if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0 || 266 (flags & ~XFS_DQ_ALLTYPES)) { 267 xfs_debug(mp, "%s: flags=%x m_qflags=%x", 268 __func__, flags, mp->m_qflags); 269 return -EINVAL; 270 } 271 272 if (flags & XFS_DQ_USER) { 273 error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_uquotino); 274 if (error) 275 return error; 276 } 277 if (flags & XFS_DQ_GROUP) { 278 error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_gquotino); 279 if (error) 280 return error; 281 } 282 if (flags & XFS_DQ_PROJ) 283 error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_pquotino); 284 285 return error; 286 } 287 288 /* 289 * Switch on (a given) quota enforcement for a filesystem. This takes 290 * effect immediately. 291 * (Switching on quota accounting must be done at mount time.) 292 */ 293 int 294 xfs_qm_scall_quotaon( 295 xfs_mount_t *mp, 296 uint flags) 297 { 298 int error; 299 uint qf; 300 301 flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD); 302 /* 303 * Switching on quota accounting must be done at mount time. 304 */ 305 flags &= ~(XFS_ALL_QUOTA_ACCT); 306 307 if (flags == 0) { 308 xfs_debug(mp, "%s: zero flags, m_qflags=%x", 309 __func__, mp->m_qflags); 310 return -EINVAL; 311 } 312 313 /* 314 * Can't enforce without accounting. We check the superblock 315 * qflags here instead of m_qflags because rootfs can have 316 * quota acct on ondisk without m_qflags' knowing. 317 */ 318 if (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 && 319 (flags & XFS_UQUOTA_ENFD)) || 320 ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 && 321 (flags & XFS_GQUOTA_ENFD)) || 322 ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 && 323 (flags & XFS_PQUOTA_ENFD))) { 324 xfs_debug(mp, 325 "%s: Can't enforce without acct, flags=%x sbflags=%x", 326 __func__, flags, mp->m_sb.sb_qflags); 327 return -EINVAL; 328 } 329 /* 330 * If everything's up to-date incore, then don't waste time. 331 */ 332 if ((mp->m_qflags & flags) == flags) 333 return -EEXIST; 334 335 /* 336 * Change sb_qflags on disk but not incore mp->qflags 337 * if this is the root filesystem. 338 */ 339 spin_lock(&mp->m_sb_lock); 340 qf = mp->m_sb.sb_qflags; 341 mp->m_sb.sb_qflags = qf | flags; 342 spin_unlock(&mp->m_sb_lock); 343 344 /* 345 * There's nothing to change if it's the same. 346 */ 347 if ((qf & flags) == flags) 348 return -EEXIST; 349 350 error = xfs_sync_sb(mp, false); 351 if (error) 352 return error; 353 /* 354 * If we aren't trying to switch on quota enforcement, we are done. 355 */ 356 if (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) != 357 (mp->m_qflags & XFS_UQUOTA_ACCT)) || 358 ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) != 359 (mp->m_qflags & XFS_PQUOTA_ACCT)) || 360 ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) != 361 (mp->m_qflags & XFS_GQUOTA_ACCT))) 362 return 0; 363 364 if (! XFS_IS_QUOTA_RUNNING(mp)) 365 return -ESRCH; 366 367 /* 368 * Switch on quota enforcement in core. 369 */ 370 mutex_lock(&mp->m_quotainfo->qi_quotaofflock); 371 mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD); 372 mutex_unlock(&mp->m_quotainfo->qi_quotaofflock); 373 374 return 0; 375 } 376 377 #define XFS_QC_MASK \ 378 (QC_LIMIT_MASK | QC_TIMER_MASK | QC_WARNS_MASK) 379 380 /* 381 * Adjust quota limits, and start/stop timers accordingly. 382 */ 383 int 384 xfs_qm_scall_setqlim( 385 struct xfs_mount *mp, 386 xfs_dqid_t id, 387 uint type, 388 struct qc_dqblk *newlim) 389 { 390 struct xfs_quotainfo *q = mp->m_quotainfo; 391 struct xfs_disk_dquot *ddq; 392 struct xfs_dquot *dqp; 393 struct xfs_trans *tp; 394 struct xfs_def_quota *defq; 395 int error; 396 xfs_qcnt_t hard, soft; 397 398 if (newlim->d_fieldmask & ~XFS_QC_MASK) 399 return -EINVAL; 400 if ((newlim->d_fieldmask & XFS_QC_MASK) == 0) 401 return 0; 402 403 /* 404 * We don't want to race with a quotaoff so take the quotaoff lock. 405 * We don't hold an inode lock, so there's nothing else to stop 406 * a quotaoff from happening. 407 */ 408 mutex_lock(&q->qi_quotaofflock); 409 410 /* 411 * Get the dquot (locked) before we start, as we need to do a 412 * transaction to allocate it if it doesn't exist. Once we have the 413 * dquot, unlock it so we can start the next transaction safely. We hold 414 * a reference to the dquot, so it's safe to do this unlock/lock without 415 * it being reclaimed in the mean time. 416 */ 417 error = xfs_qm_dqget(mp, id, type, true, &dqp); 418 if (error) { 419 ASSERT(error != -ENOENT); 420 goto out_unlock; 421 } 422 423 defq = xfs_get_defquota(dqp, q); 424 xfs_dqunlock(dqp); 425 426 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_setqlim, 0, 0, 0, &tp); 427 if (error) 428 goto out_rele; 429 430 xfs_dqlock(dqp); 431 xfs_trans_dqjoin(tp, dqp); 432 ddq = &dqp->q_core; 433 434 /* 435 * Make sure that hardlimits are >= soft limits before changing. 436 */ 437 hard = (newlim->d_fieldmask & QC_SPC_HARD) ? 438 (xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_hardlimit) : 439 be64_to_cpu(ddq->d_blk_hardlimit); 440 soft = (newlim->d_fieldmask & QC_SPC_SOFT) ? 441 (xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_spc_softlimit) : 442 be64_to_cpu(ddq->d_blk_softlimit); 443 if (hard == 0 || hard >= soft) { 444 ddq->d_blk_hardlimit = cpu_to_be64(hard); 445 ddq->d_blk_softlimit = cpu_to_be64(soft); 446 xfs_dquot_set_prealloc_limits(dqp); 447 if (id == 0) { 448 defq->bhardlimit = hard; 449 defq->bsoftlimit = soft; 450 } 451 } else { 452 xfs_debug(mp, "blkhard %Ld < blksoft %Ld", hard, soft); 453 } 454 hard = (newlim->d_fieldmask & QC_RT_SPC_HARD) ? 455 (xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_hardlimit) : 456 be64_to_cpu(ddq->d_rtb_hardlimit); 457 soft = (newlim->d_fieldmask & QC_RT_SPC_SOFT) ? 458 (xfs_qcnt_t) XFS_B_TO_FSB(mp, newlim->d_rt_spc_softlimit) : 459 be64_to_cpu(ddq->d_rtb_softlimit); 460 if (hard == 0 || hard >= soft) { 461 ddq->d_rtb_hardlimit = cpu_to_be64(hard); 462 ddq->d_rtb_softlimit = cpu_to_be64(soft); 463 if (id == 0) { 464 defq->rtbhardlimit = hard; 465 defq->rtbsoftlimit = soft; 466 } 467 } else { 468 xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld", hard, soft); 469 } 470 471 hard = (newlim->d_fieldmask & QC_INO_HARD) ? 472 (xfs_qcnt_t) newlim->d_ino_hardlimit : 473 be64_to_cpu(ddq->d_ino_hardlimit); 474 soft = (newlim->d_fieldmask & QC_INO_SOFT) ? 475 (xfs_qcnt_t) newlim->d_ino_softlimit : 476 be64_to_cpu(ddq->d_ino_softlimit); 477 if (hard == 0 || hard >= soft) { 478 ddq->d_ino_hardlimit = cpu_to_be64(hard); 479 ddq->d_ino_softlimit = cpu_to_be64(soft); 480 if (id == 0) { 481 defq->ihardlimit = hard; 482 defq->isoftlimit = soft; 483 } 484 } else { 485 xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft); 486 } 487 488 /* 489 * Update warnings counter(s) if requested 490 */ 491 if (newlim->d_fieldmask & QC_SPC_WARNS) 492 ddq->d_bwarns = cpu_to_be16(newlim->d_spc_warns); 493 if (newlim->d_fieldmask & QC_INO_WARNS) 494 ddq->d_iwarns = cpu_to_be16(newlim->d_ino_warns); 495 if (newlim->d_fieldmask & QC_RT_SPC_WARNS) 496 ddq->d_rtbwarns = cpu_to_be16(newlim->d_rt_spc_warns); 497 498 if (id == 0) { 499 /* 500 * Timelimits for the super user set the relative time 501 * the other users can be over quota for this file system. 502 * If it is zero a default is used. Ditto for the default 503 * soft and hard limit values (already done, above), and 504 * for warnings. 505 */ 506 if (newlim->d_fieldmask & QC_SPC_TIMER) { 507 q->qi_btimelimit = newlim->d_spc_timer; 508 ddq->d_btimer = cpu_to_be32(newlim->d_spc_timer); 509 } 510 if (newlim->d_fieldmask & QC_INO_TIMER) { 511 q->qi_itimelimit = newlim->d_ino_timer; 512 ddq->d_itimer = cpu_to_be32(newlim->d_ino_timer); 513 } 514 if (newlim->d_fieldmask & QC_RT_SPC_TIMER) { 515 q->qi_rtbtimelimit = newlim->d_rt_spc_timer; 516 ddq->d_rtbtimer = cpu_to_be32(newlim->d_rt_spc_timer); 517 } 518 if (newlim->d_fieldmask & QC_SPC_WARNS) 519 q->qi_bwarnlimit = newlim->d_spc_warns; 520 if (newlim->d_fieldmask & QC_INO_WARNS) 521 q->qi_iwarnlimit = newlim->d_ino_warns; 522 if (newlim->d_fieldmask & QC_RT_SPC_WARNS) 523 q->qi_rtbwarnlimit = newlim->d_rt_spc_warns; 524 } else { 525 /* 526 * If the user is now over quota, start the timelimit. 527 * The user will not be 'warned'. 528 * Note that we keep the timers ticking, whether enforcement 529 * is on or off. We don't really want to bother with iterating 530 * over all ondisk dquots and turning the timers on/off. 531 */ 532 xfs_qm_adjust_dqtimers(mp, ddq); 533 } 534 dqp->dq_flags |= XFS_DQ_DIRTY; 535 xfs_trans_log_dquot(tp, dqp); 536 537 error = xfs_trans_commit(tp); 538 539 out_rele: 540 xfs_qm_dqrele(dqp); 541 out_unlock: 542 mutex_unlock(&q->qi_quotaofflock); 543 return error; 544 } 545 546 STATIC int 547 xfs_qm_log_quotaoff_end( 548 xfs_mount_t *mp, 549 xfs_qoff_logitem_t *startqoff, 550 uint flags) 551 { 552 xfs_trans_t *tp; 553 int error; 554 xfs_qoff_logitem_t *qoffi; 555 556 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_equotaoff, 0, 0, 0, &tp); 557 if (error) 558 return error; 559 560 qoffi = xfs_trans_get_qoff_item(tp, startqoff, 561 flags & XFS_ALL_QUOTA_ACCT); 562 xfs_trans_log_quotaoff_item(tp, qoffi); 563 564 /* 565 * We have to make sure that the transaction is secure on disk before we 566 * return and actually stop quota accounting. So, make it synchronous. 567 * We don't care about quotoff's performance. 568 */ 569 xfs_trans_set_sync(tp); 570 return xfs_trans_commit(tp); 571 } 572 573 574 STATIC int 575 xfs_qm_log_quotaoff( 576 xfs_mount_t *mp, 577 xfs_qoff_logitem_t **qoffstartp, 578 uint flags) 579 { 580 xfs_trans_t *tp; 581 int error; 582 xfs_qoff_logitem_t *qoffi; 583 584 *qoffstartp = NULL; 585 586 error = xfs_trans_alloc(mp, &M_RES(mp)->tr_qm_quotaoff, 0, 0, 0, &tp); 587 if (error) 588 goto out; 589 590 qoffi = xfs_trans_get_qoff_item(tp, NULL, flags & XFS_ALL_QUOTA_ACCT); 591 xfs_trans_log_quotaoff_item(tp, qoffi); 592 593 spin_lock(&mp->m_sb_lock); 594 mp->m_sb.sb_qflags = (mp->m_qflags & ~(flags)) & XFS_MOUNT_QUOTA_ALL; 595 spin_unlock(&mp->m_sb_lock); 596 597 xfs_log_sb(tp); 598 599 /* 600 * We have to make sure that the transaction is secure on disk before we 601 * return and actually stop quota accounting. So, make it synchronous. 602 * We don't care about quotoff's performance. 603 */ 604 xfs_trans_set_sync(tp); 605 error = xfs_trans_commit(tp); 606 if (error) 607 goto out; 608 609 *qoffstartp = qoffi; 610 out: 611 return error; 612 } 613 614 /* Fill out the quota context. */ 615 static void 616 xfs_qm_scall_getquota_fill_qc( 617 struct xfs_mount *mp, 618 uint type, 619 const struct xfs_dquot *dqp, 620 struct qc_dqblk *dst) 621 { 622 memset(dst, 0, sizeof(*dst)); 623 dst->d_spc_hardlimit = 624 XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_blk_hardlimit)); 625 dst->d_spc_softlimit = 626 XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_blk_softlimit)); 627 dst->d_ino_hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit); 628 dst->d_ino_softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit); 629 dst->d_space = XFS_FSB_TO_B(mp, dqp->q_res_bcount); 630 dst->d_ino_count = dqp->q_res_icount; 631 dst->d_spc_timer = be32_to_cpu(dqp->q_core.d_btimer); 632 dst->d_ino_timer = be32_to_cpu(dqp->q_core.d_itimer); 633 dst->d_ino_warns = be16_to_cpu(dqp->q_core.d_iwarns); 634 dst->d_spc_warns = be16_to_cpu(dqp->q_core.d_bwarns); 635 dst->d_rt_spc_hardlimit = 636 XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_hardlimit)); 637 dst->d_rt_spc_softlimit = 638 XFS_FSB_TO_B(mp, be64_to_cpu(dqp->q_core.d_rtb_softlimit)); 639 dst->d_rt_space = XFS_FSB_TO_B(mp, dqp->q_res_rtbcount); 640 dst->d_rt_spc_timer = be32_to_cpu(dqp->q_core.d_rtbtimer); 641 dst->d_rt_spc_warns = be16_to_cpu(dqp->q_core.d_rtbwarns); 642 643 /* 644 * Internally, we don't reset all the timers when quota enforcement 645 * gets turned off. No need to confuse the user level code, 646 * so return zeroes in that case. 647 */ 648 if ((!XFS_IS_UQUOTA_ENFORCED(mp) && 649 dqp->q_core.d_flags == XFS_DQ_USER) || 650 (!XFS_IS_GQUOTA_ENFORCED(mp) && 651 dqp->q_core.d_flags == XFS_DQ_GROUP) || 652 (!XFS_IS_PQUOTA_ENFORCED(mp) && 653 dqp->q_core.d_flags == XFS_DQ_PROJ)) { 654 dst->d_spc_timer = 0; 655 dst->d_ino_timer = 0; 656 dst->d_rt_spc_timer = 0; 657 } 658 659 #ifdef DEBUG 660 if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQ_USER) || 661 (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQ_GROUP) || 662 (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQ_PROJ)) && 663 dqp->q_core.d_id != 0) { 664 if ((dst->d_space > dst->d_spc_softlimit) && 665 (dst->d_spc_softlimit > 0)) { 666 ASSERT(dst->d_spc_timer != 0); 667 } 668 if ((dst->d_ino_count > dst->d_ino_softlimit) && 669 (dst->d_ino_softlimit > 0)) { 670 ASSERT(dst->d_ino_timer != 0); 671 } 672 } 673 #endif 674 } 675 676 /* Return the quota information for the dquot matching id. */ 677 int 678 xfs_qm_scall_getquota( 679 struct xfs_mount *mp, 680 xfs_dqid_t id, 681 uint type, 682 struct qc_dqblk *dst) 683 { 684 struct xfs_dquot *dqp; 685 int error; 686 687 /* 688 * Try to get the dquot. We don't want it allocated on disk, so don't 689 * set doalloc. If it doesn't exist, we'll get ENOENT back. 690 */ 691 error = xfs_qm_dqget(mp, id, type, false, &dqp); 692 if (error) 693 return error; 694 695 /* 696 * If everything's NULL, this dquot doesn't quite exist as far as 697 * our utility programs are concerned. 698 */ 699 if (XFS_IS_DQUOT_UNINITIALIZED(dqp)) { 700 error = -ENOENT; 701 goto out_put; 702 } 703 704 xfs_qm_scall_getquota_fill_qc(mp, type, dqp, dst); 705 706 out_put: 707 xfs_qm_dqput(dqp); 708 return error; 709 } 710 711 /* 712 * Return the quota information for the first initialized dquot whose id 713 * is at least as high as id. 714 */ 715 int 716 xfs_qm_scall_getquota_next( 717 struct xfs_mount *mp, 718 xfs_dqid_t *id, 719 uint type, 720 struct qc_dqblk *dst) 721 { 722 struct xfs_dquot *dqp; 723 int error; 724 725 error = xfs_qm_dqget_next(mp, *id, type, &dqp); 726 if (error) 727 return error; 728 729 /* Fill in the ID we actually read from disk */ 730 *id = be32_to_cpu(dqp->q_core.d_id); 731 732 xfs_qm_scall_getquota_fill_qc(mp, type, dqp, dst); 733 734 xfs_qm_dqput(dqp); 735 return error; 736 } 737 738 STATIC int 739 xfs_dqrele_inode( 740 struct xfs_inode *ip, 741 int flags, 742 void *args) 743 { 744 /* skip quota inodes */ 745 if (ip == ip->i_mount->m_quotainfo->qi_uquotaip || 746 ip == ip->i_mount->m_quotainfo->qi_gquotaip || 747 ip == ip->i_mount->m_quotainfo->qi_pquotaip) { 748 ASSERT(ip->i_udquot == NULL); 749 ASSERT(ip->i_gdquot == NULL); 750 ASSERT(ip->i_pdquot == NULL); 751 return 0; 752 } 753 754 xfs_ilock(ip, XFS_ILOCK_EXCL); 755 if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) { 756 xfs_qm_dqrele(ip->i_udquot); 757 ip->i_udquot = NULL; 758 } 759 if ((flags & XFS_GQUOTA_ACCT) && ip->i_gdquot) { 760 xfs_qm_dqrele(ip->i_gdquot); 761 ip->i_gdquot = NULL; 762 } 763 if ((flags & XFS_PQUOTA_ACCT) && ip->i_pdquot) { 764 xfs_qm_dqrele(ip->i_pdquot); 765 ip->i_pdquot = NULL; 766 } 767 xfs_iunlock(ip, XFS_ILOCK_EXCL); 768 return 0; 769 } 770 771 772 /* 773 * Go thru all the inodes in the file system, releasing their dquots. 774 * 775 * Note that the mount structure gets modified to indicate that quotas are off 776 * AFTER this, in the case of quotaoff. 777 */ 778 void 779 xfs_qm_dqrele_all_inodes( 780 struct xfs_mount *mp, 781 uint flags) 782 { 783 ASSERT(mp->m_quotainfo); 784 xfs_inode_ag_iterator_flags(mp, xfs_dqrele_inode, flags, NULL, 785 XFS_AGITER_INEW_WAIT); 786 } 787