10b61f8a4SDave Chinner // SPDX-License-Identifier: GPL-2.0 21da177e4SLinus Torvalds /* 37b718769SNathan Scott * Copyright (c) 2000-2005 Silicon Graphics, Inc. 47b718769SNathan Scott * All Rights Reserved. 51da177e4SLinus Torvalds */ 61da177e4SLinus Torvalds #include "xfs.h" 7a844f451SNathan Scott #include "xfs_fs.h" 870a9883cSDave Chinner #include "xfs_shared.h" 9239880efSDave Chinner #include "xfs_format.h" 10239880efSDave Chinner #include "xfs_log_format.h" 11239880efSDave Chinner #include "xfs_trans_resv.h" 12a844f451SNathan Scott #include "xfs_bit.h" 131da177e4SLinus Torvalds #include "xfs_sb.h" 141da177e4SLinus Torvalds #include "xfs_mount.h" 151da177e4SLinus Torvalds #include "xfs_inode.h" 16a4fbe6abSDave Chinner #include "xfs_dir2.h" 17a844f451SNathan Scott #include "xfs_ialloc.h" 181da177e4SLinus Torvalds #include "xfs_alloc.h" 191da177e4SLinus Torvalds #include "xfs_rtalloc.h" 201da177e4SLinus Torvalds #include "xfs_bmap.h" 21a4fbe6abSDave Chinner #include "xfs_trans.h" 22a4fbe6abSDave Chinner #include "xfs_trans_priv.h" 23a4fbe6abSDave Chinner #include "xfs_log.h" 24b5f17becSDave Chinner #include "xfs_log_priv.h" 251da177e4SLinus Torvalds #include "xfs_error.h" 261da177e4SLinus Torvalds #include "xfs_quota.h" 271da177e4SLinus Torvalds #include "xfs_fsops.h" 286d8b79cfSDave Chinner #include "xfs_icache.h" 29a31b1d3dSBrian Foster #include "xfs_sysfs.h" 30035e00acSDarrick J. Wong #include "xfs_rmap_btree.h" 311946b91cSDarrick J. Wong #include "xfs_refcount_btree.h" 32174edb0eSDarrick J. Wong #include "xfs_reflink.h" 33ebf55872SChristoph Hellwig #include "xfs_extent_busy.h" 3439353ff6SDarrick J. Wong #include "xfs_health.h" 3513eaec4bSDarrick J. Wong #include "xfs_trace.h" 369bbafc71SDave Chinner #include "xfs_ag.h" 377099bd0fSChristoph Hellwig #include "xfs_rtbitmap.h" 38d7a74cadSDarrick J. Wong #include "scrub/stats.h" 391da177e4SLinus Torvalds 4027174203SChristoph Hellwig static DEFINE_MUTEX(xfs_uuid_table_mutex); 4127174203SChristoph Hellwig static int xfs_uuid_table_size; 4227174203SChristoph Hellwig static uuid_t *xfs_uuid_table; 4327174203SChristoph Hellwig 44af3b6382SDarrick J. Wong void 45af3b6382SDarrick J. Wong xfs_uuid_table_free(void) 46af3b6382SDarrick J. Wong { 47af3b6382SDarrick J. Wong if (xfs_uuid_table_size == 0) 48af3b6382SDarrick J. Wong return; 49d4c75a1bSDave Chinner kfree(xfs_uuid_table); 50af3b6382SDarrick J. Wong xfs_uuid_table = NULL; 51af3b6382SDarrick J. Wong xfs_uuid_table_size = 0; 52af3b6382SDarrick J. Wong } 53af3b6382SDarrick J. Wong 5427174203SChristoph Hellwig /* 5527174203SChristoph Hellwig * See if the UUID is unique among mounted XFS filesystems. 5627174203SChristoph Hellwig * Mount fails if UUID is nil or a FS with the same UUID is already mounted. 5727174203SChristoph Hellwig */ 5827174203SChristoph Hellwig STATIC int 5927174203SChristoph Hellwig xfs_uuid_mount( 6027174203SChristoph Hellwig struct xfs_mount *mp) 6127174203SChristoph Hellwig { 6227174203SChristoph Hellwig uuid_t *uuid = &mp->m_sb.sb_uuid; 6327174203SChristoph Hellwig int hole, i; 6427174203SChristoph Hellwig 658f720d9fSAmir Goldstein /* Publish UUID in struct super_block */ 66a4af51ceSKent Overstreet super_set_uuid(mp->m_super, uuid->b, sizeof(*uuid)); 678f720d9fSAmir Goldstein 680560f31aSDave Chinner if (xfs_has_nouuid(mp)) 6927174203SChristoph Hellwig return 0; 7027174203SChristoph Hellwig 71d905fdaaSAmir Goldstein if (uuid_is_null(uuid)) { 72d905fdaaSAmir Goldstein xfs_warn(mp, "Filesystem has null UUID - can't mount"); 732451337dSDave Chinner return -EINVAL; 7427174203SChristoph Hellwig } 7527174203SChristoph Hellwig 7627174203SChristoph Hellwig mutex_lock(&xfs_uuid_table_mutex); 7727174203SChristoph Hellwig for (i = 0, hole = -1; i < xfs_uuid_table_size; i++) { 78d905fdaaSAmir Goldstein if (uuid_is_null(&xfs_uuid_table[i])) { 7927174203SChristoph Hellwig hole = i; 8027174203SChristoph Hellwig continue; 8127174203SChristoph Hellwig } 8227174203SChristoph Hellwig if (uuid_equal(uuid, &xfs_uuid_table[i])) 8327174203SChristoph Hellwig goto out_duplicate; 8427174203SChristoph Hellwig } 8527174203SChristoph Hellwig 8627174203SChristoph Hellwig if (hole < 0) { 87771915c4SCarlos Maiolino xfs_uuid_table = krealloc(xfs_uuid_table, 8827174203SChristoph Hellwig (xfs_uuid_table_size + 1) * sizeof(*xfs_uuid_table), 89771915c4SCarlos Maiolino GFP_KERNEL | __GFP_NOFAIL); 9027174203SChristoph Hellwig hole = xfs_uuid_table_size++; 9127174203SChristoph Hellwig } 9227174203SChristoph Hellwig xfs_uuid_table[hole] = *uuid; 9327174203SChristoph Hellwig mutex_unlock(&xfs_uuid_table_mutex); 9427174203SChristoph Hellwig 9527174203SChristoph Hellwig return 0; 9627174203SChristoph Hellwig 9727174203SChristoph Hellwig out_duplicate: 9827174203SChristoph Hellwig mutex_unlock(&xfs_uuid_table_mutex); 99021000e5SMitsuo Hayasaka xfs_warn(mp, "Filesystem has duplicate UUID %pU - can't mount", uuid); 1002451337dSDave Chinner return -EINVAL; 10127174203SChristoph Hellwig } 10227174203SChristoph Hellwig 10327174203SChristoph Hellwig STATIC void 10427174203SChristoph Hellwig xfs_uuid_unmount( 10527174203SChristoph Hellwig struct xfs_mount *mp) 10627174203SChristoph Hellwig { 10727174203SChristoph Hellwig uuid_t *uuid = &mp->m_sb.sb_uuid; 10827174203SChristoph Hellwig int i; 10927174203SChristoph Hellwig 1100560f31aSDave Chinner if (xfs_has_nouuid(mp)) 11127174203SChristoph Hellwig return; 11227174203SChristoph Hellwig 11327174203SChristoph Hellwig mutex_lock(&xfs_uuid_table_mutex); 11427174203SChristoph Hellwig for (i = 0; i < xfs_uuid_table_size; i++) { 115d905fdaaSAmir Goldstein if (uuid_is_null(&xfs_uuid_table[i])) 11627174203SChristoph Hellwig continue; 11727174203SChristoph Hellwig if (!uuid_equal(uuid, &xfs_uuid_table[i])) 11827174203SChristoph Hellwig continue; 11927174203SChristoph Hellwig memset(&xfs_uuid_table[i], 0, sizeof(uuid_t)); 12027174203SChristoph Hellwig break; 12127174203SChristoph Hellwig } 12227174203SChristoph Hellwig ASSERT(i < xfs_uuid_table_size); 12327174203SChristoph Hellwig mutex_unlock(&xfs_uuid_table_mutex); 12427174203SChristoph Hellwig } 12527174203SChristoph Hellwig 1264cc929eeSNathan Scott /* 1274cc929eeSNathan Scott * Check size of device based on the (data/realtime) block count. 1284cc929eeSNathan Scott * Note: this check is used by the growfs code as well as mount. 1294cc929eeSNathan Scott */ 1304cc929eeSNathan Scott int 1314cc929eeSNathan Scott xfs_sb_validate_fsb_count( 1324cc929eeSNathan Scott xfs_sb_t *sbp, 133c8ce540dSDarrick J. Wong uint64_t nblocks) 1344cc929eeSNathan Scott { 1354cc929eeSNathan Scott ASSERT(PAGE_SHIFT >= sbp->sb_blocklog); 1364cc929eeSNathan Scott ASSERT(sbp->sb_blocklog >= BBSHIFT); 1374cc929eeSNathan Scott 138d5cf09baSChristoph Hellwig /* Limited by ULONG_MAX of page cache index */ 13909cbfeafSKirill A. Shutemov if (nblocks >> (PAGE_SHIFT - sbp->sb_blocklog) > ULONG_MAX) 1402451337dSDave Chinner return -EFBIG; 1414cc929eeSNathan Scott return 0; 1424cc929eeSNathan Scott } 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds /* 1451da177e4SLinus Torvalds * xfs_readsb 1461da177e4SLinus Torvalds * 1471da177e4SLinus Torvalds * Does the initial read of the superblock. 1481da177e4SLinus Torvalds */ 1491da177e4SLinus Torvalds int 150ff55068cSDave Chinner xfs_readsb( 151ff55068cSDave Chinner struct xfs_mount *mp, 152ff55068cSDave Chinner int flags) 1531da177e4SLinus Torvalds { 1541da177e4SLinus Torvalds unsigned int sector_size; 15504a1e6c5SDave Chinner struct xfs_buf *bp; 15604a1e6c5SDave Chinner struct xfs_sb *sbp = &mp->m_sb; 1571da177e4SLinus Torvalds int error; 158af34e09dSDave Chinner int loud = !(flags & XFS_MFSI_QUIET); 159daba5427SEric Sandeen const struct xfs_buf_ops *buf_ops; 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds ASSERT(mp->m_sb_bp == NULL); 1621da177e4SLinus Torvalds ASSERT(mp->m_ddev_targp != NULL); 1631da177e4SLinus Torvalds 1641da177e4SLinus Torvalds /* 165daba5427SEric Sandeen * For the initial read, we must guess at the sector 166daba5427SEric Sandeen * size based on the block device. It's enough to 167daba5427SEric Sandeen * get the sb_sectsize out of the superblock and 168daba5427SEric Sandeen * then reread with the proper length. 169daba5427SEric Sandeen * We don't verify it yet, because it may not be complete. 170daba5427SEric Sandeen */ 171daba5427SEric Sandeen sector_size = xfs_getsize_buftarg(mp->m_ddev_targp); 172daba5427SEric Sandeen buf_ops = NULL; 173daba5427SEric Sandeen 174daba5427SEric Sandeen /* 175c891c30aSBrian Foster * Allocate a (locked) buffer to hold the superblock. This will be kept 176c891c30aSBrian Foster * around at all times to optimize access to the superblock. Therefore, 177c891c30aSBrian Foster * set XBF_NO_IOACCT to make sure it doesn't hold the buftarg count 178c891c30aSBrian Foster * elevated. 1791da177e4SLinus Torvalds */ 18026af6552SDave Chinner reread: 181ba372674SDave Chinner error = xfs_buf_read_uncached(mp->m_ddev_targp, XFS_SB_DADDR, 182c891c30aSBrian Foster BTOBB(sector_size), XBF_NO_IOACCT, &bp, 183c891c30aSBrian Foster buf_ops); 184ba372674SDave Chinner if (error) { 185eab4e633SDave Chinner if (loud) 186e721f504SDave Chinner xfs_warn(mp, "SB validate failed with error %d.", error); 187ac75a1f7SDave Chinner /* bad CRC means corrupted metadata */ 1882451337dSDave Chinner if (error == -EFSBADCRC) 1892451337dSDave Chinner error = -EFSCORRUPTED; 190ba372674SDave Chinner return error; 191eab4e633SDave Chinner } 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds /* 1941da177e4SLinus Torvalds * Initialize the mount structure from the superblock. 1951da177e4SLinus Torvalds */ 1963e6e8afdSChristoph Hellwig xfs_sb_from_disk(sbp, bp->b_addr); 197556b8883SDave Chinner 198556b8883SDave Chinner /* 199556b8883SDave Chinner * If we haven't validated the superblock, do so now before we try 200556b8883SDave Chinner * to check the sector size and reread the superblock appropriately. 201556b8883SDave Chinner */ 202556b8883SDave Chinner if (sbp->sb_magicnum != XFS_SB_MAGIC) { 203556b8883SDave Chinner if (loud) 204556b8883SDave Chinner xfs_warn(mp, "Invalid superblock magic number"); 2052451337dSDave Chinner error = -EINVAL; 206556b8883SDave Chinner goto release_buf; 207556b8883SDave Chinner } 208ff55068cSDave Chinner 2091da177e4SLinus Torvalds /* 2101da177e4SLinus Torvalds * We must be able to do sector-sized and sector-aligned IO. 2111da177e4SLinus Torvalds */ 21204a1e6c5SDave Chinner if (sector_size > sbp->sb_sectsize) { 213af34e09dSDave Chinner if (loud) 214af34e09dSDave Chinner xfs_warn(mp, "device supports %u byte sectors (not %u)", 21504a1e6c5SDave Chinner sector_size, sbp->sb_sectsize); 2162451337dSDave Chinner error = -ENOSYS; 21726af6552SDave Chinner goto release_buf; 2181da177e4SLinus Torvalds } 2191da177e4SLinus Torvalds 220556b8883SDave Chinner if (buf_ops == NULL) { 2211da177e4SLinus Torvalds /* 222daba5427SEric Sandeen * Re-read the superblock so the buffer is correctly sized, 223daba5427SEric Sandeen * and properly verified. 2241da177e4SLinus Torvalds */ 2251da177e4SLinus Torvalds xfs_buf_relse(bp); 22604a1e6c5SDave Chinner sector_size = sbp->sb_sectsize; 227daba5427SEric Sandeen buf_ops = loud ? &xfs_sb_buf_ops : &xfs_sb_quiet_buf_ops; 22826af6552SDave Chinner goto reread; 2291da177e4SLinus Torvalds } 2301da177e4SLinus Torvalds 231a1d86e8dSDave Chinner mp->m_features |= xfs_sb_version_to_features(sbp); 2325681ca40SDave Chinner xfs_reinit_percpu_counters(mp); 2338d280b98SDavid Chinner 234f759784cSDarrick J. Wong /* 235f759784cSDarrick J. Wong * If logged xattrs are enabled after log recovery finishes, then set 236f759784cSDarrick J. Wong * the opstate so that log recovery will work properly. 237f759784cSDarrick J. Wong */ 238f759784cSDarrick J. Wong if (xfs_sb_version_haslogxattrs(&mp->m_sb)) 239f759784cSDarrick J. Wong xfs_set_using_logged_xattrs(mp); 240f759784cSDarrick J. Wong 24104a1e6c5SDave Chinner /* no need to be quiet anymore, so reset the buf ops */ 24204a1e6c5SDave Chinner bp->b_ops = &xfs_sb_buf_ops; 24304a1e6c5SDave Chinner 2441da177e4SLinus Torvalds mp->m_sb_bp = bp; 24526af6552SDave Chinner xfs_buf_unlock(bp); 2461da177e4SLinus Torvalds return 0; 2471da177e4SLinus Torvalds 24826af6552SDave Chinner release_buf: 2491da177e4SLinus Torvalds xfs_buf_relse(bp); 2501da177e4SLinus Torvalds return error; 2511da177e4SLinus Torvalds } 2521da177e4SLinus Torvalds 2531da177e4SLinus Torvalds /* 25413eaec4bSDarrick J. Wong * If the sunit/swidth change would move the precomputed root inode value, we 25513eaec4bSDarrick J. Wong * must reject the ondisk change because repair will stumble over that. 25613eaec4bSDarrick J. Wong * However, we allow the mount to proceed because we never rejected this 25713eaec4bSDarrick J. Wong * combination before. Returns true to update the sb, false otherwise. 25813eaec4bSDarrick J. Wong */ 25913eaec4bSDarrick J. Wong static inline int 26013eaec4bSDarrick J. Wong xfs_check_new_dalign( 26113eaec4bSDarrick J. Wong struct xfs_mount *mp, 26213eaec4bSDarrick J. Wong int new_dalign, 26313eaec4bSDarrick J. Wong bool *update_sb) 26413eaec4bSDarrick J. Wong { 26513eaec4bSDarrick J. Wong struct xfs_sb *sbp = &mp->m_sb; 26613eaec4bSDarrick J. Wong xfs_ino_t calc_ino; 26713eaec4bSDarrick J. Wong 26813eaec4bSDarrick J. Wong calc_ino = xfs_ialloc_calc_rootino(mp, new_dalign); 26913eaec4bSDarrick J. Wong trace_xfs_check_new_dalign(mp, new_dalign, calc_ino); 27013eaec4bSDarrick J. Wong 27113eaec4bSDarrick J. Wong if (sbp->sb_rootino == calc_ino) { 27213eaec4bSDarrick J. Wong *update_sb = true; 27313eaec4bSDarrick J. Wong return 0; 27413eaec4bSDarrick J. Wong } 27513eaec4bSDarrick J. Wong 27613eaec4bSDarrick J. Wong xfs_warn(mp, 27713eaec4bSDarrick J. Wong "Cannot change stripe alignment; would require moving root inode."); 27813eaec4bSDarrick J. Wong 27913eaec4bSDarrick J. Wong /* 28013eaec4bSDarrick J. Wong * XXX: Next time we add a new incompat feature, this should start 28113eaec4bSDarrick J. Wong * returning -EINVAL to fail the mount. Until then, spit out a warning 28213eaec4bSDarrick J. Wong * that we're ignoring the administrator's instructions. 28313eaec4bSDarrick J. Wong */ 28413eaec4bSDarrick J. Wong xfs_warn(mp, "Skipping superblock stripe alignment update."); 28513eaec4bSDarrick J. Wong *update_sb = false; 28613eaec4bSDarrick J. Wong return 0; 28713eaec4bSDarrick J. Wong } 28813eaec4bSDarrick J. Wong 28913eaec4bSDarrick J. Wong /* 2904f5b1b3aSDarrick J. Wong * If we were provided with new sunit/swidth values as mount options, make sure 2914f5b1b3aSDarrick J. Wong * that they pass basic alignment and superblock feature checks, and convert 2924f5b1b3aSDarrick J. Wong * them into the same units (FSB) that everything else expects. This step 2934f5b1b3aSDarrick J. Wong * /must/ be done before computing the inode geometry. 2941da177e4SLinus Torvalds */ 2950771fb45SEric Sandeen STATIC int 2964f5b1b3aSDarrick J. Wong xfs_validate_new_dalign( 2974f5b1b3aSDarrick J. Wong struct xfs_mount *mp) 2981da177e4SLinus Torvalds { 2994f5b1b3aSDarrick J. Wong if (mp->m_dalign == 0) 3004f5b1b3aSDarrick J. Wong return 0; 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds /* 3031da177e4SLinus Torvalds * If stripe unit and stripe width are not multiples 3041da177e4SLinus Torvalds * of the fs blocksize turn off alignment. 3051da177e4SLinus Torvalds */ 3061da177e4SLinus Torvalds if ((BBTOB(mp->m_dalign) & mp->m_blockmask) || 3071da177e4SLinus Torvalds (BBTOB(mp->m_swidth) & mp->m_blockmask)) { 30839a45d84SJie Liu xfs_warn(mp, 30939a45d84SJie Liu "alignment check failed: sunit/swidth vs. blocksize(%d)", 3104f5b1b3aSDarrick J. Wong mp->m_sb.sb_blocksize); 3112451337dSDave Chinner return -EINVAL; 312de94a2e1SZeng Heng } 313de94a2e1SZeng Heng 3141da177e4SLinus Torvalds /* 3151da177e4SLinus Torvalds * Convert the stripe unit and width to FSBs. 3161da177e4SLinus Torvalds */ 3171da177e4SLinus Torvalds mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign); 3184f5b1b3aSDarrick J. Wong if (mp->m_dalign && (mp->m_sb.sb_agblocks % mp->m_dalign)) { 31953487786SDave Chinner xfs_warn(mp, 32039a45d84SJie Liu "alignment check failed: sunit/swidth vs. agsize(%d)", 3214f5b1b3aSDarrick J. Wong mp->m_sb.sb_agblocks); 3222451337dSDave Chinner return -EINVAL; 323de94a2e1SZeng Heng } 324de94a2e1SZeng Heng 325de94a2e1SZeng Heng if (!mp->m_dalign) { 32639a45d84SJie Liu xfs_warn(mp, 32739a45d84SJie Liu "alignment check failed: sunit(%d) less than bsize(%d)", 3284f5b1b3aSDarrick J. Wong mp->m_dalign, mp->m_sb.sb_blocksize); 3292451337dSDave Chinner return -EINVAL; 3301da177e4SLinus Torvalds } 331de94a2e1SZeng Heng 332de94a2e1SZeng Heng mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth); 3331da177e4SLinus Torvalds 33438c26bfdSDave Chinner if (!xfs_has_dalign(mp)) { 33534d7f603SJie Liu xfs_warn(mp, 33634d7f603SJie Liu "cannot change alignment: superblock does not support data alignment"); 3372451337dSDave Chinner return -EINVAL; 3381da177e4SLinus Torvalds } 3394f5b1b3aSDarrick J. Wong 3404f5b1b3aSDarrick J. Wong return 0; 3414f5b1b3aSDarrick J. Wong } 3424f5b1b3aSDarrick J. Wong 3434f5b1b3aSDarrick J. Wong /* Update alignment values based on mount options and sb values. */ 3444f5b1b3aSDarrick J. Wong STATIC int 3454f5b1b3aSDarrick J. Wong xfs_update_alignment( 3464f5b1b3aSDarrick J. Wong struct xfs_mount *mp) 3474f5b1b3aSDarrick J. Wong { 3484f5b1b3aSDarrick J. Wong struct xfs_sb *sbp = &mp->m_sb; 3494f5b1b3aSDarrick J. Wong 3504f5b1b3aSDarrick J. Wong if (mp->m_dalign) { 35113eaec4bSDarrick J. Wong bool update_sb; 35213eaec4bSDarrick J. Wong int error; 35313eaec4bSDarrick J. Wong 3544f5b1b3aSDarrick J. Wong if (sbp->sb_unit == mp->m_dalign && 3554f5b1b3aSDarrick J. Wong sbp->sb_width == mp->m_swidth) 3564f5b1b3aSDarrick J. Wong return 0; 3574f5b1b3aSDarrick J. Wong 35813eaec4bSDarrick J. Wong error = xfs_check_new_dalign(mp, mp->m_dalign, &update_sb); 35913eaec4bSDarrick J. Wong if (error || !update_sb) 36013eaec4bSDarrick J. Wong return error; 36113eaec4bSDarrick J. Wong 3624f5b1b3aSDarrick J. Wong sbp->sb_unit = mp->m_dalign; 3634f5b1b3aSDarrick J. Wong sbp->sb_width = mp->m_swidth; 3644f5b1b3aSDarrick J. Wong mp->m_update_sb = true; 3650560f31aSDave Chinner } else if (!xfs_has_noalign(mp) && xfs_has_dalign(mp)) { 3661da177e4SLinus Torvalds mp->m_dalign = sbp->sb_unit; 3671da177e4SLinus Torvalds mp->m_swidth = sbp->sb_width; 3681da177e4SLinus Torvalds } 3691da177e4SLinus Torvalds 3700771fb45SEric Sandeen return 0; 3710771fb45SEric Sandeen } 3721da177e4SLinus Torvalds 3730771fb45SEric Sandeen /* 374055388a3SDave Chinner * precalculate the low space thresholds for dynamic speculative preallocation. 375055388a3SDave Chinner */ 376055388a3SDave Chinner void 377055388a3SDave Chinner xfs_set_low_space_thresholds( 378055388a3SDave Chinner struct xfs_mount *mp) 379055388a3SDave Chinner { 38065f03d86SDarrick J. Wong uint64_t dblocks = mp->m_sb.sb_dblocks; 38165f03d86SDarrick J. Wong uint64_t rtexts = mp->m_sb.sb_rextents; 382055388a3SDave Chinner int i; 383055388a3SDave Chinner 38465f03d86SDarrick J. Wong do_div(dblocks, 100); 38565f03d86SDarrick J. Wong do_div(rtexts, 100); 386055388a3SDave Chinner 38765f03d86SDarrick J. Wong for (i = 0; i < XFS_LOWSP_MAX; i++) { 38865f03d86SDarrick J. Wong mp->m_low_space[i] = dblocks * (i + 1); 38965f03d86SDarrick J. Wong mp->m_low_rtexts[i] = rtexts * (i + 1); 390055388a3SDave Chinner } 391055388a3SDave Chinner } 392055388a3SDave Chinner 3931da177e4SLinus Torvalds /* 3940471f62eSZhi Yong Wu * Check that the data (and log if separate) is an ok size. 3951da177e4SLinus Torvalds */ 3960771fb45SEric Sandeen STATIC int 397ba372674SDave Chinner xfs_check_sizes( 398ba372674SDave Chinner struct xfs_mount *mp) 3990771fb45SEric Sandeen { 400ba372674SDave Chinner struct xfs_buf *bp; 4010771fb45SEric Sandeen xfs_daddr_t d; 402ba372674SDave Chinner int error; 4030771fb45SEric Sandeen 4041da177e4SLinus Torvalds d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks); 4051da177e4SLinus Torvalds if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) { 4060b932cccSDave Chinner xfs_warn(mp, "filesystem size mismatch detected"); 4072451337dSDave Chinner return -EFBIG; 4081da177e4SLinus Torvalds } 409ba372674SDave Chinner error = xfs_buf_read_uncached(mp->m_ddev_targp, 4101da177e4SLinus Torvalds d - XFS_FSS_TO_BB(mp, 1), 411ba372674SDave Chinner XFS_FSS_TO_BB(mp, 1), 0, &bp, NULL); 412ba372674SDave Chinner if (error) { 4130b932cccSDave Chinner xfs_warn(mp, "last sector read failed"); 414ba372674SDave Chinner return error; 4151da177e4SLinus Torvalds } 4161922c949SDave Chinner xfs_buf_relse(bp); 4171da177e4SLinus Torvalds 418ba372674SDave Chinner if (mp->m_logdev_targp == mp->m_ddev_targp) 419ba372674SDave Chinner return 0; 420ba372674SDave Chinner 4211da177e4SLinus Torvalds d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks); 4221da177e4SLinus Torvalds if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) { 4230b932cccSDave Chinner xfs_warn(mp, "log size mismatch detected"); 4242451337dSDave Chinner return -EFBIG; 4251da177e4SLinus Torvalds } 426ba372674SDave Chinner error = xfs_buf_read_uncached(mp->m_logdev_targp, 4271da177e4SLinus Torvalds d - XFS_FSB_TO_BB(mp, 1), 428ba372674SDave Chinner XFS_FSB_TO_BB(mp, 1), 0, &bp, NULL); 429ba372674SDave Chinner if (error) { 4300b932cccSDave Chinner xfs_warn(mp, "log device read failed"); 431ba372674SDave Chinner return error; 4321da177e4SLinus Torvalds } 4331922c949SDave Chinner xfs_buf_relse(bp); 4340771fb45SEric Sandeen return 0; 4350771fb45SEric Sandeen } 4360771fb45SEric Sandeen 4370771fb45SEric Sandeen /* 4387d095257SChristoph Hellwig * Clear the quotaflags in memory and in the superblock. 4397d095257SChristoph Hellwig */ 4407d095257SChristoph Hellwig int 4417d095257SChristoph Hellwig xfs_mount_reset_sbqflags( 4427d095257SChristoph Hellwig struct xfs_mount *mp) 4437d095257SChristoph Hellwig { 4447d095257SChristoph Hellwig mp->m_qflags = 0; 4457d095257SChristoph Hellwig 44661e63ecbSDave Chinner /* It is OK to look at sb_qflags in the mount path without m_sb_lock. */ 4477d095257SChristoph Hellwig if (mp->m_sb.sb_qflags == 0) 4487d095257SChristoph Hellwig return 0; 4497d095257SChristoph Hellwig spin_lock(&mp->m_sb_lock); 4507d095257SChristoph Hellwig mp->m_sb.sb_qflags = 0; 4517d095257SChristoph Hellwig spin_unlock(&mp->m_sb_lock); 4527d095257SChristoph Hellwig 45361e63ecbSDave Chinner if (!xfs_fs_writable(mp, SB_FREEZE_WRITE)) 4547d095257SChristoph Hellwig return 0; 4557d095257SChristoph Hellwig 45661e63ecbSDave Chinner return xfs_sync_sb(mp, false); 4577d095257SChristoph Hellwig } 4587d095257SChristoph Hellwig 459c8ce540dSDarrick J. Wong uint64_t 460d5db0f97SEric Sandeen xfs_default_resblks(xfs_mount_t *mp) 461d5db0f97SEric Sandeen { 462c8ce540dSDarrick J. Wong uint64_t resblks; 463d5db0f97SEric Sandeen 464d5db0f97SEric Sandeen /* 4658babd8a2SDave Chinner * We default to 5% or 8192 fsbs of space reserved, whichever is 4668babd8a2SDave Chinner * smaller. This is intended to cover concurrent allocation 4678babd8a2SDave Chinner * transactions when we initially hit enospc. These each require a 4 4688babd8a2SDave Chinner * block reservation. Hence by default we cover roughly 2000 concurrent 4698babd8a2SDave Chinner * allocation reservations. 470d5db0f97SEric Sandeen */ 471d5db0f97SEric Sandeen resblks = mp->m_sb.sb_dblocks; 472d5db0f97SEric Sandeen do_div(resblks, 20); 473c8ce540dSDarrick J. Wong resblks = min_t(uint64_t, resblks, 8192); 474d5db0f97SEric Sandeen return resblks; 475d5db0f97SEric Sandeen } 476d5db0f97SEric Sandeen 4772e9e6481SDarrick J. Wong /* Ensure the summary counts are correct. */ 4782e9e6481SDarrick J. Wong STATIC int 4792e9e6481SDarrick J. Wong xfs_check_summary_counts( 4802e9e6481SDarrick J. Wong struct xfs_mount *mp) 4812e9e6481SDarrick J. Wong { 4825a605fd6SDarrick J. Wong int error = 0; 4835a605fd6SDarrick J. Wong 4842e9e6481SDarrick J. Wong /* 4852e9e6481SDarrick J. Wong * The AG0 superblock verifier rejects in-progress filesystems, 4862e9e6481SDarrick J. Wong * so we should never see the flag set this far into mounting. 4872e9e6481SDarrick J. Wong */ 4882e9e6481SDarrick J. Wong if (mp->m_sb.sb_inprogress) { 4892e9e6481SDarrick J. Wong xfs_err(mp, "sb_inprogress set after log recovery??"); 4902e9e6481SDarrick J. Wong WARN_ON(1); 4912e9e6481SDarrick J. Wong return -EFSCORRUPTED; 4922e9e6481SDarrick J. Wong } 4932e9e6481SDarrick J. Wong 4942e9e6481SDarrick J. Wong /* 4952e9e6481SDarrick J. Wong * Now the log is mounted, we know if it was an unclean shutdown or 4962e9e6481SDarrick J. Wong * not. If it was, with the first phase of recovery has completed, we 4972e9e6481SDarrick J. Wong * have consistent AG blocks on disk. We have not recovered EFIs yet, 4982e9e6481SDarrick J. Wong * but they are recovered transactionally in the second recovery phase 4992e9e6481SDarrick J. Wong * later. 5002e9e6481SDarrick J. Wong * 5012e9e6481SDarrick J. Wong * If the log was clean when we mounted, we can check the summary 5022e9e6481SDarrick J. Wong * counters. If any of them are obviously incorrect, we can recompute 5032e9e6481SDarrick J. Wong * them from the AGF headers in the next step. 5042e9e6481SDarrick J. Wong */ 5052e973b2cSDave Chinner if (xfs_is_clean(mp) && 5062e9e6481SDarrick J. Wong (mp->m_sb.sb_fdblocks > mp->m_sb.sb_dblocks || 50700d22a1cSDarrick J. Wong !xfs_verify_icount(mp, mp->m_sb.sb_icount) || 5082e9e6481SDarrick J. Wong mp->m_sb.sb_ifree > mp->m_sb.sb_icount)) 50939353ff6SDarrick J. Wong xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS); 5102e9e6481SDarrick J. Wong 5112e9e6481SDarrick J. Wong /* 5122e9e6481SDarrick J. Wong * We can safely re-initialise incore superblock counters from the 5132e9e6481SDarrick J. Wong * per-ag data. These may not be correct if the filesystem was not 5142e9e6481SDarrick J. Wong * cleanly unmounted, so we waited for recovery to finish before doing 5152e9e6481SDarrick J. Wong * this. 5162e9e6481SDarrick J. Wong * 5172e9e6481SDarrick J. Wong * If the filesystem was cleanly unmounted or the previous check did 5182e9e6481SDarrick J. Wong * not flag anything weird, then we can trust the values in the 5192e9e6481SDarrick J. Wong * superblock to be correct and we don't need to do anything here. 5202e9e6481SDarrick J. Wong * Otherwise, recalculate the summary counters. 5212e9e6481SDarrick J. Wong */ 5225a605fd6SDarrick J. Wong if ((xfs_has_lazysbcount(mp) && !xfs_is_clean(mp)) || 5235a605fd6SDarrick J. Wong xfs_fs_has_sickness(mp, XFS_SICK_FS_COUNTERS)) { 5245a605fd6SDarrick J. Wong error = xfs_initialize_perag_data(mp, mp->m_sb.sb_agcount); 5255a605fd6SDarrick J. Wong if (error) 5265a605fd6SDarrick J. Wong return error; 5275a605fd6SDarrick J. Wong } 5282e9e6481SDarrick J. Wong 5295a605fd6SDarrick J. Wong /* 5305a605fd6SDarrick J. Wong * Older kernels misused sb_frextents to reflect both incore 5315a605fd6SDarrick J. Wong * reservations made by running transactions and the actual count of 5325a605fd6SDarrick J. Wong * free rt extents in the ondisk metadata. Transactions committed 5335a605fd6SDarrick J. Wong * during runtime can therefore contain a superblock update that 5345a605fd6SDarrick J. Wong * undercounts the number of free rt extents tracked in the rt bitmap. 5355a605fd6SDarrick J. Wong * A clean unmount record will have the correct frextents value since 5365a605fd6SDarrick J. Wong * there can be no other transactions running at that point. 5375a605fd6SDarrick J. Wong * 5385a605fd6SDarrick J. Wong * If we're mounting the rt volume after recovering the log, recompute 5395a605fd6SDarrick J. Wong * frextents from the rtbitmap file to fix the inconsistency. 5405a605fd6SDarrick J. Wong */ 5415a605fd6SDarrick J. Wong if (xfs_has_realtime(mp) && !xfs_is_clean(mp)) { 5425a605fd6SDarrick J. Wong error = xfs_rtalloc_reinit_frextents(mp); 5435a605fd6SDarrick J. Wong if (error) 5445a605fd6SDarrick J. Wong return error; 5455a605fd6SDarrick J. Wong } 5465a605fd6SDarrick J. Wong 5475a605fd6SDarrick J. Wong return 0; 5482e9e6481SDarrick J. Wong } 5492e9e6481SDarrick J. Wong 55059f6ab40SLong Li static void 55159f6ab40SLong Li xfs_unmount_check( 55259f6ab40SLong Li struct xfs_mount *mp) 55359f6ab40SLong Li { 55459f6ab40SLong Li if (xfs_is_shutdown(mp)) 55559f6ab40SLong Li return; 55659f6ab40SLong Li 55759f6ab40SLong Li if (percpu_counter_sum(&mp->m_ifree) > 55859f6ab40SLong Li percpu_counter_sum(&mp->m_icount)) { 55959f6ab40SLong Li xfs_alert(mp, "ifree/icount mismatch at unmount"); 56059f6ab40SLong Li xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS); 56159f6ab40SLong Li } 56259f6ab40SLong Li } 56359f6ab40SLong Li 5647d095257SChristoph Hellwig /* 565d336f7ebSDarrick J. Wong * Flush and reclaim dirty inodes in preparation for unmount. Inodes and 566d336f7ebSDarrick J. Wong * internal inode structures can be sitting in the CIL and AIL at this point, 567d336f7ebSDarrick J. Wong * so we need to unpin them, write them back and/or reclaim them before unmount 568ab23a776SDave Chinner * can proceed. In other words, callers are required to have inactivated all 569ab23a776SDave Chinner * inodes. 570d336f7ebSDarrick J. Wong * 571d336f7ebSDarrick J. Wong * An inode cluster that has been freed can have its buffer still pinned in 572d336f7ebSDarrick J. Wong * memory because the transaction is still sitting in a iclog. The stale inodes 573d336f7ebSDarrick J. Wong * on that buffer will be pinned to the buffer until the transaction hits the 574d336f7ebSDarrick J. Wong * disk and the callbacks run. Pushing the AIL will skip the stale inodes and 575d336f7ebSDarrick J. Wong * may never see the pinned buffer, so nothing will push out the iclog and 576d336f7ebSDarrick J. Wong * unpin the buffer. 577d336f7ebSDarrick J. Wong * 578d336f7ebSDarrick J. Wong * Hence we need to force the log to unpin everything first. However, log 579d336f7ebSDarrick J. Wong * forces don't wait for the discards they issue to complete, so we have to 580d336f7ebSDarrick J. Wong * explicitly wait for them to complete here as well. 581d336f7ebSDarrick J. Wong * 582d336f7ebSDarrick J. Wong * Then we can tell the world we are unmounting so that error handling knows 583d336f7ebSDarrick J. Wong * that the filesystem is going away and we should error out anything that we 584d336f7ebSDarrick J. Wong * have been retrying in the background. This will prevent never-ending 585d336f7ebSDarrick J. Wong * retries in AIL pushing from hanging the unmount. 586d336f7ebSDarrick J. Wong * 587d336f7ebSDarrick J. Wong * Finally, we can push the AIL to clean all the remaining dirty objects, then 588d336f7ebSDarrick J. Wong * reclaim the remaining inodes that are still in memory at this point in time. 589d336f7ebSDarrick J. Wong */ 590d336f7ebSDarrick J. Wong static void 591d336f7ebSDarrick J. Wong xfs_unmount_flush_inodes( 592d336f7ebSDarrick J. Wong struct xfs_mount *mp) 593d336f7ebSDarrick J. Wong { 594d336f7ebSDarrick J. Wong xfs_log_force(mp, XFS_LOG_SYNC); 595d336f7ebSDarrick J. Wong xfs_extent_busy_wait_all(mp); 596d336f7ebSDarrick J. Wong flush_workqueue(xfs_discard_wq); 597d336f7ebSDarrick J. Wong 598*ca57120dSJohn Garry xfs_set_unmounting(mp); 599d336f7ebSDarrick J. Wong 600d336f7ebSDarrick J. Wong xfs_ail_push_all_sync(mp->m_ail); 601ab23a776SDave Chinner xfs_inodegc_stop(mp); 602d336f7ebSDarrick J. Wong cancel_delayed_work_sync(&mp->m_reclaim_work); 603d336f7ebSDarrick J. Wong xfs_reclaim_inodes(mp); 604d336f7ebSDarrick J. Wong xfs_health_unmount(mp); 605d336f7ebSDarrick J. Wong } 606d336f7ebSDarrick J. Wong 607b2941046SDave Chinner static void 608b2941046SDave Chinner xfs_mount_setup_inode_geom( 609b2941046SDave Chinner struct xfs_mount *mp) 610b2941046SDave Chinner { 611b2941046SDave Chinner struct xfs_ino_geometry *igeo = M_IGEO(mp); 612b2941046SDave Chinner 613b2941046SDave Chinner igeo->attr_fork_offset = xfs_bmap_compute_attr_offset(mp); 614b2941046SDave Chinner ASSERT(igeo->attr_fork_offset < XFS_LITINO(mp)); 615b2941046SDave Chinner 616b2941046SDave Chinner xfs_ialloc_setup_geometry(mp); 617b2941046SDave Chinner } 618b2941046SDave Chinner 619b74e15d7SDarrick J. Wong /* Compute maximum possible height for per-AG btree types for this fs. */ 620b74e15d7SDarrick J. Wong static inline void 621b74e15d7SDarrick J. Wong xfs_agbtree_compute_maxlevels( 622b74e15d7SDarrick J. Wong struct xfs_mount *mp) 623b74e15d7SDarrick J. Wong { 624b74e15d7SDarrick J. Wong unsigned int levels; 625b74e15d7SDarrick J. Wong 626b74e15d7SDarrick J. Wong levels = max(mp->m_alloc_maxlevels, M_IGEO(mp)->inobt_maxlevels); 627b74e15d7SDarrick J. Wong levels = max(levels, mp->m_rmap_maxlevels); 628b74e15d7SDarrick J. Wong mp->m_agbtree_maxlevels = max(levels, mp->m_refc_maxlevels); 629b74e15d7SDarrick J. Wong } 630b74e15d7SDarrick J. Wong 631d336f7ebSDarrick J. Wong /* 6320771fb45SEric Sandeen * This function does the following on an initial mount of a file system: 6330771fb45SEric Sandeen * - reads the superblock from disk and init the mount struct 6340771fb45SEric Sandeen * - if we're a 32-bit kernel, do a size check on the superblock 6350771fb45SEric Sandeen * so we don't mount terabyte filesystems 6360771fb45SEric Sandeen * - init mount struct realtime fields 6370771fb45SEric Sandeen * - allocate inode hash table for fs 6380771fb45SEric Sandeen * - init directory manager 6390771fb45SEric Sandeen * - perform recovery and init the log manager 6400771fb45SEric Sandeen */ 6410771fb45SEric Sandeen int 6420771fb45SEric Sandeen xfs_mountfs( 643f0b2efadSBrian Foster struct xfs_mount *mp) 6440771fb45SEric Sandeen { 645f0b2efadSBrian Foster struct xfs_sb *sbp = &(mp->m_sb); 646f0b2efadSBrian Foster struct xfs_inode *rip; 647ef325959SDarrick J. Wong struct xfs_ino_geometry *igeo = M_IGEO(mp); 6487d095257SChristoph Hellwig uint quotamount = 0; 6497d095257SChristoph Hellwig uint quotaflags = 0; 6500771fb45SEric Sandeen int error = 0; 6510771fb45SEric Sandeen 652ff55068cSDave Chinner xfs_sb_mount_common(mp, sbp); 6530771fb45SEric Sandeen 6540771fb45SEric Sandeen /* 655074e427bSDave Chinner * Check for a mismatched features2 values. Older kernels read & wrote 656074e427bSDave Chinner * into the wrong sb offset for sb_features2 on some platforms due to 657074e427bSDave Chinner * xfs_sb_t not being 64bit size aligned when sb_features2 was added, 658074e427bSDave Chinner * which made older superblock reading/writing routines swap it as a 659074e427bSDave Chinner * 64-bit value. 660ee1c0908SDavid Chinner * 661e6957ea4SEric Sandeen * For backwards compatibility, we make both slots equal. 662e6957ea4SEric Sandeen * 663074e427bSDave Chinner * If we detect a mismatched field, we OR the set bits into the existing 664074e427bSDave Chinner * features2 field in case it has already been modified; we don't want 665074e427bSDave Chinner * to lose any features. We then update the bad location with the ORed 666074e427bSDave Chinner * value so that older kernels will see any features2 flags. The 667074e427bSDave Chinner * superblock writeback code ensures the new sb_features2 is copied to 668074e427bSDave Chinner * sb_bad_features2 before it is logged or written to disk. 669ee1c0908SDavid Chinner */ 670e6957ea4SEric Sandeen if (xfs_sb_has_mismatched_features2(sbp)) { 6710b932cccSDave Chinner xfs_warn(mp, "correcting sb_features alignment problem"); 672ee1c0908SDavid Chinner sbp->sb_features2 |= sbp->sb_bad_features2; 67361e63ecbSDave Chinner mp->m_update_sb = true; 6747c12f296STim Shimmin } 675e6957ea4SEric Sandeen 676ee1c0908SDavid Chinner 677263997a6SDave Chinner /* always use v2 inodes by default now */ 678263997a6SDave Chinner if (!(mp->m_sb.sb_versionnum & XFS_SB_VERSION_NLINKBIT)) { 679263997a6SDave Chinner mp->m_sb.sb_versionnum |= XFS_SB_VERSION_NLINKBIT; 68038c26bfdSDave Chinner mp->m_features |= XFS_FEAT_NLINK; 68161e63ecbSDave Chinner mp->m_update_sb = true; 682263997a6SDave Chinner } 683263997a6SDave Chinner 684ee1c0908SDavid Chinner /* 6854f5b1b3aSDarrick J. Wong * If we were given new sunit/swidth options, do some basic validation 6864f5b1b3aSDarrick J. Wong * checks and convert the incore dalign and swidth values to the 6874f5b1b3aSDarrick J. Wong * same units (FSB) that everything else uses. This /must/ happen 6884f5b1b3aSDarrick J. Wong * before computing the inode geometry. 6890771fb45SEric Sandeen */ 6904f5b1b3aSDarrick J. Wong error = xfs_validate_new_dalign(mp); 6910771fb45SEric Sandeen if (error) 692f9057e3dSChristoph Hellwig goto out; 6930771fb45SEric Sandeen 6940771fb45SEric Sandeen xfs_alloc_compute_maxlevels(mp); 6950771fb45SEric Sandeen xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK); 6960771fb45SEric Sandeen xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK); 697b2941046SDave Chinner xfs_mount_setup_inode_geom(mp); 698035e00acSDarrick J. Wong xfs_rmapbt_compute_maxlevels(mp); 6991946b91cSDarrick J. Wong xfs_refcountbt_compute_maxlevels(mp); 7000771fb45SEric Sandeen 701b74e15d7SDarrick J. Wong xfs_agbtree_compute_maxlevels(mp); 702b74e15d7SDarrick J. Wong 7034f5b1b3aSDarrick J. Wong /* 7044f5b1b3aSDarrick J. Wong * Check if sb_agblocks is aligned at stripe boundary. If sb_agblocks 7054f5b1b3aSDarrick J. Wong * is NOT aligned turn off m_dalign since allocator alignment is within 7064f5b1b3aSDarrick J. Wong * an ag, therefore ag has to be aligned at stripe boundary. Note that 7074f5b1b3aSDarrick J. Wong * we must compute the free space and rmap btree geometry before doing 7084f5b1b3aSDarrick J. Wong * this. 7094f5b1b3aSDarrick J. Wong */ 7104f5b1b3aSDarrick J. Wong error = xfs_update_alignment(mp); 7114f5b1b3aSDarrick J. Wong if (error) 7124f5b1b3aSDarrick J. Wong goto out; 7134f5b1b3aSDarrick J. Wong 714e6b3bb78SCarlos Maiolino /* enable fail_at_unmount as default */ 715749f24f3SThomas Meyer mp->m_fail_unmount = true; 716e6b3bb78SCarlos Maiolino 717231e8725SKent Overstreet super_set_sysfs_name_id(mp->m_super); 718231e8725SKent Overstreet 719e1d3d218SIan Kent error = xfs_sysfs_init(&mp->m_kobj, &xfs_mp_ktype, 720e1d3d218SIan Kent NULL, mp->m_super->s_id); 72127174203SChristoph Hellwig if (error) 722f9057e3dSChristoph Hellwig goto out; 7231da177e4SLinus Torvalds 724225e4635SBill O'Donnell error = xfs_sysfs_init(&mp->m_stats.xs_kobj, &xfs_stats_ktype, 725225e4635SBill O'Donnell &mp->m_kobj, "stats"); 726a31b1d3dSBrian Foster if (error) 727a31b1d3dSBrian Foster goto out_remove_sysfs; 728a31b1d3dSBrian Foster 729d7a74cadSDarrick J. Wong xchk_stats_register(mp->m_scrub_stats, mp->m_debugfs); 730d7a74cadSDarrick J. Wong 731192852beSCarlos Maiolino error = xfs_error_sysfs_init(mp); 732225e4635SBill O'Donnell if (error) 733d7a74cadSDarrick J. Wong goto out_remove_scrub_stats; 734225e4635SBill O'Donnell 73531965ef3SDarrick J. Wong error = xfs_errortag_init(mp); 73631965ef3SDarrick J. Wong if (error) 73731965ef3SDarrick J. Wong goto out_remove_error_sysfs; 738192852beSCarlos Maiolino 739192852beSCarlos Maiolino error = xfs_uuid_mount(mp); 740192852beSCarlos Maiolino if (error) 74131965ef3SDarrick J. Wong goto out_remove_errortag; 742192852beSCarlos Maiolino 7431da177e4SLinus Torvalds /* 7442fcddee8SChristoph Hellwig * Update the preferred write size based on the information from the 7452fcddee8SChristoph Hellwig * on-disk superblock. 7460771fb45SEric Sandeen */ 7472fcddee8SChristoph Hellwig mp->m_allocsize_log = 7482fcddee8SChristoph Hellwig max_t(uint32_t, sbp->sb_blocklog, mp->m_allocsize_log); 7492fcddee8SChristoph Hellwig mp->m_allocsize_blocks = 1U << (mp->m_allocsize_log - sbp->sb_blocklog); 7500771fb45SEric Sandeen 751055388a3SDave Chinner /* set the low space thresholds for dynamic preallocation */ 752055388a3SDave Chinner xfs_set_low_space_thresholds(mp); 753055388a3SDave Chinner 7540771fb45SEric Sandeen /* 755e5376fc1SBrian Foster * If enabled, sparse inode chunk alignment is expected to match the 756e5376fc1SBrian Foster * cluster size. Full inode chunk alignment must match the chunk size, 757e5376fc1SBrian Foster * but that is checked on sb read verification... 758e5376fc1SBrian Foster */ 75938c26bfdSDave Chinner if (xfs_has_sparseinodes(mp) && 760e5376fc1SBrian Foster mp->m_sb.sb_spino_align != 761490d451fSDarrick J. Wong XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw)) { 762e5376fc1SBrian Foster xfs_warn(mp, 763e5376fc1SBrian Foster "Sparse inode block alignment (%u) must match cluster size (%llu).", 764e5376fc1SBrian Foster mp->m_sb.sb_spino_align, 765490d451fSDarrick J. Wong XFS_B_TO_FSBT(mp, igeo->inode_cluster_size_raw)); 766e5376fc1SBrian Foster error = -EINVAL; 767e5376fc1SBrian Foster goto out_remove_uuid; 768e5376fc1SBrian Foster } 769e5376fc1SBrian Foster 770e5376fc1SBrian Foster /* 771c2bfbc9bSZhi Yong Wu * Check that the data (and log if separate) is an ok size. 7720771fb45SEric Sandeen */ 7734249023aSChristoph Hellwig error = xfs_check_sizes(mp); 7740771fb45SEric Sandeen if (error) 775f9057e3dSChristoph Hellwig goto out_remove_uuid; 7760771fb45SEric Sandeen 7770771fb45SEric Sandeen /* 7781da177e4SLinus Torvalds * Initialize realtime fields in the mount structure 7791da177e4SLinus Torvalds */ 7800771fb45SEric Sandeen error = xfs_rtmount_init(mp); 7810771fb45SEric Sandeen if (error) { 7820b932cccSDave Chinner xfs_warn(mp, "RT mount failed"); 783f9057e3dSChristoph Hellwig goto out_remove_uuid; 7841da177e4SLinus Torvalds } 7851da177e4SLinus Torvalds 7861da177e4SLinus Torvalds /* 7871da177e4SLinus Torvalds * Copies the low order bits of the timestamp and the randomly 7881da177e4SLinus Torvalds * set "sequence" number out of a UUID. 7891da177e4SLinus Torvalds */ 790cb0ba6ccSChristoph Hellwig mp->m_fixedfsid[0] = 791cb0ba6ccSChristoph Hellwig (get_unaligned_be16(&sbp->sb_uuid.b[8]) << 16) | 792cb0ba6ccSChristoph Hellwig get_unaligned_be16(&sbp->sb_uuid.b[4]); 793cb0ba6ccSChristoph Hellwig mp->m_fixedfsid[1] = get_unaligned_be32(&sbp->sb_uuid.b[0]); 7941da177e4SLinus Torvalds 7950650b554SDave Chinner error = xfs_da_mount(mp); 7960650b554SDave Chinner if (error) { 7970650b554SDave Chinner xfs_warn(mp, "Failed dir/attr init: %d", error); 7980650b554SDave Chinner goto out_remove_uuid; 7990650b554SDave Chinner } 8001da177e4SLinus Torvalds 8011da177e4SLinus Torvalds /* 8021da177e4SLinus Torvalds * Initialize the precomputed transaction reservations values. 8031da177e4SLinus Torvalds */ 8041da177e4SLinus Torvalds xfs_trans_init(mp); 8051da177e4SLinus Torvalds 8061da177e4SLinus Torvalds /* 8071da177e4SLinus Torvalds * Allocate and initialize the per-ag data. 8081da177e4SLinus Torvalds */ 8090800169eSDave Chinner error = xfs_initialize_perag(mp, sbp->sb_agcount, mp->m_sb.sb_dblocks, 8100800169eSDave Chinner &mp->m_maxagi); 8111c1c6ebcSDave Chinner if (error) { 8120b932cccSDave Chinner xfs_warn(mp, "Failed per-ag init: %d", error); 8130650b554SDave Chinner goto out_free_dir; 8141c1c6ebcSDave Chinner } 8151da177e4SLinus Torvalds 816a71895c5SDarrick J. Wong if (XFS_IS_CORRUPT(mp, !sbp->sb_logblocks)) { 8170b932cccSDave Chinner xfs_warn(mp, "no log defined"); 8182451337dSDave Chinner error = -EFSCORRUPTED; 819f9057e3dSChristoph Hellwig goto out_free_perag; 820f9057e3dSChristoph Hellwig } 821f9057e3dSChristoph Hellwig 82240b1de00SDarrick J. Wong error = xfs_inodegc_register_shrinker(mp); 82340b1de00SDarrick J. Wong if (error) 82440b1de00SDarrick J. Wong goto out_fail_wait; 82540b1de00SDarrick J. Wong 8261da177e4SLinus Torvalds /* 827f0b2efadSBrian Foster * Log's mount-time initialization. The first part of recovery can place 828f0b2efadSBrian Foster * some items on the AIL, to be handled when recovery is finished or 829f0b2efadSBrian Foster * cancelled. 8301da177e4SLinus Torvalds */ 8311da177e4SLinus Torvalds error = xfs_log_mount(mp, mp->m_logdev_targp, 8321da177e4SLinus Torvalds XFS_FSB_TO_DADDR(mp, sbp->sb_logstart), 8331da177e4SLinus Torvalds XFS_FSB_TO_BB(mp, sbp->sb_logblocks)); 8341da177e4SLinus Torvalds if (error) { 8350b932cccSDave Chinner xfs_warn(mp, "log mount failed"); 83640b1de00SDarrick J. Wong goto out_inodegc_shrinker; 8371da177e4SLinus Torvalds } 8381da177e4SLinus Torvalds 839f759784cSDarrick J. Wong /* 840f759784cSDarrick J. Wong * If logged xattrs are still enabled after log recovery finishes, then 841f759784cSDarrick J. Wong * they'll be available until unmount. Otherwise, turn them off. 842f759784cSDarrick J. Wong */ 843f759784cSDarrick J. Wong if (xfs_sb_version_haslogxattrs(&mp->m_sb)) 844f759784cSDarrick J. Wong xfs_set_using_logged_xattrs(mp); 845f759784cSDarrick J. Wong else 846f759784cSDarrick J. Wong xfs_clear_using_logged_xattrs(mp); 847f759784cSDarrick J. Wong 848ab23a776SDave Chinner /* Enable background inode inactivation workers. */ 849ab23a776SDave Chinner xfs_inodegc_start(mp); 8506f649091SDarrick J. Wong xfs_blockgc_start(mp); 851ab23a776SDave Chinner 85292821e2bSDavid Chinner /* 853e23b55d5SDave Chinner * Now that we've recovered any pending superblock feature bit 854e23b55d5SDave Chinner * additions, we can finish setting up the attr2 behaviour for the 8550560f31aSDave Chinner * mount. The noattr2 option overrides the superblock flag, so only 8560560f31aSDave Chinner * check the superblock feature flag if the mount option is not set. 857e23b55d5SDave Chinner */ 8580560f31aSDave Chinner if (xfs_has_noattr2(mp)) { 8590560f31aSDave Chinner mp->m_features &= ~XFS_FEAT_ATTR2; 8600560f31aSDave Chinner } else if (!xfs_has_attr2(mp) && 8610560f31aSDave Chinner (mp->m_sb.sb_features2 & XFS_SB_VERSION2_ATTR2BIT)) { 8620560f31aSDave Chinner mp->m_features |= XFS_FEAT_ATTR2; 8630560f31aSDave Chinner } 864e23b55d5SDave Chinner 865e23b55d5SDave Chinner /* 8661da177e4SLinus Torvalds * Get and sanity-check the root inode. 8671da177e4SLinus Torvalds * Save the pointer to it in the mount structure. 8681da177e4SLinus Torvalds */ 869541b5accSDave Chinner error = xfs_iget(mp, NULL, sbp->sb_rootino, XFS_IGET_UNTRUSTED, 870541b5accSDave Chinner XFS_ILOCK_EXCL, &rip); 8711da177e4SLinus Torvalds if (error) { 872541b5accSDave Chinner xfs_warn(mp, 873541b5accSDave Chinner "Failed to read root inode 0x%llx, error %d", 874541b5accSDave Chinner sbp->sb_rootino, -error); 875f9057e3dSChristoph Hellwig goto out_log_dealloc; 8761da177e4SLinus Torvalds } 8771da177e4SLinus Torvalds 8781da177e4SLinus Torvalds ASSERT(rip != NULL); 8791da177e4SLinus Torvalds 880a71895c5SDarrick J. Wong if (XFS_IS_CORRUPT(mp, !S_ISDIR(VFS_I(rip)->i_mode))) { 8810b932cccSDave Chinner xfs_warn(mp, "corrupted root inode %llu: not a directory", 882b6574520SNathan Scott (unsigned long long)rip->i_ino); 8831da177e4SLinus Torvalds xfs_iunlock(rip, XFS_ILOCK_EXCL); 8842451337dSDave Chinner error = -EFSCORRUPTED; 885f9057e3dSChristoph Hellwig goto out_rele_rip; 8861da177e4SLinus Torvalds } 8871da177e4SLinus Torvalds mp->m_rootip = rip; /* save it */ 8881da177e4SLinus Torvalds 8891da177e4SLinus Torvalds xfs_iunlock(rip, XFS_ILOCK_EXCL); 8901da177e4SLinus Torvalds 8911da177e4SLinus Torvalds /* 8921da177e4SLinus Torvalds * Initialize realtime inode pointers in the mount structure 8931da177e4SLinus Torvalds */ 8940771fb45SEric Sandeen error = xfs_rtmount_inodes(mp); 8950771fb45SEric Sandeen if (error) { 8961da177e4SLinus Torvalds /* 8971da177e4SLinus Torvalds * Free up the root inode. 8981da177e4SLinus Torvalds */ 8990b932cccSDave Chinner xfs_warn(mp, "failed to read RT inodes"); 900f9057e3dSChristoph Hellwig goto out_rele_rip; 9011da177e4SLinus Torvalds } 9021da177e4SLinus Torvalds 9035a605fd6SDarrick J. Wong /* Make sure the summary counts are ok. */ 9045a605fd6SDarrick J. Wong error = xfs_check_summary_counts(mp); 9055a605fd6SDarrick J. Wong if (error) 9065a605fd6SDarrick J. Wong goto out_rtunmount; 9075a605fd6SDarrick J. Wong 9081da177e4SLinus Torvalds /* 9097884bc86SChristoph Hellwig * If this is a read-only mount defer the superblock updates until 9107884bc86SChristoph Hellwig * the next remount into writeable mode. Otherwise we would never 9117884bc86SChristoph Hellwig * perform the update e.g. for the root filesystem. 9121da177e4SLinus Torvalds */ 9132e973b2cSDave Chinner if (mp->m_update_sb && !xfs_is_readonly(mp)) { 91461e63ecbSDave Chinner error = xfs_sync_sb(mp, false); 915e5720eecSDavid Chinner if (error) { 9160b932cccSDave Chinner xfs_warn(mp, "failed to write sb changes"); 917b93b6e43SChristoph Hellwig goto out_rtunmount; 918e5720eecSDavid Chinner } 919e5720eecSDavid Chinner } 9201da177e4SLinus Torvalds 9211da177e4SLinus Torvalds /* 9221da177e4SLinus Torvalds * Initialise the XFS quota management subsystem for this mount 9231da177e4SLinus Torvalds */ 924149e53afSChristoph Hellwig if (XFS_IS_QUOTA_ON(mp)) { 9257d095257SChristoph Hellwig error = xfs_qm_newmount(mp, "amount, "aflags); 9260771fb45SEric Sandeen if (error) 927b93b6e43SChristoph Hellwig goto out_rtunmount; 9287d095257SChristoph Hellwig } else { 9297d095257SChristoph Hellwig /* 9307d095257SChristoph Hellwig * If a file system had quotas running earlier, but decided to 9317d095257SChristoph Hellwig * mount without -o uquota/pquota/gquota options, revoke the 9327d095257SChristoph Hellwig * quotachecked license. 9337d095257SChristoph Hellwig */ 9347d095257SChristoph Hellwig if (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT) { 9350b932cccSDave Chinner xfs_notice(mp, "resetting quota flags"); 9367d095257SChristoph Hellwig error = xfs_mount_reset_sbqflags(mp); 9377d095257SChristoph Hellwig if (error) 938a70a4fa5SBrian Foster goto out_rtunmount; 9397d095257SChristoph Hellwig } 9407d095257SChristoph Hellwig } 9411da177e4SLinus Torvalds 9421da177e4SLinus Torvalds /* 943f0b2efadSBrian Foster * Finish recovering the file system. This part needed to be delayed 944f0b2efadSBrian Foster * until after the root and real-time bitmap inodes were consistently 94581ed9475SDarrick J. Wong * read in. Temporarily create per-AG space reservations for metadata 94681ed9475SDarrick J. Wong * btree shape changes because space freeing transactions (for inode 94781ed9475SDarrick J. Wong * inactivation) require the per-AG reservation in lieu of reserving 94881ed9475SDarrick J. Wong * blocks. 9491da177e4SLinus Torvalds */ 95081ed9475SDarrick J. Wong error = xfs_fs_reserve_ag_blocks(mp); 95181ed9475SDarrick J. Wong if (error && error == -ENOSPC) 95281ed9475SDarrick J. Wong xfs_warn(mp, 95381ed9475SDarrick J. Wong "ENOSPC reserving per-AG metadata pool, log recovery may fail."); 9544249023aSChristoph Hellwig error = xfs_log_mount_finish(mp); 95581ed9475SDarrick J. Wong xfs_fs_unreserve_ag_blocks(mp); 9561da177e4SLinus Torvalds if (error) { 9570b932cccSDave Chinner xfs_warn(mp, "log mount finish failed"); 958b93b6e43SChristoph Hellwig goto out_rtunmount; 9591da177e4SLinus Torvalds } 9601da177e4SLinus Torvalds 9611da177e4SLinus Torvalds /* 962ddeb14f4SDave Chinner * Now the log is fully replayed, we can transition to full read-only 963ddeb14f4SDave Chinner * mode for read-only mounts. This will sync all the metadata and clean 964ddeb14f4SDave Chinner * the log so that the recovery we just performed does not have to be 965ddeb14f4SDave Chinner * replayed again on the next mount. 966ddeb14f4SDave Chinner * 967ddeb14f4SDave Chinner * We use the same quiesce mechanism as the rw->ro remount, as they are 968ddeb14f4SDave Chinner * semantically identical operations. 969ddeb14f4SDave Chinner */ 9702e973b2cSDave Chinner if (xfs_is_readonly(mp) && !xfs_has_norecovery(mp)) 971ea2064daSBrian Foster xfs_log_clean(mp); 972ddeb14f4SDave Chinner 973ddeb14f4SDave Chinner /* 9741da177e4SLinus Torvalds * Complete the quota initialisation, post-log-replay component. 9751da177e4SLinus Torvalds */ 9767d095257SChristoph Hellwig if (quotamount) { 9777d095257SChristoph Hellwig ASSERT(mp->m_qflags == 0); 9787d095257SChristoph Hellwig mp->m_qflags = quotaflags; 9797d095257SChristoph Hellwig 9807d095257SChristoph Hellwig xfs_qm_mount_quotas(mp); 9817d095257SChristoph Hellwig } 9827d095257SChristoph Hellwig 98384e1e99fSDavid Chinner /* 98484e1e99fSDavid Chinner * Now we are mounted, reserve a small amount of unused space for 98584e1e99fSDavid Chinner * privileged transactions. This is needed so that transaction 98684e1e99fSDavid Chinner * space required for critical operations can dip into this pool 98784e1e99fSDavid Chinner * when at ENOSPC. This is needed for operations like create with 98884e1e99fSDavid Chinner * attr, unwritten extent conversion at ENOSPC, etc. Data allocations 98984e1e99fSDavid Chinner * are not allowed to use this reserved space. 9908babd8a2SDave Chinner * 9918babd8a2SDave Chinner * This may drive us straight to ENOSPC on mount, but that implies 9928babd8a2SDave Chinner * we were already there on the last unmount. Warn if this occurs. 99384e1e99fSDavid Chinner */ 9942e973b2cSDave Chinner if (!xfs_is_readonly(mp)) { 995646ddf0cSChristoph Hellwig error = xfs_reserve_blocks(mp, xfs_default_resblks(mp)); 996714082bcSDavid Chinner if (error) 9970b932cccSDave Chinner xfs_warn(mp, 9980b932cccSDave Chinner "Unable to allocate reserve blocks. Continuing without reserve pool."); 999174edb0eSDarrick J. Wong 100084d69619SDarrick J. Wong /* Reserve AG blocks for future btree expansion. */ 100184d69619SDarrick J. Wong error = xfs_fs_reserve_ag_blocks(mp); 100284d69619SDarrick J. Wong if (error && error != -ENOSPC) 100384d69619SDarrick J. Wong goto out_agresv; 1004d5db0f97SEric Sandeen } 100584e1e99fSDavid Chinner 10061da177e4SLinus Torvalds return 0; 10071da177e4SLinus Torvalds 100884d69619SDarrick J. Wong out_agresv: 100984d69619SDarrick J. Wong xfs_fs_unreserve_ag_blocks(mp); 1010174edb0eSDarrick J. Wong xfs_qm_unmount_quotas(mp); 1011b93b6e43SChristoph Hellwig out_rtunmount: 1012b93b6e43SChristoph Hellwig xfs_rtunmount_inodes(mp); 1013f9057e3dSChristoph Hellwig out_rele_rip: 101444a8736bSDarrick J. Wong xfs_irele(rip); 101577aff8c7SDarrick J. Wong /* Clean out dquots that might be in memory after quotacheck. */ 101677aff8c7SDarrick J. Wong xfs_qm_unmount(mp); 1017ab23a776SDave Chinner 1018ab23a776SDave Chinner /* 1019ab23a776SDave Chinner * Inactivate all inodes that might still be in memory after a log 1020ab23a776SDave Chinner * intent recovery failure so that reclaim can free them. Metadata 1021ab23a776SDave Chinner * inodes and the root directory shouldn't need inactivation, but the 1022ab23a776SDave Chinner * mount failed for some reason, so pull down all the state and flee. 1023ab23a776SDave Chinner */ 1024ab23a776SDave Chinner xfs_inodegc_flush(mp); 1025ab23a776SDave Chinner 10262d1d1da3SDarrick J. Wong /* 1027d336f7ebSDarrick J. Wong * Flush all inode reclamation work and flush the log. 10282d1d1da3SDarrick J. Wong * We have to do this /after/ rtunmount and qm_unmount because those 10292d1d1da3SDarrick J. Wong * two will have scheduled delayed reclaim for the rt/quota inodes. 10302d1d1da3SDarrick J. Wong * 10312d1d1da3SDarrick J. Wong * This is slightly different from the unmountfs call sequence 10322d1d1da3SDarrick J. Wong * because we could be tearing down a partially set up mount. In 10332d1d1da3SDarrick J. Wong * particular, if log_mount_finish fails we bail out without calling 10342d1d1da3SDarrick J. Wong * qm_unmount_quotas and therefore rely on qm_unmount to release the 10352d1d1da3SDarrick J. Wong * quota inodes. 10362d1d1da3SDarrick J. Wong */ 1037d336f7ebSDarrick J. Wong xfs_unmount_flush_inodes(mp); 1038f9057e3dSChristoph Hellwig out_log_dealloc: 1039f0b2efadSBrian Foster xfs_log_mount_cancel(mp); 104040b1de00SDarrick J. Wong out_inodegc_shrinker: 10411a86a53dSQi Zheng shrinker_free(mp->m_inodegc_shrinker); 1042d4f3512bSDave Chinner out_fail_wait: 1043d4f3512bSDave Chinner if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) 104410fb9ac1SBrian Foster xfs_buftarg_drain(mp->m_logdev_targp); 104510fb9ac1SBrian Foster xfs_buftarg_drain(mp->m_ddev_targp); 1046f9057e3dSChristoph Hellwig out_free_perag: 1047ff4f038cSChristoph Hellwig xfs_free_perag(mp); 10480650b554SDave Chinner out_free_dir: 10490650b554SDave Chinner xfs_da_unmount(mp); 1050f9057e3dSChristoph Hellwig out_remove_uuid: 105127174203SChristoph Hellwig xfs_uuid_unmount(mp); 105231965ef3SDarrick J. Wong out_remove_errortag: 105331965ef3SDarrick J. Wong xfs_errortag_del(mp); 1054192852beSCarlos Maiolino out_remove_error_sysfs: 1055192852beSCarlos Maiolino xfs_error_sysfs_del(mp); 1056d7a74cadSDarrick J. Wong out_remove_scrub_stats: 1057d7a74cadSDarrick J. Wong xchk_stats_unregister(mp->m_scrub_stats); 1058225e4635SBill O'Donnell xfs_sysfs_del(&mp->m_stats.xs_kobj); 1059a31b1d3dSBrian Foster out_remove_sysfs: 1060a31b1d3dSBrian Foster xfs_sysfs_del(&mp->m_kobj); 1061f9057e3dSChristoph Hellwig out: 10621da177e4SLinus Torvalds return error; 10631da177e4SLinus Torvalds } 10641da177e4SLinus Torvalds 10651da177e4SLinus Torvalds /* 10661da177e4SLinus Torvalds * This flushes out the inodes,dquots and the superblock, unmounts the 10671da177e4SLinus Torvalds * log and makes sure that incore structures are freed. 10681da177e4SLinus Torvalds */ 106941b5c2e7SChristoph Hellwig void 107041b5c2e7SChristoph Hellwig xfs_unmountfs( 107141b5c2e7SChristoph Hellwig struct xfs_mount *mp) 10721da177e4SLinus Torvalds { 107341b5c2e7SChristoph Hellwig int error; 10741da177e4SLinus Torvalds 1075ab23a776SDave Chinner /* 1076ab23a776SDave Chinner * Perform all on-disk metadata updates required to inactivate inodes 1077ab23a776SDave Chinner * that the VFS evicted earlier in the unmount process. Freeing inodes 1078ab23a776SDave Chinner * and discarding CoW fork preallocations can cause shape changes to 1079ab23a776SDave Chinner * the free inode and refcount btrees, respectively, so we must finish 1080ab23a776SDave Chinner * this before we discard the metadata space reservations. Metadata 1081ab23a776SDave Chinner * inodes and the root directory do not require inactivation. 1082ab23a776SDave Chinner */ 1083ab23a776SDave Chinner xfs_inodegc_flush(mp); 1084ab23a776SDave Chinner 1085c9a6526fSDarrick J. Wong xfs_blockgc_stop(mp); 108684d69619SDarrick J. Wong xfs_fs_unreserve_ag_blocks(mp); 10877d095257SChristoph Hellwig xfs_qm_unmount_quotas(mp); 1088b93b6e43SChristoph Hellwig xfs_rtunmount_inodes(mp); 108944a8736bSDarrick J. Wong xfs_irele(mp->m_rootip); 109077508ec8SChristoph Hellwig 1091d336f7ebSDarrick J. Wong xfs_unmount_flush_inodes(mp); 10921da177e4SLinus Torvalds 10937d095257SChristoph Hellwig xfs_qm_unmount(mp); 1094a357a121SLachlan McIlroy 10951da177e4SLinus Torvalds /* 109684e1e99fSDavid Chinner * Unreserve any blocks we have so that when we unmount we don't account 109784e1e99fSDavid Chinner * the reserved free space as used. This is really only necessary for 109884e1e99fSDavid Chinner * lazy superblock counting because it trusts the incore superblock 10999da096fdSMalcolm Parsons * counters to be absolutely correct on clean unmount. 110084e1e99fSDavid Chinner * 110184e1e99fSDavid Chinner * We don't bother correcting this elsewhere for lazy superblock 110284e1e99fSDavid Chinner * counting because on mount of an unclean filesystem we reconstruct the 110384e1e99fSDavid Chinner * correct counter value and this is irrelevant. 110484e1e99fSDavid Chinner * 110584e1e99fSDavid Chinner * For non-lazy counter filesystems, this doesn't matter at all because 110684e1e99fSDavid Chinner * we only every apply deltas to the superblock and hence the incore 110784e1e99fSDavid Chinner * value does not matter.... 110884e1e99fSDavid Chinner */ 1109646ddf0cSChristoph Hellwig error = xfs_reserve_blocks(mp, 0); 1110714082bcSDavid Chinner if (error) 11110b932cccSDave Chinner xfs_warn(mp, "Unable to free reserved block pool. " 1112714082bcSDavid Chinner "Freespace may not be correct on next mount."); 111359f6ab40SLong Li xfs_unmount_check(mp); 1114714082bcSDavid Chinner 11155302a5c8SDarrick J. Wong /* 11165302a5c8SDarrick J. Wong * Indicate that it's ok to clear log incompat bits before cleaning 11175302a5c8SDarrick J. Wong * the log and writing the unmount record. 11185302a5c8SDarrick J. Wong */ 11195302a5c8SDarrick J. Wong xfs_set_done_with_log_incompat(mp); 112021b699c8SChristoph Hellwig xfs_log_unmount(mp); 11210650b554SDave Chinner xfs_da_unmount(mp); 112227174203SChristoph Hellwig xfs_uuid_unmount(mp); 11231da177e4SLinus Torvalds 11241550d0b0SChristoph Hellwig #if defined(DEBUG) 112531965ef3SDarrick J. Wong xfs_errortag_clearall(mp); 11261da177e4SLinus Torvalds #endif 11271a86a53dSQi Zheng shrinker_free(mp->m_inodegc_shrinker); 1128ff4f038cSChristoph Hellwig xfs_free_perag(mp); 1129a31b1d3dSBrian Foster 113031965ef3SDarrick J. Wong xfs_errortag_del(mp); 1131192852beSCarlos Maiolino xfs_error_sysfs_del(mp); 1132d7a74cadSDarrick J. Wong xchk_stats_unregister(mp->m_scrub_stats); 1133225e4635SBill O'Donnell xfs_sysfs_del(&mp->m_stats.xs_kobj); 1134a31b1d3dSBrian Foster xfs_sysfs_del(&mp->m_kobj); 11351da177e4SLinus Torvalds } 11361da177e4SLinus Torvalds 113791ee575fSBrian Foster /* 113891ee575fSBrian Foster * Determine whether modifications can proceed. The caller specifies the minimum 113991ee575fSBrian Foster * freeze level for which modifications should not be allowed. This allows 114091ee575fSBrian Foster * certain operations to proceed while the freeze sequence is in progress, if 114191ee575fSBrian Foster * necessary. 114291ee575fSBrian Foster */ 114391ee575fSBrian Foster bool 114491ee575fSBrian Foster xfs_fs_writable( 114591ee575fSBrian Foster struct xfs_mount *mp, 114691ee575fSBrian Foster int level) 114792821e2bSDavid Chinner { 114891ee575fSBrian Foster ASSERT(level > SB_UNFROZEN); 114991ee575fSBrian Foster if ((mp->m_super->s_writers.frozen >= level) || 115075c8c50fSDave Chinner xfs_is_shutdown(mp) || xfs_is_readonly(mp)) 115191ee575fSBrian Foster return false; 115291ee575fSBrian Foster 115391ee575fSBrian Foster return true; 115492821e2bSDavid Chinner } 115592821e2bSDavid Chinner 1156f30f656eSChristoph Hellwig void 1157f30f656eSChristoph Hellwig xfs_add_freecounter( 11580d485adaSDave Chinner struct xfs_mount *mp, 11592229276cSDarrick J. Wong struct percpu_counter *counter, 1160f30f656eSChristoph Hellwig uint64_t delta) 11610d485adaSDave Chinner { 1162f30f656eSChristoph Hellwig bool has_resv_pool = (counter == &mp->m_fdblocks); 1163f30f656eSChristoph Hellwig uint64_t res_used; 11642229276cSDarrick J. Wong 11650d485adaSDave Chinner /* 1166f30f656eSChristoph Hellwig * If the reserve pool is depleted, put blocks back into it first. 1167f30f656eSChristoph Hellwig * Most of the time the pool is full. 11680d485adaSDave Chinner */ 1169f30f656eSChristoph Hellwig if (!has_resv_pool || mp->m_resblks == mp->m_resblks_avail) { 11702229276cSDarrick J. Wong percpu_counter_add(counter, delta); 1171f30f656eSChristoph Hellwig return; 11720d485adaSDave Chinner } 11730d485adaSDave Chinner 11740d485adaSDave Chinner spin_lock(&mp->m_sb_lock); 1175f30f656eSChristoph Hellwig res_used = mp->m_resblks - mp->m_resblks_avail; 11760d485adaSDave Chinner if (res_used > delta) { 11770d485adaSDave Chinner mp->m_resblks_avail += delta; 11780d485adaSDave Chinner } else { 11790d485adaSDave Chinner delta -= res_used; 11800d485adaSDave Chinner mp->m_resblks_avail = mp->m_resblks; 11812229276cSDarrick J. Wong percpu_counter_add(counter, delta); 11820d485adaSDave Chinner } 11830d485adaSDave Chinner spin_unlock(&mp->m_sb_lock); 11840d485adaSDave Chinner } 11850d485adaSDave Chinner 1186f30f656eSChristoph Hellwig int 1187f30f656eSChristoph Hellwig xfs_dec_freecounter( 1188f30f656eSChristoph Hellwig struct xfs_mount *mp, 1189f30f656eSChristoph Hellwig struct percpu_counter *counter, 1190f30f656eSChristoph Hellwig uint64_t delta, 1191f30f656eSChristoph Hellwig bool rsvd) 1192f30f656eSChristoph Hellwig { 1193f30f656eSChristoph Hellwig int64_t lcounter; 1194f30f656eSChristoph Hellwig uint64_t set_aside = 0; 1195f30f656eSChristoph Hellwig s32 batch; 1196f30f656eSChristoph Hellwig bool has_resv_pool; 1197f30f656eSChristoph Hellwig 1198f30f656eSChristoph Hellwig ASSERT(counter == &mp->m_fdblocks || counter == &mp->m_frextents); 1199f30f656eSChristoph Hellwig has_resv_pool = (counter == &mp->m_fdblocks); 1200f30f656eSChristoph Hellwig if (rsvd) 1201f30f656eSChristoph Hellwig ASSERT(has_resv_pool); 1202f30f656eSChristoph Hellwig 12030d485adaSDave Chinner /* 12040d485adaSDave Chinner * Taking blocks away, need to be more accurate the closer we 12050d485adaSDave Chinner * are to zero. 12060d485adaSDave Chinner * 12070d485adaSDave Chinner * If the counter has a value of less than 2 * max batch size, 12080d485adaSDave Chinner * then make everything serialise as we are real close to 12090d485adaSDave Chinner * ENOSPC. 12100d485adaSDave Chinner */ 12112229276cSDarrick J. Wong if (__percpu_counter_compare(counter, 2 * XFS_FDBLOCKS_BATCH, 12128c1903d3SDave Chinner XFS_FDBLOCKS_BATCH) < 0) 12130d485adaSDave Chinner batch = 1; 12140d485adaSDave Chinner else 12158c1903d3SDave Chinner batch = XFS_FDBLOCKS_BATCH; 12160d485adaSDave Chinner 1217fd43cf60SBrian Foster /* 1218fd43cf60SBrian Foster * Set aside allocbt blocks because these blocks are tracked as free 1219fd43cf60SBrian Foster * space but not available for allocation. Technically this means that a 1220fd43cf60SBrian Foster * single reservation cannot consume all remaining free space, but the 1221fd43cf60SBrian Foster * ratio of allocbt blocks to usable free blocks should be rather small. 1222fd43cf60SBrian Foster * The tradeoff without this is that filesystems that maintain high 1223fd43cf60SBrian Foster * perag block reservations can over reserve physical block availability 1224fd43cf60SBrian Foster * and fail physical allocation, which leads to much more serious 1225fd43cf60SBrian Foster * problems (i.e. transaction abort, pagecache discards, etc.) than 1226fd43cf60SBrian Foster * slightly premature -ENOSPC. 1227fd43cf60SBrian Foster */ 12282229276cSDarrick J. Wong if (has_resv_pool) 1229c8c56825SDarrick J. Wong set_aside = xfs_fdblocks_unavailable(mp); 1230f30f656eSChristoph Hellwig percpu_counter_add_batch(counter, -((int64_t)delta), batch); 12312229276cSDarrick J. Wong if (__percpu_counter_compare(counter, set_aside, 12328c1903d3SDave Chinner XFS_FDBLOCKS_BATCH) >= 0) { 12330d485adaSDave Chinner /* we had space! */ 12340d485adaSDave Chinner return 0; 12350d485adaSDave Chinner } 12360d485adaSDave Chinner 12370d485adaSDave Chinner /* 12380d485adaSDave Chinner * lock up the sb for dipping into reserves before releasing the space 12390d485adaSDave Chinner * that took us to ENOSPC. 12400d485adaSDave Chinner */ 12410d485adaSDave Chinner spin_lock(&mp->m_sb_lock); 1242f30f656eSChristoph Hellwig percpu_counter_add(counter, delta); 12432229276cSDarrick J. Wong if (!has_resv_pool || !rsvd) 12440d485adaSDave Chinner goto fdblocks_enospc; 12450d485adaSDave Chinner 1246f30f656eSChristoph Hellwig lcounter = (long long)mp->m_resblks_avail - delta; 12470d485adaSDave Chinner if (lcounter >= 0) { 12480d485adaSDave Chinner mp->m_resblks_avail = lcounter; 12490d485adaSDave Chinner spin_unlock(&mp->m_sb_lock); 12500d485adaSDave Chinner return 0; 12510d485adaSDave Chinner } 1252ec43f6daSEric Sandeen xfs_warn_once(mp, 1253ec43f6daSEric Sandeen "Reserve blocks depleted! Consider increasing reserve pool size."); 1254ec43f6daSEric Sandeen 12550d485adaSDave Chinner fdblocks_enospc: 12560d485adaSDave Chinner spin_unlock(&mp->m_sb_lock); 12570d485adaSDave Chinner return -ENOSPC; 12580d485adaSDave Chinner } 12590d485adaSDave Chinner 12601da177e4SLinus Torvalds /* 12611da177e4SLinus Torvalds * Used to free the superblock along various error paths. 12621da177e4SLinus Torvalds */ 12631da177e4SLinus Torvalds void 12641da177e4SLinus Torvalds xfs_freesb( 126526af6552SDave Chinner struct xfs_mount *mp) 12661da177e4SLinus Torvalds { 126726af6552SDave Chinner struct xfs_buf *bp = mp->m_sb_bp; 12681da177e4SLinus Torvalds 126926af6552SDave Chinner xfs_buf_lock(bp); 12701da177e4SLinus Torvalds mp->m_sb_bp = NULL; 127126af6552SDave Chinner xfs_buf_relse(bp); 12721da177e4SLinus Torvalds } 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds /* 1275dda35b8fSChristoph Hellwig * If the underlying (data/log/rt) device is readonly, there are some 1276dda35b8fSChristoph Hellwig * operations that cannot proceed. 1277dda35b8fSChristoph Hellwig */ 1278dda35b8fSChristoph Hellwig int 1279dda35b8fSChristoph Hellwig xfs_dev_is_read_only( 1280dda35b8fSChristoph Hellwig struct xfs_mount *mp, 1281dda35b8fSChristoph Hellwig char *message) 1282dda35b8fSChristoph Hellwig { 1283dda35b8fSChristoph Hellwig if (xfs_readonly_buftarg(mp->m_ddev_targp) || 1284dda35b8fSChristoph Hellwig xfs_readonly_buftarg(mp->m_logdev_targp) || 1285dda35b8fSChristoph Hellwig (mp->m_rtdev_targp && xfs_readonly_buftarg(mp->m_rtdev_targp))) { 12860b932cccSDave Chinner xfs_notice(mp, "%s required on read-only device.", message); 12870b932cccSDave Chinner xfs_notice(mp, "write access unavailable, cannot proceed."); 12882451337dSDave Chinner return -EROFS; 1289dda35b8fSChristoph Hellwig } 1290dda35b8fSChristoph Hellwig return 0; 1291dda35b8fSChristoph Hellwig } 1292f467cad9SDarrick J. Wong 1293f467cad9SDarrick J. Wong /* Force the summary counters to be recalculated at next mount. */ 1294f467cad9SDarrick J. Wong void 1295f467cad9SDarrick J. Wong xfs_force_summary_recalc( 1296f467cad9SDarrick J. Wong struct xfs_mount *mp) 1297f467cad9SDarrick J. Wong { 129838c26bfdSDave Chinner if (!xfs_has_lazysbcount(mp)) 1299f467cad9SDarrick J. Wong return; 1300f467cad9SDarrick J. Wong 130139353ff6SDarrick J. Wong xfs_fs_mark_sick(mp, XFS_SICK_FS_COUNTERS); 1302f467cad9SDarrick J. Wong } 13039fe82b8cSDarrick J. Wong 13049fe82b8cSDarrick J. Wong /* 1305908ce71eSDarrick J. Wong * Enable a log incompat feature flag in the primary superblock. The caller 1306908ce71eSDarrick J. Wong * cannot have any other transactions in progress. 1307908ce71eSDarrick J. Wong */ 1308908ce71eSDarrick J. Wong int 1309908ce71eSDarrick J. Wong xfs_add_incompat_log_feature( 1310908ce71eSDarrick J. Wong struct xfs_mount *mp, 1311908ce71eSDarrick J. Wong uint32_t feature) 1312908ce71eSDarrick J. Wong { 1313908ce71eSDarrick J. Wong struct xfs_dsb *dsb; 1314908ce71eSDarrick J. Wong int error; 1315908ce71eSDarrick J. Wong 1316908ce71eSDarrick J. Wong ASSERT(hweight32(feature) == 1); 1317908ce71eSDarrick J. Wong ASSERT(!(feature & XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN)); 1318908ce71eSDarrick J. Wong 1319908ce71eSDarrick J. Wong /* 1320908ce71eSDarrick J. Wong * Force the log to disk and kick the background AIL thread to reduce 1321908ce71eSDarrick J. Wong * the chances that the bwrite will stall waiting for the AIL to unpin 1322908ce71eSDarrick J. Wong * the primary superblock buffer. This isn't a data integrity 1323908ce71eSDarrick J. Wong * operation, so we don't need a synchronous push. 1324908ce71eSDarrick J. Wong */ 1325908ce71eSDarrick J. Wong error = xfs_log_force(mp, XFS_LOG_SYNC); 1326908ce71eSDarrick J. Wong if (error) 1327908ce71eSDarrick J. Wong return error; 1328908ce71eSDarrick J. Wong xfs_ail_push_all(mp->m_ail); 1329908ce71eSDarrick J. Wong 1330908ce71eSDarrick J. Wong /* 1331908ce71eSDarrick J. Wong * Lock the primary superblock buffer to serialize all callers that 1332908ce71eSDarrick J. Wong * are trying to set feature bits. 1333908ce71eSDarrick J. Wong */ 1334908ce71eSDarrick J. Wong xfs_buf_lock(mp->m_sb_bp); 1335908ce71eSDarrick J. Wong xfs_buf_hold(mp->m_sb_bp); 1336908ce71eSDarrick J. Wong 133775c8c50fSDave Chinner if (xfs_is_shutdown(mp)) { 1338908ce71eSDarrick J. Wong error = -EIO; 1339908ce71eSDarrick J. Wong goto rele; 1340908ce71eSDarrick J. Wong } 1341908ce71eSDarrick J. Wong 1342908ce71eSDarrick J. Wong if (xfs_sb_has_incompat_log_feature(&mp->m_sb, feature)) 1343908ce71eSDarrick J. Wong goto rele; 1344908ce71eSDarrick J. Wong 1345908ce71eSDarrick J. Wong /* 1346908ce71eSDarrick J. Wong * Write the primary superblock to disk immediately, because we need 1347908ce71eSDarrick J. Wong * the log_incompat bit to be set in the primary super now to protect 1348908ce71eSDarrick J. Wong * the log items that we're going to commit later. 1349908ce71eSDarrick J. Wong */ 1350908ce71eSDarrick J. Wong dsb = mp->m_sb_bp->b_addr; 1351908ce71eSDarrick J. Wong xfs_sb_to_disk(dsb, &mp->m_sb); 1352908ce71eSDarrick J. Wong dsb->sb_features_log_incompat |= cpu_to_be32(feature); 1353908ce71eSDarrick J. Wong error = xfs_bwrite(mp->m_sb_bp); 1354908ce71eSDarrick J. Wong if (error) 1355908ce71eSDarrick J. Wong goto shutdown; 1356908ce71eSDarrick J. Wong 1357908ce71eSDarrick J. Wong /* 1358908ce71eSDarrick J. Wong * Add the feature bits to the incore superblock before we unlock the 1359908ce71eSDarrick J. Wong * buffer. 1360908ce71eSDarrick J. Wong */ 1361908ce71eSDarrick J. Wong xfs_sb_add_incompat_log_features(&mp->m_sb, feature); 1362908ce71eSDarrick J. Wong xfs_buf_relse(mp->m_sb_bp); 1363908ce71eSDarrick J. Wong 1364908ce71eSDarrick J. Wong /* Log the superblock to disk. */ 1365908ce71eSDarrick J. Wong return xfs_sync_sb(mp, false); 1366908ce71eSDarrick J. Wong shutdown: 1367908ce71eSDarrick J. Wong xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR); 1368908ce71eSDarrick J. Wong rele: 1369908ce71eSDarrick J. Wong xfs_buf_relse(mp->m_sb_bp); 1370908ce71eSDarrick J. Wong return error; 1371908ce71eSDarrick J. Wong } 1372908ce71eSDarrick J. Wong 1373908ce71eSDarrick J. Wong /* 1374908ce71eSDarrick J. Wong * Clear all the log incompat flags from the superblock. 1375908ce71eSDarrick J. Wong * 1376908ce71eSDarrick J. Wong * The caller cannot be in a transaction, must ensure that the log does not 1377908ce71eSDarrick J. Wong * contain any log items protected by any log incompat bit, and must ensure 1378908ce71eSDarrick J. Wong * that there are no other threads that depend on the state of the log incompat 1379908ce71eSDarrick J. Wong * feature flags in the primary super. 1380908ce71eSDarrick J. Wong * 1381908ce71eSDarrick J. Wong * Returns true if the superblock is dirty. 1382908ce71eSDarrick J. Wong */ 1383908ce71eSDarrick J. Wong bool 1384908ce71eSDarrick J. Wong xfs_clear_incompat_log_features( 1385908ce71eSDarrick J. Wong struct xfs_mount *mp) 1386908ce71eSDarrick J. Wong { 1387908ce71eSDarrick J. Wong bool ret = false; 1388908ce71eSDarrick J. Wong 1389ebd9027dSDave Chinner if (!xfs_has_crc(mp) || 1390908ce71eSDarrick J. Wong !xfs_sb_has_incompat_log_feature(&mp->m_sb, 1391908ce71eSDarrick J. Wong XFS_SB_FEAT_INCOMPAT_LOG_ALL) || 13925302a5c8SDarrick J. Wong xfs_is_shutdown(mp) || 13935302a5c8SDarrick J. Wong !xfs_is_done_with_log_incompat(mp)) 1394908ce71eSDarrick J. Wong return false; 1395908ce71eSDarrick J. Wong 1396908ce71eSDarrick J. Wong /* 1397908ce71eSDarrick J. Wong * Update the incore superblock. We synchronize on the primary super 1398908ce71eSDarrick J. Wong * buffer lock to be consistent with the add function, though at least 1399908ce71eSDarrick J. Wong * in theory this shouldn't be necessary. 1400908ce71eSDarrick J. Wong */ 1401908ce71eSDarrick J. Wong xfs_buf_lock(mp->m_sb_bp); 1402908ce71eSDarrick J. Wong xfs_buf_hold(mp->m_sb_bp); 1403908ce71eSDarrick J. Wong 1404908ce71eSDarrick J. Wong if (xfs_sb_has_incompat_log_feature(&mp->m_sb, 1405908ce71eSDarrick J. Wong XFS_SB_FEAT_INCOMPAT_LOG_ALL)) { 1406908ce71eSDarrick J. Wong xfs_sb_remove_incompat_log_features(&mp->m_sb); 1407908ce71eSDarrick J. Wong ret = true; 1408908ce71eSDarrick J. Wong } 1409908ce71eSDarrick J. Wong 1410908ce71eSDarrick J. Wong xfs_buf_relse(mp->m_sb_bp); 1411908ce71eSDarrick J. Wong return ret; 1412908ce71eSDarrick J. Wong } 1413908ce71eSDarrick J. Wong 1414908ce71eSDarrick J. Wong /* 14159fe82b8cSDarrick J. Wong * Update the in-core delayed block counter. 14169fe82b8cSDarrick J. Wong * 14179fe82b8cSDarrick J. Wong * We prefer to update the counter without having to take a spinlock for every 14189fe82b8cSDarrick J. Wong * counter update (i.e. batching). Each change to delayed allocation 14199fe82b8cSDarrick J. Wong * reservations can change can easily exceed the default percpu counter 14209fe82b8cSDarrick J. Wong * batching, so we use a larger batch factor here. 14219fe82b8cSDarrick J. Wong * 14229fe82b8cSDarrick J. Wong * Note that we don't currently have any callers requiring fast summation 14239fe82b8cSDarrick J. Wong * (e.g. percpu_counter_read) so we can use a big batch value here. 14249fe82b8cSDarrick J. Wong */ 14259fe82b8cSDarrick J. Wong #define XFS_DELALLOC_BATCH (4096) 14269fe82b8cSDarrick J. Wong void 14279fe82b8cSDarrick J. Wong xfs_mod_delalloc( 14287099bd0fSChristoph Hellwig struct xfs_inode *ip, 14297099bd0fSChristoph Hellwig int64_t data_delta, 14307099bd0fSChristoph Hellwig int64_t ind_delta) 14319fe82b8cSDarrick J. Wong { 14327099bd0fSChristoph Hellwig struct xfs_mount *mp = ip->i_mount; 14337099bd0fSChristoph Hellwig 14347099bd0fSChristoph Hellwig if (XFS_IS_REALTIME_INODE(ip)) { 14357099bd0fSChristoph Hellwig percpu_counter_add_batch(&mp->m_delalloc_rtextents, 14367099bd0fSChristoph Hellwig xfs_rtb_to_rtx(mp, data_delta), 14377099bd0fSChristoph Hellwig XFS_DELALLOC_BATCH); 14387099bd0fSChristoph Hellwig if (!ind_delta) 14397099bd0fSChristoph Hellwig return; 14407099bd0fSChristoph Hellwig data_delta = 0; 14417099bd0fSChristoph Hellwig } 14427099bd0fSChristoph Hellwig percpu_counter_add_batch(&mp->m_delalloc_blks, data_delta + ind_delta, 14439fe82b8cSDarrick J. Wong XFS_DELALLOC_BATCH); 14449fe82b8cSDarrick J. Wong } 1445