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