1448 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Copyright (c) 2000-2005 Silicon Graphics, Inc.4 * All Rights Reserved.5 */6#include "xfs.h"7#include "xfs_fs.h"8#include "xfs_shared.h"9#include "xfs_format.h"10#include "xfs_log_format.h"11#include "xfs_trans_resv.h"12#include "xfs_bit.h"13#include "xfs_sb.h"14#include "xfs_mount.h"15#include "xfs_inode.h"16#include "xfs_dir2.h"17#include "xfs_ialloc.h"18#include "xfs_alloc.h"19#include "xfs_rtalloc.h"20#include "xfs_bmap.h"21#include "xfs_trans.h"22#include "xfs_trans_priv.h"23#include "xfs_log.h"24#include "xfs_log_priv.h"25#include "xfs_error.h"26#include "xfs_quota.h"27#include "xfs_fsops.h"28#include "xfs_icache.h"29#include "xfs_sysfs.h"30#include "xfs_rmap_btree.h"31#include "xfs_refcount_btree.h"32#include "xfs_reflink.h"33#include "xfs_extent_busy.h"34#include "xfs_health.h"35#include "xfs_trace.h"36#include "xfs_ag.h"37#include "xfs_rtbitmap.h"38#include "scrub/stats.h"39 40static DEFINE_MUTEX(xfs_uuid_table_mutex);41static int xfs_uuid_table_size;42static uuid_t *xfs_uuid_table;43 44void45xfs_uuid_table_free(void)46{47 if (xfs_uuid_table_size == 0)48 return;49 kfree(xfs_uuid_table);50 xfs_uuid_table = NULL;51 xfs_uuid_table_size = 0;52}53 54/*55 * See if the UUID is unique among mounted XFS filesystems.56 * Mount fails if UUID is nil or a FS with the same UUID is already mounted.57 */58STATIC int59xfs_uuid_mount(60 struct xfs_mount *mp)61{62 uuid_t *uuid = &mp->m_sb.sb_uuid;63 int hole, i;64 65 /* Publish UUID in struct super_block */66 super_set_uuid(mp->m_super, uuid->b, sizeof(*uuid));67 68 if (xfs_has_nouuid(mp))69 return 0;70 71 if (uuid_is_null(uuid)) {72 xfs_warn(mp, "Filesystem has null UUID - can't mount");73 return -EINVAL;74 }75 76 mutex_lock(&xfs_uuid_table_mutex);77 for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) {78 if (uuid_is_null(&xfs_uuid_table[i])) {79 hole = i;80 continue;81 }82 if (uuid_equal(uuid, &xfs_uuid_table[i]))83 goto out_duplicate;84 }85 86 if (hole < 0) {87 xfs_uuid_table = krealloc(xfs_uuid_table,88 (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table),89 GFP_KERNEL | __GFP_NOFAIL);90 hole = xfs_uuid_table_size++;91 }92 xfs_uuid_table[hole] = *uuid;93 mutex_unlock(&xfs_uuid_table_mutex);94 95 return 0;96 97 out_duplicate:98 mutex_unlock(&xfs_uuid_table_mutex);99 xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid);100 return -EINVAL;101}102 103STATIC void104xfs_uuid_unmount(105 struct xfs_mount *mp)106{107 uuid_t *uuid = &mp->m_sb.sb_uuid;108 int i;109 110 if (xfs_has_nouuid(mp))111 return;112 113 mutex_lock(&xfs_uuid_table_mutex);114 for (i = 0; i < xfs_uuid_table_size; i++) {115 if (uuid_is_null(&xfs_uuid_table[i]))116 continue;117 if (!uuid_equal(uuid, &xfs_uuid_table[i]))118 continue;119 memset(&xfs_uuid_table[i], 0, sizeof(uuid_t));120 break;121 }122 ASSERT(i < xfs_uuid_table_size);123 mutex_unlock(&xfs_uuid_table_mutex);124}125 126/*127 * Check size of device based on the (data/realtime) block count.128 * Note: this check is used by the growfs code as well as mount.129 */130int131xfs_sb_validate_fsb_count(132 xfs_sb_t *sbp,133 uint64_t nblocks)134{135 uint64_t max_bytes;136 137 ASSERT(sbp->sb_blocklog >= BBSHIFT);138 139 if (check_shl_overflow(nblocks, sbp->sb_blocklog, &max_bytes))140 return -EFBIG;141 142 /* Limited by ULONG_MAX of page cache index */143 if (max_bytes >> PAGE_SHIFT > ULONG_MAX)144 return -EFBIG;145 return 0;146}147 148/*149 * xfs_readsb150 *151 * Does the initial read of the superblock.152 */153int154xfs_readsb(155 struct xfs_mount *mp,156 int flags)157{158 unsigned int sector_size;159 struct xfs_buf *bp;160 struct xfs_sb *sbp = &mp->m_sb;161 int error;162 int loud = !(flags & XFS_MFSI_QUIET);163 const struct xfs_buf_ops *buf_ops;164 165 ASSERT(mp->m_sb_bp == NULL);166 ASSERT(mp->m_ddev_targp != NULL);167 168 /*169 * For the initial read, we must guess at the sector170 * size based on the block device. It's enough to171 * get the sb_sectsize out of the superblock and172 * then reread with the proper length.173 * We don't verify it yet, because it may not be complete.174 */175 sector_size = xfs_getsize_buftarg(mp->m_ddev_targp);176 buf_ops = NULL;177 178 /*179 * Allocate a (locked) buffer to hold the superblock. This will be kept180 * around at all times to optimize access to the superblock. Therefore,181 * set XBF_NO_IOACCT to make sure it doesn't hold the buftarg count182 * elevated.183 */184reread:185 error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR,186 BTOBB(sector_size), XBF_NO_IOACCT, &bp,187 buf_ops);188 if (error) {189 if (loud)190 xfs_warn(mp, "SB validate failed with error %d.", error);191 /* bad CRC means corrupted metadata */192 if (error == -EFSBADCRC)193 error = -EFSCORRUPTED;194 return error;195 }196 197 /*198 * Initialize the mount structure from the superblock.199 */200 xfs_sb_from_disk(sbp, bp->b_addr);201 202 /*203 * If we haven't validated the superblock, do so now before we try204 * to check the sector size and reread the superblock appropriately.205 */206 if (sbp->sb_magicnum != XFS_SB_MAGIC) {207 if (loud)208 xfs_warn(mp, "Invalid superblock magic number");209 error = -EINVAL;210 goto release_buf;211 }212 213 /*214 * We must be able to do sector-sized and sector-aligned IO.215 */216 if (sector_size > sbp->sb_sectsize) {217 if (loud)218 xfs_warn(mp, "device supports %u byte sectors (not %u)",219 sector_size, sbp->sb_sectsize);220 error = -ENOSYS;221 goto release_buf;222 }223 224 if (buf_ops == NULL) {225 /*226 * Re-read the superblock so the buffer is correctly sized,227 * and properly verified.228 */229 xfs_buf_relse(bp);230 sector_size = sbp->sb_sectsize;231 buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops;232 goto reread;233 }234 235 mp->m_features |= xfs_sb_version_to_features(sbp);236 xfs_reinit_percpu_counters(mp);237 238 /*239 * If logged xattrs are enabled after log recovery finishes, then set240 * the opstate so that log recovery will work properly.241 */242 if (xfs_sb_version_haslogxattrs(&mp->m_sb))243 xfs_set_using_logged_xattrs(mp);244 245 /* no need to be quiet anymore, so reset the buf ops */246 bp->b_ops = &xfs_sb_buf_ops;247 248 mp->m_sb_bp = bp;249 xfs_buf_unlock(bp);250 return 0;251 252release_buf:253 xfs_buf_relse(bp);254 return error;255}256 257/*258 * If the sunit/swidth change would move the precomputed root inode value, we259 * must reject the ondisk change because repair will stumble over that.260 * However, we allow the mount to proceed because we never rejected this261 * combination before. Returns true to update the sb, false otherwise.262 */263static inline int264xfs_check_new_dalign(265 struct xfs_mount *mp,266 int new_dalign,267 bool *update_sb)268{269 struct xfs_sb *sbp = &mp->m_sb;270 xfs_ino_t calc_ino;271 272 calc_ino = xfs_ialloc_calc_rootino(mp, new_dalign);273 trace_xfs_check_new_dalign(mp, new_dalign, calc_ino);274 275 if (sbp->sb_rootino == calc_ino) {276 *update_sb = true;277 return 0;278 }279 280 xfs_warn(mp,281"Cannot change stripe alignment; would require moving root inode.");282 283 /*284 * XXX: Next time we add a new incompat feature, this should start285 * returning -EINVAL to fail the mount. Until then, spit out a warning286 * that we're ignoring the administrator's instructions.287 */288 xfs_warn(mp, "Skipping superblock stripe alignment update.");289 *update_sb = false;290 return 0;291}292 293/*294 * If we were provided with new sunit/swidth values as mount options, make sure295 * that they pass basic alignment and superblock feature checks, and convert296 * them into the same units (FSB) that everything else expects. This step297 * /must/ be done before computing the inode geometry.298 */299STATIC int300xfs_validate_new_dalign(301 struct xfs_mount *mp)302{303 if (mp->m_dalign == 0)304 return 0;305 306 /*307 * If stripe unit and stripe width are not multiples308 * of the fs blocksize turn off alignment.309 */310 if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||311 (BBTOB(mp->m_swidth) & mp->m_blockmask)) {312 xfs_warn(mp,313 "alignment check failed: sunit/swidth vs. blocksize(%d)",314 mp->m_sb.sb_blocksize);315 return -EINVAL;316 }317 318 /*319 * Convert the stripe unit and width to FSBs.320 */321 mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);322 if (mp->m_dalign && (mp->m_sb.sb_agblocks % mp->m_dalign)) {323 xfs_warn(mp,324 "alignment check failed: sunit/swidth vs. agsize(%d)",325 mp->m_sb.sb_agblocks);326 return -EINVAL;327 }328 329 if (!mp->m_dalign) {330 xfs_warn(mp,331 "alignment check failed: sunit(%d) less than bsize(%d)",332 mp->m_dalign, mp->m_sb.sb_blocksize);333 return -EINVAL;334 }335 336 mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);337 338 if (!xfs_has_dalign(mp)) {339 xfs_warn(mp,340"cannot change alignment: superblock does not support data alignment");341 return -EINVAL;342 }343 344 return 0;345}346 347/* Update alignment values based on mount options and sb values. */348STATIC int349xfs_update_alignment(350 struct xfs_mount *mp)351{352 struct xfs_sb *sbp = &mp->m_sb;353 354 if (mp->m_dalign) {355 bool update_sb;356 int error;357 358 if (sbp->sb_unit == mp->m_dalign &&359 sbp->sb_width == mp->m_swidth)360 return 0;361 362 error = xfs_check_new_dalign(mp, mp->m_dalign, &update_sb);363 if (error || !update_sb)364 return error;365 366 sbp->sb_unit = mp->m_dalign;367 sbp->sb_width = mp->m_swidth;368 mp->m_update_sb = true;369 } else if (!xfs_has_noalign(mp) && xfs_has_dalign(mp)) {370 mp->m_dalign = sbp->sb_unit;371 mp->m_swidth = sbp->sb_width;372 }373 374 return 0;375}376 377/*378 * precalculate the low space thresholds for dynamic speculative preallocation.379 */380void381xfs_set_low_space_thresholds(382 struct xfs_mount *mp)383{384 uint64_t dblocks = mp->m_sb.sb_dblocks;385 uint64_t rtexts = mp->m_sb.sb_rextents;386 int i;387 388 do_div(dblocks, 100);389 do_div(rtexts, 100);390 391 for (i = 0; i < XFS_LOWSP_MAX; i++) {392 mp->m_low_space[i] = dblocks * (i + 1);393 mp->m_low_rtexts[i] = rtexts * (i + 1);394 }395}396 397/*398 * Check that the data (and log if separate) is an ok size.399 */400STATIC int401xfs_check_sizes(402 struct xfs_mount *mp)403{404 struct xfs_buf *bp;405 xfs_daddr_t d;406 int error;407 408 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks);409 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) {410 xfs_warn(mp, "filesystem size mismatch detected");411 return -EFBIG;412 }413 error = xfs_buf_read_uncached(mp->m_ddev_targp,414 d - XFS_FSS_TO_BB(mp, 1),415 XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL);416 if (error) {417 xfs_warn(mp, "last sector read failed");418 return error;419 }420 xfs_buf_relse(bp);421 422 if (mp->m_logdev_targp == mp->m_ddev_targp)423 return 0;424 425 d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks);426 if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) {427 xfs_warn(mp, "log size mismatch detected");428 return -EFBIG;429 }430 error = xfs_buf_read_uncached(mp->m_logdev_targp,431 d - XFS_FSB_TO_BB(mp, 1),432 XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL);433 if (error) {434 xfs_warn(mp, "log device read failed");435 return error;436 }437 xfs_buf_relse(bp);438 return 0;439}440 441/*442 * Clear the quotaflags in memory and in the superblock.443 */444int445xfs_mount_reset_sbqflags(446 struct xfs_mount *mp)447{448 mp->m_qflags = 0;449 450 /* It is OK to look at sb_qflags in the mount path without m_sb_lock. */451 if (mp->m_sb.sb_qflags == 0)452 return 0;453 spin_lock(&mp->m_sb_lock);454 mp->m_sb.sb_qflags = 0;455 spin_unlock(&mp->m_sb_lock);456 457 if (!xfs_fs_writable(mp, SB_FREEZE_WRITE))458 return 0;459 460 return xfs_sync_sb(mp, false);461}462 463uint64_t464xfs_default_resblks(xfs_mount_t *mp)465{466 uint64_t resblks;467 468 /*469 * We default to 5% or 8192 fsbs of space reserved, whichever is470 * smaller. This is intended to cover concurrent allocation471 * transactions when we initially hit enospc. These each require a 4472 * block reservation. Hence by default we cover roughly 2000 concurrent473 * allocation reservations.474 */475 resblks = mp->m_sb.sb_dblocks;476 do_div(resblks, 20);477 resblks = min_t(uint64_t, resblks, 8192);478 return resblks;479}480 481/* Ensure the summary counts are correct. */482STATIC int483xfs_check_summary_counts(484 struct xfs_mount *mp)485{486 int error = 0;487 488 /*489 * The AG0 superblock verifier rejects in-progress filesystems,490 * so we should never see the flag set this far into mounting.491 */492 if (mp->m_sb.sb_inprogress) {493 xfs_err(mp, "sb_inprogress set after log recovery??");494 WARN_ON(1);495 return -EFSCORRUPTED;496 }497 498 /*499 * Now the log is mounted, we know if it was an unclean shutdown or500 * not. If it was, with the first phase of recovery has completed, we501 * have consistent AG blocks on disk. We have not recovered EFIs yet,502 * but they are recovered transactionally in the second recovery phase503 * later.504 *505 * If the log was clean when we mounted, we can check the summary506 * counters. If any of them are obviously incorrect, we can recompute507 * them from the AGF headers in the next step.508 */509 if (xfs_is_clean(mp) &&510 (mp->m_sb.sb_fdblocks > mp->m_sb.sb_dblocks ||511 !xfs_verify_icount(mp, mp->m_sb.sb_icount) ||512 mp->m_sb.sb_ifree > mp->m_sb.sb_icount))513 xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);514 515 /*516 * We can safely re-initialise incore superblock counters from the517 * per-ag data. These may not be correct if the filesystem was not518 * cleanly unmounted, so we waited for recovery to finish before doing519 * this.520 *521 * If the filesystem was cleanly unmounted or the previous check did522 * not flag anything weird, then we can trust the values in the523 * superblock to be correct and we don't need to do anything here.524 * Otherwise, recalculate the summary counters.525 */526 if ((xfs_has_lazysbcount(mp) && !xfs_is_clean(mp)) ||527 xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS)) {528 error = xfs_initialize_perag_data(mp, mp->m_sb.sb_agcount);529 if (error)530 return error;531 }532 533 /*534 * Older kernels misused sb_frextents to reflect both incore535 * reservations made by running transactions and the actual count of536 * free rt extents in the ondisk metadata. Transactions committed537 * during runtime can therefore contain a superblock update that538 * undercounts the number of free rt extents tracked in the rt bitmap.539 * A clean unmount record will have the correct frextents value since540 * there can be no other transactions running at that point.541 *542 * If we're mounting the rt volume after recovering the log, recompute543 * frextents from the rtbitmap file to fix the inconsistency.544 */545 if (xfs_has_realtime(mp) && !xfs_is_clean(mp)) {546 error = xfs_rtalloc_reinit_frextents(mp);547 if (error)548 return error;549 }550 551 return 0;552}553 554static void555xfs_unmount_check(556 struct xfs_mount *mp)557{558 if (xfs_is_shutdown(mp))559 return;560 561 if (percpu_counter_sum(&mp->m_ifree) >562 percpu_counter_sum(&mp->m_icount)) {563 xfs_alert(mp, "ifree/icount mismatch at unmount");564 xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);565 }566}567 568/*569 * Flush and reclaim dirty inodes in preparation for unmount. Inodes and570 * internal inode structures can be sitting in the CIL and AIL at this point,571 * so we need to unpin them, write them back and/or reclaim them before unmount572 * can proceed. In other words, callers are required to have inactivated all573 * inodes.574 *575 * An inode cluster that has been freed can have its buffer still pinned in576 * memory because the transaction is still sitting in a iclog. The stale inodes577 * on that buffer will be pinned to the buffer until the transaction hits the578 * disk and the callbacks run. Pushing the AIL will skip the stale inodes and579 * may never see the pinned buffer, so nothing will push out the iclog and580 * unpin the buffer.581 *582 * Hence we need to force the log to unpin everything first. However, log583 * forces don't wait for the discards they issue to complete, so we have to584 * explicitly wait for them to complete here as well.585 *586 * Then we can tell the world we are unmounting so that error handling knows587 * that the filesystem is going away and we should error out anything that we588 * have been retrying in the background. This will prevent never-ending589 * retries in AIL pushing from hanging the unmount.590 *591 * Finally, we can push the AIL to clean all the remaining dirty objects, then592 * reclaim the remaining inodes that are still in memory at this point in time.593 */594static void595xfs_unmount_flush_inodes(596 struct xfs_mount *mp)597{598 xfs_log_force(mp, XFS_LOG_SYNC);599 xfs_extent_busy_wait_all(mp);600 flush_workqueue(xfs_discard_wq);601 602 xfs_set_unmounting(mp);603 604 xfs_ail_push_all_sync(mp->m_ail);605 xfs_inodegc_stop(mp);606 cancel_delayed_work_sync(&mp->m_reclaim_work);607 xfs_reclaim_inodes(mp);608 xfs_health_unmount(mp);609}610 611static void612xfs_mount_setup_inode_geom(613 struct xfs_mount *mp)614{615 struct xfs_ino_geometry *igeo = M_IGEO(mp);616 617 igeo->attr_fork_offset = xfs_bmap_compute_attr_offset(mp);618 ASSERT(igeo->attr_fork_offset < XFS_LITINO(mp));619 620 xfs_ialloc_setup_geometry(mp);621}622 623/* Compute maximum possible height for per-AG btree types for this fs. */624static inline void625xfs_agbtree_compute_maxlevels(626 struct xfs_mount *mp)627{628 unsigned int levels;629 630 levels = max(mp->m_alloc_maxlevels, M_IGEO(mp)->inobt_maxlevels);631 levels = max(levels, mp->m_rmap_maxlevels);632 mp->m_agbtree_maxlevels = max(levels, mp->m_refc_maxlevels);633}634 635/*636 * This function does the following on an initial mount of a file system:637 * - reads the superblock from disk and init the mount struct638 * - if we're a 32-bit kernel, do a size check on the superblock639 * so we don't mount terabyte filesystems640 * - init mount struct realtime fields641 * - allocate inode hash table for fs642 * - init directory manager643 * - perform recovery and init the log manager644 */645int646xfs_mountfs(647 struct xfs_mount *mp)648{649 struct xfs_sb *sbp = &(mp->m_sb);650 struct xfs_inode *rip;651 struct xfs_ino_geometry *igeo = M_IGEO(mp);652 uint quotamount = 0;653 uint quotaflags = 0;654 int error = 0;655 656 xfs_sb_mount_common(mp, sbp);657 658 /*659 * Check for a mismatched features2 values. Older kernels read & wrote660 * into the wrong sb offset for sb_features2 on some platforms due to661 * xfs_sb_t not being 64bit size aligned when sb_features2 was added,662 * which made older superblock reading/writing routines swap it as a663 * 64-bit value.664 *665 * For backwards compatibility, we make both slots equal.666 *667 * If we detect a mismatched field, we OR the set bits into the existing668 * features2 field in case it has already been modified; we don't want669 * to lose any features. We then update the bad location with the ORed670 * value so that older kernels will see any features2 flags. The671 * superblock writeback code ensures the new sb_features2 is copied to672 * sb_bad_features2 before it is logged or written to disk.673 */674 if (xfs_sb_has_mismatched_features2(sbp)) {675 xfs_warn(mp, "correcting sb_features alignment problem");676 sbp->sb_features2 |= sbp->sb_bad_features2;677 mp->m_update_sb = true;678 }679 680 681 /* always use v2 inodes by default now */682 if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) {683 mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT;684 mp->m_features |= XFS_FEAT_NLINK;685 mp->m_update_sb = true;686 }687 688 /*689 * If we were given new sunit/swidth options, do some basic validation690 * checks and convert the incore dalign and swidth values to the691 * same units (FSB) that everything else uses. This /must/ happen692 * before computing the inode geometry.693 */694 error = xfs_validate_new_dalign(mp);695 if (error)696 goto out;697 698 xfs_alloc_compute_maxlevels(mp);699 xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);700 xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);701 xfs_mount_setup_inode_geom(mp);702 xfs_rmapbt_compute_maxlevels(mp);703 xfs_refcountbt_compute_maxlevels(mp);704 705 xfs_agbtree_compute_maxlevels(mp);706 707 /*708 * Check if sb_agblocks is aligned at stripe boundary. If sb_agblocks709 * is NOT aligned turn off m_dalign since allocator alignment is within710 * an ag, therefore ag has to be aligned at stripe boundary. Note that711 * we must compute the free space and rmap btree geometry before doing712 * this.713 */714 error = xfs_update_alignment(mp);715 if (error)716 goto out;717 718 /* enable fail_at_unmount as default */719 mp->m_fail_unmount = true;720 721 super_set_sysfs_name_id(mp->m_super);722 723 error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype,724 NULL, mp->m_super->s_id);725 if (error)726 goto out;727 728 error = xfs_sysfs_init(&mp->m_stats.xs_kobj, &xfs_stats_ktype,729 &mp->m_kobj, "stats");730 if (error)731 goto out_remove_sysfs;732 733 xchk_stats_register(mp->m_scrub_stats, mp->m_debugfs);734 735 error = xfs_error_sysfs_init(mp);736 if (error)737 goto out_remove_scrub_stats;738 739 error = xfs_errortag_init(mp);740 if (error)741 goto out_remove_error_sysfs;742 743 error = xfs_uuid_mount(mp);744 if (error)745 goto out_remove_errortag;746 747 /*748 * Update the preferred write size based on the information from the749 * on-disk superblock.750 */751 mp->m_allocsize_log =752 max_t(uint32_t, sbp->sb_blocklog, mp->m_allocsize_log);753 mp->m_allocsize_blocks = 1U << (mp->m_allocsize_log - sbp->sb_blocklog);754 755 /* set the low space thresholds for dynamic preallocation */756 xfs_set_low_space_thresholds(mp);757 758 /*759 * If enabled, sparse inode chunk alignment is expected to match the760 * cluster size. Full inode chunk alignment must match the chunk size,761 * but that is checked on sb read verification...762 */763 if (xfs_has_sparseinodes(mp) &&764 mp->m_sb.sb_spino_align !=765 XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw)) {766 xfs_warn(mp,767 "Sparse inode block alignment (%u) must match cluster size (%llu).",768 mp->m_sb.sb_spino_align,769 XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw));770 error = -EINVAL;771 goto out_remove_uuid;772 }773 774 /*775 * Check that the data (and log if separate) is an ok size.776 */777 error = xfs_check_sizes(mp);778 if (error)779 goto out_remove_uuid;780 781 /*782 * Initialize realtime fields in the mount structure783 */784 error = xfs_rtmount_init(mp);785 if (error) {786 xfs_warn(mp, "RT mount failed");787 goto out_remove_uuid;788 }789 790 /*791 * Copies the low order bits of the timestamp and the randomly792 * set "sequence" number out of a UUID.793 */794 mp->m_fixedfsid[0] =795 (get_unaligned_be16(&sbp->sb_uuid.b[8]) << 16) |796 get_unaligned_be16(&sbp->sb_uuid.b[4]);797 mp->m_fixedfsid[1] = get_unaligned_be32(&sbp->sb_uuid.b[0]);798 799 error = xfs_da_mount(mp);800 if (error) {801 xfs_warn(mp, "Failed dir/attr init: %d", error);802 goto out_remove_uuid;803 }804 805 /*806 * Initialize the precomputed transaction reservations values.807 */808 xfs_trans_init(mp);809 810 /*811 * Allocate and initialize the per-ag data.812 */813 error = xfs_initialize_perag(mp, 0, sbp->sb_agcount,814 mp->m_sb.sb_dblocks, &mp->m_maxagi);815 if (error) {816 xfs_warn(mp, "Failed per-ag init: %d", error);817 goto out_free_dir;818 }819 820 if (XFS_IS_CORRUPT(mp, !sbp->sb_logblocks)) {821 xfs_warn(mp, "no log defined");822 error = -EFSCORRUPTED;823 goto out_free_perag;824 }825 826 error = xfs_inodegc_register_shrinker(mp);827 if (error)828 goto out_fail_wait;829 830 /*831 * Log's mount-time initialization. The first part of recovery can place832 * some items on the AIL, to be handled when recovery is finished or833 * cancelled.834 */835 error = xfs_log_mount(mp, mp->m_logdev_targp,836 XFS_FSB_TO_DADDR(mp, sbp->sb_logstart),837 XFS_FSB_TO_BB(mp, sbp->sb_logblocks));838 if (error) {839 xfs_warn(mp, "log mount failed");840 goto out_inodegc_shrinker;841 }842 843 /*844 * If logged xattrs are still enabled after log recovery finishes, then845 * they'll be available until unmount. Otherwise, turn them off.846 */847 if (xfs_sb_version_haslogxattrs(&mp->m_sb))848 xfs_set_using_logged_xattrs(mp);849 else850 xfs_clear_using_logged_xattrs(mp);851 852 /* Enable background inode inactivation workers. */853 xfs_inodegc_start(mp);854 xfs_blockgc_start(mp);855 856 /*857 * Now that we've recovered any pending superblock feature bit858 * additions, we can finish setting up the attr2 behaviour for the859 * mount. The noattr2 option overrides the superblock flag, so only860 * check the superblock feature flag if the mount option is not set.861 */862 if (xfs_has_noattr2(mp)) {863 mp->m_features &= ~XFS_FEAT_ATTR2;864 } else if (!xfs_has_attr2(mp) &&865 (mp->m_sb.sb_features2 & XFS_SB_VERSION2_ATTR2BIT)) {866 mp->m_features |= XFS_FEAT_ATTR2;867 }868 869 /*870 * Get and sanity-check the root inode.871 * Save the pointer to it in the mount structure.872 */873 error = xfs_iget(mp, NULL, sbp->sb_rootino, XFS_IGET_UNTRUSTED,874 XFS_ILOCK_EXCL, &rip);875 if (error) {876 xfs_warn(mp,877 "Failed to read root inode 0x%llx, error %d",878 sbp->sb_rootino, -error);879 goto out_log_dealloc;880 }881 882 ASSERT(rip != NULL);883 884 if (XFS_IS_CORRUPT(mp, !S_ISDIR(VFS_I(rip)->i_mode))) {885 xfs_warn(mp, "corrupted root inode %llu: not a directory",886 (unsigned long long)rip->i_ino);887 xfs_iunlock(rip, XFS_ILOCK_EXCL);888 error = -EFSCORRUPTED;889 goto out_rele_rip;890 }891 mp->m_rootip = rip; /* save it */892 893 xfs_iunlock(rip, XFS_ILOCK_EXCL);894 895 /*896 * Initialize realtime inode pointers in the mount structure897 */898 error = xfs_rtmount_inodes(mp);899 if (error) {900 /*901 * Free up the root inode.902 */903 xfs_warn(mp, "failed to read RT inodes");904 goto out_rele_rip;905 }906 907 /* Make sure the summary counts are ok. */908 error = xfs_check_summary_counts(mp);909 if (error)910 goto out_rtunmount;911 912 /*913 * If this is a read-only mount defer the superblock updates until914 * the next remount into writeable mode. Otherwise we would never915 * perform the update e.g. for the root filesystem.916 */917 if (mp->m_update_sb && !xfs_is_readonly(mp)) {918 error = xfs_sync_sb(mp, false);919 if (error) {920 xfs_warn(mp, "failed to write sb changes");921 goto out_rtunmount;922 }923 }924 925 /*926 * Initialise the XFS quota management subsystem for this mount927 */928 if (XFS_IS_QUOTA_ON(mp)) {929 error = xfs_qm_newmount(mp, "amount, "aflags);930 if (error)931 goto out_rtunmount;932 } else {933 /*934 * If a file system had quotas running earlier, but decided to935 * mount without -o uquota/pquota/gquota options, revoke the936 * quotachecked license.937 */938 if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) {939 xfs_notice(mp, "resetting quota flags");940 error = xfs_mount_reset_sbqflags(mp);941 if (error)942 goto out_rtunmount;943 }944 }945 946 /*947 * Finish recovering the file system. This part needed to be delayed948 * until after the root and real-time bitmap inodes were consistently949 * read in. Temporarily create per-AG space reservations for metadata950 * btree shape changes because space freeing transactions (for inode951 * inactivation) require the per-AG reservation in lieu of reserving952 * blocks.953 */954 error = xfs_fs_reserve_ag_blocks(mp);955 if (error && error == -ENOSPC)956 xfs_warn(mp,957 "ENOSPC reserving per-AG metadata pool, log recovery may fail.");958 error = xfs_log_mount_finish(mp);959 xfs_fs_unreserve_ag_blocks(mp);960 if (error) {961 xfs_warn(mp, "log mount finish failed");962 goto out_rtunmount;963 }964 965 /*966 * Now the log is fully replayed, we can transition to full read-only967 * mode for read-only mounts. This will sync all the metadata and clean968 * the log so that the recovery we just performed does not have to be969 * replayed again on the next mount.970 *971 * We use the same quiesce mechanism as the rw->ro remount, as they are972 * semantically identical operations.973 */974 if (xfs_is_readonly(mp) && !xfs_has_norecovery(mp))975 xfs_log_clean(mp);976 977 /*978 * Complete the quota initialisation, post-log-replay component.979 */980 if (quotamount) {981 ASSERT(mp->m_qflags == 0);982 mp->m_qflags = quotaflags;983 984 xfs_qm_mount_quotas(mp);985 }986 987 /*988 * Now we are mounted, reserve a small amount of unused space for989 * privileged transactions. This is needed so that transaction990 * space required for critical operations can dip into this pool991 * when at ENOSPC. This is needed for operations like create with992 * attr, unwritten extent conversion at ENOSPC, etc. Data allocations993 * are not allowed to use this reserved space.994 *995 * This may drive us straight to ENOSPC on mount, but that implies996 * we were already there on the last unmount. Warn if this occurs.997 */998 if (!xfs_is_readonly(mp)) {999 error = xfs_reserve_blocks(mp, xfs_default_resblks(mp));1000 if (error)1001 xfs_warn(mp,1002 "Unable to allocate reserve blocks. Continuing without reserve pool.");1003 1004 /* Reserve AG blocks for future btree expansion. */1005 error = xfs_fs_reserve_ag_blocks(mp);1006 if (error && error != -ENOSPC)1007 goto out_agresv;1008 }1009 1010 return 0;1011 1012 out_agresv:1013 xfs_fs_unreserve_ag_blocks(mp);1014 xfs_qm_unmount_quotas(mp);1015 out_rtunmount:1016 xfs_rtunmount_inodes(mp);1017 out_rele_rip:1018 xfs_irele(rip);1019 /* Clean out dquots that might be in memory after quotacheck. */1020 xfs_qm_unmount(mp);1021 1022 /*1023 * Inactivate all inodes that might still be in memory after a log1024 * intent recovery failure so that reclaim can free them. Metadata1025 * inodes and the root directory shouldn't need inactivation, but the1026 * mount failed for some reason, so pull down all the state and flee.1027 */1028 xfs_inodegc_flush(mp);1029 1030 /*1031 * Flush all inode reclamation work and flush the log.1032 * We have to do this /after/ rtunmount and qm_unmount because those1033 * two will have scheduled delayed reclaim for the rt/quota inodes.1034 *1035 * This is slightly different from the unmountfs call sequence1036 * because we could be tearing down a partially set up mount. In1037 * particular, if log_mount_finish fails we bail out without calling1038 * qm_unmount_quotas and therefore rely on qm_unmount to release the1039 * quota inodes.1040 */1041 xfs_unmount_flush_inodes(mp);1042 out_log_dealloc:1043 xfs_log_mount_cancel(mp);1044 out_inodegc_shrinker:1045 shrinker_free(mp->m_inodegc_shrinker);1046 out_fail_wait:1047 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)1048 xfs_buftarg_drain(mp->m_logdev_targp);1049 xfs_buftarg_drain(mp->m_ddev_targp);1050 out_free_perag:1051 xfs_free_perag_range(mp, 0, mp->m_sb.sb_agcount);1052 out_free_dir:1053 xfs_da_unmount(mp);1054 out_remove_uuid:1055 xfs_uuid_unmount(mp);1056 out_remove_errortag:1057 xfs_errortag_del(mp);1058 out_remove_error_sysfs:1059 xfs_error_sysfs_del(mp);1060 out_remove_scrub_stats:1061 xchk_stats_unregister(mp->m_scrub_stats);1062 xfs_sysfs_del(&mp->m_stats.xs_kobj);1063 out_remove_sysfs:1064 xfs_sysfs_del(&mp->m_kobj);1065 out:1066 return error;1067}1068 1069/*1070 * This flushes out the inodes,dquots and the superblock, unmounts the1071 * log and makes sure that incore structures are freed.1072 */1073void1074xfs_unmountfs(1075 struct xfs_mount *mp)1076{1077 int error;1078 1079 /*1080 * Perform all on-disk metadata updates required to inactivate inodes1081 * that the VFS evicted earlier in the unmount process. Freeing inodes1082 * and discarding CoW fork preallocations can cause shape changes to1083 * the free inode and refcount btrees, respectively, so we must finish1084 * this before we discard the metadata space reservations. Metadata1085 * inodes and the root directory do not require inactivation.1086 */1087 xfs_inodegc_flush(mp);1088 1089 xfs_blockgc_stop(mp);1090 xfs_fs_unreserve_ag_blocks(mp);1091 xfs_qm_unmount_quotas(mp);1092 xfs_rtunmount_inodes(mp);1093 xfs_irele(mp->m_rootip);1094 1095 xfs_unmount_flush_inodes(mp);1096 1097 xfs_qm_unmount(mp);1098 1099 /*1100 * Unreserve any blocks we have so that when we unmount we don't account1101 * the reserved free space as used. This is really only necessary for1102 * lazy superblock counting because it trusts the incore superblock1103 * counters to be absolutely correct on clean unmount.1104 *1105 * We don't bother correcting this elsewhere for lazy superblock1106 * counting because on mount of an unclean filesystem we reconstruct the1107 * correct counter value and this is irrelevant.1108 *1109 * For non-lazy counter filesystems, this doesn't matter at all because1110 * we only every apply deltas to the superblock and hence the incore1111 * value does not matter....1112 */1113 error = xfs_reserve_blocks(mp, 0);1114 if (error)1115 xfs_warn(mp, "Unable to free reserved block pool. "1116 "Freespace may not be correct on next mount.");1117 xfs_unmount_check(mp);1118 1119 /*1120 * Indicate that it's ok to clear log incompat bits before cleaning1121 * the log and writing the unmount record.1122 */1123 xfs_set_done_with_log_incompat(mp);1124 xfs_log_unmount(mp);1125 xfs_da_unmount(mp);1126 xfs_uuid_unmount(mp);1127 1128#if defined(DEBUG)1129 xfs_errortag_clearall(mp);1130#endif1131 shrinker_free(mp->m_inodegc_shrinker);1132 xfs_free_perag_range(mp, 0, mp->m_sb.sb_agcount);1133 xfs_errortag_del(mp);1134 xfs_error_sysfs_del(mp);1135 xchk_stats_unregister(mp->m_scrub_stats);1136 xfs_sysfs_del(&mp->m_stats.xs_kobj);1137 xfs_sysfs_del(&mp->m_kobj);1138}1139 1140/*1141 * Determine whether modifications can proceed. The caller specifies the minimum1142 * freeze level for which modifications should not be allowed. This allows1143 * certain operations to proceed while the freeze sequence is in progress, if1144 * necessary.1145 */1146bool1147xfs_fs_writable(1148 struct xfs_mount *mp,1149 int level)1150{1151 ASSERT(level > SB_UNFROZEN);1152 if ((mp->m_super->s_writers.frozen >= level) ||1153 xfs_is_shutdown(mp) || xfs_is_readonly(mp))1154 return false;1155 1156 return true;1157}1158 1159void1160xfs_add_freecounter(1161 struct xfs_mount *mp,1162 struct percpu_counter *counter,1163 uint64_t delta)1164{1165 bool has_resv_pool = (counter == &mp->m_fdblocks);1166 uint64_t res_used;1167 1168 /*1169 * If the reserve pool is depleted, put blocks back into it first.1170 * Most of the time the pool is full.1171 */1172 if (!has_resv_pool || mp->m_resblks == mp->m_resblks_avail) {1173 percpu_counter_add(counter, delta);1174 return;1175 }1176 1177 spin_lock(&mp->m_sb_lock);1178 res_used = mp->m_resblks - mp->m_resblks_avail;1179 if (res_used > delta) {1180 mp->m_resblks_avail += delta;1181 } else {1182 delta -= res_used;1183 mp->m_resblks_avail = mp->m_resblks;1184 percpu_counter_add(counter, delta);1185 }1186 spin_unlock(&mp->m_sb_lock);1187}1188 1189int1190xfs_dec_freecounter(1191 struct xfs_mount *mp,1192 struct percpu_counter *counter,1193 uint64_t delta,1194 bool rsvd)1195{1196 int64_t lcounter;1197 uint64_t set_aside = 0;1198 s32 batch;1199 bool has_resv_pool;1200 1201 ASSERT(counter == &mp->m_fdblocks || counter == &mp->m_frextents);1202 has_resv_pool = (counter == &mp->m_fdblocks);1203 if (rsvd)1204 ASSERT(has_resv_pool);1205 1206 /*1207 * Taking blocks away, need to be more accurate the closer we1208 * are to zero.1209 *1210 * If the counter has a value of less than 2 * max batch size,1211 * then make everything serialise as we are real close to1212 * ENOSPC.1213 */1214 if (__percpu_counter_compare(counter, 2 * XFS_FDBLOCKS_BATCH,1215 XFS_FDBLOCKS_BATCH) < 0)1216 batch = 1;1217 else1218 batch = XFS_FDBLOCKS_BATCH;1219 1220 /*1221 * Set aside allocbt blocks because these blocks are tracked as free1222 * space but not available for allocation. Technically this means that a1223 * single reservation cannot consume all remaining free space, but the1224 * ratio of allocbt blocks to usable free blocks should be rather small.1225 * The tradeoff without this is that filesystems that maintain high1226 * perag block reservations can over reserve physical block availability1227 * and fail physical allocation, which leads to much more serious1228 * problems (i.e. transaction abort, pagecache discards, etc.) than1229 * slightly premature -ENOSPC.1230 */1231 if (has_resv_pool)1232 set_aside = xfs_fdblocks_unavailable(mp);1233 percpu_counter_add_batch(counter, -((int64_t)delta), batch);1234 if (__percpu_counter_compare(counter, set_aside,1235 XFS_FDBLOCKS_BATCH) >= 0) {1236 /* we had space! */1237 return 0;1238 }1239 1240 /*1241 * lock up the sb for dipping into reserves before releasing the space1242 * that took us to ENOSPC.1243 */1244 spin_lock(&mp->m_sb_lock);1245 percpu_counter_add(counter, delta);1246 if (!has_resv_pool || !rsvd)1247 goto fdblocks_enospc;1248 1249 lcounter = (long long)mp->m_resblks_avail - delta;1250 if (lcounter >= 0) {1251 mp->m_resblks_avail = lcounter;1252 spin_unlock(&mp->m_sb_lock);1253 return 0;1254 }1255 xfs_warn_once(mp,1256"Reserve blocks depleted! Consider increasing reserve pool size.");1257 1258fdblocks_enospc:1259 spin_unlock(&mp->m_sb_lock);1260 return -ENOSPC;1261}1262 1263/*1264 * Used to free the superblock along various error paths.1265 */1266void1267xfs_freesb(1268 struct xfs_mount *mp)1269{1270 struct xfs_buf *bp = mp->m_sb_bp;1271 1272 xfs_buf_lock(bp);1273 mp->m_sb_bp = NULL;1274 xfs_buf_relse(bp);1275}1276 1277/*1278 * If the underlying (data/log/rt) device is readonly, there are some1279 * operations that cannot proceed.1280 */1281int1282xfs_dev_is_read_only(1283 struct xfs_mount *mp,1284 char *message)1285{1286 if (xfs_readonly_buftarg(mp->m_ddev_targp) ||1287 xfs_readonly_buftarg(mp->m_logdev_targp) ||1288 (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) {1289 xfs_notice(mp, "%s required on read-only device.", message);1290 xfs_notice(mp, "write access unavailable, cannot proceed.");1291 return -EROFS;1292 }1293 return 0;1294}1295 1296/* Force the summary counters to be recalculated at next mount. */1297void1298xfs_force_summary_recalc(1299 struct xfs_mount *mp)1300{1301 if (!xfs_has_lazysbcount(mp))1302 return;1303 1304 xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS);1305}1306 1307/*1308 * Enable a log incompat feature flag in the primary superblock. The caller1309 * cannot have any other transactions in progress.1310 */1311int1312xfs_add_incompat_log_feature(1313 struct xfs_mount *mp,1314 uint32_t feature)1315{1316 struct xfs_dsb *dsb;1317 int error;1318 1319 ASSERT(hweight32(feature) == 1);1320 ASSERT(!(feature & XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN));1321 1322 /*1323 * Force the log to disk and kick the background AIL thread to reduce1324 * the chances that the bwrite will stall waiting for the AIL to unpin1325 * the primary superblock buffer. This isn't a data integrity1326 * operation, so we don't need a synchronous push.1327 */1328 error = xfs_log_force(mp, XFS_LOG_SYNC);1329 if (error)1330 return error;1331 xfs_ail_push_all(mp->m_ail);1332 1333 /*1334 * Lock the primary superblock buffer to serialize all callers that1335 * are trying to set feature bits.1336 */1337 xfs_buf_lock(mp->m_sb_bp);1338 xfs_buf_hold(mp->m_sb_bp);1339 1340 if (xfs_is_shutdown(mp)) {1341 error = -EIO;1342 goto rele;1343 }1344 1345 if (xfs_sb_has_incompat_log_feature(&mp->m_sb, feature))1346 goto rele;1347 1348 /*1349 * Write the primary superblock to disk immediately, because we need1350 * the log_incompat bit to be set in the primary super now to protect1351 * the log items that we're going to commit later.1352 */1353 dsb = mp->m_sb_bp->b_addr;1354 xfs_sb_to_disk(dsb, &mp->m_sb);1355 dsb->sb_features_log_incompat |= cpu_to_be32(feature);1356 error = xfs_bwrite(mp->m_sb_bp);1357 if (error)1358 goto shutdown;1359 1360 /*1361 * Add the feature bits to the incore superblock before we unlock the1362 * buffer.1363 */1364 xfs_sb_add_incompat_log_features(&mp->m_sb, feature);1365 xfs_buf_relse(mp->m_sb_bp);1366 1367 /* Log the superblock to disk. */1368 return xfs_sync_sb(mp, false);1369shutdown:1370 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);1371rele:1372 xfs_buf_relse(mp->m_sb_bp);1373 return error;1374}1375 1376/*1377 * Clear all the log incompat flags from the superblock.1378 *1379 * The caller cannot be in a transaction, must ensure that the log does not1380 * contain any log items protected by any log incompat bit, and must ensure1381 * that there are no other threads that depend on the state of the log incompat1382 * feature flags in the primary super.1383 *1384 * Returns true if the superblock is dirty.1385 */1386bool1387xfs_clear_incompat_log_features(1388 struct xfs_mount *mp)1389{1390 bool ret = false;1391 1392 if (!xfs_has_crc(mp) ||1393 !xfs_sb_has_incompat_log_feature(&mp->m_sb,1394 XFS_SB_FEAT_INCOMPAT_LOG_ALL) ||1395 xfs_is_shutdown(mp) ||1396 !xfs_is_done_with_log_incompat(mp))1397 return false;1398 1399 /*1400 * Update the incore superblock. We synchronize on the primary super1401 * buffer lock to be consistent with the add function, though at least1402 * in theory this shouldn't be necessary.1403 */1404 xfs_buf_lock(mp->m_sb_bp);1405 xfs_buf_hold(mp->m_sb_bp);1406 1407 if (xfs_sb_has_incompat_log_feature(&mp->m_sb,1408 XFS_SB_FEAT_INCOMPAT_LOG_ALL)) {1409 xfs_sb_remove_incompat_log_features(&mp->m_sb);1410 ret = true;1411 }1412 1413 xfs_buf_relse(mp->m_sb_bp);1414 return ret;1415}1416 1417/*1418 * Update the in-core delayed block counter.1419 *1420 * We prefer to update the counter without having to take a spinlock for every1421 * counter update (i.e. batching). Each change to delayed allocation1422 * reservations can change can easily exceed the default percpu counter1423 * batching, so we use a larger batch factor here.1424 *1425 * Note that we don't currently have any callers requiring fast summation1426 * (e.g. percpu_counter_read) so we can use a big batch value here.1427 */1428#define XFS_DELALLOC_BATCH (4096)1429void1430xfs_mod_delalloc(1431 struct xfs_inode *ip,1432 int64_t data_delta,1433 int64_t ind_delta)1434{1435 struct xfs_mount *mp = ip->i_mount;1436 1437 if (XFS_IS_REALTIME_INODE(ip)) {1438 percpu_counter_add_batch(&mp->m_delalloc_rtextents,1439 xfs_rtb_to_rtx(mp, data_delta),1440 XFS_DELALLOC_BATCH);1441 if (!ind_delta)1442 return;1443 data_delta = 0;1444 }1445 percpu_counter_add_batch(&mp->m_delalloc_blks, data_delta + ind_delta,1446 XFS_DELALLOC_BATCH);1447}1448