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_shared.h" 21 #include "xfs_format.h" 22 #include "xfs_log_format.h" 23 #include "xfs_trans_resv.h" 24 #include "xfs_bit.h" 25 #include "xfs_sb.h" 26 #include "xfs_mount.h" 27 #include "xfs_da_format.h" 28 #include "xfs_da_btree.h" 29 #include "xfs_inode.h" 30 #include "xfs_dir2.h" 31 #include "xfs_ialloc.h" 32 #include "xfs_alloc.h" 33 #include "xfs_rtalloc.h" 34 #include "xfs_bmap.h" 35 #include "xfs_trans.h" 36 #include "xfs_trans_priv.h" 37 #include "xfs_log.h" 38 #include "xfs_error.h" 39 #include "xfs_quota.h" 40 #include "xfs_fsops.h" 41 #include "xfs_trace.h" 42 #include "xfs_icache.h" 43 #include "xfs_sysfs.h" 44 45 46 static DEFINE_MUTEX(xfs_uuid_table_mutex); 47 static int xfs_uuid_table_size; 48 static uuid_t *xfs_uuid_table; 49 50 void 51 xfs_uuid_table_free(void) 52 { 53 if (xfs_uuid_table_size == 0) 54 return; 55 kmem_free(xfs_uuid_table); 56 xfs_uuid_table = NULL; 57 xfs_uuid_table_size = 0; 58 } 59 60 /* 61 * See if the UUID is unique among mounted XFS filesystems. 62 * Mount fails if UUID is nil or a FS with the same UUID is already mounted. 63 */ 64 STATIC int 65 xfs_uuid_mount( 66 struct xfs_mount *mp) 67 { 68 uuid_t *uuid = &mp->m_sb.sb_uuid; 69 int hole, i; 70 71 if (mp->m_flags & XFS_MOUNT_NOUUID) 72 return 0; 73 74 if (uuid_is_nil(uuid)) { 75 xfs_warn(mp, "Filesystem has nil UUID - can't mount"); 76 return -EINVAL; 77 } 78 79 mutex_lock(&xfs_uuid_table_mutex); 80 for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) { 81 if (uuid_is_nil(&xfs_uuid_table[i])) { 82 hole = i; 83 continue; 84 } 85 if (uuid_equal(uuid, &xfs_uuid_table[i])) 86 goto out_duplicate; 87 } 88 89 if (hole < 0) { 90 xfs_uuid_table = kmem_realloc(xfs_uuid_table, 91 (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table), 92 xfs_uuid_table_size * sizeof(*xfs_uuid_table), 93 KM_SLEEP); 94 hole = xfs_uuid_table_size++; 95 } 96 xfs_uuid_table[hole] = *uuid; 97 mutex_unlock(&xfs_uuid_table_mutex); 98 99 return 0; 100 101 out_duplicate: 102 mutex_unlock(&xfs_uuid_table_mutex); 103 xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid); 104 return -EINVAL; 105 } 106 107 STATIC void 108 xfs_uuid_unmount( 109 struct xfs_mount *mp) 110 { 111 uuid_t *uuid = &mp->m_sb.sb_uuid; 112 int i; 113 114 if (mp->m_flags & XFS_MOUNT_NOUUID) 115 return; 116 117 mutex_lock(&xfs_uuid_table_mutex); 118 for (i = 0; i < xfs_uuid_table_size; i++) { 119 if (uuid_is_nil(&xfs_uuid_table[i])) 120 continue; 121 if (!uuid_equal(uuid, &xfs_uuid_table[i])) 122 continue; 123 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t)); 124 break; 125 } 126 ASSERT(i < xfs_uuid_table_size); 127 mutex_unlock(&xfs_uuid_table_mutex); 128 } 129 130 131 STATIC void 132 __xfs_free_perag( 133 struct rcu_head *head) 134 { 135 struct xfs_perag *pag = container_of(head, struct xfs_perag, rcu_head); 136 137 ASSERT(atomic_read(&pag->pag_ref) == 0); 138 kmem_free(pag); 139 } 140 141 /* 142 * Free up the per-ag resources associated with the mount structure. 143 */ 144 STATIC void 145 xfs_free_perag( 146 xfs_mount_t *mp) 147 { 148 xfs_agnumber_t agno; 149 struct xfs_perag *pag; 150 151 for (agno = 0; agno < mp->m_sb.sb_agcount; agno++) { 152 spin_lock(&mp->m_perag_lock); 153 pag = radix_tree_delete(&mp->m_perag_tree, agno); 154 spin_unlock(&mp->m_perag_lock); 155 ASSERT(pag); 156 ASSERT(atomic_read(&pag->pag_ref) == 0); 157 call_rcu(&pag->rcu_head, __xfs_free_perag); 158 } 159 } 160 161 /* 162 * Check size of device based on the (data/realtime) block count. 163 * Note: this check is used by the growfs code as well as mount. 164 */ 165 int 166 xfs_sb_validate_fsb_count( 167 xfs_sb_t *sbp, 168 __uint64_t nblocks) 169 { 170 ASSERT(PAGE_SHIFT >= sbp->sb_blocklog); 171 ASSERT(sbp->sb_blocklog >= BBSHIFT); 172 173 /* Limited by ULONG_MAX of page cache index */ 174 if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX) 175 return -EFBIG; 176 return 0; 177 } 178 179 int 180 xfs_initialize_perag( 181 xfs_mount_t *mp, 182 xfs_agnumber_t agcount, 183 xfs_agnumber_t *maxagi) 184 { 185 xfs_agnumber_t index; 186 xfs_agnumber_t first_initialised = 0; 187 xfs_perag_t *pag; 188 int error = -ENOMEM; 189 190 /* 191 * Walk the current per-ag tree so we don't try to initialise AGs 192 * that already exist (growfs case). Allocate and insert all the 193 * AGs we don't find ready for initialisation. 194 */ 195 for (index = 0; index < agcount; index++) { 196 pag = xfs_perag_get(mp, index); 197 if (pag) { 198 xfs_perag_put(pag); 199 continue; 200 } 201 if (!first_initialised) 202 first_initialised = index; 203 204 pag = kmem_zalloc(sizeof(*pag), KM_MAYFAIL); 205 if (!pag) 206 goto out_unwind; 207 pag->pag_agno = index; 208 pag->pag_mount = mp; 209 spin_lock_init(&pag->pag_ici_lock); 210 mutex_init(&pag->pag_ici_reclaim_lock); 211 INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC); 212 spin_lock_init(&pag->pag_buf_lock); 213 pag->pag_buf_tree = RB_ROOT; 214 215 if (radix_tree_preload(GFP_NOFS)) 216 goto out_unwind; 217 218 spin_lock(&mp->m_perag_lock); 219 if (radix_tree_insert(&mp->m_perag_tree, index, pag)) { 220 BUG(); 221 spin_unlock(&mp->m_perag_lock); 222 radix_tree_preload_end(); 223 error = -EEXIST; 224 goto out_unwind; 225 } 226 spin_unlock(&mp->m_perag_lock); 227 radix_tree_preload_end(); 228 } 229 230 index = xfs_set_inode_alloc(mp, agcount); 231 232 if (maxagi) 233 *maxagi = index; 234 return 0; 235 236 out_unwind: 237 kmem_free(pag); 238 for (; index > first_initialised; index--) { 239 pag = radix_tree_delete(&mp->m_perag_tree, index); 240 kmem_free(pag); 241 } 242 return error; 243 } 244 245 /* 246 * xfs_readsb 247 * 248 * Does the initial read of the superblock. 249 */ 250 int 251 xfs_readsb( 252 struct xfs_mount *mp, 253 int flags) 254 { 255 unsigned int sector_size; 256 struct xfs_buf *bp; 257 struct xfs_sb *sbp = &mp->m_sb; 258 int error; 259 int loud = !(flags & XFS_MFSI_QUIET); 260 const struct xfs_buf_ops *buf_ops; 261 262 ASSERT(mp->m_sb_bp == NULL); 263 ASSERT(mp->m_ddev_targp != NULL); 264 265 /* 266 * For the initial read, we must guess at the sector 267 * size based on the block device. It's enough to 268 * get the sb_sectsize out of the superblock and 269 * then reread with the proper length. 270 * We don't verify it yet, because it may not be complete. 271 */ 272 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp); 273 buf_ops = NULL; 274 275 /* 276 * Allocate a (locked) buffer to hold the superblock. 277 * This will be kept around at all times to optimize 278 * access to the superblock. 279 */ 280 reread: 281 error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR, 282 BTOBB(sector_size), 0, &bp, buf_ops); 283 if (error) { 284 if (loud) 285 xfs_warn(mp, "SB validate failed with error %d.", error); 286 /* bad CRC means corrupted metadata */ 287 if (error == -EFSBADCRC) 288 error = -EFSCORRUPTED; 289 return error; 290 } 291 292 /* 293 * Initialize the mount structure from the superblock. 294 */ 295 xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp)); 296 297 /* 298 * If we haven't validated the superblock, do so now before we try 299 * to check the sector size and reread the superblock appropriately. 300 */ 301 if (sbp->sb_magicnum != XFS_SB_MAGIC) { 302 if (loud) 303 xfs_warn(mp, "Invalid superblock magic number"); 304 error = -EINVAL; 305 goto release_buf; 306 } 307 308 /* 309 * We must be able to do sector-sized and sector-aligned IO. 310 */ 311 if (sector_size > sbp->sb_sectsize) { 312 if (loud) 313 xfs_warn(mp, "device supports %u byte sectors (not %u)", 314 sector_size, sbp->sb_sectsize); 315 error = -ENOSYS; 316 goto release_buf; 317 } 318 319 if (buf_ops == NULL) { 320 /* 321 * Re-read the superblock so the buffer is correctly sized, 322 * and properly verified. 323 */ 324 xfs_buf_relse(bp); 325 sector_size = sbp->sb_sectsize; 326 buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops; 327 goto reread; 328 } 329 330 xfs_reinit_percpu_counters(mp); 331 332 /* no need to be quiet anymore, so reset the buf ops */ 333 bp->b_ops = &xfs_sb_buf_ops; 334 335 mp->m_sb_bp = bp; 336 xfs_buf_unlock(bp); 337 return 0; 338 339 release_buf: 340 xfs_buf_relse(bp); 341 return error; 342 } 343 344 /* 345 * Update alignment values based on mount options and sb values 346 */ 347 STATIC int 348 xfs_update_alignment(xfs_mount_t *mp) 349 { 350 xfs_sb_t *sbp = &(mp->m_sb); 351 352 if (mp->m_dalign) { 353 /* 354 * If stripe unit and stripe width are not multiples 355 * of the fs blocksize turn off alignment. 356 */ 357 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) || 358 (BBTOB(mp->m_swidth) & mp->m_blockmask)) { 359 xfs_warn(mp, 360 "alignment check failed: sunit/swidth vs. blocksize(%d)", 361 sbp->sb_blocksize); 362 return -EINVAL; 363 } else { 364 /* 365 * Convert the stripe unit and width to FSBs. 366 */ 367 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign); 368 if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) { 369 xfs_warn(mp, 370 "alignment check failed: sunit/swidth vs. agsize(%d)", 371 sbp->sb_agblocks); 372 return -EINVAL; 373 } else if (mp->m_dalign) { 374 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth); 375 } else { 376 xfs_warn(mp, 377 "alignment check failed: sunit(%d) less than bsize(%d)", 378 mp->m_dalign, sbp->sb_blocksize); 379 return -EINVAL; 380 } 381 } 382 383 /* 384 * Update superblock with new values 385 * and log changes 386 */ 387 if (xfs_sb_version_hasdalign(sbp)) { 388 if (sbp->sb_unit != mp->m_dalign) { 389 sbp->sb_unit = mp->m_dalign; 390 mp->m_update_sb = true; 391 } 392 if (sbp->sb_width != mp->m_swidth) { 393 sbp->sb_width = mp->m_swidth; 394 mp->m_update_sb = true; 395 } 396 } else { 397 xfs_warn(mp, 398 "cannot change alignment: superblock does not support data alignment"); 399 return -EINVAL; 400 } 401 } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN && 402 xfs_sb_version_hasdalign(&mp->m_sb)) { 403 mp->m_dalign = sbp->sb_unit; 404 mp->m_swidth = sbp->sb_width; 405 } 406 407 return 0; 408 } 409 410 /* 411 * Set the maximum inode count for this filesystem 412 */ 413 STATIC void 414 xfs_set_maxicount(xfs_mount_t *mp) 415 { 416 xfs_sb_t *sbp = &(mp->m_sb); 417 __uint64_t icount; 418 419 if (sbp->sb_imax_pct) { 420 /* 421 * Make sure the maximum inode count is a multiple 422 * of the units we allocate inodes in. 423 */ 424 icount = sbp->sb_dblocks * sbp->sb_imax_pct; 425 do_div(icount, 100); 426 do_div(icount, mp->m_ialloc_blks); 427 mp->m_maxicount = (icount * mp->m_ialloc_blks) << 428 sbp->sb_inopblog; 429 } else { 430 mp->m_maxicount = 0; 431 } 432 } 433 434 /* 435 * Set the default minimum read and write sizes unless 436 * already specified in a mount option. 437 * We use smaller I/O sizes when the file system 438 * is being used for NFS service (wsync mount option). 439 */ 440 STATIC void 441 xfs_set_rw_sizes(xfs_mount_t *mp) 442 { 443 xfs_sb_t *sbp = &(mp->m_sb); 444 int readio_log, writeio_log; 445 446 if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) { 447 if (mp->m_flags & XFS_MOUNT_WSYNC) { 448 readio_log = XFS_WSYNC_READIO_LOG; 449 writeio_log = XFS_WSYNC_WRITEIO_LOG; 450 } else { 451 readio_log = XFS_READIO_LOG_LARGE; 452 writeio_log = XFS_WRITEIO_LOG_LARGE; 453 } 454 } else { 455 readio_log = mp->m_readio_log; 456 writeio_log = mp->m_writeio_log; 457 } 458 459 if (sbp->sb_blocklog > readio_log) { 460 mp->m_readio_log = sbp->sb_blocklog; 461 } else { 462 mp->m_readio_log = readio_log; 463 } 464 mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog); 465 if (sbp->sb_blocklog > writeio_log) { 466 mp->m_writeio_log = sbp->sb_blocklog; 467 } else { 468 mp->m_writeio_log = writeio_log; 469 } 470 mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog); 471 } 472 473 /* 474 * precalculate the low space thresholds for dynamic speculative preallocation. 475 */ 476 void 477 xfs_set_low_space_thresholds( 478 struct xfs_mount *mp) 479 { 480 int i; 481 482 for (i = 0; i < XFS_LOWSP_MAX; i++) { 483 __uint64_t space = mp->m_sb.sb_dblocks; 484 485 do_div(space, 100); 486 mp->m_low_space[i] = space * (i + 1); 487 } 488 } 489 490 491 /* 492 * Set whether we're using inode alignment. 493 */ 494 STATIC void 495 xfs_set_inoalignment(xfs_mount_t *mp) 496 { 497 if (xfs_sb_version_hasalign(&mp->m_sb) && 498 mp->m_sb.sb_inoalignmt >= 499 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) 500 mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1; 501 else 502 mp->m_inoalign_mask = 0; 503 /* 504 * If we are using stripe alignment, check whether 505 * the stripe unit is a multiple of the inode alignment 506 */ 507 if (mp->m_dalign && mp->m_inoalign_mask && 508 !(mp->m_dalign & mp->m_inoalign_mask)) 509 mp->m_sinoalign = mp->m_dalign; 510 else 511 mp->m_sinoalign = 0; 512 } 513 514 /* 515 * Check that the data (and log if separate) is an ok size. 516 */ 517 STATIC int 518 xfs_check_sizes( 519 struct xfs_mount *mp) 520 { 521 struct xfs_buf *bp; 522 xfs_daddr_t d; 523 int error; 524 525 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks); 526 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) { 527 xfs_warn(mp, "filesystem size mismatch detected"); 528 return -EFBIG; 529 } 530 error = xfs_buf_read_uncached(mp->m_ddev_targp, 531 d - XFS_FSS_TO_BB(mp, 1), 532 XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL); 533 if (error) { 534 xfs_warn(mp, "last sector read failed"); 535 return error; 536 } 537 xfs_buf_relse(bp); 538 539 if (mp->m_logdev_targp == mp->m_ddev_targp) 540 return 0; 541 542 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks); 543 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) { 544 xfs_warn(mp, "log size mismatch detected"); 545 return -EFBIG; 546 } 547 error = xfs_buf_read_uncached(mp->m_logdev_targp, 548 d - XFS_FSB_TO_BB(mp, 1), 549 XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL); 550 if (error) { 551 xfs_warn(mp, "log device read failed"); 552 return error; 553 } 554 xfs_buf_relse(bp); 555 return 0; 556 } 557 558 /* 559 * Clear the quotaflags in memory and in the superblock. 560 */ 561 int 562 xfs_mount_reset_sbqflags( 563 struct xfs_mount *mp) 564 { 565 mp->m_qflags = 0; 566 567 /* It is OK to look at sb_qflags in the mount path without m_sb_lock. */ 568 if (mp->m_sb.sb_qflags == 0) 569 return 0; 570 spin_lock(&mp->m_sb_lock); 571 mp->m_sb.sb_qflags = 0; 572 spin_unlock(&mp->m_sb_lock); 573 574 if (!xfs_fs_writable(mp, SB_FREEZE_WRITE)) 575 return 0; 576 577 return xfs_sync_sb(mp, false); 578 } 579 580 __uint64_t 581 xfs_default_resblks(xfs_mount_t *mp) 582 { 583 __uint64_t resblks; 584 585 /* 586 * We default to 5% or 8192 fsbs of space reserved, whichever is 587 * smaller. This is intended to cover concurrent allocation 588 * transactions when we initially hit enospc. These each require a 4 589 * block reservation. Hence by default we cover roughly 2000 concurrent 590 * allocation reservations. 591 */ 592 resblks = mp->m_sb.sb_dblocks; 593 do_div(resblks, 20); 594 resblks = min_t(__uint64_t, resblks, 8192); 595 return resblks; 596 } 597 598 /* 599 * This function does the following on an initial mount of a file system: 600 * - reads the superblock from disk and init the mount struct 601 * - if we're a 32-bit kernel, do a size check on the superblock 602 * so we don't mount terabyte filesystems 603 * - init mount struct realtime fields 604 * - allocate inode hash table for fs 605 * - init directory manager 606 * - perform recovery and init the log manager 607 */ 608 int 609 xfs_mountfs( 610 struct xfs_mount *mp) 611 { 612 struct xfs_sb *sbp = &(mp->m_sb); 613 struct xfs_inode *rip; 614 __uint64_t resblks; 615 uint quotamount = 0; 616 uint quotaflags = 0; 617 int error = 0; 618 619 xfs_sb_mount_common(mp, sbp); 620 621 /* 622 * Check for a mismatched features2 values. Older kernels read & wrote 623 * into the wrong sb offset for sb_features2 on some platforms due to 624 * xfs_sb_t not being 64bit size aligned when sb_features2 was added, 625 * which made older superblock reading/writing routines swap it as a 626 * 64-bit value. 627 * 628 * For backwards compatibility, we make both slots equal. 629 * 630 * If we detect a mismatched field, we OR the set bits into the existing 631 * features2 field in case it has already been modified; we don't want 632 * to lose any features. We then update the bad location with the ORed 633 * value so that older kernels will see any features2 flags. The 634 * superblock writeback code ensures the new sb_features2 is copied to 635 * sb_bad_features2 before it is logged or written to disk. 636 */ 637 if (xfs_sb_has_mismatched_features2(sbp)) { 638 xfs_warn(mp, "correcting sb_features alignment problem"); 639 sbp->sb_features2 |= sbp->sb_bad_features2; 640 mp->m_update_sb = true; 641 642 /* 643 * Re-check for ATTR2 in case it was found in bad_features2 644 * slot. 645 */ 646 if (xfs_sb_version_hasattr2(&mp->m_sb) && 647 !(mp->m_flags & XFS_MOUNT_NOATTR2)) 648 mp->m_flags |= XFS_MOUNT_ATTR2; 649 } 650 651 if (xfs_sb_version_hasattr2(&mp->m_sb) && 652 (mp->m_flags & XFS_MOUNT_NOATTR2)) { 653 xfs_sb_version_removeattr2(&mp->m_sb); 654 mp->m_update_sb = true; 655 656 /* update sb_versionnum for the clearing of the morebits */ 657 if (!sbp->sb_features2) 658 mp->m_update_sb = true; 659 } 660 661 /* always use v2 inodes by default now */ 662 if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) { 663 mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT; 664 mp->m_update_sb = true; 665 } 666 667 /* 668 * Check if sb_agblocks is aligned at stripe boundary 669 * If sb_agblocks is NOT aligned turn off m_dalign since 670 * allocator alignment is within an ag, therefore ag has 671 * to be aligned at stripe boundary. 672 */ 673 error = xfs_update_alignment(mp); 674 if (error) 675 goto out; 676 677 xfs_alloc_compute_maxlevels(mp); 678 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK); 679 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK); 680 xfs_ialloc_compute_maxlevels(mp); 681 682 xfs_set_maxicount(mp); 683 684 error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype, NULL, mp->m_fsname); 685 if (error) 686 goto out; 687 688 error = xfs_sysfs_init(&mp->m_stats.xs_kobj, &xfs_stats_ktype, 689 &mp->m_kobj, "stats"); 690 if (error) 691 goto out_remove_sysfs; 692 693 error = xfs_uuid_mount(mp); 694 if (error) 695 goto out_del_stats; 696 697 /* 698 * Set the minimum read and write sizes 699 */ 700 xfs_set_rw_sizes(mp); 701 702 /* set the low space thresholds for dynamic preallocation */ 703 xfs_set_low_space_thresholds(mp); 704 705 /* 706 * Set the inode cluster size. 707 * This may still be overridden by the file system 708 * block size if it is larger than the chosen cluster size. 709 * 710 * For v5 filesystems, scale the cluster size with the inode size to 711 * keep a constant ratio of inode per cluster buffer, but only if mkfs 712 * has set the inode alignment value appropriately for larger cluster 713 * sizes. 714 */ 715 mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE; 716 if (xfs_sb_version_hascrc(&mp->m_sb)) { 717 int new_size = mp->m_inode_cluster_size; 718 719 new_size *= mp->m_sb.sb_inodesize / XFS_DINODE_MIN_SIZE; 720 if (mp->m_sb.sb_inoalignmt >= XFS_B_TO_FSBT(mp, new_size)) 721 mp->m_inode_cluster_size = new_size; 722 } 723 724 /* 725 * If enabled, sparse inode chunk alignment is expected to match the 726 * cluster size. Full inode chunk alignment must match the chunk size, 727 * but that is checked on sb read verification... 728 */ 729 if (xfs_sb_version_hassparseinodes(&mp->m_sb) && 730 mp->m_sb.sb_spino_align != 731 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) { 732 xfs_warn(mp, 733 "Sparse inode block alignment (%u) must match cluster size (%llu).", 734 mp->m_sb.sb_spino_align, 735 XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)); 736 error = -EINVAL; 737 goto out_remove_uuid; 738 } 739 740 /* 741 * Set inode alignment fields 742 */ 743 xfs_set_inoalignment(mp); 744 745 /* 746 * Check that the data (and log if separate) is an ok size. 747 */ 748 error = xfs_check_sizes(mp); 749 if (error) 750 goto out_remove_uuid; 751 752 /* 753 * Initialize realtime fields in the mount structure 754 */ 755 error = xfs_rtmount_init(mp); 756 if (error) { 757 xfs_warn(mp, "RT mount failed"); 758 goto out_remove_uuid; 759 } 760 761 /* 762 * Copies the low order bits of the timestamp and the randomly 763 * set "sequence" number out of a UUID. 764 */ 765 uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid); 766 767 mp->m_dmevmask = 0; /* not persistent; set after each mount */ 768 769 error = xfs_da_mount(mp); 770 if (error) { 771 xfs_warn(mp, "Failed dir/attr init: %d", error); 772 goto out_remove_uuid; 773 } 774 775 /* 776 * Initialize the precomputed transaction reservations values. 777 */ 778 xfs_trans_init(mp); 779 780 /* 781 * Allocate and initialize the per-ag data. 782 */ 783 spin_lock_init(&mp->m_perag_lock); 784 INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC); 785 error = xfs_initialize_perag(mp, sbp->sb_agcount, &mp->m_maxagi); 786 if (error) { 787 xfs_warn(mp, "Failed per-ag init: %d", error); 788 goto out_free_dir; 789 } 790 791 if (!sbp->sb_logblocks) { 792 xfs_warn(mp, "no log defined"); 793 XFS_ERROR_REPORT("xfs_mountfs", XFS_ERRLEVEL_LOW, mp); 794 error = -EFSCORRUPTED; 795 goto out_free_perag; 796 } 797 798 /* 799 * Log's mount-time initialization. The first part of recovery can place 800 * some items on the AIL, to be handled when recovery is finished or 801 * cancelled. 802 */ 803 error = xfs_log_mount(mp, mp->m_logdev_targp, 804 XFS_FSB_TO_DADDR(mp, sbp->sb_logstart), 805 XFS_FSB_TO_BB(mp, sbp->sb_logblocks)); 806 if (error) { 807 xfs_warn(mp, "log mount failed"); 808 goto out_fail_wait; 809 } 810 811 /* 812 * Now the log is mounted, we know if it was an unclean shutdown or 813 * not. If it was, with the first phase of recovery has completed, we 814 * have consistent AG blocks on disk. We have not recovered EFIs yet, 815 * but they are recovered transactionally in the second recovery phase 816 * later. 817 * 818 * Hence we can safely re-initialise incore superblock counters from 819 * the per-ag data. These may not be correct if the filesystem was not 820 * cleanly unmounted, so we need to wait for recovery to finish before 821 * doing this. 822 * 823 * If the filesystem was cleanly unmounted, then we can trust the 824 * values in the superblock to be correct and we don't need to do 825 * anything here. 826 * 827 * If we are currently making the filesystem, the initialisation will 828 * fail as the perag data is in an undefined state. 829 */ 830 if (xfs_sb_version_haslazysbcount(&mp->m_sb) && 831 !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) && 832 !mp->m_sb.sb_inprogress) { 833 error = xfs_initialize_perag_data(mp, sbp->sb_agcount); 834 if (error) 835 goto out_log_dealloc; 836 } 837 838 /* 839 * Get and sanity-check the root inode. 840 * Save the pointer to it in the mount structure. 841 */ 842 error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip); 843 if (error) { 844 xfs_warn(mp, "failed to read root inode"); 845 goto out_log_dealloc; 846 } 847 848 ASSERT(rip != NULL); 849 850 if (unlikely(!S_ISDIR(VFS_I(rip)->i_mode))) { 851 xfs_warn(mp, "corrupted root inode %llu: not a directory", 852 (unsigned long long)rip->i_ino); 853 xfs_iunlock(rip, XFS_ILOCK_EXCL); 854 XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW, 855 mp); 856 error = -EFSCORRUPTED; 857 goto out_rele_rip; 858 } 859 mp->m_rootip = rip; /* save it */ 860 861 xfs_iunlock(rip, XFS_ILOCK_EXCL); 862 863 /* 864 * Initialize realtime inode pointers in the mount structure 865 */ 866 error = xfs_rtmount_inodes(mp); 867 if (error) { 868 /* 869 * Free up the root inode. 870 */ 871 xfs_warn(mp, "failed to read RT inodes"); 872 goto out_rele_rip; 873 } 874 875 /* 876 * If this is a read-only mount defer the superblock updates until 877 * the next remount into writeable mode. Otherwise we would never 878 * perform the update e.g. for the root filesystem. 879 */ 880 if (mp->m_update_sb && !(mp->m_flags & XFS_MOUNT_RDONLY)) { 881 error = xfs_sync_sb(mp, false); 882 if (error) { 883 xfs_warn(mp, "failed to write sb changes"); 884 goto out_rtunmount; 885 } 886 } 887 888 /* 889 * Initialise the XFS quota management subsystem for this mount 890 */ 891 if (XFS_IS_QUOTA_RUNNING(mp)) { 892 error = xfs_qm_newmount(mp, "amount, "aflags); 893 if (error) 894 goto out_rtunmount; 895 } else { 896 ASSERT(!XFS_IS_QUOTA_ON(mp)); 897 898 /* 899 * If a file system had quotas running earlier, but decided to 900 * mount without -o uquota/pquota/gquota options, revoke the 901 * quotachecked license. 902 */ 903 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) { 904 xfs_notice(mp, "resetting quota flags"); 905 error = xfs_mount_reset_sbqflags(mp); 906 if (error) 907 goto out_rtunmount; 908 } 909 } 910 911 /* 912 * Finish recovering the file system. This part needed to be delayed 913 * until after the root and real-time bitmap inodes were consistently 914 * read in. 915 */ 916 error = xfs_log_mount_finish(mp); 917 if (error) { 918 xfs_warn(mp, "log mount finish failed"); 919 goto out_rtunmount; 920 } 921 922 /* 923 * Complete the quota initialisation, post-log-replay component. 924 */ 925 if (quotamount) { 926 ASSERT(mp->m_qflags == 0); 927 mp->m_qflags = quotaflags; 928 929 xfs_qm_mount_quotas(mp); 930 } 931 932 /* 933 * Now we are mounted, reserve a small amount of unused space for 934 * privileged transactions. This is needed so that transaction 935 * space required for critical operations can dip into this pool 936 * when at ENOSPC. This is needed for operations like create with 937 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations 938 * are not allowed to use this reserved space. 939 * 940 * This may drive us straight to ENOSPC on mount, but that implies 941 * we were already there on the last unmount. Warn if this occurs. 942 */ 943 if (!(mp->m_flags & XFS_MOUNT_RDONLY)) { 944 resblks = xfs_default_resblks(mp); 945 error = xfs_reserve_blocks(mp, &resblks, NULL); 946 if (error) 947 xfs_warn(mp, 948 "Unable to allocate reserve blocks. Continuing without reserve pool."); 949 } 950 951 return 0; 952 953 out_rtunmount: 954 xfs_rtunmount_inodes(mp); 955 out_rele_rip: 956 IRELE(rip); 957 cancel_delayed_work_sync(&mp->m_reclaim_work); 958 xfs_reclaim_inodes(mp, SYNC_WAIT); 959 out_log_dealloc: 960 xfs_log_mount_cancel(mp); 961 out_fail_wait: 962 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) 963 xfs_wait_buftarg(mp->m_logdev_targp); 964 xfs_wait_buftarg(mp->m_ddev_targp); 965 out_free_perag: 966 xfs_free_perag(mp); 967 out_free_dir: 968 xfs_da_unmount(mp); 969 out_remove_uuid: 970 xfs_uuid_unmount(mp); 971 out_del_stats: 972 xfs_sysfs_del(&mp->m_stats.xs_kobj); 973 out_remove_sysfs: 974 xfs_sysfs_del(&mp->m_kobj); 975 out: 976 return error; 977 } 978 979 /* 980 * This flushes out the inodes,dquots and the superblock, unmounts the 981 * log and makes sure that incore structures are freed. 982 */ 983 void 984 xfs_unmountfs( 985 struct xfs_mount *mp) 986 { 987 __uint64_t resblks; 988 int error; 989 990 cancel_delayed_work_sync(&mp->m_eofblocks_work); 991 992 xfs_qm_unmount_quotas(mp); 993 xfs_rtunmount_inodes(mp); 994 IRELE(mp->m_rootip); 995 996 /* 997 * We can potentially deadlock here if we have an inode cluster 998 * that has been freed has its buffer still pinned in memory because 999 * the transaction is still sitting in a iclog. The stale inodes 1000 * on that buffer will have their flush locks held until the 1001 * transaction hits the disk and the callbacks run. the inode 1002 * flush takes the flush lock unconditionally and with nothing to 1003 * push out the iclog we will never get that unlocked. hence we 1004 * need to force the log first. 1005 */ 1006 xfs_log_force(mp, XFS_LOG_SYNC); 1007 1008 /* 1009 * Flush all pending changes from the AIL. 1010 */ 1011 xfs_ail_push_all_sync(mp->m_ail); 1012 1013 /* 1014 * And reclaim all inodes. At this point there should be no dirty 1015 * inodes and none should be pinned or locked, but use synchronous 1016 * reclaim just to be sure. We can stop background inode reclaim 1017 * here as well if it is still running. 1018 */ 1019 cancel_delayed_work_sync(&mp->m_reclaim_work); 1020 xfs_reclaim_inodes(mp, SYNC_WAIT); 1021 1022 xfs_qm_unmount(mp); 1023 1024 /* 1025 * Unreserve any blocks we have so that when we unmount we don't account 1026 * the reserved free space as used. This is really only necessary for 1027 * lazy superblock counting because it trusts the incore superblock 1028 * counters to be absolutely correct on clean unmount. 1029 * 1030 * We don't bother correcting this elsewhere for lazy superblock 1031 * counting because on mount of an unclean filesystem we reconstruct the 1032 * correct counter value and this is irrelevant. 1033 * 1034 * For non-lazy counter filesystems, this doesn't matter at all because 1035 * we only every apply deltas to the superblock and hence the incore 1036 * value does not matter.... 1037 */ 1038 resblks = 0; 1039 error = xfs_reserve_blocks(mp, &resblks, NULL); 1040 if (error) 1041 xfs_warn(mp, "Unable to free reserved block pool. " 1042 "Freespace may not be correct on next mount."); 1043 1044 error = xfs_log_sbcount(mp); 1045 if (error) 1046 xfs_warn(mp, "Unable to update superblock counters. " 1047 "Freespace may not be correct on next mount."); 1048 1049 1050 xfs_log_unmount(mp); 1051 xfs_da_unmount(mp); 1052 xfs_uuid_unmount(mp); 1053 1054 #if defined(DEBUG) 1055 xfs_errortag_clearall(mp, 0); 1056 #endif 1057 xfs_free_perag(mp); 1058 1059 xfs_sysfs_del(&mp->m_stats.xs_kobj); 1060 xfs_sysfs_del(&mp->m_kobj); 1061 } 1062 1063 /* 1064 * Determine whether modifications can proceed. The caller specifies the minimum 1065 * freeze level for which modifications should not be allowed. This allows 1066 * certain operations to proceed while the freeze sequence is in progress, if 1067 * necessary. 1068 */ 1069 bool 1070 xfs_fs_writable( 1071 struct xfs_mount *mp, 1072 int level) 1073 { 1074 ASSERT(level > SB_UNFROZEN); 1075 if ((mp->m_super->s_writers.frozen >= level) || 1076 XFS_FORCED_SHUTDOWN(mp) || (mp->m_flags & XFS_MOUNT_RDONLY)) 1077 return false; 1078 1079 return true; 1080 } 1081 1082 /* 1083 * xfs_log_sbcount 1084 * 1085 * Sync the superblock counters to disk. 1086 * 1087 * Note this code can be called during the process of freezing, so we use the 1088 * transaction allocator that does not block when the transaction subsystem is 1089 * in its frozen state. 1090 */ 1091 int 1092 xfs_log_sbcount(xfs_mount_t *mp) 1093 { 1094 /* allow this to proceed during the freeze sequence... */ 1095 if (!xfs_fs_writable(mp, SB_FREEZE_COMPLETE)) 1096 return 0; 1097 1098 /* 1099 * we don't need to do this if we are updating the superblock 1100 * counters on every modification. 1101 */ 1102 if (!xfs_sb_version_haslazysbcount(&mp->m_sb)) 1103 return 0; 1104 1105 return xfs_sync_sb(mp, true); 1106 } 1107 1108 /* 1109 * Deltas for the inode count are +/-64, hence we use a large batch size 1110 * of 128 so we don't need to take the counter lock on every update. 1111 */ 1112 #define XFS_ICOUNT_BATCH 128 1113 int 1114 xfs_mod_icount( 1115 struct xfs_mount *mp, 1116 int64_t delta) 1117 { 1118 __percpu_counter_add(&mp->m_icount, delta, XFS_ICOUNT_BATCH); 1119 if (__percpu_counter_compare(&mp->m_icount, 0, XFS_ICOUNT_BATCH) < 0) { 1120 ASSERT(0); 1121 percpu_counter_add(&mp->m_icount, -delta); 1122 return -EINVAL; 1123 } 1124 return 0; 1125 } 1126 1127 int 1128 xfs_mod_ifree( 1129 struct xfs_mount *mp, 1130 int64_t delta) 1131 { 1132 percpu_counter_add(&mp->m_ifree, delta); 1133 if (percpu_counter_compare(&mp->m_ifree, 0) < 0) { 1134 ASSERT(0); 1135 percpu_counter_add(&mp->m_ifree, -delta); 1136 return -EINVAL; 1137 } 1138 return 0; 1139 } 1140 1141 /* 1142 * Deltas for the block count can vary from 1 to very large, but lock contention 1143 * only occurs on frequent small block count updates such as in the delayed 1144 * allocation path for buffered writes (page a time updates). Hence we set 1145 * a large batch count (1024) to minimise global counter updates except when 1146 * we get near to ENOSPC and we have to be very accurate with our updates. 1147 */ 1148 #define XFS_FDBLOCKS_BATCH 1024 1149 int 1150 xfs_mod_fdblocks( 1151 struct xfs_mount *mp, 1152 int64_t delta, 1153 bool rsvd) 1154 { 1155 int64_t lcounter; 1156 long long res_used; 1157 s32 batch; 1158 1159 if (delta > 0) { 1160 /* 1161 * If the reserve pool is depleted, put blocks back into it 1162 * first. Most of the time the pool is full. 1163 */ 1164 if (likely(mp->m_resblks == mp->m_resblks_avail)) { 1165 percpu_counter_add(&mp->m_fdblocks, delta); 1166 return 0; 1167 } 1168 1169 spin_lock(&mp->m_sb_lock); 1170 res_used = (long long)(mp->m_resblks - mp->m_resblks_avail); 1171 1172 if (res_used > delta) { 1173 mp->m_resblks_avail += delta; 1174 } else { 1175 delta -= res_used; 1176 mp->m_resblks_avail = mp->m_resblks; 1177 percpu_counter_add(&mp->m_fdblocks, delta); 1178 } 1179 spin_unlock(&mp->m_sb_lock); 1180 return 0; 1181 } 1182 1183 /* 1184 * Taking blocks away, need to be more accurate the closer we 1185 * are to zero. 1186 * 1187 * If the counter has a value of less than 2 * max batch size, 1188 * then make everything serialise as we are real close to 1189 * ENOSPC. 1190 */ 1191 if (__percpu_counter_compare(&mp->m_fdblocks, 2 * XFS_FDBLOCKS_BATCH, 1192 XFS_FDBLOCKS_BATCH) < 0) 1193 batch = 1; 1194 else 1195 batch = XFS_FDBLOCKS_BATCH; 1196 1197 __percpu_counter_add(&mp->m_fdblocks, delta, batch); 1198 if (__percpu_counter_compare(&mp->m_fdblocks, XFS_ALLOC_SET_ASIDE(mp), 1199 XFS_FDBLOCKS_BATCH) >= 0) { 1200 /* we had space! */ 1201 return 0; 1202 } 1203 1204 /* 1205 * lock up the sb for dipping into reserves before releasing the space 1206 * that took us to ENOSPC. 1207 */ 1208 spin_lock(&mp->m_sb_lock); 1209 percpu_counter_add(&mp->m_fdblocks, -delta); 1210 if (!rsvd) 1211 goto fdblocks_enospc; 1212 1213 lcounter = (long long)mp->m_resblks_avail + delta; 1214 if (lcounter >= 0) { 1215 mp->m_resblks_avail = lcounter; 1216 spin_unlock(&mp->m_sb_lock); 1217 return 0; 1218 } 1219 printk_once(KERN_WARNING 1220 "Filesystem \"%s\": reserve blocks depleted! " 1221 "Consider increasing reserve pool size.", 1222 mp->m_fsname); 1223 fdblocks_enospc: 1224 spin_unlock(&mp->m_sb_lock); 1225 return -ENOSPC; 1226 } 1227 1228 int 1229 xfs_mod_frextents( 1230 struct xfs_mount *mp, 1231 int64_t delta) 1232 { 1233 int64_t lcounter; 1234 int ret = 0; 1235 1236 spin_lock(&mp->m_sb_lock); 1237 lcounter = mp->m_sb.sb_frextents + delta; 1238 if (lcounter < 0) 1239 ret = -ENOSPC; 1240 else 1241 mp->m_sb.sb_frextents = lcounter; 1242 spin_unlock(&mp->m_sb_lock); 1243 return ret; 1244 } 1245 1246 /* 1247 * xfs_getsb() is called to obtain the buffer for the superblock. 1248 * The buffer is returned locked and read in from disk. 1249 * The buffer should be released with a call to xfs_brelse(). 1250 * 1251 * If the flags parameter is BUF_TRYLOCK, then we'll only return 1252 * the superblock buffer if it can be locked without sleeping. 1253 * If it can't then we'll return NULL. 1254 */ 1255 struct xfs_buf * 1256 xfs_getsb( 1257 struct xfs_mount *mp, 1258 int flags) 1259 { 1260 struct xfs_buf *bp = mp->m_sb_bp; 1261 1262 if (!xfs_buf_trylock(bp)) { 1263 if (flags & XBF_TRYLOCK) 1264 return NULL; 1265 xfs_buf_lock(bp); 1266 } 1267 1268 xfs_buf_hold(bp); 1269 ASSERT(bp->b_flags & XBF_DONE); 1270 return bp; 1271 } 1272 1273 /* 1274 * Used to free the superblock along various error paths. 1275 */ 1276 void 1277 xfs_freesb( 1278 struct xfs_mount *mp) 1279 { 1280 struct xfs_buf *bp = mp->m_sb_bp; 1281 1282 xfs_buf_lock(bp); 1283 mp->m_sb_bp = NULL; 1284 xfs_buf_relse(bp); 1285 } 1286 1287 /* 1288 * If the underlying (data/log/rt) device is readonly, there are some 1289 * operations that cannot proceed. 1290 */ 1291 int 1292 xfs_dev_is_read_only( 1293 struct xfs_mount *mp, 1294 char *message) 1295 { 1296 if (xfs_readonly_buftarg(mp->m_ddev_targp) || 1297 xfs_readonly_buftarg(mp->m_logdev_targp) || 1298 (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) { 1299 xfs_notice(mp, "%s required on read-only device.", message); 1300 xfs_notice(mp, "write access unavailable, cannot proceed."); 1301 return -EROFS; 1302 } 1303 return 0; 1304 } 1305