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 #include "xfs.h" 19 #include "xfs_fs.h" 20 #include "xfs_bit.h" 21 #include "xfs_log.h" 22 #include "xfs_trans.h" 23 #include "xfs_sb.h" 24 #include "xfs_ag.h" 25 #include "xfs_alloc.h" 26 #include "xfs_quota.h" 27 #include "xfs_mount.h" 28 #include "xfs_bmap_btree.h" 29 #include "xfs_ialloc_btree.h" 30 #include "xfs_dinode.h" 31 #include "xfs_inode.h" 32 #include "xfs_ialloc.h" 33 #include "xfs_itable.h" 34 #include "xfs_rtalloc.h" 35 #include "xfs_error.h" 36 #include "xfs_bmap.h" 37 #include "xfs_attr.h" 38 #include "xfs_buf_item.h" 39 #include "xfs_trans_space.h" 40 #include "xfs_utils.h" 41 #include "xfs_qm.h" 42 #include "xfs_trace.h" 43 #include "xfs_icache.h" 44 45 /* 46 * The global quota manager. There is only one of these for the entire 47 * system, _not_ one per file system. XQM keeps track of the overall 48 * quota functionality, including maintaining the freelist and hash 49 * tables of dquots. 50 */ 51 STATIC int xfs_qm_init_quotainos(xfs_mount_t *); 52 STATIC int xfs_qm_init_quotainfo(xfs_mount_t *); 53 STATIC int xfs_qm_shake(struct shrinker *, struct shrink_control *); 54 55 /* 56 * We use the batch lookup interface to iterate over the dquots as it 57 * currently is the only interface into the radix tree code that allows 58 * fuzzy lookups instead of exact matches. Holding the lock over multiple 59 * operations is fine as all callers are used either during mount/umount 60 * or quotaoff. 61 */ 62 #define XFS_DQ_LOOKUP_BATCH 32 63 64 STATIC int 65 xfs_qm_dquot_walk( 66 struct xfs_mount *mp, 67 int type, 68 int (*execute)(struct xfs_dquot *dqp, void *data), 69 void *data) 70 { 71 struct xfs_quotainfo *qi = mp->m_quotainfo; 72 struct radix_tree_root *tree = XFS_DQUOT_TREE(qi, type); 73 uint32_t next_index; 74 int last_error = 0; 75 int skipped; 76 int nr_found; 77 78 restart: 79 skipped = 0; 80 next_index = 0; 81 nr_found = 0; 82 83 while (1) { 84 struct xfs_dquot *batch[XFS_DQ_LOOKUP_BATCH]; 85 int error = 0; 86 int i; 87 88 mutex_lock(&qi->qi_tree_lock); 89 nr_found = radix_tree_gang_lookup(tree, (void **)batch, 90 next_index, XFS_DQ_LOOKUP_BATCH); 91 if (!nr_found) { 92 mutex_unlock(&qi->qi_tree_lock); 93 break; 94 } 95 96 for (i = 0; i < nr_found; i++) { 97 struct xfs_dquot *dqp = batch[i]; 98 99 next_index = be32_to_cpu(dqp->q_core.d_id) + 1; 100 101 error = execute(batch[i], data); 102 if (error == EAGAIN) { 103 skipped++; 104 continue; 105 } 106 if (error && last_error != EFSCORRUPTED) 107 last_error = error; 108 } 109 110 mutex_unlock(&qi->qi_tree_lock); 111 112 /* bail out if the filesystem is corrupted. */ 113 if (last_error == EFSCORRUPTED) { 114 skipped = 0; 115 break; 116 } 117 } 118 119 if (skipped) { 120 delay(1); 121 goto restart; 122 } 123 124 return last_error; 125 } 126 127 128 /* 129 * Purge a dquot from all tracking data structures and free it. 130 */ 131 STATIC int 132 xfs_qm_dqpurge( 133 struct xfs_dquot *dqp, 134 void *data) 135 { 136 struct xfs_mount *mp = dqp->q_mount; 137 struct xfs_quotainfo *qi = mp->m_quotainfo; 138 struct xfs_dquot *gdqp = NULL; 139 140 xfs_dqlock(dqp); 141 if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0) { 142 xfs_dqunlock(dqp); 143 return EAGAIN; 144 } 145 146 /* 147 * If this quota has a group hint attached, prepare for releasing it 148 * now. 149 */ 150 gdqp = dqp->q_gdquot; 151 if (gdqp) { 152 xfs_dqlock(gdqp); 153 dqp->q_gdquot = NULL; 154 } 155 156 dqp->dq_flags |= XFS_DQ_FREEING; 157 158 xfs_dqflock(dqp); 159 160 /* 161 * If we are turning this type of quotas off, we don't care 162 * about the dirty metadata sitting in this dquot. OTOH, if 163 * we're unmounting, we do care, so we flush it and wait. 164 */ 165 if (XFS_DQ_IS_DIRTY(dqp)) { 166 struct xfs_buf *bp = NULL; 167 int error; 168 169 /* 170 * We don't care about getting disk errors here. We need 171 * to purge this dquot anyway, so we go ahead regardless. 172 */ 173 error = xfs_qm_dqflush(dqp, &bp); 174 if (error) { 175 xfs_warn(mp, "%s: dquot %p flush failed", 176 __func__, dqp); 177 } else { 178 error = xfs_bwrite(bp); 179 xfs_buf_relse(bp); 180 } 181 xfs_dqflock(dqp); 182 } 183 184 ASSERT(atomic_read(&dqp->q_pincount) == 0); 185 ASSERT(XFS_FORCED_SHUTDOWN(mp) || 186 !(dqp->q_logitem.qli_item.li_flags & XFS_LI_IN_AIL)); 187 188 xfs_dqfunlock(dqp); 189 xfs_dqunlock(dqp); 190 191 radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags), 192 be32_to_cpu(dqp->q_core.d_id)); 193 qi->qi_dquots--; 194 195 /* 196 * We move dquots to the freelist as soon as their reference count 197 * hits zero, so it really should be on the freelist here. 198 */ 199 mutex_lock(&qi->qi_lru_lock); 200 ASSERT(!list_empty(&dqp->q_lru)); 201 list_del_init(&dqp->q_lru); 202 qi->qi_lru_count--; 203 XFS_STATS_DEC(xs_qm_dquot_unused); 204 mutex_unlock(&qi->qi_lru_lock); 205 206 xfs_qm_dqdestroy(dqp); 207 208 if (gdqp) 209 xfs_qm_dqput(gdqp); 210 return 0; 211 } 212 213 /* 214 * Purge the dquot cache. 215 */ 216 void 217 xfs_qm_dqpurge_all( 218 struct xfs_mount *mp, 219 uint flags) 220 { 221 if (flags & XFS_QMOPT_UQUOTA) 222 xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL); 223 if (flags & XFS_QMOPT_GQUOTA) 224 xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL); 225 if (flags & XFS_QMOPT_PQUOTA) 226 xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL); 227 } 228 229 /* 230 * Just destroy the quotainfo structure. 231 */ 232 void 233 xfs_qm_unmount( 234 struct xfs_mount *mp) 235 { 236 if (mp->m_quotainfo) { 237 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL); 238 xfs_qm_destroy_quotainfo(mp); 239 } 240 } 241 242 243 /* 244 * This is called from xfs_mountfs to start quotas and initialize all 245 * necessary data structures like quotainfo. This is also responsible for 246 * running a quotacheck as necessary. We are guaranteed that the superblock 247 * is consistently read in at this point. 248 * 249 * If we fail here, the mount will continue with quota turned off. We don't 250 * need to inidicate success or failure at all. 251 */ 252 void 253 xfs_qm_mount_quotas( 254 xfs_mount_t *mp) 255 { 256 int error = 0; 257 uint sbf; 258 259 /* 260 * If quotas on realtime volumes is not supported, we disable 261 * quotas immediately. 262 */ 263 if (mp->m_sb.sb_rextents) { 264 xfs_notice(mp, "Cannot turn on quotas for realtime filesystem"); 265 mp->m_qflags = 0; 266 goto write_changes; 267 } 268 269 ASSERT(XFS_IS_QUOTA_RUNNING(mp)); 270 271 /* 272 * Allocate the quotainfo structure inside the mount struct, and 273 * create quotainode(s), and change/rev superblock if necessary. 274 */ 275 error = xfs_qm_init_quotainfo(mp); 276 if (error) { 277 /* 278 * We must turn off quotas. 279 */ 280 ASSERT(mp->m_quotainfo == NULL); 281 mp->m_qflags = 0; 282 goto write_changes; 283 } 284 /* 285 * If any of the quotas are not consistent, do a quotacheck. 286 */ 287 if (XFS_QM_NEED_QUOTACHECK(mp)) { 288 error = xfs_qm_quotacheck(mp); 289 if (error) { 290 /* Quotacheck failed and disabled quotas. */ 291 return; 292 } 293 } 294 /* 295 * If one type of quotas is off, then it will lose its 296 * quotachecked status, since we won't be doing accounting for 297 * that type anymore. 298 */ 299 if (!XFS_IS_UQUOTA_ON(mp)) 300 mp->m_qflags &= ~XFS_UQUOTA_CHKD; 301 if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp))) 302 mp->m_qflags &= ~XFS_OQUOTA_CHKD; 303 304 write_changes: 305 /* 306 * We actually don't have to acquire the m_sb_lock at all. 307 * This can only be called from mount, and that's single threaded. XXX 308 */ 309 spin_lock(&mp->m_sb_lock); 310 sbf = mp->m_sb.sb_qflags; 311 mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL; 312 spin_unlock(&mp->m_sb_lock); 313 314 if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) { 315 if (xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS)) { 316 /* 317 * We could only have been turning quotas off. 318 * We aren't in very good shape actually because 319 * the incore structures are convinced that quotas are 320 * off, but the on disk superblock doesn't know that ! 321 */ 322 ASSERT(!(XFS_IS_QUOTA_RUNNING(mp))); 323 xfs_alert(mp, "%s: Superblock update failed!", 324 __func__); 325 } 326 } 327 328 if (error) { 329 xfs_warn(mp, "Failed to initialize disk quotas."); 330 return; 331 } 332 } 333 334 /* 335 * Called from the vfsops layer. 336 */ 337 void 338 xfs_qm_unmount_quotas( 339 xfs_mount_t *mp) 340 { 341 /* 342 * Release the dquots that root inode, et al might be holding, 343 * before we flush quotas and blow away the quotainfo structure. 344 */ 345 ASSERT(mp->m_rootip); 346 xfs_qm_dqdetach(mp->m_rootip); 347 if (mp->m_rbmip) 348 xfs_qm_dqdetach(mp->m_rbmip); 349 if (mp->m_rsumip) 350 xfs_qm_dqdetach(mp->m_rsumip); 351 352 /* 353 * Release the quota inodes. 354 */ 355 if (mp->m_quotainfo) { 356 if (mp->m_quotainfo->qi_uquotaip) { 357 IRELE(mp->m_quotainfo->qi_uquotaip); 358 mp->m_quotainfo->qi_uquotaip = NULL; 359 } 360 if (mp->m_quotainfo->qi_gquotaip) { 361 IRELE(mp->m_quotainfo->qi_gquotaip); 362 mp->m_quotainfo->qi_gquotaip = NULL; 363 } 364 } 365 } 366 367 STATIC int 368 xfs_qm_dqattach_one( 369 xfs_inode_t *ip, 370 xfs_dqid_t id, 371 uint type, 372 uint doalloc, 373 xfs_dquot_t *udqhint, /* hint */ 374 xfs_dquot_t **IO_idqpp) 375 { 376 xfs_dquot_t *dqp; 377 int error; 378 379 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 380 error = 0; 381 382 /* 383 * See if we already have it in the inode itself. IO_idqpp is 384 * &i_udquot or &i_gdquot. This made the code look weird, but 385 * made the logic a lot simpler. 386 */ 387 dqp = *IO_idqpp; 388 if (dqp) { 389 trace_xfs_dqattach_found(dqp); 390 return 0; 391 } 392 393 /* 394 * udqhint is the i_udquot field in inode, and is non-NULL only 395 * when the type arg is group/project. Its purpose is to save a 396 * lookup by dqid (xfs_qm_dqget) by caching a group dquot inside 397 * the user dquot. 398 */ 399 if (udqhint) { 400 ASSERT(type == XFS_DQ_GROUP || type == XFS_DQ_PROJ); 401 xfs_dqlock(udqhint); 402 403 /* 404 * No need to take dqlock to look at the id. 405 * 406 * The ID can't change until it gets reclaimed, and it won't 407 * be reclaimed as long as we have a ref from inode and we 408 * hold the ilock. 409 */ 410 dqp = udqhint->q_gdquot; 411 if (dqp && be32_to_cpu(dqp->q_core.d_id) == id) { 412 ASSERT(*IO_idqpp == NULL); 413 414 *IO_idqpp = xfs_qm_dqhold(dqp); 415 xfs_dqunlock(udqhint); 416 return 0; 417 } 418 419 /* 420 * We can't hold a dquot lock when we call the dqget code. 421 * We'll deadlock in no time, because of (not conforming to) 422 * lock ordering - the inodelock comes before any dquot lock, 423 * and we may drop and reacquire the ilock in xfs_qm_dqget(). 424 */ 425 xfs_dqunlock(udqhint); 426 } 427 428 /* 429 * Find the dquot from somewhere. This bumps the 430 * reference count of dquot and returns it locked. 431 * This can return ENOENT if dquot didn't exist on 432 * disk and we didn't ask it to allocate; 433 * ESRCH if quotas got turned off suddenly. 434 */ 435 error = xfs_qm_dqget(ip->i_mount, ip, id, type, 436 doalloc | XFS_QMOPT_DOWARN, &dqp); 437 if (error) 438 return error; 439 440 trace_xfs_dqattach_get(dqp); 441 442 /* 443 * dqget may have dropped and re-acquired the ilock, but it guarantees 444 * that the dquot returned is the one that should go in the inode. 445 */ 446 *IO_idqpp = dqp; 447 xfs_dqunlock(dqp); 448 return 0; 449 } 450 451 452 /* 453 * Given a udquot and gdquot, attach a ptr to the group dquot in the 454 * udquot as a hint for future lookups. 455 */ 456 STATIC void 457 xfs_qm_dqattach_grouphint( 458 xfs_dquot_t *udq, 459 xfs_dquot_t *gdq) 460 { 461 xfs_dquot_t *tmp; 462 463 xfs_dqlock(udq); 464 465 tmp = udq->q_gdquot; 466 if (tmp) { 467 if (tmp == gdq) 468 goto done; 469 470 udq->q_gdquot = NULL; 471 xfs_qm_dqrele(tmp); 472 } 473 474 udq->q_gdquot = xfs_qm_dqhold(gdq); 475 done: 476 xfs_dqunlock(udq); 477 } 478 479 static bool 480 xfs_qm_need_dqattach( 481 struct xfs_inode *ip) 482 { 483 struct xfs_mount *mp = ip->i_mount; 484 485 if (!XFS_IS_QUOTA_RUNNING(mp)) 486 return false; 487 if (!XFS_IS_QUOTA_ON(mp)) 488 return false; 489 if (!XFS_NOT_DQATTACHED(mp, ip)) 490 return false; 491 if (ip->i_ino == mp->m_sb.sb_uquotino || 492 ip->i_ino == mp->m_sb.sb_gquotino) 493 return false; 494 return true; 495 } 496 497 /* 498 * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON 499 * into account. 500 * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed. 501 * Inode may get unlocked and relocked in here, and the caller must deal with 502 * the consequences. 503 */ 504 int 505 xfs_qm_dqattach_locked( 506 xfs_inode_t *ip, 507 uint flags) 508 { 509 xfs_mount_t *mp = ip->i_mount; 510 uint nquotas = 0; 511 int error = 0; 512 513 if (!xfs_qm_need_dqattach(ip)) 514 return 0; 515 516 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 517 518 if (XFS_IS_UQUOTA_ON(mp)) { 519 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER, 520 flags & XFS_QMOPT_DQALLOC, 521 NULL, &ip->i_udquot); 522 if (error) 523 goto done; 524 nquotas++; 525 } 526 527 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 528 if (XFS_IS_OQUOTA_ON(mp)) { 529 error = XFS_IS_GQUOTA_ON(mp) ? 530 xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP, 531 flags & XFS_QMOPT_DQALLOC, 532 ip->i_udquot, &ip->i_gdquot) : 533 xfs_qm_dqattach_one(ip, xfs_get_projid(ip), XFS_DQ_PROJ, 534 flags & XFS_QMOPT_DQALLOC, 535 ip->i_udquot, &ip->i_gdquot); 536 /* 537 * Don't worry about the udquot that we may have 538 * attached above. It'll get detached, if not already. 539 */ 540 if (error) 541 goto done; 542 nquotas++; 543 } 544 545 /* 546 * Attach this group quota to the user quota as a hint. 547 * This WON'T, in general, result in a thrash. 548 */ 549 if (nquotas == 2) { 550 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 551 ASSERT(ip->i_udquot); 552 ASSERT(ip->i_gdquot); 553 554 /* 555 * We do not have i_udquot locked at this point, but this check 556 * is OK since we don't depend on the i_gdquot to be accurate 557 * 100% all the time. It is just a hint, and this will 558 * succeed in general. 559 */ 560 if (ip->i_udquot->q_gdquot != ip->i_gdquot) 561 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot); 562 } 563 564 done: 565 #ifdef DEBUG 566 if (!error) { 567 if (XFS_IS_UQUOTA_ON(mp)) 568 ASSERT(ip->i_udquot); 569 if (XFS_IS_OQUOTA_ON(mp)) 570 ASSERT(ip->i_gdquot); 571 } 572 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 573 #endif 574 return error; 575 } 576 577 int 578 xfs_qm_dqattach( 579 struct xfs_inode *ip, 580 uint flags) 581 { 582 int error; 583 584 if (!xfs_qm_need_dqattach(ip)) 585 return 0; 586 587 xfs_ilock(ip, XFS_ILOCK_EXCL); 588 error = xfs_qm_dqattach_locked(ip, flags); 589 xfs_iunlock(ip, XFS_ILOCK_EXCL); 590 591 return error; 592 } 593 594 /* 595 * Release dquots (and their references) if any. 596 * The inode should be locked EXCL except when this's called by 597 * xfs_ireclaim. 598 */ 599 void 600 xfs_qm_dqdetach( 601 xfs_inode_t *ip) 602 { 603 if (!(ip->i_udquot || ip->i_gdquot)) 604 return; 605 606 trace_xfs_dquot_dqdetach(ip); 607 608 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino); 609 ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino); 610 if (ip->i_udquot) { 611 xfs_qm_dqrele(ip->i_udquot); 612 ip->i_udquot = NULL; 613 } 614 if (ip->i_gdquot) { 615 xfs_qm_dqrele(ip->i_gdquot); 616 ip->i_gdquot = NULL; 617 } 618 } 619 620 int 621 xfs_qm_calc_dquots_per_chunk( 622 struct xfs_mount *mp, 623 unsigned int nbblks) /* basic block units */ 624 { 625 unsigned int ndquots; 626 627 ASSERT(nbblks > 0); 628 ndquots = BBTOB(nbblks); 629 do_div(ndquots, sizeof(xfs_dqblk_t)); 630 631 return ndquots; 632 } 633 634 /* 635 * This initializes all the quota information that's kept in the 636 * mount structure 637 */ 638 STATIC int 639 xfs_qm_init_quotainfo( 640 xfs_mount_t *mp) 641 { 642 xfs_quotainfo_t *qinf; 643 int error; 644 xfs_dquot_t *dqp; 645 646 ASSERT(XFS_IS_QUOTA_RUNNING(mp)); 647 648 qinf = mp->m_quotainfo = kmem_zalloc(sizeof(xfs_quotainfo_t), KM_SLEEP); 649 650 /* 651 * See if quotainodes are setup, and if not, allocate them, 652 * and change the superblock accordingly. 653 */ 654 if ((error = xfs_qm_init_quotainos(mp))) { 655 kmem_free(qinf); 656 mp->m_quotainfo = NULL; 657 return error; 658 } 659 660 INIT_RADIX_TREE(&qinf->qi_uquota_tree, GFP_NOFS); 661 INIT_RADIX_TREE(&qinf->qi_gquota_tree, GFP_NOFS); 662 mutex_init(&qinf->qi_tree_lock); 663 664 INIT_LIST_HEAD(&qinf->qi_lru_list); 665 qinf->qi_lru_count = 0; 666 mutex_init(&qinf->qi_lru_lock); 667 668 /* mutex used to serialize quotaoffs */ 669 mutex_init(&qinf->qi_quotaofflock); 670 671 /* Precalc some constants */ 672 qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB); 673 qinf->qi_dqperchunk = xfs_qm_calc_dquots_per_chunk(mp, 674 qinf->qi_dqchunklen); 675 676 mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD); 677 678 /* 679 * We try to get the limits from the superuser's limits fields. 680 * This is quite hacky, but it is standard quota practice. 681 * 682 * We look at the USR dquot with id == 0 first, but if user quotas 683 * are not enabled we goto the GRP dquot with id == 0. 684 * We don't really care to keep separate default limits for user 685 * and group quotas, at least not at this point. 686 * 687 * Since we may not have done a quotacheck by this point, just read 688 * the dquot without attaching it to any hashtables or lists. 689 */ 690 error = xfs_qm_dqread(mp, 0, 691 XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER : 692 (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP : 693 XFS_DQ_PROJ), 694 XFS_QMOPT_DOWARN, &dqp); 695 if (!error) { 696 xfs_disk_dquot_t *ddqp = &dqp->q_core; 697 698 /* 699 * The warnings and timers set the grace period given to 700 * a user or group before he or she can not perform any 701 * more writing. If it is zero, a default is used. 702 */ 703 qinf->qi_btimelimit = ddqp->d_btimer ? 704 be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT; 705 qinf->qi_itimelimit = ddqp->d_itimer ? 706 be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT; 707 qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ? 708 be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT; 709 qinf->qi_bwarnlimit = ddqp->d_bwarns ? 710 be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT; 711 qinf->qi_iwarnlimit = ddqp->d_iwarns ? 712 be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT; 713 qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ? 714 be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT; 715 qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit); 716 qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit); 717 qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit); 718 qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit); 719 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit); 720 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit); 721 722 xfs_qm_dqdestroy(dqp); 723 } else { 724 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT; 725 qinf->qi_itimelimit = XFS_QM_ITIMELIMIT; 726 qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT; 727 qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT; 728 qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT; 729 qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT; 730 } 731 732 qinf->qi_shrinker.shrink = xfs_qm_shake; 733 qinf->qi_shrinker.seeks = DEFAULT_SEEKS; 734 register_shrinker(&qinf->qi_shrinker); 735 return 0; 736 } 737 738 739 /* 740 * Gets called when unmounting a filesystem or when all quotas get 741 * turned off. 742 * This purges the quota inodes, destroys locks and frees itself. 743 */ 744 void 745 xfs_qm_destroy_quotainfo( 746 xfs_mount_t *mp) 747 { 748 xfs_quotainfo_t *qi; 749 750 qi = mp->m_quotainfo; 751 ASSERT(qi != NULL); 752 753 unregister_shrinker(&qi->qi_shrinker); 754 755 if (qi->qi_uquotaip) { 756 IRELE(qi->qi_uquotaip); 757 qi->qi_uquotaip = NULL; /* paranoia */ 758 } 759 if (qi->qi_gquotaip) { 760 IRELE(qi->qi_gquotaip); 761 qi->qi_gquotaip = NULL; 762 } 763 mutex_destroy(&qi->qi_quotaofflock); 764 kmem_free(qi); 765 mp->m_quotainfo = NULL; 766 } 767 768 /* 769 * Create an inode and return with a reference already taken, but unlocked 770 * This is how we create quota inodes 771 */ 772 STATIC int 773 xfs_qm_qino_alloc( 774 xfs_mount_t *mp, 775 xfs_inode_t **ip, 776 __int64_t sbfields, 777 uint flags) 778 { 779 xfs_trans_t *tp; 780 int error; 781 int committed; 782 783 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QINOCREATE); 784 if ((error = xfs_trans_reserve(tp, 785 XFS_QM_QINOCREATE_SPACE_RES(mp), 786 XFS_CREATE_LOG_RES(mp), 0, 787 XFS_TRANS_PERM_LOG_RES, 788 XFS_CREATE_LOG_COUNT))) { 789 xfs_trans_cancel(tp, 0); 790 return error; 791 } 792 793 error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, 1, ip, &committed); 794 if (error) { 795 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | 796 XFS_TRANS_ABORT); 797 return error; 798 } 799 800 /* 801 * Make the changes in the superblock, and log those too. 802 * sbfields arg may contain fields other than *QUOTINO; 803 * VERSIONNUM for example. 804 */ 805 spin_lock(&mp->m_sb_lock); 806 if (flags & XFS_QMOPT_SBVERSION) { 807 ASSERT(!xfs_sb_version_hasquota(&mp->m_sb)); 808 ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO | 809 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) == 810 (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO | 811 XFS_SB_GQUOTINO | XFS_SB_QFLAGS)); 812 813 xfs_sb_version_addquota(&mp->m_sb); 814 mp->m_sb.sb_uquotino = NULLFSINO; 815 mp->m_sb.sb_gquotino = NULLFSINO; 816 817 /* qflags will get updated _after_ quotacheck */ 818 mp->m_sb.sb_qflags = 0; 819 } 820 if (flags & XFS_QMOPT_UQUOTA) 821 mp->m_sb.sb_uquotino = (*ip)->i_ino; 822 else 823 mp->m_sb.sb_gquotino = (*ip)->i_ino; 824 spin_unlock(&mp->m_sb_lock); 825 xfs_mod_sb(tp, sbfields); 826 827 if ((error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES))) { 828 xfs_alert(mp, "%s failed (error %d)!", __func__, error); 829 return error; 830 } 831 return 0; 832 } 833 834 835 STATIC void 836 xfs_qm_reset_dqcounts( 837 xfs_mount_t *mp, 838 xfs_buf_t *bp, 839 xfs_dqid_t id, 840 uint type) 841 { 842 xfs_disk_dquot_t *ddq; 843 int j; 844 845 trace_xfs_reset_dqcounts(bp, _RET_IP_); 846 847 /* 848 * Reset all counters and timers. They'll be 849 * started afresh by xfs_qm_quotacheck. 850 */ 851 #ifdef DEBUG 852 j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB); 853 do_div(j, sizeof(xfs_dqblk_t)); 854 ASSERT(mp->m_quotainfo->qi_dqperchunk == j); 855 #endif 856 ddq = bp->b_addr; 857 for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) { 858 /* 859 * Do a sanity check, and if needed, repair the dqblk. Don't 860 * output any warnings because it's perfectly possible to 861 * find uninitialised dquot blks. See comment in xfs_qm_dqcheck. 862 */ 863 (void) xfs_qm_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR, 864 "xfs_quotacheck"); 865 ddq->d_bcount = 0; 866 ddq->d_icount = 0; 867 ddq->d_rtbcount = 0; 868 ddq->d_btimer = 0; 869 ddq->d_itimer = 0; 870 ddq->d_rtbtimer = 0; 871 ddq->d_bwarns = 0; 872 ddq->d_iwarns = 0; 873 ddq->d_rtbwarns = 0; 874 ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1); 875 } 876 } 877 878 STATIC int 879 xfs_qm_dqiter_bufs( 880 struct xfs_mount *mp, 881 xfs_dqid_t firstid, 882 xfs_fsblock_t bno, 883 xfs_filblks_t blkcnt, 884 uint flags, 885 struct list_head *buffer_list) 886 { 887 struct xfs_buf *bp; 888 int error; 889 int type; 890 891 ASSERT(blkcnt > 0); 892 type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER : 893 (flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP); 894 error = 0; 895 896 /* 897 * Blkcnt arg can be a very big number, and might even be 898 * larger than the log itself. So, we have to break it up into 899 * manageable-sized transactions. 900 * Note that we don't start a permanent transaction here; we might 901 * not be able to get a log reservation for the whole thing up front, 902 * and we don't really care to either, because we just discard 903 * everything if we were to crash in the middle of this loop. 904 */ 905 while (blkcnt--) { 906 error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, 907 XFS_FSB_TO_DADDR(mp, bno), 908 mp->m_quotainfo->qi_dqchunklen, 0, &bp, 909 &xfs_dquot_buf_ops); 910 if (error) 911 break; 912 913 /* 914 * XXX(hch): need to figure out if it makes sense to validate 915 * the CRC here. 916 */ 917 xfs_qm_reset_dqcounts(mp, bp, firstid, type); 918 xfs_buf_delwri_queue(bp, buffer_list); 919 xfs_buf_relse(bp); 920 /* 921 * goto the next block. 922 */ 923 bno++; 924 firstid += mp->m_quotainfo->qi_dqperchunk; 925 } 926 927 return error; 928 } 929 930 /* 931 * Iterate over all allocated USR/GRP/PRJ dquots in the system, calling a 932 * caller supplied function for every chunk of dquots that we find. 933 */ 934 STATIC int 935 xfs_qm_dqiterate( 936 struct xfs_mount *mp, 937 struct xfs_inode *qip, 938 uint flags, 939 struct list_head *buffer_list) 940 { 941 struct xfs_bmbt_irec *map; 942 int i, nmaps; /* number of map entries */ 943 int error; /* return value */ 944 xfs_fileoff_t lblkno; 945 xfs_filblks_t maxlblkcnt; 946 xfs_dqid_t firstid; 947 xfs_fsblock_t rablkno; 948 xfs_filblks_t rablkcnt; 949 950 error = 0; 951 /* 952 * This looks racy, but we can't keep an inode lock across a 953 * trans_reserve. But, this gets called during quotacheck, and that 954 * happens only at mount time which is single threaded. 955 */ 956 if (qip->i_d.di_nblocks == 0) 957 return 0; 958 959 map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), KM_SLEEP); 960 961 lblkno = 0; 962 maxlblkcnt = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes); 963 do { 964 nmaps = XFS_DQITER_MAP_SIZE; 965 /* 966 * We aren't changing the inode itself. Just changing 967 * some of its data. No new blocks are added here, and 968 * the inode is never added to the transaction. 969 */ 970 xfs_ilock(qip, XFS_ILOCK_SHARED); 971 error = xfs_bmapi_read(qip, lblkno, maxlblkcnt - lblkno, 972 map, &nmaps, 0); 973 xfs_iunlock(qip, XFS_ILOCK_SHARED); 974 if (error) 975 break; 976 977 ASSERT(nmaps <= XFS_DQITER_MAP_SIZE); 978 for (i = 0; i < nmaps; i++) { 979 ASSERT(map[i].br_startblock != DELAYSTARTBLOCK); 980 ASSERT(map[i].br_blockcount); 981 982 983 lblkno += map[i].br_blockcount; 984 985 if (map[i].br_startblock == HOLESTARTBLOCK) 986 continue; 987 988 firstid = (xfs_dqid_t) map[i].br_startoff * 989 mp->m_quotainfo->qi_dqperchunk; 990 /* 991 * Do a read-ahead on the next extent. 992 */ 993 if ((i+1 < nmaps) && 994 (map[i+1].br_startblock != HOLESTARTBLOCK)) { 995 rablkcnt = map[i+1].br_blockcount; 996 rablkno = map[i+1].br_startblock; 997 while (rablkcnt--) { 998 xfs_buf_readahead(mp->m_ddev_targp, 999 XFS_FSB_TO_DADDR(mp, rablkno), 1000 mp->m_quotainfo->qi_dqchunklen, 1001 NULL); 1002 rablkno++; 1003 } 1004 } 1005 /* 1006 * Iterate thru all the blks in the extent and 1007 * reset the counters of all the dquots inside them. 1008 */ 1009 error = xfs_qm_dqiter_bufs(mp, firstid, 1010 map[i].br_startblock, 1011 map[i].br_blockcount, 1012 flags, buffer_list); 1013 if (error) 1014 goto out; 1015 } 1016 } while (nmaps > 0); 1017 1018 out: 1019 kmem_free(map); 1020 return error; 1021 } 1022 1023 /* 1024 * Called by dqusage_adjust in doing a quotacheck. 1025 * 1026 * Given the inode, and a dquot id this updates both the incore dqout as well 1027 * as the buffer copy. This is so that once the quotacheck is done, we can 1028 * just log all the buffers, as opposed to logging numerous updates to 1029 * individual dquots. 1030 */ 1031 STATIC int 1032 xfs_qm_quotacheck_dqadjust( 1033 struct xfs_inode *ip, 1034 xfs_dqid_t id, 1035 uint type, 1036 xfs_qcnt_t nblks, 1037 xfs_qcnt_t rtblks) 1038 { 1039 struct xfs_mount *mp = ip->i_mount; 1040 struct xfs_dquot *dqp; 1041 int error; 1042 1043 error = xfs_qm_dqget(mp, ip, id, type, 1044 XFS_QMOPT_DQALLOC | XFS_QMOPT_DOWARN, &dqp); 1045 if (error) { 1046 /* 1047 * Shouldn't be able to turn off quotas here. 1048 */ 1049 ASSERT(error != ESRCH); 1050 ASSERT(error != ENOENT); 1051 return error; 1052 } 1053 1054 trace_xfs_dqadjust(dqp); 1055 1056 /* 1057 * Adjust the inode count and the block count to reflect this inode's 1058 * resource usage. 1059 */ 1060 be64_add_cpu(&dqp->q_core.d_icount, 1); 1061 dqp->q_res_icount++; 1062 if (nblks) { 1063 be64_add_cpu(&dqp->q_core.d_bcount, nblks); 1064 dqp->q_res_bcount += nblks; 1065 } 1066 if (rtblks) { 1067 be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks); 1068 dqp->q_res_rtbcount += rtblks; 1069 } 1070 1071 /* 1072 * Set default limits, adjust timers (since we changed usages) 1073 * 1074 * There are no timers for the default values set in the root dquot. 1075 */ 1076 if (dqp->q_core.d_id) { 1077 xfs_qm_adjust_dqlimits(mp, dqp); 1078 xfs_qm_adjust_dqtimers(mp, &dqp->q_core); 1079 } 1080 1081 dqp->dq_flags |= XFS_DQ_DIRTY; 1082 xfs_qm_dqput(dqp); 1083 return 0; 1084 } 1085 1086 STATIC int 1087 xfs_qm_get_rtblks( 1088 xfs_inode_t *ip, 1089 xfs_qcnt_t *O_rtblks) 1090 { 1091 xfs_filblks_t rtblks; /* total rt blks */ 1092 xfs_extnum_t idx; /* extent record index */ 1093 xfs_ifork_t *ifp; /* inode fork pointer */ 1094 xfs_extnum_t nextents; /* number of extent entries */ 1095 int error; 1096 1097 ASSERT(XFS_IS_REALTIME_INODE(ip)); 1098 ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK); 1099 if (!(ifp->if_flags & XFS_IFEXTENTS)) { 1100 if ((error = xfs_iread_extents(NULL, ip, XFS_DATA_FORK))) 1101 return error; 1102 } 1103 rtblks = 0; 1104 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t); 1105 for (idx = 0; idx < nextents; idx++) 1106 rtblks += xfs_bmbt_get_blockcount(xfs_iext_get_ext(ifp, idx)); 1107 *O_rtblks = (xfs_qcnt_t)rtblks; 1108 return 0; 1109 } 1110 1111 /* 1112 * callback routine supplied to bulkstat(). Given an inumber, find its 1113 * dquots and update them to account for resources taken by that inode. 1114 */ 1115 /* ARGSUSED */ 1116 STATIC int 1117 xfs_qm_dqusage_adjust( 1118 xfs_mount_t *mp, /* mount point for filesystem */ 1119 xfs_ino_t ino, /* inode number to get data for */ 1120 void __user *buffer, /* not used */ 1121 int ubsize, /* not used */ 1122 int *ubused, /* not used */ 1123 int *res) /* result code value */ 1124 { 1125 xfs_inode_t *ip; 1126 xfs_qcnt_t nblks, rtblks = 0; 1127 int error; 1128 1129 ASSERT(XFS_IS_QUOTA_RUNNING(mp)); 1130 1131 /* 1132 * rootino must have its resources accounted for, not so with the quota 1133 * inodes. 1134 */ 1135 if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) { 1136 *res = BULKSTAT_RV_NOTHING; 1137 return XFS_ERROR(EINVAL); 1138 } 1139 1140 /* 1141 * We don't _need_ to take the ilock EXCL. However, the xfs_qm_dqget 1142 * interface expects the inode to be exclusively locked because that's 1143 * the case in all other instances. It's OK that we do this because 1144 * quotacheck is done only at mount time. 1145 */ 1146 error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_EXCL, &ip); 1147 if (error) { 1148 *res = BULKSTAT_RV_NOTHING; 1149 return error; 1150 } 1151 1152 ASSERT(ip->i_delayed_blks == 0); 1153 1154 if (XFS_IS_REALTIME_INODE(ip)) { 1155 /* 1156 * Walk thru the extent list and count the realtime blocks. 1157 */ 1158 error = xfs_qm_get_rtblks(ip, &rtblks); 1159 if (error) 1160 goto error0; 1161 } 1162 1163 nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks; 1164 1165 /* 1166 * Add the (disk blocks and inode) resources occupied by this 1167 * inode to its dquots. We do this adjustment in the incore dquot, 1168 * and also copy the changes to its buffer. 1169 * We don't care about putting these changes in a transaction 1170 * envelope because if we crash in the middle of a 'quotacheck' 1171 * we have to start from the beginning anyway. 1172 * Once we're done, we'll log all the dquot bufs. 1173 * 1174 * The *QUOTA_ON checks below may look pretty racy, but quotachecks 1175 * and quotaoffs don't race. (Quotachecks happen at mount time only). 1176 */ 1177 if (XFS_IS_UQUOTA_ON(mp)) { 1178 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_uid, 1179 XFS_DQ_USER, nblks, rtblks); 1180 if (error) 1181 goto error0; 1182 } 1183 1184 if (XFS_IS_GQUOTA_ON(mp)) { 1185 error = xfs_qm_quotacheck_dqadjust(ip, ip->i_d.di_gid, 1186 XFS_DQ_GROUP, nblks, rtblks); 1187 if (error) 1188 goto error0; 1189 } 1190 1191 if (XFS_IS_PQUOTA_ON(mp)) { 1192 error = xfs_qm_quotacheck_dqadjust(ip, xfs_get_projid(ip), 1193 XFS_DQ_PROJ, nblks, rtblks); 1194 if (error) 1195 goto error0; 1196 } 1197 1198 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1199 IRELE(ip); 1200 *res = BULKSTAT_RV_DIDONE; 1201 return 0; 1202 1203 error0: 1204 xfs_iunlock(ip, XFS_ILOCK_EXCL); 1205 IRELE(ip); 1206 *res = BULKSTAT_RV_GIVEUP; 1207 return error; 1208 } 1209 1210 STATIC int 1211 xfs_qm_flush_one( 1212 struct xfs_dquot *dqp, 1213 void *data) 1214 { 1215 struct list_head *buffer_list = data; 1216 struct xfs_buf *bp = NULL; 1217 int error = 0; 1218 1219 xfs_dqlock(dqp); 1220 if (dqp->dq_flags & XFS_DQ_FREEING) 1221 goto out_unlock; 1222 if (!XFS_DQ_IS_DIRTY(dqp)) 1223 goto out_unlock; 1224 1225 xfs_dqflock(dqp); 1226 error = xfs_qm_dqflush(dqp, &bp); 1227 if (error) 1228 goto out_unlock; 1229 1230 xfs_buf_delwri_queue(bp, buffer_list); 1231 xfs_buf_relse(bp); 1232 out_unlock: 1233 xfs_dqunlock(dqp); 1234 return error; 1235 } 1236 1237 /* 1238 * Walk thru all the filesystem inodes and construct a consistent view 1239 * of the disk quota world. If the quotacheck fails, disable quotas. 1240 */ 1241 int 1242 xfs_qm_quotacheck( 1243 xfs_mount_t *mp) 1244 { 1245 int done, count, error, error2; 1246 xfs_ino_t lastino; 1247 size_t structsz; 1248 xfs_inode_t *uip, *gip; 1249 uint flags; 1250 LIST_HEAD (buffer_list); 1251 1252 count = INT_MAX; 1253 structsz = 1; 1254 lastino = 0; 1255 flags = 0; 1256 1257 ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip); 1258 ASSERT(XFS_IS_QUOTA_RUNNING(mp)); 1259 1260 xfs_notice(mp, "Quotacheck needed: Please wait."); 1261 1262 /* 1263 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset 1264 * their counters to zero. We need a clean slate. 1265 * We don't log our changes till later. 1266 */ 1267 uip = mp->m_quotainfo->qi_uquotaip; 1268 if (uip) { 1269 error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA, 1270 &buffer_list); 1271 if (error) 1272 goto error_return; 1273 flags |= XFS_UQUOTA_CHKD; 1274 } 1275 1276 gip = mp->m_quotainfo->qi_gquotaip; 1277 if (gip) { 1278 error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ? 1279 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA, 1280 &buffer_list); 1281 if (error) 1282 goto error_return; 1283 flags |= XFS_OQUOTA_CHKD; 1284 } 1285 1286 do { 1287 /* 1288 * Iterate thru all the inodes in the file system, 1289 * adjusting the corresponding dquot counters in core. 1290 */ 1291 error = xfs_bulkstat(mp, &lastino, &count, 1292 xfs_qm_dqusage_adjust, 1293 structsz, NULL, &done); 1294 if (error) 1295 break; 1296 1297 } while (!done); 1298 1299 /* 1300 * We've made all the changes that we need to make incore. Flush them 1301 * down to disk buffers if everything was updated successfully. 1302 */ 1303 if (XFS_IS_UQUOTA_ON(mp)) { 1304 error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one, 1305 &buffer_list); 1306 } 1307 if (XFS_IS_GQUOTA_ON(mp)) { 1308 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one, 1309 &buffer_list); 1310 if (!error) 1311 error = error2; 1312 } 1313 if (XFS_IS_PQUOTA_ON(mp)) { 1314 error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one, 1315 &buffer_list); 1316 if (!error) 1317 error = error2; 1318 } 1319 1320 error2 = xfs_buf_delwri_submit(&buffer_list); 1321 if (!error) 1322 error = error2; 1323 1324 /* 1325 * We can get this error if we couldn't do a dquot allocation inside 1326 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the 1327 * dirty dquots that might be cached, we just want to get rid of them 1328 * and turn quotaoff. The dquots won't be attached to any of the inodes 1329 * at this point (because we intentionally didn't in dqget_noattach). 1330 */ 1331 if (error) { 1332 xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL); 1333 goto error_return; 1334 } 1335 1336 /* 1337 * If one type of quotas is off, then it will lose its 1338 * quotachecked status, since we won't be doing accounting for 1339 * that type anymore. 1340 */ 1341 mp->m_qflags &= ~XFS_ALL_QUOTA_CHKD; 1342 mp->m_qflags |= flags; 1343 1344 error_return: 1345 while (!list_empty(&buffer_list)) { 1346 struct xfs_buf *bp = 1347 list_first_entry(&buffer_list, struct xfs_buf, b_list); 1348 list_del_init(&bp->b_list); 1349 xfs_buf_relse(bp); 1350 } 1351 1352 if (error) { 1353 xfs_warn(mp, 1354 "Quotacheck: Unsuccessful (Error %d): Disabling quotas.", 1355 error); 1356 /* 1357 * We must turn off quotas. 1358 */ 1359 ASSERT(mp->m_quotainfo != NULL); 1360 xfs_qm_destroy_quotainfo(mp); 1361 if (xfs_mount_reset_sbqflags(mp)) { 1362 xfs_warn(mp, 1363 "Quotacheck: Failed to reset quota flags."); 1364 } 1365 } else 1366 xfs_notice(mp, "Quotacheck: Done."); 1367 return (error); 1368 } 1369 1370 /* 1371 * This is called after the superblock has been read in and we're ready to 1372 * iget the quota inodes. 1373 */ 1374 STATIC int 1375 xfs_qm_init_quotainos( 1376 xfs_mount_t *mp) 1377 { 1378 xfs_inode_t *uip, *gip; 1379 int error; 1380 __int64_t sbflags; 1381 uint flags; 1382 1383 ASSERT(mp->m_quotainfo); 1384 uip = gip = NULL; 1385 sbflags = 0; 1386 flags = 0; 1387 1388 /* 1389 * Get the uquota and gquota inodes 1390 */ 1391 if (xfs_sb_version_hasquota(&mp->m_sb)) { 1392 if (XFS_IS_UQUOTA_ON(mp) && 1393 mp->m_sb.sb_uquotino != NULLFSINO) { 1394 ASSERT(mp->m_sb.sb_uquotino > 0); 1395 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino, 1396 0, 0, &uip))) 1397 return XFS_ERROR(error); 1398 } 1399 if (XFS_IS_OQUOTA_ON(mp) && 1400 mp->m_sb.sb_gquotino != NULLFSINO) { 1401 ASSERT(mp->m_sb.sb_gquotino > 0); 1402 if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino, 1403 0, 0, &gip))) { 1404 if (uip) 1405 IRELE(uip); 1406 return XFS_ERROR(error); 1407 } 1408 } 1409 } else { 1410 flags |= XFS_QMOPT_SBVERSION; 1411 sbflags |= (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO | 1412 XFS_SB_GQUOTINO | XFS_SB_QFLAGS); 1413 } 1414 1415 /* 1416 * Create the two inodes, if they don't exist already. The changes 1417 * made above will get added to a transaction and logged in one of 1418 * the qino_alloc calls below. If the device is readonly, 1419 * temporarily switch to read-write to do this. 1420 */ 1421 if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) { 1422 if ((error = xfs_qm_qino_alloc(mp, &uip, 1423 sbflags | XFS_SB_UQUOTINO, 1424 flags | XFS_QMOPT_UQUOTA))) 1425 return XFS_ERROR(error); 1426 1427 flags &= ~XFS_QMOPT_SBVERSION; 1428 } 1429 if (XFS_IS_OQUOTA_ON(mp) && gip == NULL) { 1430 flags |= (XFS_IS_GQUOTA_ON(mp) ? 1431 XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA); 1432 error = xfs_qm_qino_alloc(mp, &gip, 1433 sbflags | XFS_SB_GQUOTINO, flags); 1434 if (error) { 1435 if (uip) 1436 IRELE(uip); 1437 1438 return XFS_ERROR(error); 1439 } 1440 } 1441 1442 mp->m_quotainfo->qi_uquotaip = uip; 1443 mp->m_quotainfo->qi_gquotaip = gip; 1444 1445 return 0; 1446 } 1447 1448 STATIC void 1449 xfs_qm_dqfree_one( 1450 struct xfs_dquot *dqp) 1451 { 1452 struct xfs_mount *mp = dqp->q_mount; 1453 struct xfs_quotainfo *qi = mp->m_quotainfo; 1454 1455 mutex_lock(&qi->qi_tree_lock); 1456 radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags), 1457 be32_to_cpu(dqp->q_core.d_id)); 1458 1459 qi->qi_dquots--; 1460 mutex_unlock(&qi->qi_tree_lock); 1461 1462 xfs_qm_dqdestroy(dqp); 1463 } 1464 1465 STATIC void 1466 xfs_qm_dqreclaim_one( 1467 struct xfs_dquot *dqp, 1468 struct list_head *buffer_list, 1469 struct list_head *dispose_list) 1470 { 1471 struct xfs_mount *mp = dqp->q_mount; 1472 struct xfs_quotainfo *qi = mp->m_quotainfo; 1473 int error; 1474 1475 if (!xfs_dqlock_nowait(dqp)) 1476 goto out_move_tail; 1477 1478 /* 1479 * This dquot has acquired a reference in the meantime remove it from 1480 * the freelist and try again. 1481 */ 1482 if (dqp->q_nrefs) { 1483 xfs_dqunlock(dqp); 1484 1485 trace_xfs_dqreclaim_want(dqp); 1486 XFS_STATS_INC(xs_qm_dqwants); 1487 1488 list_del_init(&dqp->q_lru); 1489 qi->qi_lru_count--; 1490 XFS_STATS_DEC(xs_qm_dquot_unused); 1491 return; 1492 } 1493 1494 /* 1495 * Try to grab the flush lock. If this dquot is in the process of 1496 * getting flushed to disk, we don't want to reclaim it. 1497 */ 1498 if (!xfs_dqflock_nowait(dqp)) 1499 goto out_unlock_move_tail; 1500 1501 if (XFS_DQ_IS_DIRTY(dqp)) { 1502 struct xfs_buf *bp = NULL; 1503 1504 trace_xfs_dqreclaim_dirty(dqp); 1505 1506 error = xfs_qm_dqflush(dqp, &bp); 1507 if (error) { 1508 xfs_warn(mp, "%s: dquot %p flush failed", 1509 __func__, dqp); 1510 goto out_unlock_move_tail; 1511 } 1512 1513 xfs_buf_delwri_queue(bp, buffer_list); 1514 xfs_buf_relse(bp); 1515 /* 1516 * Give the dquot another try on the freelist, as the 1517 * flushing will take some time. 1518 */ 1519 goto out_unlock_move_tail; 1520 } 1521 xfs_dqfunlock(dqp); 1522 1523 /* 1524 * Prevent lookups now that we are past the point of no return. 1525 */ 1526 dqp->dq_flags |= XFS_DQ_FREEING; 1527 xfs_dqunlock(dqp); 1528 1529 ASSERT(dqp->q_nrefs == 0); 1530 list_move_tail(&dqp->q_lru, dispose_list); 1531 qi->qi_lru_count--; 1532 XFS_STATS_DEC(xs_qm_dquot_unused); 1533 1534 trace_xfs_dqreclaim_done(dqp); 1535 XFS_STATS_INC(xs_qm_dqreclaims); 1536 return; 1537 1538 /* 1539 * Move the dquot to the tail of the list so that we don't spin on it. 1540 */ 1541 out_unlock_move_tail: 1542 xfs_dqunlock(dqp); 1543 out_move_tail: 1544 list_move_tail(&dqp->q_lru, &qi->qi_lru_list); 1545 trace_xfs_dqreclaim_busy(dqp); 1546 XFS_STATS_INC(xs_qm_dqreclaim_misses); 1547 } 1548 1549 STATIC int 1550 xfs_qm_shake( 1551 struct shrinker *shrink, 1552 struct shrink_control *sc) 1553 { 1554 struct xfs_quotainfo *qi = 1555 container_of(shrink, struct xfs_quotainfo, qi_shrinker); 1556 int nr_to_scan = sc->nr_to_scan; 1557 LIST_HEAD (buffer_list); 1558 LIST_HEAD (dispose_list); 1559 struct xfs_dquot *dqp; 1560 int error; 1561 1562 if ((sc->gfp_mask & (__GFP_FS|__GFP_WAIT)) != (__GFP_FS|__GFP_WAIT)) 1563 return 0; 1564 if (!nr_to_scan) 1565 goto out; 1566 1567 mutex_lock(&qi->qi_lru_lock); 1568 while (!list_empty(&qi->qi_lru_list)) { 1569 if (nr_to_scan-- <= 0) 1570 break; 1571 dqp = list_first_entry(&qi->qi_lru_list, struct xfs_dquot, 1572 q_lru); 1573 xfs_qm_dqreclaim_one(dqp, &buffer_list, &dispose_list); 1574 } 1575 mutex_unlock(&qi->qi_lru_lock); 1576 1577 error = xfs_buf_delwri_submit(&buffer_list); 1578 if (error) 1579 xfs_warn(NULL, "%s: dquot reclaim failed", __func__); 1580 1581 while (!list_empty(&dispose_list)) { 1582 dqp = list_first_entry(&dispose_list, struct xfs_dquot, q_lru); 1583 list_del_init(&dqp->q_lru); 1584 xfs_qm_dqfree_one(dqp); 1585 } 1586 1587 out: 1588 return (qi->qi_lru_count / 100) * sysctl_vfs_cache_pressure; 1589 } 1590 1591 /* 1592 * Start a transaction and write the incore superblock changes to 1593 * disk. flags parameter indicates which fields have changed. 1594 */ 1595 int 1596 xfs_qm_write_sb_changes( 1597 xfs_mount_t *mp, 1598 __int64_t flags) 1599 { 1600 xfs_trans_t *tp; 1601 int error; 1602 1603 tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE); 1604 error = xfs_trans_reserve(tp, 0, XFS_QM_SBCHANGE_LOG_RES(mp), 1605 0, 0, XFS_DEFAULT_LOG_COUNT); 1606 if (error) { 1607 xfs_trans_cancel(tp, 0); 1608 return error; 1609 } 1610 1611 xfs_mod_sb(tp, flags); 1612 error = xfs_trans_commit(tp, 0); 1613 1614 return error; 1615 } 1616 1617 1618 /* --------------- utility functions for vnodeops ---------------- */ 1619 1620 1621 /* 1622 * Given an inode, a uid, gid and prid make sure that we have 1623 * allocated relevant dquot(s) on disk, and that we won't exceed inode 1624 * quotas by creating this file. 1625 * This also attaches dquot(s) to the given inode after locking it, 1626 * and returns the dquots corresponding to the uid and/or gid. 1627 * 1628 * in : inode (unlocked) 1629 * out : udquot, gdquot with references taken and unlocked 1630 */ 1631 int 1632 xfs_qm_vop_dqalloc( 1633 struct xfs_inode *ip, 1634 uid_t uid, 1635 gid_t gid, 1636 prid_t prid, 1637 uint flags, 1638 struct xfs_dquot **O_udqpp, 1639 struct xfs_dquot **O_gdqpp) 1640 { 1641 struct xfs_mount *mp = ip->i_mount; 1642 struct xfs_dquot *uq, *gq; 1643 int error; 1644 uint lockflags; 1645 1646 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp)) 1647 return 0; 1648 1649 lockflags = XFS_ILOCK_EXCL; 1650 xfs_ilock(ip, lockflags); 1651 1652 if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip)) 1653 gid = ip->i_d.di_gid; 1654 1655 /* 1656 * Attach the dquot(s) to this inode, doing a dquot allocation 1657 * if necessary. The dquot(s) will not be locked. 1658 */ 1659 if (XFS_NOT_DQATTACHED(mp, ip)) { 1660 error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC); 1661 if (error) { 1662 xfs_iunlock(ip, lockflags); 1663 return error; 1664 } 1665 } 1666 1667 uq = gq = NULL; 1668 if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) { 1669 if (ip->i_d.di_uid != uid) { 1670 /* 1671 * What we need is the dquot that has this uid, and 1672 * if we send the inode to dqget, the uid of the inode 1673 * takes priority over what's sent in the uid argument. 1674 * We must unlock inode here before calling dqget if 1675 * we're not sending the inode, because otherwise 1676 * we'll deadlock by doing trans_reserve while 1677 * holding ilock. 1678 */ 1679 xfs_iunlock(ip, lockflags); 1680 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid, 1681 XFS_DQ_USER, 1682 XFS_QMOPT_DQALLOC | 1683 XFS_QMOPT_DOWARN, 1684 &uq))) { 1685 ASSERT(error != ENOENT); 1686 return error; 1687 } 1688 /* 1689 * Get the ilock in the right order. 1690 */ 1691 xfs_dqunlock(uq); 1692 lockflags = XFS_ILOCK_SHARED; 1693 xfs_ilock(ip, lockflags); 1694 } else { 1695 /* 1696 * Take an extra reference, because we'll return 1697 * this to caller 1698 */ 1699 ASSERT(ip->i_udquot); 1700 uq = xfs_qm_dqhold(ip->i_udquot); 1701 } 1702 } 1703 if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) { 1704 if (ip->i_d.di_gid != gid) { 1705 xfs_iunlock(ip, lockflags); 1706 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid, 1707 XFS_DQ_GROUP, 1708 XFS_QMOPT_DQALLOC | 1709 XFS_QMOPT_DOWARN, 1710 &gq))) { 1711 if (uq) 1712 xfs_qm_dqrele(uq); 1713 ASSERT(error != ENOENT); 1714 return error; 1715 } 1716 xfs_dqunlock(gq); 1717 lockflags = XFS_ILOCK_SHARED; 1718 xfs_ilock(ip, lockflags); 1719 } else { 1720 ASSERT(ip->i_gdquot); 1721 gq = xfs_qm_dqhold(ip->i_gdquot); 1722 } 1723 } else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) { 1724 if (xfs_get_projid(ip) != prid) { 1725 xfs_iunlock(ip, lockflags); 1726 if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid, 1727 XFS_DQ_PROJ, 1728 XFS_QMOPT_DQALLOC | 1729 XFS_QMOPT_DOWARN, 1730 &gq))) { 1731 if (uq) 1732 xfs_qm_dqrele(uq); 1733 ASSERT(error != ENOENT); 1734 return (error); 1735 } 1736 xfs_dqunlock(gq); 1737 lockflags = XFS_ILOCK_SHARED; 1738 xfs_ilock(ip, lockflags); 1739 } else { 1740 ASSERT(ip->i_gdquot); 1741 gq = xfs_qm_dqhold(ip->i_gdquot); 1742 } 1743 } 1744 if (uq) 1745 trace_xfs_dquot_dqalloc(ip); 1746 1747 xfs_iunlock(ip, lockflags); 1748 if (O_udqpp) 1749 *O_udqpp = uq; 1750 else if (uq) 1751 xfs_qm_dqrele(uq); 1752 if (O_gdqpp) 1753 *O_gdqpp = gq; 1754 else if (gq) 1755 xfs_qm_dqrele(gq); 1756 return 0; 1757 } 1758 1759 /* 1760 * Actually transfer ownership, and do dquot modifications. 1761 * These were already reserved. 1762 */ 1763 xfs_dquot_t * 1764 xfs_qm_vop_chown( 1765 xfs_trans_t *tp, 1766 xfs_inode_t *ip, 1767 xfs_dquot_t **IO_olddq, 1768 xfs_dquot_t *newdq) 1769 { 1770 xfs_dquot_t *prevdq; 1771 uint bfield = XFS_IS_REALTIME_INODE(ip) ? 1772 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT; 1773 1774 1775 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 1776 ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount)); 1777 1778 /* old dquot */ 1779 prevdq = *IO_olddq; 1780 ASSERT(prevdq); 1781 ASSERT(prevdq != newdq); 1782 1783 xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks)); 1784 xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1); 1785 1786 /* the sparkling new dquot */ 1787 xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks); 1788 xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1); 1789 1790 /* 1791 * Take an extra reference, because the inode is going to keep 1792 * this dquot pointer even after the trans_commit. 1793 */ 1794 *IO_olddq = xfs_qm_dqhold(newdq); 1795 1796 return prevdq; 1797 } 1798 1799 /* 1800 * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID). 1801 */ 1802 int 1803 xfs_qm_vop_chown_reserve( 1804 xfs_trans_t *tp, 1805 xfs_inode_t *ip, 1806 xfs_dquot_t *udqp, 1807 xfs_dquot_t *gdqp, 1808 uint flags) 1809 { 1810 xfs_mount_t *mp = ip->i_mount; 1811 uint delblks, blkflags, prjflags = 0; 1812 xfs_dquot_t *unresudq, *unresgdq, *delblksudq, *delblksgdq; 1813 int error; 1814 1815 1816 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED)); 1817 ASSERT(XFS_IS_QUOTA_RUNNING(mp)); 1818 1819 delblks = ip->i_delayed_blks; 1820 delblksudq = delblksgdq = unresudq = unresgdq = NULL; 1821 blkflags = XFS_IS_REALTIME_INODE(ip) ? 1822 XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS; 1823 1824 if (XFS_IS_UQUOTA_ON(mp) && udqp && 1825 ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) { 1826 delblksudq = udqp; 1827 /* 1828 * If there are delayed allocation blocks, then we have to 1829 * unreserve those from the old dquot, and add them to the 1830 * new dquot. 1831 */ 1832 if (delblks) { 1833 ASSERT(ip->i_udquot); 1834 unresudq = ip->i_udquot; 1835 } 1836 } 1837 if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) { 1838 if (XFS_IS_PQUOTA_ON(ip->i_mount) && 1839 xfs_get_projid(ip) != be32_to_cpu(gdqp->q_core.d_id)) 1840 prjflags = XFS_QMOPT_ENOSPC; 1841 1842 if (prjflags || 1843 (XFS_IS_GQUOTA_ON(ip->i_mount) && 1844 ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) { 1845 delblksgdq = gdqp; 1846 if (delblks) { 1847 ASSERT(ip->i_gdquot); 1848 unresgdq = ip->i_gdquot; 1849 } 1850 } 1851 } 1852 1853 if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount, 1854 delblksudq, delblksgdq, ip->i_d.di_nblocks, 1, 1855 flags | blkflags | prjflags))) 1856 return (error); 1857 1858 /* 1859 * Do the delayed blks reservations/unreservations now. Since, these 1860 * are done without the help of a transaction, if a reservation fails 1861 * its previous reservations won't be automatically undone by trans 1862 * code. So, we have to do it manually here. 1863 */ 1864 if (delblks) { 1865 /* 1866 * Do the reservations first. Unreservation can't fail. 1867 */ 1868 ASSERT(delblksudq || delblksgdq); 1869 ASSERT(unresudq || unresgdq); 1870 if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount, 1871 delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0, 1872 flags | blkflags | prjflags))) 1873 return (error); 1874 xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount, 1875 unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0, 1876 blkflags); 1877 } 1878 1879 return (0); 1880 } 1881 1882 int 1883 xfs_qm_vop_rename_dqattach( 1884 struct xfs_inode **i_tab) 1885 { 1886 struct xfs_mount *mp = i_tab[0]->i_mount; 1887 int i; 1888 1889 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp)) 1890 return 0; 1891 1892 for (i = 0; (i < 4 && i_tab[i]); i++) { 1893 struct xfs_inode *ip = i_tab[i]; 1894 int error; 1895 1896 /* 1897 * Watch out for duplicate entries in the table. 1898 */ 1899 if (i == 0 || ip != i_tab[i-1]) { 1900 if (XFS_NOT_DQATTACHED(mp, ip)) { 1901 error = xfs_qm_dqattach(ip, 0); 1902 if (error) 1903 return error; 1904 } 1905 } 1906 } 1907 return 0; 1908 } 1909 1910 void 1911 xfs_qm_vop_create_dqattach( 1912 struct xfs_trans *tp, 1913 struct xfs_inode *ip, 1914 struct xfs_dquot *udqp, 1915 struct xfs_dquot *gdqp) 1916 { 1917 struct xfs_mount *mp = tp->t_mountp; 1918 1919 if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp)) 1920 return; 1921 1922 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL)); 1923 ASSERT(XFS_IS_QUOTA_RUNNING(mp)); 1924 1925 if (udqp) { 1926 ASSERT(ip->i_udquot == NULL); 1927 ASSERT(XFS_IS_UQUOTA_ON(mp)); 1928 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id)); 1929 1930 ip->i_udquot = xfs_qm_dqhold(udqp); 1931 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1); 1932 } 1933 if (gdqp) { 1934 ASSERT(ip->i_gdquot == NULL); 1935 ASSERT(XFS_IS_OQUOTA_ON(mp)); 1936 ASSERT((XFS_IS_GQUOTA_ON(mp) ? 1937 ip->i_d.di_gid : xfs_get_projid(ip)) == 1938 be32_to_cpu(gdqp->q_core.d_id)); 1939 1940 ip->i_gdquot = xfs_qm_dqhold(gdqp); 1941 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1); 1942 } 1943 } 1944 1945