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