11da177e4SLinus Torvalds /* 27b718769SNathan Scott * Copyright (c) 2000-2005 Silicon Graphics, Inc. 37b718769SNathan Scott * All Rights Reserved. 41da177e4SLinus Torvalds * 57b718769SNathan Scott * This program is free software; you can redistribute it and/or 67b718769SNathan Scott * modify it under the terms of the GNU General Public License as 71da177e4SLinus Torvalds * published by the Free Software Foundation. 81da177e4SLinus Torvalds * 97b718769SNathan Scott * This program is distributed in the hope that it would be useful, 107b718769SNathan Scott * but WITHOUT ANY WARRANTY; without even the implied warranty of 117b718769SNathan Scott * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 127b718769SNathan Scott * GNU General Public License for more details. 131da177e4SLinus Torvalds * 147b718769SNathan Scott * You should have received a copy of the GNU General Public License 157b718769SNathan Scott * along with this program; if not, write the Free Software Foundation, 167b718769SNathan Scott * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 171da177e4SLinus Torvalds */ 181da177e4SLinus Torvalds #include "xfs.h" 19a844f451SNathan Scott #include "xfs_fs.h" 201da177e4SLinus Torvalds #include "xfs_types.h" 21a844f451SNathan Scott #include "xfs_bit.h" 221da177e4SLinus Torvalds #include "xfs_log.h" 23a844f451SNathan Scott #include "xfs_inum.h" 241da177e4SLinus Torvalds #include "xfs_trans.h" 251da177e4SLinus Torvalds #include "xfs_sb.h" 261da177e4SLinus Torvalds #include "xfs_ag.h" 271da177e4SLinus Torvalds #include "xfs_dir2.h" 281da177e4SLinus Torvalds #include "xfs_dmapi.h" 291da177e4SLinus Torvalds #include "xfs_mount.h" 301da177e4SLinus Torvalds #include "xfs_bmap_btree.h" 31a844f451SNathan Scott #include "xfs_alloc_btree.h" 321da177e4SLinus Torvalds #include "xfs_ialloc_btree.h" 331da177e4SLinus Torvalds #include "xfs_dir2_sf.h" 34a844f451SNathan Scott #include "xfs_attr_sf.h" 351da177e4SLinus Torvalds #include "xfs_dinode.h" 361da177e4SLinus Torvalds #include "xfs_inode.h" 37a844f451SNathan Scott #include "xfs_btree.h" 38a844f451SNathan Scott #include "xfs_ialloc.h" 391da177e4SLinus Torvalds #include "xfs_alloc.h" 401da177e4SLinus Torvalds #include "xfs_rtalloc.h" 411da177e4SLinus Torvalds #include "xfs_bmap.h" 421da177e4SLinus Torvalds #include "xfs_error.h" 431da177e4SLinus Torvalds #include "xfs_rw.h" 441da177e4SLinus Torvalds #include "xfs_quota.h" 451da177e4SLinus Torvalds #include "xfs_fsops.h" 4643355099SChristoph Hellwig #include "xfs_utils.h" 471da177e4SLinus Torvalds 48ee1c0908SDavid Chinner STATIC void xfs_mount_log_sb(xfs_mount_t *, __int64_t); 491da177e4SLinus Torvalds STATIC int xfs_uuid_mount(xfs_mount_t *); 501da177e4SLinus Torvalds STATIC void xfs_uuid_unmount(xfs_mount_t *mp); 51ba0f32d4SChristoph Hellwig STATIC void xfs_unmountfs_wait(xfs_mount_t *); 521da177e4SLinus Torvalds 538d280b98SDavid Chinner 548d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 558d280b98SDavid Chinner STATIC void xfs_icsb_destroy_counters(xfs_mount_t *); 5620f4ebf2SDavid Chinner STATIC void xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t, 5720f4ebf2SDavid Chinner int, int); 588d280b98SDavid Chinner STATIC void xfs_icsb_sync_counters(xfs_mount_t *); 598d280b98SDavid Chinner STATIC int xfs_icsb_modify_counters(xfs_mount_t *, xfs_sb_field_t, 6020f4ebf2SDavid Chinner int64_t, int); 61*36fbe6e6SDavid Chinner STATIC void xfs_icsb_disable_counter(xfs_mount_t *, xfs_sb_field_t); 628d280b98SDavid Chinner 638d280b98SDavid Chinner #else 648d280b98SDavid Chinner 658d280b98SDavid Chinner #define xfs_icsb_destroy_counters(mp) do { } while (0) 6620b64285SDavid Chinner #define xfs_icsb_balance_counter(mp, a, b, c) do { } while (0) 678d280b98SDavid Chinner #define xfs_icsb_sync_counters(mp) do { } while (0) 688d280b98SDavid Chinner #define xfs_icsb_modify_counters(mp, a, b, c) do { } while (0) 698d280b98SDavid Chinner 708d280b98SDavid Chinner #endif 718d280b98SDavid Chinner 721df84c93SChristoph Hellwig static const struct { 731da177e4SLinus Torvalds short offset; 741da177e4SLinus Torvalds short type; /* 0 = integer 751da177e4SLinus Torvalds * 1 = binary / string (no translation) 761da177e4SLinus Torvalds */ 771da177e4SLinus Torvalds } xfs_sb_info[] = { 781da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_magicnum), 0 }, 791da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_blocksize), 0 }, 801da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_dblocks), 0 }, 811da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rblocks), 0 }, 821da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rextents), 0 }, 831da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_uuid), 1 }, 841da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logstart), 0 }, 851da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rootino), 0 }, 861da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rbmino), 0 }, 871da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rsumino), 0 }, 881da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rextsize), 0 }, 891da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_agblocks), 0 }, 901da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_agcount), 0 }, 911da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rbmblocks), 0 }, 921da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logblocks), 0 }, 931da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_versionnum), 0 }, 941da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_sectsize), 0 }, 951da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inodesize), 0 }, 961da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inopblock), 0 }, 971da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_fname[0]), 1 }, 981da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_blocklog), 0 }, 991da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_sectlog), 0 }, 1001da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inodelog), 0 }, 1011da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inopblog), 0 }, 1021da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_agblklog), 0 }, 1031da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rextslog), 0 }, 1041da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inprogress), 0 }, 1051da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_imax_pct), 0 }, 1061da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_icount), 0 }, 1071da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_ifree), 0 }, 1081da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_fdblocks), 0 }, 1091da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_frextents), 0 }, 1101da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_uquotino), 0 }, 1111da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_gquotino), 0 }, 1121da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_qflags), 0 }, 1131da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_flags), 0 }, 1141da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_shared_vn), 0 }, 1151da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inoalignmt), 0 }, 1161da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_unit), 0 }, 1171da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_width), 0 }, 1181da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_dirblklog), 0 }, 1191da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logsectlog), 0 }, 1201da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logsectsize),0 }, 1211da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logsunit), 0 }, 1221da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_features2), 0 }, 123ee1c0908SDavid Chinner { offsetof(xfs_sb_t, sb_bad_features2), 0 }, 1241da177e4SLinus Torvalds { sizeof(xfs_sb_t), 0 } 1251da177e4SLinus Torvalds }; 1261da177e4SLinus Torvalds 1271da177e4SLinus Torvalds /* 1281da177e4SLinus Torvalds * Return a pointer to an initialized xfs_mount structure. 1291da177e4SLinus Torvalds */ 1301da177e4SLinus Torvalds xfs_mount_t * 1311da177e4SLinus Torvalds xfs_mount_init(void) 1321da177e4SLinus Torvalds { 1331da177e4SLinus Torvalds xfs_mount_t *mp; 1341da177e4SLinus Torvalds 1358d280b98SDavid Chinner mp = kmem_zalloc(sizeof(xfs_mount_t), KM_SLEEP); 1368d280b98SDavid Chinner 1378d280b98SDavid Chinner if (xfs_icsb_init_counters(mp)) { 1388d280b98SDavid Chinner mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB; 1398d280b98SDavid Chinner } 1401da177e4SLinus Torvalds 141007c61c6SEric Sandeen spin_lock_init(&mp->m_sb_lock); 142794ee1baSJes Sorensen mutex_init(&mp->m_ilock); 143cc92e7acSChristoph Hellwig mutex_init(&mp->m_growlock); 1441da177e4SLinus Torvalds atomic_set(&mp->m_active_trans, 0); 1451da177e4SLinus Torvalds 1461da177e4SLinus Torvalds return mp; 1471da177e4SLinus Torvalds } 1481da177e4SLinus Torvalds 1491da177e4SLinus Torvalds /* 1501da177e4SLinus Torvalds * Free up the resources associated with a mount structure. Assume that 1511da177e4SLinus Torvalds * the structure was initially zeroed, so we can tell which fields got 1521da177e4SLinus Torvalds * initialized. 1531da177e4SLinus Torvalds */ 1541da177e4SLinus Torvalds void 1551da177e4SLinus Torvalds xfs_mount_free( 156745f6919SChristoph Hellwig xfs_mount_t *mp) 1571da177e4SLinus Torvalds { 1581da177e4SLinus Torvalds if (mp->m_perag) { 1591da177e4SLinus Torvalds int agno; 1601da177e4SLinus Torvalds 1611da177e4SLinus Torvalds for (agno = 0; agno < mp->m_maxagi; agno++) 1621da177e4SLinus Torvalds if (mp->m_perag[agno].pagb_list) 1631da177e4SLinus Torvalds kmem_free(mp->m_perag[agno].pagb_list, 1641da177e4SLinus Torvalds sizeof(xfs_perag_busy_t) * 1651da177e4SLinus Torvalds XFS_PAGB_NUM_SLOTS); 1661da177e4SLinus Torvalds kmem_free(mp->m_perag, 1671da177e4SLinus Torvalds sizeof(xfs_perag_t) * mp->m_sb.sb_agcount); 1681da177e4SLinus Torvalds } 1691da177e4SLinus Torvalds 170287f3dadSDonald Douwsma spinlock_destroy(&mp->m_ail_lock); 1711da177e4SLinus Torvalds spinlock_destroy(&mp->m_sb_lock); 1721da177e4SLinus Torvalds mutex_destroy(&mp->m_ilock); 173cc92e7acSChristoph Hellwig mutex_destroy(&mp->m_growlock); 1741da177e4SLinus Torvalds if (mp->m_quotainfo) 1751da177e4SLinus Torvalds XFS_QM_DONE(mp); 1761da177e4SLinus Torvalds 1771da177e4SLinus Torvalds if (mp->m_fsname != NULL) 1781da177e4SLinus Torvalds kmem_free(mp->m_fsname, mp->m_fsname_len); 179fc1f8c1cSNathan Scott if (mp->m_rtname != NULL) 180fc1f8c1cSNathan Scott kmem_free(mp->m_rtname, strlen(mp->m_rtname) + 1); 181fc1f8c1cSNathan Scott if (mp->m_logname != NULL) 182fc1f8c1cSNathan Scott kmem_free(mp->m_logname, strlen(mp->m_logname) + 1); 1831da177e4SLinus Torvalds 1848d280b98SDavid Chinner xfs_icsb_destroy_counters(mp); 1851da177e4SLinus Torvalds } 1861da177e4SLinus Torvalds 1874cc929eeSNathan Scott /* 1884cc929eeSNathan Scott * Check size of device based on the (data/realtime) block count. 1894cc929eeSNathan Scott * Note: this check is used by the growfs code as well as mount. 1904cc929eeSNathan Scott */ 1914cc929eeSNathan Scott int 1924cc929eeSNathan Scott xfs_sb_validate_fsb_count( 1934cc929eeSNathan Scott xfs_sb_t *sbp, 1944cc929eeSNathan Scott __uint64_t nblocks) 1954cc929eeSNathan Scott { 1964cc929eeSNathan Scott ASSERT(PAGE_SHIFT >= sbp->sb_blocklog); 1974cc929eeSNathan Scott ASSERT(sbp->sb_blocklog >= BBSHIFT); 1984cc929eeSNathan Scott 1994cc929eeSNathan Scott #if XFS_BIG_BLKNOS /* Limited by ULONG_MAX of page cache index */ 2004cc929eeSNathan Scott if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX) 2014cc929eeSNathan Scott return E2BIG; 2024cc929eeSNathan Scott #else /* Limited by UINT_MAX of sectors */ 2034cc929eeSNathan Scott if (nblocks << (sbp->sb_blocklog - BBSHIFT) > UINT_MAX) 2044cc929eeSNathan Scott return E2BIG; 2054cc929eeSNathan Scott #endif 2064cc929eeSNathan Scott return 0; 2074cc929eeSNathan Scott } 2081da177e4SLinus Torvalds 2091da177e4SLinus Torvalds /* 2101da177e4SLinus Torvalds * Check the validity of the SB found. 2111da177e4SLinus Torvalds */ 2121da177e4SLinus Torvalds STATIC int 2131da177e4SLinus Torvalds xfs_mount_validate_sb( 2141da177e4SLinus Torvalds xfs_mount_t *mp, 215764d1f89SNathan Scott xfs_sb_t *sbp, 216764d1f89SNathan Scott int flags) 2171da177e4SLinus Torvalds { 2181da177e4SLinus Torvalds /* 2191da177e4SLinus Torvalds * If the log device and data device have the 2201da177e4SLinus Torvalds * same device number, the log is internal. 2211da177e4SLinus Torvalds * Consequently, the sb_logstart should be non-zero. If 2221da177e4SLinus Torvalds * we have a zero sb_logstart in this case, we may be trying to mount 2231da177e4SLinus Torvalds * a volume filesystem in a non-volume manner. 2241da177e4SLinus Torvalds */ 2251da177e4SLinus Torvalds if (sbp->sb_magicnum != XFS_SB_MAGIC) { 226764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "bad magic number"); 2271da177e4SLinus Torvalds return XFS_ERROR(EWRONGFS); 2281da177e4SLinus Torvalds } 2291da177e4SLinus Torvalds 23062118709SEric Sandeen if (!xfs_sb_good_version(sbp)) { 231764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "bad version"); 2321da177e4SLinus Torvalds return XFS_ERROR(EWRONGFS); 2331da177e4SLinus Torvalds } 2341da177e4SLinus Torvalds 2351da177e4SLinus Torvalds if (unlikely( 2361da177e4SLinus Torvalds sbp->sb_logstart == 0 && mp->m_logdev_targp == mp->m_ddev_targp)) { 237764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 238764d1f89SNathan Scott "filesystem is marked as having an external log; " 2391da177e4SLinus Torvalds "specify logdev on the\nmount command line."); 240764d1f89SNathan Scott return XFS_ERROR(EINVAL); 2411da177e4SLinus Torvalds } 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds if (unlikely( 2441da177e4SLinus Torvalds sbp->sb_logstart != 0 && mp->m_logdev_targp != mp->m_ddev_targp)) { 245764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 246764d1f89SNathan Scott "filesystem is marked as having an internal log; " 247764d1f89SNathan Scott "do not specify logdev on\nthe mount command line."); 248764d1f89SNathan Scott return XFS_ERROR(EINVAL); 2491da177e4SLinus Torvalds } 2501da177e4SLinus Torvalds 2511da177e4SLinus Torvalds /* 2521da177e4SLinus Torvalds * More sanity checking. These were stolen directly from 2531da177e4SLinus Torvalds * xfs_repair. 2541da177e4SLinus Torvalds */ 2551da177e4SLinus Torvalds if (unlikely( 2561da177e4SLinus Torvalds sbp->sb_agcount <= 0 || 2571da177e4SLinus Torvalds sbp->sb_sectsize < XFS_MIN_SECTORSIZE || 2581da177e4SLinus Torvalds sbp->sb_sectsize > XFS_MAX_SECTORSIZE || 2591da177e4SLinus Torvalds sbp->sb_sectlog < XFS_MIN_SECTORSIZE_LOG || 2601da177e4SLinus Torvalds sbp->sb_sectlog > XFS_MAX_SECTORSIZE_LOG || 2611da177e4SLinus Torvalds sbp->sb_blocksize < XFS_MIN_BLOCKSIZE || 2621da177e4SLinus Torvalds sbp->sb_blocksize > XFS_MAX_BLOCKSIZE || 2631da177e4SLinus Torvalds sbp->sb_blocklog < XFS_MIN_BLOCKSIZE_LOG || 2641da177e4SLinus Torvalds sbp->sb_blocklog > XFS_MAX_BLOCKSIZE_LOG || 2651da177e4SLinus Torvalds sbp->sb_inodesize < XFS_DINODE_MIN_SIZE || 2661da177e4SLinus Torvalds sbp->sb_inodesize > XFS_DINODE_MAX_SIZE || 2679f989c94SNathan Scott sbp->sb_inodelog < XFS_DINODE_MIN_LOG || 2689f989c94SNathan Scott sbp->sb_inodelog > XFS_DINODE_MAX_LOG || 2699f989c94SNathan Scott (sbp->sb_blocklog - sbp->sb_inodelog != sbp->sb_inopblog) || 2701da177e4SLinus Torvalds (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE) || 2711da177e4SLinus Torvalds (sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE) || 272e50bd16fSNathan Scott (sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */))) { 273764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB sanity check 1 failed"); 2741da177e4SLinus Torvalds return XFS_ERROR(EFSCORRUPTED); 2751da177e4SLinus Torvalds } 2761da177e4SLinus Torvalds 2771da177e4SLinus Torvalds /* 2781da177e4SLinus Torvalds * Sanity check AG count, size fields against data size field 2791da177e4SLinus Torvalds */ 2801da177e4SLinus Torvalds if (unlikely( 2811da177e4SLinus Torvalds sbp->sb_dblocks == 0 || 2821da177e4SLinus Torvalds sbp->sb_dblocks > 2831da177e4SLinus Torvalds (xfs_drfsbno_t)sbp->sb_agcount * sbp->sb_agblocks || 2841da177e4SLinus Torvalds sbp->sb_dblocks < (xfs_drfsbno_t)(sbp->sb_agcount - 1) * 2851da177e4SLinus Torvalds sbp->sb_agblocks + XFS_MIN_AG_BLOCKS)) { 286764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB sanity check 2 failed"); 2871da177e4SLinus Torvalds return XFS_ERROR(EFSCORRUPTED); 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds 2904cc929eeSNathan Scott if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) || 2914cc929eeSNathan Scott xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) { 292764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 293764d1f89SNathan Scott "file system too large to be mounted on this system."); 2941da177e4SLinus Torvalds return XFS_ERROR(E2BIG); 2951da177e4SLinus Torvalds } 2961da177e4SLinus Torvalds 2971da177e4SLinus Torvalds if (unlikely(sbp->sb_inprogress)) { 298764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "file system busy"); 2991da177e4SLinus Torvalds return XFS_ERROR(EFSCORRUPTED); 3001da177e4SLinus Torvalds } 3011da177e4SLinus Torvalds 3021da177e4SLinus Torvalds /* 303de20614bSNathan Scott * Version 1 directory format has never worked on Linux. 304de20614bSNathan Scott */ 30562118709SEric Sandeen if (unlikely(!xfs_sb_version_hasdirv2(sbp))) { 306764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 307764d1f89SNathan Scott "file system using version 1 directory format"); 308de20614bSNathan Scott return XFS_ERROR(ENOSYS); 309de20614bSNathan Scott } 310de20614bSNathan Scott 311de20614bSNathan Scott /* 3121da177e4SLinus Torvalds * Until this is fixed only page-sized or smaller data blocks work. 3131da177e4SLinus Torvalds */ 3141da177e4SLinus Torvalds if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) { 315764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 316764d1f89SNathan Scott "file system with blocksize %d bytes", 3171da177e4SLinus Torvalds sbp->sb_blocksize); 318764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 319764d1f89SNathan Scott "only pagesize (%ld) or less will currently work.", 3201da177e4SLinus Torvalds PAGE_SIZE); 3211da177e4SLinus Torvalds return XFS_ERROR(ENOSYS); 3221da177e4SLinus Torvalds } 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds return 0; 3251da177e4SLinus Torvalds } 3261da177e4SLinus Torvalds 327da353b0dSDavid Chinner STATIC void 328da353b0dSDavid Chinner xfs_initialize_perag_icache( 329da353b0dSDavid Chinner xfs_perag_t *pag) 330da353b0dSDavid Chinner { 331da353b0dSDavid Chinner if (!pag->pag_ici_init) { 332da353b0dSDavid Chinner rwlock_init(&pag->pag_ici_lock); 333da353b0dSDavid Chinner INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC); 334da353b0dSDavid Chinner pag->pag_ici_init = 1; 335da353b0dSDavid Chinner } 336da353b0dSDavid Chinner } 337da353b0dSDavid Chinner 3381da177e4SLinus Torvalds xfs_agnumber_t 339c11e2c36SNathan Scott xfs_initialize_perag( 340c11e2c36SNathan Scott xfs_mount_t *mp, 341c11e2c36SNathan Scott xfs_agnumber_t agcount) 3421da177e4SLinus Torvalds { 3431da177e4SLinus Torvalds xfs_agnumber_t index, max_metadata; 3441da177e4SLinus Torvalds xfs_perag_t *pag; 3451da177e4SLinus Torvalds xfs_agino_t agino; 3461da177e4SLinus Torvalds xfs_ino_t ino; 3471da177e4SLinus Torvalds xfs_sb_t *sbp = &mp->m_sb; 3481da177e4SLinus Torvalds xfs_ino_t max_inum = XFS_MAXINUMBER_32; 3491da177e4SLinus Torvalds 3501da177e4SLinus Torvalds /* Check to see if the filesystem can overflow 32 bit inodes */ 3511da177e4SLinus Torvalds agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0); 3521da177e4SLinus Torvalds ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino); 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds /* Clear the mount flag if no inode can overflow 32 bits 3551da177e4SLinus Torvalds * on this filesystem, or if specifically requested.. 3561da177e4SLinus Torvalds */ 357bd186aa9SChristoph Hellwig if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > max_inum) { 3581da177e4SLinus Torvalds mp->m_flags |= XFS_MOUNT_32BITINODES; 3591da177e4SLinus Torvalds } else { 3601da177e4SLinus Torvalds mp->m_flags &= ~XFS_MOUNT_32BITINODES; 3611da177e4SLinus Torvalds } 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds /* If we can overflow then setup the ag headers accordingly */ 3641da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_32BITINODES) { 3651da177e4SLinus Torvalds /* Calculate how much should be reserved for inodes to 3661da177e4SLinus Torvalds * meet the max inode percentage. 3671da177e4SLinus Torvalds */ 3681da177e4SLinus Torvalds if (mp->m_maxicount) { 3691da177e4SLinus Torvalds __uint64_t icount; 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds icount = sbp->sb_dblocks * sbp->sb_imax_pct; 3721da177e4SLinus Torvalds do_div(icount, 100); 3731da177e4SLinus Torvalds icount += sbp->sb_agblocks - 1; 374a749ee86SEric Sandeen do_div(icount, sbp->sb_agblocks); 3751da177e4SLinus Torvalds max_metadata = icount; 3761da177e4SLinus Torvalds } else { 3771da177e4SLinus Torvalds max_metadata = agcount; 3781da177e4SLinus Torvalds } 3791da177e4SLinus Torvalds for (index = 0; index < agcount; index++) { 3801da177e4SLinus Torvalds ino = XFS_AGINO_TO_INO(mp, index, agino); 3811da177e4SLinus Torvalds if (ino > max_inum) { 3821da177e4SLinus Torvalds index++; 3831da177e4SLinus Torvalds break; 3841da177e4SLinus Torvalds } 3851da177e4SLinus Torvalds 386c41564b5SNathan Scott /* This ag is preferred for inodes */ 3871da177e4SLinus Torvalds pag = &mp->m_perag[index]; 3881da177e4SLinus Torvalds pag->pagi_inodeok = 1; 3891da177e4SLinus Torvalds if (index < max_metadata) 3901da177e4SLinus Torvalds pag->pagf_metadata = 1; 391da353b0dSDavid Chinner xfs_initialize_perag_icache(pag); 3921da177e4SLinus Torvalds } 3931da177e4SLinus Torvalds } else { 3941da177e4SLinus Torvalds /* Setup default behavior for smaller filesystems */ 3951da177e4SLinus Torvalds for (index = 0; index < agcount; index++) { 3961da177e4SLinus Torvalds pag = &mp->m_perag[index]; 3971da177e4SLinus Torvalds pag->pagi_inodeok = 1; 398da353b0dSDavid Chinner xfs_initialize_perag_icache(pag); 3991da177e4SLinus Torvalds } 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds return index; 4021da177e4SLinus Torvalds } 4031da177e4SLinus Torvalds 4042bdf7cd0SChristoph Hellwig void 4052bdf7cd0SChristoph Hellwig xfs_sb_from_disk( 4062bdf7cd0SChristoph Hellwig xfs_sb_t *to, 4072bdf7cd0SChristoph Hellwig xfs_dsb_t *from) 4082bdf7cd0SChristoph Hellwig { 4092bdf7cd0SChristoph Hellwig to->sb_magicnum = be32_to_cpu(from->sb_magicnum); 4102bdf7cd0SChristoph Hellwig to->sb_blocksize = be32_to_cpu(from->sb_blocksize); 4112bdf7cd0SChristoph Hellwig to->sb_dblocks = be64_to_cpu(from->sb_dblocks); 4122bdf7cd0SChristoph Hellwig to->sb_rblocks = be64_to_cpu(from->sb_rblocks); 4132bdf7cd0SChristoph Hellwig to->sb_rextents = be64_to_cpu(from->sb_rextents); 4142bdf7cd0SChristoph Hellwig memcpy(&to->sb_uuid, &from->sb_uuid, sizeof(to->sb_uuid)); 4152bdf7cd0SChristoph Hellwig to->sb_logstart = be64_to_cpu(from->sb_logstart); 4162bdf7cd0SChristoph Hellwig to->sb_rootino = be64_to_cpu(from->sb_rootino); 4172bdf7cd0SChristoph Hellwig to->sb_rbmino = be64_to_cpu(from->sb_rbmino); 4182bdf7cd0SChristoph Hellwig to->sb_rsumino = be64_to_cpu(from->sb_rsumino); 4192bdf7cd0SChristoph Hellwig to->sb_rextsize = be32_to_cpu(from->sb_rextsize); 4202bdf7cd0SChristoph Hellwig to->sb_agblocks = be32_to_cpu(from->sb_agblocks); 4212bdf7cd0SChristoph Hellwig to->sb_agcount = be32_to_cpu(from->sb_agcount); 4222bdf7cd0SChristoph Hellwig to->sb_rbmblocks = be32_to_cpu(from->sb_rbmblocks); 4232bdf7cd0SChristoph Hellwig to->sb_logblocks = be32_to_cpu(from->sb_logblocks); 4242bdf7cd0SChristoph Hellwig to->sb_versionnum = be16_to_cpu(from->sb_versionnum); 4252bdf7cd0SChristoph Hellwig to->sb_sectsize = be16_to_cpu(from->sb_sectsize); 4262bdf7cd0SChristoph Hellwig to->sb_inodesize = be16_to_cpu(from->sb_inodesize); 4272bdf7cd0SChristoph Hellwig to->sb_inopblock = be16_to_cpu(from->sb_inopblock); 4282bdf7cd0SChristoph Hellwig memcpy(&to->sb_fname, &from->sb_fname, sizeof(to->sb_fname)); 4292bdf7cd0SChristoph Hellwig to->sb_blocklog = from->sb_blocklog; 4302bdf7cd0SChristoph Hellwig to->sb_sectlog = from->sb_sectlog; 4312bdf7cd0SChristoph Hellwig to->sb_inodelog = from->sb_inodelog; 4322bdf7cd0SChristoph Hellwig to->sb_inopblog = from->sb_inopblog; 4332bdf7cd0SChristoph Hellwig to->sb_agblklog = from->sb_agblklog; 4342bdf7cd0SChristoph Hellwig to->sb_rextslog = from->sb_rextslog; 4352bdf7cd0SChristoph Hellwig to->sb_inprogress = from->sb_inprogress; 4362bdf7cd0SChristoph Hellwig to->sb_imax_pct = from->sb_imax_pct; 4372bdf7cd0SChristoph Hellwig to->sb_icount = be64_to_cpu(from->sb_icount); 4382bdf7cd0SChristoph Hellwig to->sb_ifree = be64_to_cpu(from->sb_ifree); 4392bdf7cd0SChristoph Hellwig to->sb_fdblocks = be64_to_cpu(from->sb_fdblocks); 4402bdf7cd0SChristoph Hellwig to->sb_frextents = be64_to_cpu(from->sb_frextents); 4412bdf7cd0SChristoph Hellwig to->sb_uquotino = be64_to_cpu(from->sb_uquotino); 4422bdf7cd0SChristoph Hellwig to->sb_gquotino = be64_to_cpu(from->sb_gquotino); 4432bdf7cd0SChristoph Hellwig to->sb_qflags = be16_to_cpu(from->sb_qflags); 4442bdf7cd0SChristoph Hellwig to->sb_flags = from->sb_flags; 4452bdf7cd0SChristoph Hellwig to->sb_shared_vn = from->sb_shared_vn; 4462bdf7cd0SChristoph Hellwig to->sb_inoalignmt = be32_to_cpu(from->sb_inoalignmt); 4472bdf7cd0SChristoph Hellwig to->sb_unit = be32_to_cpu(from->sb_unit); 4482bdf7cd0SChristoph Hellwig to->sb_width = be32_to_cpu(from->sb_width); 4492bdf7cd0SChristoph Hellwig to->sb_dirblklog = from->sb_dirblklog; 4502bdf7cd0SChristoph Hellwig to->sb_logsectlog = from->sb_logsectlog; 4512bdf7cd0SChristoph Hellwig to->sb_logsectsize = be16_to_cpu(from->sb_logsectsize); 4522bdf7cd0SChristoph Hellwig to->sb_logsunit = be32_to_cpu(from->sb_logsunit); 4532bdf7cd0SChristoph Hellwig to->sb_features2 = be32_to_cpu(from->sb_features2); 454ee1c0908SDavid Chinner to->sb_bad_features2 = be32_to_cpu(from->sb_bad_features2); 4552bdf7cd0SChristoph Hellwig } 4562bdf7cd0SChristoph Hellwig 4571da177e4SLinus Torvalds /* 4582bdf7cd0SChristoph Hellwig * Copy in core superblock to ondisk one. 4591da177e4SLinus Torvalds * 4602bdf7cd0SChristoph Hellwig * The fields argument is mask of superblock fields to copy. 4611da177e4SLinus Torvalds */ 4621da177e4SLinus Torvalds void 4632bdf7cd0SChristoph Hellwig xfs_sb_to_disk( 4642bdf7cd0SChristoph Hellwig xfs_dsb_t *to, 4652bdf7cd0SChristoph Hellwig xfs_sb_t *from, 4661da177e4SLinus Torvalds __int64_t fields) 4671da177e4SLinus Torvalds { 4682bdf7cd0SChristoph Hellwig xfs_caddr_t to_ptr = (xfs_caddr_t)to; 4692bdf7cd0SChristoph Hellwig xfs_caddr_t from_ptr = (xfs_caddr_t)from; 4701da177e4SLinus Torvalds xfs_sb_field_t f; 4711da177e4SLinus Torvalds int first; 4721da177e4SLinus Torvalds int size; 4731da177e4SLinus Torvalds 4741da177e4SLinus Torvalds ASSERT(fields); 4751da177e4SLinus Torvalds if (!fields) 4761da177e4SLinus Torvalds return; 4771da177e4SLinus Torvalds 4781da177e4SLinus Torvalds while (fields) { 4791da177e4SLinus Torvalds f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields); 4801da177e4SLinus Torvalds first = xfs_sb_info[f].offset; 4811da177e4SLinus Torvalds size = xfs_sb_info[f + 1].offset - first; 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds ASSERT(xfs_sb_info[f].type == 0 || xfs_sb_info[f].type == 1); 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds if (size == 1 || xfs_sb_info[f].type == 1) { 4862bdf7cd0SChristoph Hellwig memcpy(to_ptr + first, from_ptr + first, size); 4871da177e4SLinus Torvalds } else { 4881da177e4SLinus Torvalds switch (size) { 4891da177e4SLinus Torvalds case 2: 4902bdf7cd0SChristoph Hellwig *(__be16 *)(to_ptr + first) = 4912bdf7cd0SChristoph Hellwig cpu_to_be16(*(__u16 *)(from_ptr + first)); 4921da177e4SLinus Torvalds break; 4931da177e4SLinus Torvalds case 4: 4942bdf7cd0SChristoph Hellwig *(__be32 *)(to_ptr + first) = 4952bdf7cd0SChristoph Hellwig cpu_to_be32(*(__u32 *)(from_ptr + first)); 4961da177e4SLinus Torvalds break; 4971da177e4SLinus Torvalds case 8: 4982bdf7cd0SChristoph Hellwig *(__be64 *)(to_ptr + first) = 4992bdf7cd0SChristoph Hellwig cpu_to_be64(*(__u64 *)(from_ptr + first)); 5001da177e4SLinus Torvalds break; 5011da177e4SLinus Torvalds default: 5021da177e4SLinus Torvalds ASSERT(0); 5031da177e4SLinus Torvalds } 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds fields &= ~(1LL << f); 5071da177e4SLinus Torvalds } 5081da177e4SLinus Torvalds } 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds /* 5111da177e4SLinus Torvalds * xfs_readsb 5121da177e4SLinus Torvalds * 5131da177e4SLinus Torvalds * Does the initial read of the superblock. 5141da177e4SLinus Torvalds */ 5151da177e4SLinus Torvalds int 516764d1f89SNathan Scott xfs_readsb(xfs_mount_t *mp, int flags) 5171da177e4SLinus Torvalds { 5181da177e4SLinus Torvalds unsigned int sector_size; 5191da177e4SLinus Torvalds unsigned int extra_flags; 5201da177e4SLinus Torvalds xfs_buf_t *bp; 5211da177e4SLinus Torvalds int error; 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds ASSERT(mp->m_sb_bp == NULL); 5241da177e4SLinus Torvalds ASSERT(mp->m_ddev_targp != NULL); 5251da177e4SLinus Torvalds 5261da177e4SLinus Torvalds /* 5271da177e4SLinus Torvalds * Allocate a (locked) buffer to hold the superblock. 5281da177e4SLinus Torvalds * This will be kept around at all times to optimize 5291da177e4SLinus Torvalds * access to the superblock. 5301da177e4SLinus Torvalds */ 5311da177e4SLinus Torvalds sector_size = xfs_getsize_buftarg(mp->m_ddev_targp); 5321da177e4SLinus Torvalds extra_flags = XFS_BUF_LOCK | XFS_BUF_MANAGE | XFS_BUF_MAPPED; 5331da177e4SLinus Torvalds 5341da177e4SLinus Torvalds bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR, 5351da177e4SLinus Torvalds BTOBB(sector_size), extra_flags); 5361da177e4SLinus Torvalds if (!bp || XFS_BUF_ISERROR(bp)) { 537764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB read failed"); 5381da177e4SLinus Torvalds error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM; 5391da177e4SLinus Torvalds goto fail; 5401da177e4SLinus Torvalds } 5411da177e4SLinus Torvalds ASSERT(XFS_BUF_ISBUSY(bp)); 5421da177e4SLinus Torvalds ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); 5431da177e4SLinus Torvalds 5441da177e4SLinus Torvalds /* 5451da177e4SLinus Torvalds * Initialize the mount structure from the superblock. 5461da177e4SLinus Torvalds * But first do some basic consistency checking. 5471da177e4SLinus Torvalds */ 5482bdf7cd0SChristoph Hellwig xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp)); 5491da177e4SLinus Torvalds 550764d1f89SNathan Scott error = xfs_mount_validate_sb(mp, &(mp->m_sb), flags); 5511da177e4SLinus Torvalds if (error) { 552764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB validate failed"); 5531da177e4SLinus Torvalds goto fail; 5541da177e4SLinus Torvalds } 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds /* 5571da177e4SLinus Torvalds * We must be able to do sector-sized and sector-aligned IO. 5581da177e4SLinus Torvalds */ 5591da177e4SLinus Torvalds if (sector_size > mp->m_sb.sb_sectsize) { 560764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 561764d1f89SNathan Scott "device supports only %u byte sectors (not %u)", 5621da177e4SLinus Torvalds sector_size, mp->m_sb.sb_sectsize); 5631da177e4SLinus Torvalds error = ENOSYS; 5641da177e4SLinus Torvalds goto fail; 5651da177e4SLinus Torvalds } 5661da177e4SLinus Torvalds 5671da177e4SLinus Torvalds /* 5681da177e4SLinus Torvalds * If device sector size is smaller than the superblock size, 5691da177e4SLinus Torvalds * re-read the superblock so the buffer is correctly sized. 5701da177e4SLinus Torvalds */ 5711da177e4SLinus Torvalds if (sector_size < mp->m_sb.sb_sectsize) { 5721da177e4SLinus Torvalds XFS_BUF_UNMANAGE(bp); 5731da177e4SLinus Torvalds xfs_buf_relse(bp); 5741da177e4SLinus Torvalds sector_size = mp->m_sb.sb_sectsize; 5751da177e4SLinus Torvalds bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR, 5761da177e4SLinus Torvalds BTOBB(sector_size), extra_flags); 5771da177e4SLinus Torvalds if (!bp || XFS_BUF_ISERROR(bp)) { 578764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB re-read failed"); 5791da177e4SLinus Torvalds error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM; 5801da177e4SLinus Torvalds goto fail; 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds ASSERT(XFS_BUF_ISBUSY(bp)); 5831da177e4SLinus Torvalds ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); 5841da177e4SLinus Torvalds } 5851da177e4SLinus Torvalds 5865478eeadSLachlan McIlroy /* Initialize per-cpu counters */ 5875478eeadSLachlan McIlroy xfs_icsb_reinit_counters(mp); 5888d280b98SDavid Chinner 5891da177e4SLinus Torvalds mp->m_sb_bp = bp; 5901da177e4SLinus Torvalds xfs_buf_relse(bp); 5911da177e4SLinus Torvalds ASSERT(XFS_BUF_VALUSEMA(bp) > 0); 5921da177e4SLinus Torvalds return 0; 5931da177e4SLinus Torvalds 5941da177e4SLinus Torvalds fail: 5951da177e4SLinus Torvalds if (bp) { 5961da177e4SLinus Torvalds XFS_BUF_UNMANAGE(bp); 5971da177e4SLinus Torvalds xfs_buf_relse(bp); 5981da177e4SLinus Torvalds } 5991da177e4SLinus Torvalds return error; 6001da177e4SLinus Torvalds } 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds 6031da177e4SLinus Torvalds /* 6041da177e4SLinus Torvalds * xfs_mount_common 6051da177e4SLinus Torvalds * 6061da177e4SLinus Torvalds * Mount initialization code establishing various mount 6071da177e4SLinus Torvalds * fields from the superblock associated with the given 6081da177e4SLinus Torvalds * mount structure 6091da177e4SLinus Torvalds */ 610ba0f32d4SChristoph Hellwig STATIC void 6111da177e4SLinus Torvalds xfs_mount_common(xfs_mount_t *mp, xfs_sb_t *sbp) 6121da177e4SLinus Torvalds { 6131da177e4SLinus Torvalds int i; 6141da177e4SLinus Torvalds 6151da177e4SLinus Torvalds mp->m_agfrotor = mp->m_agirotor = 0; 616007c61c6SEric Sandeen spin_lock_init(&mp->m_agirotor_lock); 6171da177e4SLinus Torvalds mp->m_maxagi = mp->m_sb.sb_agcount; 6181da177e4SLinus Torvalds mp->m_blkbit_log = sbp->sb_blocklog + XFS_NBBYLOG; 6191da177e4SLinus Torvalds mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT; 6201da177e4SLinus Torvalds mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT; 6211da177e4SLinus Torvalds mp->m_agno_log = xfs_highbit32(sbp->sb_agcount - 1) + 1; 6221da177e4SLinus Torvalds mp->m_agino_log = sbp->sb_inopblog + sbp->sb_agblklog; 6231da177e4SLinus Torvalds mp->m_litino = sbp->sb_inodesize - 6241da177e4SLinus Torvalds ((uint)sizeof(xfs_dinode_core_t) + (uint)sizeof(xfs_agino_t)); 6251da177e4SLinus Torvalds mp->m_blockmask = sbp->sb_blocksize - 1; 6261da177e4SLinus Torvalds mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG; 6271da177e4SLinus Torvalds mp->m_blockwmask = mp->m_blockwsize - 1; 6281da177e4SLinus Torvalds INIT_LIST_HEAD(&mp->m_del_inodes); 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds /* 6311da177e4SLinus Torvalds * Setup for attributes, in case they get created. 6321da177e4SLinus Torvalds * This value is for inodes getting attributes for the first time, 6331da177e4SLinus Torvalds * the per-inode value is for old attribute values. 6341da177e4SLinus Torvalds */ 6351da177e4SLinus Torvalds ASSERT(sbp->sb_inodesize >= 256 && sbp->sb_inodesize <= 2048); 6361da177e4SLinus Torvalds switch (sbp->sb_inodesize) { 6371da177e4SLinus Torvalds case 256: 638d8cc890dSNathan Scott mp->m_attroffset = XFS_LITINO(mp) - 639d8cc890dSNathan Scott XFS_BMDR_SPACE_CALC(MINABTPTRS); 6401da177e4SLinus Torvalds break; 6411da177e4SLinus Torvalds case 512: 6421da177e4SLinus Torvalds case 1024: 6431da177e4SLinus Torvalds case 2048: 644d8cc890dSNathan Scott mp->m_attroffset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS); 6451da177e4SLinus Torvalds break; 6461da177e4SLinus Torvalds default: 6471da177e4SLinus Torvalds ASSERT(0); 6481da177e4SLinus Torvalds } 6491da177e4SLinus Torvalds ASSERT(mp->m_attroffset < XFS_LITINO(mp)); 6501da177e4SLinus Torvalds 6511da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 6521da177e4SLinus Torvalds mp->m_alloc_mxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize, 6531da177e4SLinus Torvalds xfs_alloc, i == 0); 6541da177e4SLinus Torvalds mp->m_alloc_mnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize, 6551da177e4SLinus Torvalds xfs_alloc, i == 0); 6561da177e4SLinus Torvalds } 6571da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 6581da177e4SLinus Torvalds mp->m_bmap_dmxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize, 6591da177e4SLinus Torvalds xfs_bmbt, i == 0); 6601da177e4SLinus Torvalds mp->m_bmap_dmnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize, 6611da177e4SLinus Torvalds xfs_bmbt, i == 0); 6621da177e4SLinus Torvalds } 6631da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 6641da177e4SLinus Torvalds mp->m_inobt_mxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize, 6651da177e4SLinus Torvalds xfs_inobt, i == 0); 6661da177e4SLinus Torvalds mp->m_inobt_mnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize, 6671da177e4SLinus Torvalds xfs_inobt, i == 0); 6681da177e4SLinus Torvalds } 6691da177e4SLinus Torvalds 6701da177e4SLinus Torvalds mp->m_bsize = XFS_FSB_TO_BB(mp, 1); 6711da177e4SLinus Torvalds mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK, 6721da177e4SLinus Torvalds sbp->sb_inopblock); 6731da177e4SLinus Torvalds mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog; 6741da177e4SLinus Torvalds } 67592821e2bSDavid Chinner 67692821e2bSDavid Chinner /* 67792821e2bSDavid Chinner * xfs_initialize_perag_data 67892821e2bSDavid Chinner * 67992821e2bSDavid Chinner * Read in each per-ag structure so we can count up the number of 68092821e2bSDavid Chinner * allocated inodes, free inodes and used filesystem blocks as this 68192821e2bSDavid Chinner * information is no longer persistent in the superblock. Once we have 68292821e2bSDavid Chinner * this information, write it into the in-core superblock structure. 68392821e2bSDavid Chinner */ 68492821e2bSDavid Chinner STATIC int 68592821e2bSDavid Chinner xfs_initialize_perag_data(xfs_mount_t *mp, xfs_agnumber_t agcount) 68692821e2bSDavid Chinner { 68792821e2bSDavid Chinner xfs_agnumber_t index; 68892821e2bSDavid Chinner xfs_perag_t *pag; 68992821e2bSDavid Chinner xfs_sb_t *sbp = &mp->m_sb; 69092821e2bSDavid Chinner uint64_t ifree = 0; 69192821e2bSDavid Chinner uint64_t ialloc = 0; 69292821e2bSDavid Chinner uint64_t bfree = 0; 69392821e2bSDavid Chinner uint64_t bfreelst = 0; 69492821e2bSDavid Chinner uint64_t btree = 0; 69592821e2bSDavid Chinner int error; 69692821e2bSDavid Chinner 69792821e2bSDavid Chinner for (index = 0; index < agcount; index++) { 69892821e2bSDavid Chinner /* 69992821e2bSDavid Chinner * read the agf, then the agi. This gets us 70092821e2bSDavid Chinner * all the inforamtion we need and populates the 70192821e2bSDavid Chinner * per-ag structures for us. 70292821e2bSDavid Chinner */ 70392821e2bSDavid Chinner error = xfs_alloc_pagf_init(mp, NULL, index, 0); 70492821e2bSDavid Chinner if (error) 70592821e2bSDavid Chinner return error; 70692821e2bSDavid Chinner 70792821e2bSDavid Chinner error = xfs_ialloc_pagi_init(mp, NULL, index); 70892821e2bSDavid Chinner if (error) 70992821e2bSDavid Chinner return error; 71092821e2bSDavid Chinner pag = &mp->m_perag[index]; 71192821e2bSDavid Chinner ifree += pag->pagi_freecount; 71292821e2bSDavid Chinner ialloc += pag->pagi_count; 71392821e2bSDavid Chinner bfree += pag->pagf_freeblks; 71492821e2bSDavid Chinner bfreelst += pag->pagf_flcount; 71592821e2bSDavid Chinner btree += pag->pagf_btreeblks; 71692821e2bSDavid Chinner } 71792821e2bSDavid Chinner /* 71892821e2bSDavid Chinner * Overwrite incore superblock counters with just-read data 71992821e2bSDavid Chinner */ 7203685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 72192821e2bSDavid Chinner sbp->sb_ifree = ifree; 72292821e2bSDavid Chinner sbp->sb_icount = ialloc; 72392821e2bSDavid Chinner sbp->sb_fdblocks = bfree + bfreelst + btree; 7243685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 72592821e2bSDavid Chinner 72692821e2bSDavid Chinner /* Fixup the per-cpu counters as well. */ 72792821e2bSDavid Chinner xfs_icsb_reinit_counters(mp); 72892821e2bSDavid Chinner 72992821e2bSDavid Chinner return 0; 73092821e2bSDavid Chinner } 73192821e2bSDavid Chinner 7321da177e4SLinus Torvalds /* 7330771fb45SEric Sandeen * Update alignment values based on mount options and sb values 7341da177e4SLinus Torvalds */ 7350771fb45SEric Sandeen STATIC int 7360771fb45SEric Sandeen xfs_update_alignment(xfs_mount_t *mp, int mfsi_flags, __uint64_t *update_flags) 7371da177e4SLinus Torvalds { 7381da177e4SLinus Torvalds xfs_sb_t *sbp = &(mp->m_sb); 7391da177e4SLinus Torvalds 7401da177e4SLinus Torvalds if (mp->m_dalign && !(mfsi_flags & XFS_MFSI_SECOND)) { 7411da177e4SLinus Torvalds /* 7421da177e4SLinus Torvalds * If stripe unit and stripe width are not multiples 7431da177e4SLinus Torvalds * of the fs blocksize turn off alignment. 7441da177e4SLinus Torvalds */ 7451da177e4SLinus Torvalds if ((BBTOB(mp->m_dalign) & mp->m_blockmask) || 7461da177e4SLinus Torvalds (BBTOB(mp->m_swidth) & mp->m_blockmask)) { 7471da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_RETERR) { 7481da177e4SLinus Torvalds cmn_err(CE_WARN, 7491da177e4SLinus Torvalds "XFS: alignment check 1 failed"); 7500771fb45SEric Sandeen return XFS_ERROR(EINVAL); 7511da177e4SLinus Torvalds } 7521da177e4SLinus Torvalds mp->m_dalign = mp->m_swidth = 0; 7531da177e4SLinus Torvalds } else { 7541da177e4SLinus Torvalds /* 7551da177e4SLinus Torvalds * Convert the stripe unit and width to FSBs. 7561da177e4SLinus Torvalds */ 7571da177e4SLinus Torvalds mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign); 7581da177e4SLinus Torvalds if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) { 7591da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_RETERR) { 7600771fb45SEric Sandeen return XFS_ERROR(EINVAL); 7611da177e4SLinus Torvalds } 7621da177e4SLinus Torvalds xfs_fs_cmn_err(CE_WARN, mp, 7631da177e4SLinus Torvalds "stripe alignment turned off: sunit(%d)/swidth(%d) incompatible with agsize(%d)", 7641da177e4SLinus Torvalds mp->m_dalign, mp->m_swidth, 7651da177e4SLinus Torvalds sbp->sb_agblocks); 7661da177e4SLinus Torvalds 7671da177e4SLinus Torvalds mp->m_dalign = 0; 7681da177e4SLinus Torvalds mp->m_swidth = 0; 7691da177e4SLinus Torvalds } else if (mp->m_dalign) { 7701da177e4SLinus Torvalds mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth); 7711da177e4SLinus Torvalds } else { 7721da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_RETERR) { 7731da177e4SLinus Torvalds xfs_fs_cmn_err(CE_WARN, mp, 7741da177e4SLinus Torvalds "stripe alignment turned off: sunit(%d) less than bsize(%d)", 7751da177e4SLinus Torvalds mp->m_dalign, 7761da177e4SLinus Torvalds mp->m_blockmask +1); 7770771fb45SEric Sandeen return XFS_ERROR(EINVAL); 7781da177e4SLinus Torvalds } 7791da177e4SLinus Torvalds mp->m_swidth = 0; 7801da177e4SLinus Torvalds } 7811da177e4SLinus Torvalds } 7821da177e4SLinus Torvalds 7831da177e4SLinus Torvalds /* 7841da177e4SLinus Torvalds * Update superblock with new values 7851da177e4SLinus Torvalds * and log changes 7861da177e4SLinus Torvalds */ 78762118709SEric Sandeen if (xfs_sb_version_hasdalign(sbp)) { 7881da177e4SLinus Torvalds if (sbp->sb_unit != mp->m_dalign) { 7891da177e4SLinus Torvalds sbp->sb_unit = mp->m_dalign; 7900771fb45SEric Sandeen *update_flags |= XFS_SB_UNIT; 7911da177e4SLinus Torvalds } 7921da177e4SLinus Torvalds if (sbp->sb_width != mp->m_swidth) { 7931da177e4SLinus Torvalds sbp->sb_width = mp->m_swidth; 7940771fb45SEric Sandeen *update_flags |= XFS_SB_WIDTH; 7951da177e4SLinus Torvalds } 7961da177e4SLinus Torvalds } 7971da177e4SLinus Torvalds } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN && 79862118709SEric Sandeen xfs_sb_version_hasdalign(&mp->m_sb)) { 7991da177e4SLinus Torvalds mp->m_dalign = sbp->sb_unit; 8001da177e4SLinus Torvalds mp->m_swidth = sbp->sb_width; 8011da177e4SLinus Torvalds } 8021da177e4SLinus Torvalds 8030771fb45SEric Sandeen return 0; 8040771fb45SEric Sandeen } 8051da177e4SLinus Torvalds 8060771fb45SEric Sandeen /* 8070771fb45SEric Sandeen * Set the maximum inode count for this filesystem 8080771fb45SEric Sandeen */ 8090771fb45SEric Sandeen STATIC void 8100771fb45SEric Sandeen xfs_set_maxicount(xfs_mount_t *mp) 8110771fb45SEric Sandeen { 8120771fb45SEric Sandeen xfs_sb_t *sbp = &(mp->m_sb); 8131da177e4SLinus Torvalds __uint64_t icount; 8141da177e4SLinus Torvalds 8150771fb45SEric Sandeen if (sbp->sb_imax_pct) { 8160771fb45SEric Sandeen /* 8170771fb45SEric Sandeen * Make sure the maximum inode count is a multiple 8180771fb45SEric Sandeen * of the units we allocate inodes in. 8191da177e4SLinus Torvalds */ 8201da177e4SLinus Torvalds icount = sbp->sb_dblocks * sbp->sb_imax_pct; 8211da177e4SLinus Torvalds do_div(icount, 100); 8221da177e4SLinus Torvalds do_div(icount, mp->m_ialloc_blks); 8231da177e4SLinus Torvalds mp->m_maxicount = (icount * mp->m_ialloc_blks) << 8241da177e4SLinus Torvalds sbp->sb_inopblog; 8250771fb45SEric Sandeen } else { 8261da177e4SLinus Torvalds mp->m_maxicount = 0; 8271da177e4SLinus Torvalds } 8281da177e4SLinus Torvalds } 8291da177e4SLinus Torvalds 8301da177e4SLinus Torvalds /* 8311da177e4SLinus Torvalds * Set the default minimum read and write sizes unless 8321da177e4SLinus Torvalds * already specified in a mount option. 8331da177e4SLinus Torvalds * We use smaller I/O sizes when the file system 8341da177e4SLinus Torvalds * is being used for NFS service (wsync mount option). 8351da177e4SLinus Torvalds */ 8360771fb45SEric Sandeen STATIC void 8370771fb45SEric Sandeen xfs_set_rw_sizes(xfs_mount_t *mp) 8380771fb45SEric Sandeen { 8390771fb45SEric Sandeen xfs_sb_t *sbp = &(mp->m_sb); 8400771fb45SEric Sandeen int readio_log, writeio_log; 8410771fb45SEric Sandeen 8421da177e4SLinus Torvalds if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) { 8431da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_WSYNC) { 8441da177e4SLinus Torvalds readio_log = XFS_WSYNC_READIO_LOG; 8451da177e4SLinus Torvalds writeio_log = XFS_WSYNC_WRITEIO_LOG; 8461da177e4SLinus Torvalds } else { 8471da177e4SLinus Torvalds readio_log = XFS_READIO_LOG_LARGE; 8481da177e4SLinus Torvalds writeio_log = XFS_WRITEIO_LOG_LARGE; 8491da177e4SLinus Torvalds } 8501da177e4SLinus Torvalds } else { 8511da177e4SLinus Torvalds readio_log = mp->m_readio_log; 8521da177e4SLinus Torvalds writeio_log = mp->m_writeio_log; 8531da177e4SLinus Torvalds } 8541da177e4SLinus Torvalds 8551da177e4SLinus Torvalds if (sbp->sb_blocklog > readio_log) { 8561da177e4SLinus Torvalds mp->m_readio_log = sbp->sb_blocklog; 8571da177e4SLinus Torvalds } else { 8581da177e4SLinus Torvalds mp->m_readio_log = readio_log; 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog); 8611da177e4SLinus Torvalds if (sbp->sb_blocklog > writeio_log) { 8621da177e4SLinus Torvalds mp->m_writeio_log = sbp->sb_blocklog; 8631da177e4SLinus Torvalds } else { 8641da177e4SLinus Torvalds mp->m_writeio_log = writeio_log; 8651da177e4SLinus Torvalds } 8661da177e4SLinus Torvalds mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog); 8670771fb45SEric Sandeen } 868425f9dddSEric Sandeen 8691da177e4SLinus Torvalds /* 8701da177e4SLinus Torvalds * Set whether we're using inode alignment. 8711da177e4SLinus Torvalds */ 8720771fb45SEric Sandeen STATIC void 8730771fb45SEric Sandeen xfs_set_inoalignment(xfs_mount_t *mp) 8740771fb45SEric Sandeen { 87562118709SEric Sandeen if (xfs_sb_version_hasalign(&mp->m_sb) && 8761da177e4SLinus Torvalds mp->m_sb.sb_inoalignmt >= 8771da177e4SLinus Torvalds XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) 8781da177e4SLinus Torvalds mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1; 8791da177e4SLinus Torvalds else 8801da177e4SLinus Torvalds mp->m_inoalign_mask = 0; 8811da177e4SLinus Torvalds /* 8821da177e4SLinus Torvalds * If we are using stripe alignment, check whether 8831da177e4SLinus Torvalds * the stripe unit is a multiple of the inode alignment 8841da177e4SLinus Torvalds */ 8851da177e4SLinus Torvalds if (mp->m_dalign && mp->m_inoalign_mask && 8861da177e4SLinus Torvalds !(mp->m_dalign & mp->m_inoalign_mask)) 8871da177e4SLinus Torvalds mp->m_sinoalign = mp->m_dalign; 8881da177e4SLinus Torvalds else 8891da177e4SLinus Torvalds mp->m_sinoalign = 0; 8900771fb45SEric Sandeen } 8910771fb45SEric Sandeen 8921da177e4SLinus Torvalds /* 8931da177e4SLinus Torvalds * Check that the data (and log if separate) are an ok size. 8941da177e4SLinus Torvalds */ 8950771fb45SEric Sandeen STATIC int 8960771fb45SEric Sandeen xfs_check_sizes(xfs_mount_t *mp, int mfsi_flags) 8970771fb45SEric Sandeen { 8980771fb45SEric Sandeen xfs_buf_t *bp; 8990771fb45SEric Sandeen xfs_daddr_t d; 9000771fb45SEric Sandeen int error; 9010771fb45SEric Sandeen 9021da177e4SLinus Torvalds d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks); 9031da177e4SLinus Torvalds if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) { 9041da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: size check 1 failed"); 9050771fb45SEric Sandeen return XFS_ERROR(E2BIG); 9061da177e4SLinus Torvalds } 9071da177e4SLinus Torvalds error = xfs_read_buf(mp, mp->m_ddev_targp, 9081da177e4SLinus Torvalds d - XFS_FSS_TO_BB(mp, 1), 9091da177e4SLinus Torvalds XFS_FSS_TO_BB(mp, 1), 0, &bp); 9101da177e4SLinus Torvalds if (!error) { 9111da177e4SLinus Torvalds xfs_buf_relse(bp); 9121da177e4SLinus Torvalds } else { 9131da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: size check 2 failed"); 9140771fb45SEric Sandeen if (error == ENOSPC) 9151da177e4SLinus Torvalds error = XFS_ERROR(E2BIG); 9160771fb45SEric Sandeen return error; 9171da177e4SLinus Torvalds } 9181da177e4SLinus Torvalds 9191da177e4SLinus Torvalds if (((mfsi_flags & XFS_MFSI_CLIENT) == 0) && 9201da177e4SLinus Torvalds mp->m_logdev_targp != mp->m_ddev_targp) { 9211da177e4SLinus Torvalds d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks); 9221da177e4SLinus Torvalds if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) { 9231da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: size check 3 failed"); 9240771fb45SEric Sandeen return XFS_ERROR(E2BIG); 9251da177e4SLinus Torvalds } 9261da177e4SLinus Torvalds error = xfs_read_buf(mp, mp->m_logdev_targp, 9271da177e4SLinus Torvalds d - XFS_FSB_TO_BB(mp, 1), 9281da177e4SLinus Torvalds XFS_FSB_TO_BB(mp, 1), 0, &bp); 9291da177e4SLinus Torvalds if (!error) { 9301da177e4SLinus Torvalds xfs_buf_relse(bp); 9311da177e4SLinus Torvalds } else { 9321da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: size check 3 failed"); 9330771fb45SEric Sandeen if (error == ENOSPC) 9341da177e4SLinus Torvalds error = XFS_ERROR(E2BIG); 9350771fb45SEric Sandeen return error; 9361da177e4SLinus Torvalds } 9370771fb45SEric Sandeen } 9380771fb45SEric Sandeen return 0; 9390771fb45SEric Sandeen } 9400771fb45SEric Sandeen 9410771fb45SEric Sandeen /* 9420771fb45SEric Sandeen * xfs_mountfs 9430771fb45SEric Sandeen * 9440771fb45SEric Sandeen * This function does the following on an initial mount of a file system: 9450771fb45SEric Sandeen * - reads the superblock from disk and init the mount struct 9460771fb45SEric Sandeen * - if we're a 32-bit kernel, do a size check on the superblock 9470771fb45SEric Sandeen * so we don't mount terabyte filesystems 9480771fb45SEric Sandeen * - init mount struct realtime fields 9490771fb45SEric Sandeen * - allocate inode hash table for fs 9500771fb45SEric Sandeen * - init directory manager 9510771fb45SEric Sandeen * - perform recovery and init the log manager 9520771fb45SEric Sandeen */ 9530771fb45SEric Sandeen int 9540771fb45SEric Sandeen xfs_mountfs( 9550771fb45SEric Sandeen xfs_mount_t *mp, 9560771fb45SEric Sandeen int mfsi_flags) 9570771fb45SEric Sandeen { 9580771fb45SEric Sandeen xfs_sb_t *sbp = &(mp->m_sb); 9590771fb45SEric Sandeen xfs_inode_t *rip; 9600771fb45SEric Sandeen __uint64_t resblks; 9610771fb45SEric Sandeen __int64_t update_flags = 0LL; 9620771fb45SEric Sandeen uint quotamount, quotaflags; 9630771fb45SEric Sandeen int agno; 9640771fb45SEric Sandeen int uuid_mounted = 0; 9650771fb45SEric Sandeen int error = 0; 9660771fb45SEric Sandeen 9670771fb45SEric Sandeen xfs_mount_common(mp, sbp); 9680771fb45SEric Sandeen 9690771fb45SEric Sandeen /* 970e6957ea4SEric Sandeen * Check for a mismatched features2 values. Older kernels 971e6957ea4SEric Sandeen * read & wrote into the wrong sb offset for sb_features2 972e6957ea4SEric Sandeen * on some platforms due to xfs_sb_t not being 64bit size aligned 973e6957ea4SEric Sandeen * when sb_features2 was added, which made older superblock 974e6957ea4SEric Sandeen * reading/writing routines swap it as a 64-bit value. 975ee1c0908SDavid Chinner * 976e6957ea4SEric Sandeen * For backwards compatibility, we make both slots equal. 977e6957ea4SEric Sandeen * 978e6957ea4SEric Sandeen * If we detect a mismatched field, we OR the set bits into the 979e6957ea4SEric Sandeen * existing features2 field in case it has already been modified; we 980e6957ea4SEric Sandeen * don't want to lose any features. We then update the bad location 981e6957ea4SEric Sandeen * with the ORed value so that older kernels will see any features2 982e6957ea4SEric Sandeen * flags, and mark the two fields as needing updates once the 983e6957ea4SEric Sandeen * transaction subsystem is online. 984ee1c0908SDavid Chinner */ 985e6957ea4SEric Sandeen if (xfs_sb_has_mismatched_features2(sbp)) { 986ee1c0908SDavid Chinner cmn_err(CE_WARN, 987ee1c0908SDavid Chinner "XFS: correcting sb_features alignment problem"); 988ee1c0908SDavid Chinner sbp->sb_features2 |= sbp->sb_bad_features2; 989e6957ea4SEric Sandeen sbp->sb_bad_features2 = sbp->sb_features2; 990ee1c0908SDavid Chinner update_flags |= XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2; 991e6957ea4SEric Sandeen 992e6957ea4SEric Sandeen /* 993e6957ea4SEric Sandeen * Re-check for ATTR2 in case it was found in bad_features2 994e6957ea4SEric Sandeen * slot. 995e6957ea4SEric Sandeen */ 996e6957ea4SEric Sandeen if (xfs_sb_version_hasattr2(&mp->m_sb)) 997e6957ea4SEric Sandeen mp->m_flags |= XFS_MOUNT_ATTR2; 998e6957ea4SEric Sandeen 999ee1c0908SDavid Chinner } 1000ee1c0908SDavid Chinner 1001ee1c0908SDavid Chinner /* 10020771fb45SEric Sandeen * Check if sb_agblocks is aligned at stripe boundary 10030771fb45SEric Sandeen * If sb_agblocks is NOT aligned turn off m_dalign since 10040771fb45SEric Sandeen * allocator alignment is within an ag, therefore ag has 10050771fb45SEric Sandeen * to be aligned at stripe boundary. 10060771fb45SEric Sandeen */ 10070771fb45SEric Sandeen error = xfs_update_alignment(mp, mfsi_flags, &update_flags); 10080771fb45SEric Sandeen if (error) 10090771fb45SEric Sandeen goto error1; 10100771fb45SEric Sandeen 10110771fb45SEric Sandeen xfs_alloc_compute_maxlevels(mp); 10120771fb45SEric Sandeen xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK); 10130771fb45SEric Sandeen xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK); 10140771fb45SEric Sandeen xfs_ialloc_compute_maxlevels(mp); 10150771fb45SEric Sandeen 10160771fb45SEric Sandeen xfs_set_maxicount(mp); 10170771fb45SEric Sandeen 10180771fb45SEric Sandeen mp->m_maxioffset = xfs_max_file_offset(sbp->sb_blocklog); 10190771fb45SEric Sandeen 10200771fb45SEric Sandeen /* 10210771fb45SEric Sandeen * XFS uses the uuid from the superblock as the unique 10220771fb45SEric Sandeen * identifier for fsid. We can not use the uuid from the volume 10230771fb45SEric Sandeen * since a single partition filesystem is identical to a single 10240771fb45SEric Sandeen * partition volume/filesystem. 10250771fb45SEric Sandeen */ 10260771fb45SEric Sandeen if ((mfsi_flags & XFS_MFSI_SECOND) == 0 && 10270771fb45SEric Sandeen (mp->m_flags & XFS_MOUNT_NOUUID) == 0) { 10280771fb45SEric Sandeen if (xfs_uuid_mount(mp)) { 10290771fb45SEric Sandeen error = XFS_ERROR(EINVAL); 10301da177e4SLinus Torvalds goto error1; 10311da177e4SLinus Torvalds } 10320771fb45SEric Sandeen uuid_mounted=1; 10331da177e4SLinus Torvalds } 10341da177e4SLinus Torvalds 10351da177e4SLinus Torvalds /* 10360771fb45SEric Sandeen * Set the minimum read and write sizes 10370771fb45SEric Sandeen */ 10380771fb45SEric Sandeen xfs_set_rw_sizes(mp); 10390771fb45SEric Sandeen 10400771fb45SEric Sandeen /* 10410771fb45SEric Sandeen * Set the inode cluster size. 10420771fb45SEric Sandeen * This may still be overridden by the file system 10430771fb45SEric Sandeen * block size if it is larger than the chosen cluster size. 10440771fb45SEric Sandeen */ 10450771fb45SEric Sandeen mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE; 10460771fb45SEric Sandeen 10470771fb45SEric Sandeen /* 10480771fb45SEric Sandeen * Set inode alignment fields 10490771fb45SEric Sandeen */ 10500771fb45SEric Sandeen xfs_set_inoalignment(mp); 10510771fb45SEric Sandeen 10520771fb45SEric Sandeen /* 10530771fb45SEric Sandeen * Check that the data (and log if separate) are an ok size. 10540771fb45SEric Sandeen */ 10550771fb45SEric Sandeen error = xfs_check_sizes(mp, mfsi_flags); 10560771fb45SEric Sandeen if (error) 10570771fb45SEric Sandeen goto error1; 10580771fb45SEric Sandeen 10590771fb45SEric Sandeen /* 10601da177e4SLinus Torvalds * Initialize realtime fields in the mount structure 10611da177e4SLinus Torvalds */ 10620771fb45SEric Sandeen error = xfs_rtmount_init(mp); 10630771fb45SEric Sandeen if (error) { 10641da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: RT mount failed"); 10651da177e4SLinus Torvalds goto error1; 10661da177e4SLinus Torvalds } 10671da177e4SLinus Torvalds 10681da177e4SLinus Torvalds /* 10691da177e4SLinus Torvalds * For client case we are done now 10701da177e4SLinus Torvalds */ 10711da177e4SLinus Torvalds if (mfsi_flags & XFS_MFSI_CLIENT) { 1072014c2544SJesper Juhl return 0; 10731da177e4SLinus Torvalds } 10741da177e4SLinus Torvalds 10751da177e4SLinus Torvalds /* 10761da177e4SLinus Torvalds * Copies the low order bits of the timestamp and the randomly 10771da177e4SLinus Torvalds * set "sequence" number out of a UUID. 10781da177e4SLinus Torvalds */ 10791da177e4SLinus Torvalds uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid); 10801da177e4SLinus Torvalds 10811da177e4SLinus Torvalds mp->m_dmevmask = 0; /* not persistent; set after each mount */ 10821da177e4SLinus Torvalds 1083f6c2d1faSNathan Scott xfs_dir_mount(mp); 10841da177e4SLinus Torvalds 10851da177e4SLinus Torvalds /* 10861da177e4SLinus Torvalds * Initialize the attribute manager's entries. 10871da177e4SLinus Torvalds */ 10881da177e4SLinus Torvalds mp->m_attr_magicpct = (mp->m_sb.sb_blocksize * 37) / 100; 10891da177e4SLinus Torvalds 10901da177e4SLinus Torvalds /* 10911da177e4SLinus Torvalds * Initialize the precomputed transaction reservations values. 10921da177e4SLinus Torvalds */ 10931da177e4SLinus Torvalds xfs_trans_init(mp); 10941da177e4SLinus Torvalds 10951da177e4SLinus Torvalds /* 10961da177e4SLinus Torvalds * Allocate and initialize the per-ag data. 10971da177e4SLinus Torvalds */ 10981da177e4SLinus Torvalds init_rwsem(&mp->m_peraglock); 10991da177e4SLinus Torvalds mp->m_perag = 11001da177e4SLinus Torvalds kmem_zalloc(sbp->sb_agcount * sizeof(xfs_perag_t), KM_SLEEP); 11011da177e4SLinus Torvalds 1102b267ce99SChristoph Hellwig mp->m_maxagi = xfs_initialize_perag(mp, sbp->sb_agcount); 11031da177e4SLinus Torvalds 11041da177e4SLinus Torvalds /* 11051da177e4SLinus Torvalds * log's mount-time initialization. Perform 1st part recovery if needed 11061da177e4SLinus Torvalds */ 11071da177e4SLinus Torvalds if (likely(sbp->sb_logblocks > 0)) { /* check for volume case */ 11081da177e4SLinus Torvalds error = xfs_log_mount(mp, mp->m_logdev_targp, 11091da177e4SLinus Torvalds XFS_FSB_TO_DADDR(mp, sbp->sb_logstart), 11101da177e4SLinus Torvalds XFS_FSB_TO_BB(mp, sbp->sb_logblocks)); 11111da177e4SLinus Torvalds if (error) { 11121da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: log mount failed"); 11131da177e4SLinus Torvalds goto error2; 11141da177e4SLinus Torvalds } 11151da177e4SLinus Torvalds } else { /* No log has been defined */ 11161da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: no log defined"); 11171da177e4SLinus Torvalds XFS_ERROR_REPORT("xfs_mountfs_int(1)", XFS_ERRLEVEL_LOW, mp); 11181da177e4SLinus Torvalds error = XFS_ERROR(EFSCORRUPTED); 11191da177e4SLinus Torvalds goto error2; 11201da177e4SLinus Torvalds } 11211da177e4SLinus Torvalds 11221da177e4SLinus Torvalds /* 112392821e2bSDavid Chinner * Now the log is mounted, we know if it was an unclean shutdown or 112492821e2bSDavid Chinner * not. If it was, with the first phase of recovery has completed, we 112592821e2bSDavid Chinner * have consistent AG blocks on disk. We have not recovered EFIs yet, 112692821e2bSDavid Chinner * but they are recovered transactionally in the second recovery phase 112792821e2bSDavid Chinner * later. 112892821e2bSDavid Chinner * 112992821e2bSDavid Chinner * Hence we can safely re-initialise incore superblock counters from 113092821e2bSDavid Chinner * the per-ag data. These may not be correct if the filesystem was not 113192821e2bSDavid Chinner * cleanly unmounted, so we need to wait for recovery to finish before 113292821e2bSDavid Chinner * doing this. 113392821e2bSDavid Chinner * 113492821e2bSDavid Chinner * If the filesystem was cleanly unmounted, then we can trust the 113592821e2bSDavid Chinner * values in the superblock to be correct and we don't need to do 113692821e2bSDavid Chinner * anything here. 113792821e2bSDavid Chinner * 113892821e2bSDavid Chinner * If we are currently making the filesystem, the initialisation will 113992821e2bSDavid Chinner * fail as the perag data is in an undefined state. 114092821e2bSDavid Chinner */ 114192821e2bSDavid Chinner 114292821e2bSDavid Chinner if (xfs_sb_version_haslazysbcount(&mp->m_sb) && 114392821e2bSDavid Chinner !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) && 114492821e2bSDavid Chinner !mp->m_sb.sb_inprogress) { 114592821e2bSDavid Chinner error = xfs_initialize_perag_data(mp, sbp->sb_agcount); 114692821e2bSDavid Chinner if (error) { 114792821e2bSDavid Chinner goto error2; 114892821e2bSDavid Chinner } 114992821e2bSDavid Chinner } 115092821e2bSDavid Chinner /* 11511da177e4SLinus Torvalds * Get and sanity-check the root inode. 11521da177e4SLinus Torvalds * Save the pointer to it in the mount structure. 11531da177e4SLinus Torvalds */ 11541da177e4SLinus Torvalds error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip, 0); 11551da177e4SLinus Torvalds if (error) { 11561da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: failed to read root inode"); 11571da177e4SLinus Torvalds goto error3; 11581da177e4SLinus Torvalds } 11591da177e4SLinus Torvalds 11601da177e4SLinus Torvalds ASSERT(rip != NULL); 11611da177e4SLinus Torvalds 11621da177e4SLinus Torvalds if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) { 11631da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: corrupted root inode"); 1164b6574520SNathan Scott cmn_err(CE_WARN, "Device %s - root %llu is not a directory", 1165b6574520SNathan Scott XFS_BUFTARG_NAME(mp->m_ddev_targp), 1166b6574520SNathan Scott (unsigned long long)rip->i_ino); 11671da177e4SLinus Torvalds xfs_iunlock(rip, XFS_ILOCK_EXCL); 11681da177e4SLinus Torvalds XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW, 11691da177e4SLinus Torvalds mp); 11701da177e4SLinus Torvalds error = XFS_ERROR(EFSCORRUPTED); 11711da177e4SLinus Torvalds goto error4; 11721da177e4SLinus Torvalds } 11731da177e4SLinus Torvalds mp->m_rootip = rip; /* save it */ 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds xfs_iunlock(rip, XFS_ILOCK_EXCL); 11761da177e4SLinus Torvalds 11771da177e4SLinus Torvalds /* 11781da177e4SLinus Torvalds * Initialize realtime inode pointers in the mount structure 11791da177e4SLinus Torvalds */ 11800771fb45SEric Sandeen error = xfs_rtmount_inodes(mp); 11810771fb45SEric Sandeen if (error) { 11821da177e4SLinus Torvalds /* 11831da177e4SLinus Torvalds * Free up the root inode. 11841da177e4SLinus Torvalds */ 11851da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: failed to read RT inodes"); 11861da177e4SLinus Torvalds goto error4; 11871da177e4SLinus Torvalds } 11881da177e4SLinus Torvalds 11891da177e4SLinus Torvalds /* 1190ee1c0908SDavid Chinner * If fs is not mounted readonly, then update the superblock changes. 11911da177e4SLinus Torvalds */ 1192bd186aa9SChristoph Hellwig if (update_flags && !(mp->m_flags & XFS_MOUNT_RDONLY)) 1193ee1c0908SDavid Chinner xfs_mount_log_sb(mp, update_flags); 11941da177e4SLinus Torvalds 11951da177e4SLinus Torvalds /* 11961da177e4SLinus Torvalds * Initialise the XFS quota management subsystem for this mount 11971da177e4SLinus Torvalds */ 11980771fb45SEric Sandeen error = XFS_QM_INIT(mp, "amount, "aflags); 11990771fb45SEric Sandeen if (error) 12001da177e4SLinus Torvalds goto error4; 12011da177e4SLinus Torvalds 12021da177e4SLinus Torvalds /* 12031da177e4SLinus Torvalds * Finish recovering the file system. This part needed to be 12041da177e4SLinus Torvalds * delayed until after the root and real-time bitmap inodes 12051da177e4SLinus Torvalds * were consistently read in. 12061da177e4SLinus Torvalds */ 12071da177e4SLinus Torvalds error = xfs_log_mount_finish(mp, mfsi_flags); 12081da177e4SLinus Torvalds if (error) { 12091da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: log mount finish failed"); 12101da177e4SLinus Torvalds goto error4; 12111da177e4SLinus Torvalds } 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds /* 12141da177e4SLinus Torvalds * Complete the quota initialisation, post-log-replay component. 12151da177e4SLinus Torvalds */ 12160771fb45SEric Sandeen error = XFS_QM_MOUNT(mp, quotamount, quotaflags, mfsi_flags); 12170771fb45SEric Sandeen if (error) 12181da177e4SLinus Torvalds goto error4; 12191da177e4SLinus Torvalds 122084e1e99fSDavid Chinner /* 122184e1e99fSDavid Chinner * Now we are mounted, reserve a small amount of unused space for 122284e1e99fSDavid Chinner * privileged transactions. This is needed so that transaction 122384e1e99fSDavid Chinner * space required for critical operations can dip into this pool 122484e1e99fSDavid Chinner * when at ENOSPC. This is needed for operations like create with 122584e1e99fSDavid Chinner * attr, unwritten extent conversion at ENOSPC, etc. Data allocations 122684e1e99fSDavid Chinner * are not allowed to use this reserved space. 122784e1e99fSDavid Chinner * 122884e1e99fSDavid Chinner * We default to 5% or 1024 fsbs of space reserved, whichever is smaller. 122984e1e99fSDavid Chinner * This may drive us straight to ENOSPC on mount, but that implies 123084e1e99fSDavid Chinner * we were already there on the last unmount. 123184e1e99fSDavid Chinner */ 123239726be2SChristoph Hellwig resblks = mp->m_sb.sb_dblocks; 123339726be2SChristoph Hellwig do_div(resblks, 20); 123439726be2SChristoph Hellwig resblks = min_t(__uint64_t, resblks, 1024); 123584e1e99fSDavid Chinner xfs_reserve_blocks(mp, &resblks, NULL); 123684e1e99fSDavid Chinner 12371da177e4SLinus Torvalds return 0; 12381da177e4SLinus Torvalds 12391da177e4SLinus Torvalds error4: 12401da177e4SLinus Torvalds /* 12411da177e4SLinus Torvalds * Free up the root inode. 12421da177e4SLinus Torvalds */ 124343355099SChristoph Hellwig IRELE(rip); 12441da177e4SLinus Torvalds error3: 12451da177e4SLinus Torvalds xfs_log_unmount_dealloc(mp); 12461da177e4SLinus Torvalds error2: 12471da177e4SLinus Torvalds for (agno = 0; agno < sbp->sb_agcount; agno++) 12481da177e4SLinus Torvalds if (mp->m_perag[agno].pagb_list) 12491da177e4SLinus Torvalds kmem_free(mp->m_perag[agno].pagb_list, 12501da177e4SLinus Torvalds sizeof(xfs_perag_busy_t) * XFS_PAGB_NUM_SLOTS); 12511da177e4SLinus Torvalds kmem_free(mp->m_perag, sbp->sb_agcount * sizeof(xfs_perag_t)); 12521da177e4SLinus Torvalds mp->m_perag = NULL; 12531da177e4SLinus Torvalds /* FALLTHROUGH */ 12541da177e4SLinus Torvalds error1: 12551da177e4SLinus Torvalds if (uuid_mounted) 12561da177e4SLinus Torvalds xfs_uuid_unmount(mp); 12571da177e4SLinus Torvalds xfs_freesb(mp); 12581da177e4SLinus Torvalds return error; 12591da177e4SLinus Torvalds } 12601da177e4SLinus Torvalds 12611da177e4SLinus Torvalds /* 12621da177e4SLinus Torvalds * xfs_unmountfs 12631da177e4SLinus Torvalds * 12641da177e4SLinus Torvalds * This flushes out the inodes,dquots and the superblock, unmounts the 12651da177e4SLinus Torvalds * log and makes sure that incore structures are freed. 12661da177e4SLinus Torvalds */ 12671da177e4SLinus Torvalds int 12681da177e4SLinus Torvalds xfs_unmountfs(xfs_mount_t *mp, struct cred *cr) 12691da177e4SLinus Torvalds { 127084e1e99fSDavid Chinner __uint64_t resblks; 12711da177e4SLinus Torvalds 1272641c56fbSDavid Chinner /* 1273641c56fbSDavid Chinner * We can potentially deadlock here if we have an inode cluster 1274641c56fbSDavid Chinner * that has been freed has it's buffer still pinned in memory because 1275641c56fbSDavid Chinner * the transaction is still sitting in a iclog. The stale inodes 1276641c56fbSDavid Chinner * on that buffer will have their flush locks held until the 1277641c56fbSDavid Chinner * transaction hits the disk and the callbacks run. the inode 1278641c56fbSDavid Chinner * flush takes the flush lock unconditionally and with nothing to 1279641c56fbSDavid Chinner * push out the iclog we will never get that unlocked. hence we 1280641c56fbSDavid Chinner * need to force the log first. 1281641c56fbSDavid Chinner */ 1282641c56fbSDavid Chinner xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC); 1283efa80278SChristoph Hellwig xfs_iflush_all(mp); 12841da177e4SLinus Torvalds 1285ee2a4f7cSNathan Scott XFS_QM_DQPURGEALL(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_UMOUNTING); 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds /* 12881da177e4SLinus Torvalds * Flush out the log synchronously so that we know for sure 12891da177e4SLinus Torvalds * that nothing is pinned. This is important because bflush() 12901da177e4SLinus Torvalds * will skip pinned buffers. 12911da177e4SLinus Torvalds */ 12921da177e4SLinus Torvalds xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC); 12931da177e4SLinus Torvalds 12941da177e4SLinus Torvalds xfs_binval(mp->m_ddev_targp); 12951da177e4SLinus Torvalds if (mp->m_rtdev_targp) { 12961da177e4SLinus Torvalds xfs_binval(mp->m_rtdev_targp); 12971da177e4SLinus Torvalds } 12981da177e4SLinus Torvalds 129984e1e99fSDavid Chinner /* 130084e1e99fSDavid Chinner * Unreserve any blocks we have so that when we unmount we don't account 130184e1e99fSDavid Chinner * the reserved free space as used. This is really only necessary for 130284e1e99fSDavid Chinner * lazy superblock counting because it trusts the incore superblock 130384e1e99fSDavid Chinner * counters to be aboslutely correct on clean unmount. 130484e1e99fSDavid Chinner * 130584e1e99fSDavid Chinner * We don't bother correcting this elsewhere for lazy superblock 130684e1e99fSDavid Chinner * counting because on mount of an unclean filesystem we reconstruct the 130784e1e99fSDavid Chinner * correct counter value and this is irrelevant. 130884e1e99fSDavid Chinner * 130984e1e99fSDavid Chinner * For non-lazy counter filesystems, this doesn't matter at all because 131084e1e99fSDavid Chinner * we only every apply deltas to the superblock and hence the incore 131184e1e99fSDavid Chinner * value does not matter.... 131284e1e99fSDavid Chinner */ 131384e1e99fSDavid Chinner resblks = 0; 131484e1e99fSDavid Chinner xfs_reserve_blocks(mp, &resblks, NULL); 131584e1e99fSDavid Chinner 131692821e2bSDavid Chinner xfs_log_sbcount(mp, 1); 13171da177e4SLinus Torvalds xfs_unmountfs_writesb(mp); 13181da177e4SLinus Torvalds xfs_unmountfs_wait(mp); /* wait for async bufs */ 13191da177e4SLinus Torvalds xfs_log_unmount(mp); /* Done! No more fs ops. */ 13201da177e4SLinus Torvalds 13211da177e4SLinus Torvalds xfs_freesb(mp); 13221da177e4SLinus Torvalds 13231da177e4SLinus Torvalds /* 13241da177e4SLinus Torvalds * All inodes from this mount point should be freed. 13251da177e4SLinus Torvalds */ 13261da177e4SLinus Torvalds ASSERT(mp->m_inodes == NULL); 13271da177e4SLinus Torvalds 13281da177e4SLinus Torvalds xfs_unmountfs_close(mp, cr); 13291da177e4SLinus Torvalds if ((mp->m_flags & XFS_MOUNT_NOUUID) == 0) 13301da177e4SLinus Torvalds xfs_uuid_unmount(mp); 13311da177e4SLinus Torvalds 13321da177e4SLinus Torvalds #if defined(DEBUG) || defined(INDUCE_IO_ERROR) 13330ce4cfd4SChristoph Hellwig xfs_errortag_clearall(mp, 0); 13341da177e4SLinus Torvalds #endif 1335745f6919SChristoph Hellwig xfs_mount_free(mp); 13361da177e4SLinus Torvalds return 0; 13371da177e4SLinus Torvalds } 13381da177e4SLinus Torvalds 13391da177e4SLinus Torvalds void 13401da177e4SLinus Torvalds xfs_unmountfs_close(xfs_mount_t *mp, struct cred *cr) 13411da177e4SLinus Torvalds { 134249ee6c91SJesper Juhl if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) 13431da177e4SLinus Torvalds xfs_free_buftarg(mp->m_logdev_targp, 1); 13441da177e4SLinus Torvalds if (mp->m_rtdev_targp) 13451da177e4SLinus Torvalds xfs_free_buftarg(mp->m_rtdev_targp, 1); 13461da177e4SLinus Torvalds xfs_free_buftarg(mp->m_ddev_targp, 0); 13471da177e4SLinus Torvalds } 13481da177e4SLinus Torvalds 1349ba0f32d4SChristoph Hellwig STATIC void 13501da177e4SLinus Torvalds xfs_unmountfs_wait(xfs_mount_t *mp) 13511da177e4SLinus Torvalds { 13521da177e4SLinus Torvalds if (mp->m_logdev_targp != mp->m_ddev_targp) 13531da177e4SLinus Torvalds xfs_wait_buftarg(mp->m_logdev_targp); 13541da177e4SLinus Torvalds if (mp->m_rtdev_targp) 13551da177e4SLinus Torvalds xfs_wait_buftarg(mp->m_rtdev_targp); 13561da177e4SLinus Torvalds xfs_wait_buftarg(mp->m_ddev_targp); 13571da177e4SLinus Torvalds } 13581da177e4SLinus Torvalds 13591da177e4SLinus Torvalds int 136092821e2bSDavid Chinner xfs_fs_writable(xfs_mount_t *mp) 136192821e2bSDavid Chinner { 1362b267ce99SChristoph Hellwig return !(xfs_test_for_freeze(mp) || XFS_FORCED_SHUTDOWN(mp) || 1363bd186aa9SChristoph Hellwig (mp->m_flags & XFS_MOUNT_RDONLY)); 136492821e2bSDavid Chinner } 136592821e2bSDavid Chinner 136692821e2bSDavid Chinner /* 136792821e2bSDavid Chinner * xfs_log_sbcount 136892821e2bSDavid Chinner * 136992821e2bSDavid Chinner * Called either periodically to keep the on disk superblock values 137092821e2bSDavid Chinner * roughly up to date or from unmount to make sure the values are 137192821e2bSDavid Chinner * correct on a clean unmount. 137292821e2bSDavid Chinner * 137392821e2bSDavid Chinner * Note this code can be called during the process of freezing, so 137492821e2bSDavid Chinner * we may need to use the transaction allocator which does not not 137592821e2bSDavid Chinner * block when the transaction subsystem is in its frozen state. 137692821e2bSDavid Chinner */ 137792821e2bSDavid Chinner int 137892821e2bSDavid Chinner xfs_log_sbcount( 137992821e2bSDavid Chinner xfs_mount_t *mp, 138092821e2bSDavid Chinner uint sync) 138192821e2bSDavid Chinner { 138292821e2bSDavid Chinner xfs_trans_t *tp; 138392821e2bSDavid Chinner int error; 138492821e2bSDavid Chinner 138592821e2bSDavid Chinner if (!xfs_fs_writable(mp)) 138692821e2bSDavid Chinner return 0; 138792821e2bSDavid Chinner 138892821e2bSDavid Chinner xfs_icsb_sync_counters(mp); 138992821e2bSDavid Chinner 139092821e2bSDavid Chinner /* 139192821e2bSDavid Chinner * we don't need to do this if we are updating the superblock 139292821e2bSDavid Chinner * counters on every modification. 139392821e2bSDavid Chinner */ 139492821e2bSDavid Chinner if (!xfs_sb_version_haslazysbcount(&mp->m_sb)) 139592821e2bSDavid Chinner return 0; 139692821e2bSDavid Chinner 139792821e2bSDavid Chinner tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT); 139892821e2bSDavid Chinner error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0, 139992821e2bSDavid Chinner XFS_DEFAULT_LOG_COUNT); 140092821e2bSDavid Chinner if (error) { 140192821e2bSDavid Chinner xfs_trans_cancel(tp, 0); 140292821e2bSDavid Chinner return error; 140392821e2bSDavid Chinner } 140492821e2bSDavid Chinner 140592821e2bSDavid Chinner xfs_mod_sb(tp, XFS_SB_IFREE | XFS_SB_ICOUNT | XFS_SB_FDBLOCKS); 140692821e2bSDavid Chinner if (sync) 140792821e2bSDavid Chinner xfs_trans_set_sync(tp); 140892821e2bSDavid Chinner xfs_trans_commit(tp, 0); 140992821e2bSDavid Chinner 141092821e2bSDavid Chinner return 0; 141192821e2bSDavid Chinner } 141292821e2bSDavid Chinner 14132bdf7cd0SChristoph Hellwig STATIC void 14142bdf7cd0SChristoph Hellwig xfs_mark_shared_ro( 14152bdf7cd0SChristoph Hellwig xfs_mount_t *mp, 14162bdf7cd0SChristoph Hellwig xfs_buf_t *bp) 14172bdf7cd0SChristoph Hellwig { 14182bdf7cd0SChristoph Hellwig xfs_dsb_t *sb = XFS_BUF_TO_SBP(bp); 14192bdf7cd0SChristoph Hellwig __uint16_t version; 14202bdf7cd0SChristoph Hellwig 14212bdf7cd0SChristoph Hellwig if (!(sb->sb_flags & XFS_SBF_READONLY)) 14222bdf7cd0SChristoph Hellwig sb->sb_flags |= XFS_SBF_READONLY; 14232bdf7cd0SChristoph Hellwig 14242bdf7cd0SChristoph Hellwig version = be16_to_cpu(sb->sb_versionnum); 14252bdf7cd0SChristoph Hellwig if ((version & XFS_SB_VERSION_NUMBITS) != XFS_SB_VERSION_4 || 14262bdf7cd0SChristoph Hellwig !(version & XFS_SB_VERSION_SHAREDBIT)) 14272bdf7cd0SChristoph Hellwig version |= XFS_SB_VERSION_SHAREDBIT; 14282bdf7cd0SChristoph Hellwig sb->sb_versionnum = cpu_to_be16(version); 14292bdf7cd0SChristoph Hellwig } 14302bdf7cd0SChristoph Hellwig 143192821e2bSDavid Chinner int 14321da177e4SLinus Torvalds xfs_unmountfs_writesb(xfs_mount_t *mp) 14331da177e4SLinus Torvalds { 14341da177e4SLinus Torvalds xfs_buf_t *sbp; 14351da177e4SLinus Torvalds int error = 0; 14361da177e4SLinus Torvalds 14371da177e4SLinus Torvalds /* 14381da177e4SLinus Torvalds * skip superblock write if fs is read-only, or 14391da177e4SLinus Torvalds * if we are doing a forced umount. 14401da177e4SLinus Torvalds */ 1441bd186aa9SChristoph Hellwig if (!((mp->m_flags & XFS_MOUNT_RDONLY) || 14421da177e4SLinus Torvalds XFS_FORCED_SHUTDOWN(mp))) { 14438d280b98SDavid Chinner 144492821e2bSDavid Chinner sbp = xfs_getsb(mp, 0); 14458d280b98SDavid Chinner 14461da177e4SLinus Torvalds /* 14471da177e4SLinus Torvalds * mark shared-readonly if desired 14481da177e4SLinus Torvalds */ 14492bdf7cd0SChristoph Hellwig if (mp->m_mk_sharedro) 14502bdf7cd0SChristoph Hellwig xfs_mark_shared_ro(mp, sbp); 145192821e2bSDavid Chinner 14521da177e4SLinus Torvalds XFS_BUF_UNDONE(sbp); 14531da177e4SLinus Torvalds XFS_BUF_UNREAD(sbp); 14541da177e4SLinus Torvalds XFS_BUF_UNDELAYWRITE(sbp); 14551da177e4SLinus Torvalds XFS_BUF_WRITE(sbp); 14561da177e4SLinus Torvalds XFS_BUF_UNASYNC(sbp); 14571da177e4SLinus Torvalds ASSERT(XFS_BUF_TARGET(sbp) == mp->m_ddev_targp); 14581da177e4SLinus Torvalds xfsbdstrat(mp, sbp); 14591da177e4SLinus Torvalds /* Nevermind errors we might get here. */ 14601da177e4SLinus Torvalds error = xfs_iowait(sbp); 14611da177e4SLinus Torvalds if (error) 14621da177e4SLinus Torvalds xfs_ioerror_alert("xfs_unmountfs_writesb", 14631da177e4SLinus Torvalds mp, sbp, XFS_BUF_ADDR(sbp)); 14641da177e4SLinus Torvalds if (error && mp->m_mk_sharedro) 14651da177e4SLinus Torvalds xfs_fs_cmn_err(CE_ALERT, mp, "Superblock write error detected while unmounting. Filesystem may not be marked shared readonly"); 14661da177e4SLinus Torvalds xfs_buf_relse(sbp); 146792821e2bSDavid Chinner } 1468014c2544SJesper Juhl return error; 14691da177e4SLinus Torvalds } 14701da177e4SLinus Torvalds 14711da177e4SLinus Torvalds /* 14721da177e4SLinus Torvalds * xfs_mod_sb() can be used to copy arbitrary changes to the 14731da177e4SLinus Torvalds * in-core superblock into the superblock buffer to be logged. 14741da177e4SLinus Torvalds * It does not provide the higher level of locking that is 14751da177e4SLinus Torvalds * needed to protect the in-core superblock from concurrent 14761da177e4SLinus Torvalds * access. 14771da177e4SLinus Torvalds */ 14781da177e4SLinus Torvalds void 14791da177e4SLinus Torvalds xfs_mod_sb(xfs_trans_t *tp, __int64_t fields) 14801da177e4SLinus Torvalds { 14811da177e4SLinus Torvalds xfs_buf_t *bp; 14821da177e4SLinus Torvalds int first; 14831da177e4SLinus Torvalds int last; 14841da177e4SLinus Torvalds xfs_mount_t *mp; 14851da177e4SLinus Torvalds xfs_sb_field_t f; 14861da177e4SLinus Torvalds 14871da177e4SLinus Torvalds ASSERT(fields); 14881da177e4SLinus Torvalds if (!fields) 14891da177e4SLinus Torvalds return; 14901da177e4SLinus Torvalds mp = tp->t_mountp; 14911da177e4SLinus Torvalds bp = xfs_trans_getsb(tp, mp, 0); 14921da177e4SLinus Torvalds first = sizeof(xfs_sb_t); 14931da177e4SLinus Torvalds last = 0; 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds /* translate/copy */ 14961da177e4SLinus Torvalds 14972bdf7cd0SChristoph Hellwig xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, fields); 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds /* find modified range */ 15001da177e4SLinus Torvalds 15011da177e4SLinus Torvalds f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields); 15021da177e4SLinus Torvalds ASSERT((1LL << f) & XFS_SB_MOD_BITS); 15031da177e4SLinus Torvalds first = xfs_sb_info[f].offset; 15041da177e4SLinus Torvalds 15051da177e4SLinus Torvalds f = (xfs_sb_field_t)xfs_highbit64((__uint64_t)fields); 15061da177e4SLinus Torvalds ASSERT((1LL << f) & XFS_SB_MOD_BITS); 15071da177e4SLinus Torvalds last = xfs_sb_info[f + 1].offset - 1; 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds xfs_trans_log_buf(tp, bp, first, last); 15101da177e4SLinus Torvalds } 1511d210a28cSYingping Lu 1512d210a28cSYingping Lu 15131da177e4SLinus Torvalds /* 15141da177e4SLinus Torvalds * xfs_mod_incore_sb_unlocked() is a utility routine common used to apply 15151da177e4SLinus Torvalds * a delta to a specified field in the in-core superblock. Simply 15161da177e4SLinus Torvalds * switch on the field indicated and apply the delta to that field. 15171da177e4SLinus Torvalds * Fields are not allowed to dip below zero, so if the delta would 15181da177e4SLinus Torvalds * do this do not apply it and return EINVAL. 15191da177e4SLinus Torvalds * 15203685c2a1SEric Sandeen * The m_sb_lock must be held when this routine is called. 15211da177e4SLinus Torvalds */ 15228d280b98SDavid Chinner int 152320f4ebf2SDavid Chinner xfs_mod_incore_sb_unlocked( 152420f4ebf2SDavid Chinner xfs_mount_t *mp, 152520f4ebf2SDavid Chinner xfs_sb_field_t field, 152620f4ebf2SDavid Chinner int64_t delta, 152720f4ebf2SDavid Chinner int rsvd) 15281da177e4SLinus Torvalds { 15291da177e4SLinus Torvalds int scounter; /* short counter for 32 bit fields */ 15301da177e4SLinus Torvalds long long lcounter; /* long counter for 64 bit fields */ 15311da177e4SLinus Torvalds long long res_used, rem; 15321da177e4SLinus Torvalds 15331da177e4SLinus Torvalds /* 15341da177e4SLinus Torvalds * With the in-core superblock spin lock held, switch 15351da177e4SLinus Torvalds * on the indicated field. Apply the delta to the 15361da177e4SLinus Torvalds * proper field. If the fields value would dip below 15371da177e4SLinus Torvalds * 0, then do not apply the delta and return EINVAL. 15381da177e4SLinus Torvalds */ 15391da177e4SLinus Torvalds switch (field) { 15401da177e4SLinus Torvalds case XFS_SBS_ICOUNT: 15411da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_icount; 15421da177e4SLinus Torvalds lcounter += delta; 15431da177e4SLinus Torvalds if (lcounter < 0) { 15441da177e4SLinus Torvalds ASSERT(0); 1545014c2544SJesper Juhl return XFS_ERROR(EINVAL); 15461da177e4SLinus Torvalds } 15471da177e4SLinus Torvalds mp->m_sb.sb_icount = lcounter; 1548014c2544SJesper Juhl return 0; 15491da177e4SLinus Torvalds case XFS_SBS_IFREE: 15501da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_ifree; 15511da177e4SLinus Torvalds lcounter += delta; 15521da177e4SLinus Torvalds if (lcounter < 0) { 15531da177e4SLinus Torvalds ASSERT(0); 1554014c2544SJesper Juhl return XFS_ERROR(EINVAL); 15551da177e4SLinus Torvalds } 15561da177e4SLinus Torvalds mp->m_sb.sb_ifree = lcounter; 1557014c2544SJesper Juhl return 0; 15581da177e4SLinus Torvalds case XFS_SBS_FDBLOCKS: 15594be536deSDavid Chinner lcounter = (long long) 15604be536deSDavid Chinner mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp); 15611da177e4SLinus Torvalds res_used = (long long)(mp->m_resblks - mp->m_resblks_avail); 15621da177e4SLinus Torvalds 15631da177e4SLinus Torvalds if (delta > 0) { /* Putting blocks back */ 15641da177e4SLinus Torvalds if (res_used > delta) { 15651da177e4SLinus Torvalds mp->m_resblks_avail += delta; 15661da177e4SLinus Torvalds } else { 15671da177e4SLinus Torvalds rem = delta - res_used; 15681da177e4SLinus Torvalds mp->m_resblks_avail = mp->m_resblks; 15691da177e4SLinus Torvalds lcounter += rem; 15701da177e4SLinus Torvalds } 15711da177e4SLinus Torvalds } else { /* Taking blocks away */ 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds lcounter += delta; 15741da177e4SLinus Torvalds 15751da177e4SLinus Torvalds /* 15761da177e4SLinus Torvalds * If were out of blocks, use any available reserved blocks if 15771da177e4SLinus Torvalds * were allowed to. 15781da177e4SLinus Torvalds */ 15791da177e4SLinus Torvalds 15801da177e4SLinus Torvalds if (lcounter < 0) { 15811da177e4SLinus Torvalds if (rsvd) { 15821da177e4SLinus Torvalds lcounter = (long long)mp->m_resblks_avail + delta; 15831da177e4SLinus Torvalds if (lcounter < 0) { 1584014c2544SJesper Juhl return XFS_ERROR(ENOSPC); 15851da177e4SLinus Torvalds } 15861da177e4SLinus Torvalds mp->m_resblks_avail = lcounter; 1587014c2544SJesper Juhl return 0; 15881da177e4SLinus Torvalds } else { /* not reserved */ 1589014c2544SJesper Juhl return XFS_ERROR(ENOSPC); 15901da177e4SLinus Torvalds } 15911da177e4SLinus Torvalds } 15921da177e4SLinus Torvalds } 15931da177e4SLinus Torvalds 15944be536deSDavid Chinner mp->m_sb.sb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp); 1595014c2544SJesper Juhl return 0; 15961da177e4SLinus Torvalds case XFS_SBS_FREXTENTS: 15971da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_frextents; 15981da177e4SLinus Torvalds lcounter += delta; 15991da177e4SLinus Torvalds if (lcounter < 0) { 1600014c2544SJesper Juhl return XFS_ERROR(ENOSPC); 16011da177e4SLinus Torvalds } 16021da177e4SLinus Torvalds mp->m_sb.sb_frextents = lcounter; 1603014c2544SJesper Juhl return 0; 16041da177e4SLinus Torvalds case XFS_SBS_DBLOCKS: 16051da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_dblocks; 16061da177e4SLinus Torvalds lcounter += delta; 16071da177e4SLinus Torvalds if (lcounter < 0) { 16081da177e4SLinus Torvalds ASSERT(0); 1609014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16101da177e4SLinus Torvalds } 16111da177e4SLinus Torvalds mp->m_sb.sb_dblocks = lcounter; 1612014c2544SJesper Juhl return 0; 16131da177e4SLinus Torvalds case XFS_SBS_AGCOUNT: 16141da177e4SLinus Torvalds scounter = mp->m_sb.sb_agcount; 16151da177e4SLinus Torvalds scounter += delta; 16161da177e4SLinus Torvalds if (scounter < 0) { 16171da177e4SLinus Torvalds ASSERT(0); 1618014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16191da177e4SLinus Torvalds } 16201da177e4SLinus Torvalds mp->m_sb.sb_agcount = scounter; 1621014c2544SJesper Juhl return 0; 16221da177e4SLinus Torvalds case XFS_SBS_IMAX_PCT: 16231da177e4SLinus Torvalds scounter = mp->m_sb.sb_imax_pct; 16241da177e4SLinus Torvalds scounter += delta; 16251da177e4SLinus Torvalds if (scounter < 0) { 16261da177e4SLinus Torvalds ASSERT(0); 1627014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16281da177e4SLinus Torvalds } 16291da177e4SLinus Torvalds mp->m_sb.sb_imax_pct = scounter; 1630014c2544SJesper Juhl return 0; 16311da177e4SLinus Torvalds case XFS_SBS_REXTSIZE: 16321da177e4SLinus Torvalds scounter = mp->m_sb.sb_rextsize; 16331da177e4SLinus Torvalds scounter += delta; 16341da177e4SLinus Torvalds if (scounter < 0) { 16351da177e4SLinus Torvalds ASSERT(0); 1636014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16371da177e4SLinus Torvalds } 16381da177e4SLinus Torvalds mp->m_sb.sb_rextsize = scounter; 1639014c2544SJesper Juhl return 0; 16401da177e4SLinus Torvalds case XFS_SBS_RBMBLOCKS: 16411da177e4SLinus Torvalds scounter = mp->m_sb.sb_rbmblocks; 16421da177e4SLinus Torvalds scounter += delta; 16431da177e4SLinus Torvalds if (scounter < 0) { 16441da177e4SLinus Torvalds ASSERT(0); 1645014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16461da177e4SLinus Torvalds } 16471da177e4SLinus Torvalds mp->m_sb.sb_rbmblocks = scounter; 1648014c2544SJesper Juhl return 0; 16491da177e4SLinus Torvalds case XFS_SBS_RBLOCKS: 16501da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_rblocks; 16511da177e4SLinus Torvalds lcounter += delta; 16521da177e4SLinus Torvalds if (lcounter < 0) { 16531da177e4SLinus Torvalds ASSERT(0); 1654014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16551da177e4SLinus Torvalds } 16561da177e4SLinus Torvalds mp->m_sb.sb_rblocks = lcounter; 1657014c2544SJesper Juhl return 0; 16581da177e4SLinus Torvalds case XFS_SBS_REXTENTS: 16591da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_rextents; 16601da177e4SLinus Torvalds lcounter += delta; 16611da177e4SLinus Torvalds if (lcounter < 0) { 16621da177e4SLinus Torvalds ASSERT(0); 1663014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16641da177e4SLinus Torvalds } 16651da177e4SLinus Torvalds mp->m_sb.sb_rextents = lcounter; 1666014c2544SJesper Juhl return 0; 16671da177e4SLinus Torvalds case XFS_SBS_REXTSLOG: 16681da177e4SLinus Torvalds scounter = mp->m_sb.sb_rextslog; 16691da177e4SLinus Torvalds scounter += delta; 16701da177e4SLinus Torvalds if (scounter < 0) { 16711da177e4SLinus Torvalds ASSERT(0); 1672014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16731da177e4SLinus Torvalds } 16741da177e4SLinus Torvalds mp->m_sb.sb_rextslog = scounter; 1675014c2544SJesper Juhl return 0; 16761da177e4SLinus Torvalds default: 16771da177e4SLinus Torvalds ASSERT(0); 1678014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16791da177e4SLinus Torvalds } 16801da177e4SLinus Torvalds } 16811da177e4SLinus Torvalds 16821da177e4SLinus Torvalds /* 16831da177e4SLinus Torvalds * xfs_mod_incore_sb() is used to change a field in the in-core 16841da177e4SLinus Torvalds * superblock structure by the specified delta. This modification 16853685c2a1SEric Sandeen * is protected by the m_sb_lock. Just use the xfs_mod_incore_sb_unlocked() 16861da177e4SLinus Torvalds * routine to do the work. 16871da177e4SLinus Torvalds */ 16881da177e4SLinus Torvalds int 168920f4ebf2SDavid Chinner xfs_mod_incore_sb( 169020f4ebf2SDavid Chinner xfs_mount_t *mp, 169120f4ebf2SDavid Chinner xfs_sb_field_t field, 169220f4ebf2SDavid Chinner int64_t delta, 169320f4ebf2SDavid Chinner int rsvd) 16941da177e4SLinus Torvalds { 16951da177e4SLinus Torvalds int status; 16961da177e4SLinus Torvalds 16978d280b98SDavid Chinner /* check for per-cpu counters */ 16988d280b98SDavid Chinner switch (field) { 16998d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 17008d280b98SDavid Chinner case XFS_SBS_ICOUNT: 17018d280b98SDavid Chinner case XFS_SBS_IFREE: 17028d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 17038d280b98SDavid Chinner if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) { 17048d280b98SDavid Chinner status = xfs_icsb_modify_counters(mp, field, 17058d280b98SDavid Chinner delta, rsvd); 17068d280b98SDavid Chinner break; 17078d280b98SDavid Chinner } 17088d280b98SDavid Chinner /* FALLTHROUGH */ 17098d280b98SDavid Chinner #endif 17108d280b98SDavid Chinner default: 17113685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 17121da177e4SLinus Torvalds status = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd); 17133685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 17148d280b98SDavid Chinner break; 17158d280b98SDavid Chinner } 17168d280b98SDavid Chinner 1717014c2544SJesper Juhl return status; 17181da177e4SLinus Torvalds } 17191da177e4SLinus Torvalds 17201da177e4SLinus Torvalds /* 17211da177e4SLinus Torvalds * xfs_mod_incore_sb_batch() is used to change more than one field 17221da177e4SLinus Torvalds * in the in-core superblock structure at a time. This modification 17231da177e4SLinus Torvalds * is protected by a lock internal to this module. The fields and 17241da177e4SLinus Torvalds * changes to those fields are specified in the array of xfs_mod_sb 17251da177e4SLinus Torvalds * structures passed in. 17261da177e4SLinus Torvalds * 17271da177e4SLinus Torvalds * Either all of the specified deltas will be applied or none of 17281da177e4SLinus Torvalds * them will. If any modified field dips below 0, then all modifications 17291da177e4SLinus Torvalds * will be backed out and EINVAL will be returned. 17301da177e4SLinus Torvalds */ 17311da177e4SLinus Torvalds int 17321da177e4SLinus Torvalds xfs_mod_incore_sb_batch(xfs_mount_t *mp, xfs_mod_sb_t *msb, uint nmsb, int rsvd) 17331da177e4SLinus Torvalds { 17341da177e4SLinus Torvalds int status=0; 17351da177e4SLinus Torvalds xfs_mod_sb_t *msbp; 17361da177e4SLinus Torvalds 17371da177e4SLinus Torvalds /* 17381da177e4SLinus Torvalds * Loop through the array of mod structures and apply each 17391da177e4SLinus Torvalds * individually. If any fail, then back out all those 17401da177e4SLinus Torvalds * which have already been applied. Do all of this within 17413685c2a1SEric Sandeen * the scope of the m_sb_lock so that all of the changes will 17421da177e4SLinus Torvalds * be atomic. 17431da177e4SLinus Torvalds */ 17443685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 17451da177e4SLinus Torvalds msbp = &msb[0]; 17461da177e4SLinus Torvalds for (msbp = &msbp[0]; msbp < (msb + nmsb); msbp++) { 17471da177e4SLinus Torvalds /* 17481da177e4SLinus Torvalds * Apply the delta at index n. If it fails, break 17491da177e4SLinus Torvalds * from the loop so we'll fall into the undo loop 17501da177e4SLinus Torvalds * below. 17511da177e4SLinus Torvalds */ 17528d280b98SDavid Chinner switch (msbp->msb_field) { 17538d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 17548d280b98SDavid Chinner case XFS_SBS_ICOUNT: 17558d280b98SDavid Chinner case XFS_SBS_IFREE: 17568d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 17578d280b98SDavid Chinner if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) { 17583685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 175920b64285SDavid Chinner status = xfs_icsb_modify_counters(mp, 17608d280b98SDavid Chinner msbp->msb_field, 17611da177e4SLinus Torvalds msbp->msb_delta, rsvd); 17623685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 17638d280b98SDavid Chinner break; 17648d280b98SDavid Chinner } 17658d280b98SDavid Chinner /* FALLTHROUGH */ 17668d280b98SDavid Chinner #endif 17678d280b98SDavid Chinner default: 17688d280b98SDavid Chinner status = xfs_mod_incore_sb_unlocked(mp, 17698d280b98SDavid Chinner msbp->msb_field, 17708d280b98SDavid Chinner msbp->msb_delta, rsvd); 17718d280b98SDavid Chinner break; 17728d280b98SDavid Chinner } 17738d280b98SDavid Chinner 17741da177e4SLinus Torvalds if (status != 0) { 17751da177e4SLinus Torvalds break; 17761da177e4SLinus Torvalds } 17771da177e4SLinus Torvalds } 17781da177e4SLinus Torvalds 17791da177e4SLinus Torvalds /* 17801da177e4SLinus Torvalds * If we didn't complete the loop above, then back out 17811da177e4SLinus Torvalds * any changes made to the superblock. If you add code 17821da177e4SLinus Torvalds * between the loop above and here, make sure that you 17831da177e4SLinus Torvalds * preserve the value of status. Loop back until 17841da177e4SLinus Torvalds * we step below the beginning of the array. Make sure 17851da177e4SLinus Torvalds * we don't touch anything back there. 17861da177e4SLinus Torvalds */ 17871da177e4SLinus Torvalds if (status != 0) { 17881da177e4SLinus Torvalds msbp--; 17891da177e4SLinus Torvalds while (msbp >= msb) { 17908d280b98SDavid Chinner switch (msbp->msb_field) { 17918d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 17928d280b98SDavid Chinner case XFS_SBS_ICOUNT: 17938d280b98SDavid Chinner case XFS_SBS_IFREE: 17948d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 17958d280b98SDavid Chinner if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) { 17963685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 179720b64285SDavid Chinner status = xfs_icsb_modify_counters(mp, 17988d280b98SDavid Chinner msbp->msb_field, 17998d280b98SDavid Chinner -(msbp->msb_delta), 18008d280b98SDavid Chinner rsvd); 18013685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 18028d280b98SDavid Chinner break; 18038d280b98SDavid Chinner } 18048d280b98SDavid Chinner /* FALLTHROUGH */ 18058d280b98SDavid Chinner #endif 18068d280b98SDavid Chinner default: 18071da177e4SLinus Torvalds status = xfs_mod_incore_sb_unlocked(mp, 18088d280b98SDavid Chinner msbp->msb_field, 18098d280b98SDavid Chinner -(msbp->msb_delta), 18108d280b98SDavid Chinner rsvd); 18118d280b98SDavid Chinner break; 18128d280b98SDavid Chinner } 18131da177e4SLinus Torvalds ASSERT(status == 0); 18141da177e4SLinus Torvalds msbp--; 18151da177e4SLinus Torvalds } 18161da177e4SLinus Torvalds } 18173685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 1818014c2544SJesper Juhl return status; 18191da177e4SLinus Torvalds } 18201da177e4SLinus Torvalds 18211da177e4SLinus Torvalds /* 18221da177e4SLinus Torvalds * xfs_getsb() is called to obtain the buffer for the superblock. 18231da177e4SLinus Torvalds * The buffer is returned locked and read in from disk. 18241da177e4SLinus Torvalds * The buffer should be released with a call to xfs_brelse(). 18251da177e4SLinus Torvalds * 18261da177e4SLinus Torvalds * If the flags parameter is BUF_TRYLOCK, then we'll only return 18271da177e4SLinus Torvalds * the superblock buffer if it can be locked without sleeping. 18281da177e4SLinus Torvalds * If it can't then we'll return NULL. 18291da177e4SLinus Torvalds */ 18301da177e4SLinus Torvalds xfs_buf_t * 18311da177e4SLinus Torvalds xfs_getsb( 18321da177e4SLinus Torvalds xfs_mount_t *mp, 18331da177e4SLinus Torvalds int flags) 18341da177e4SLinus Torvalds { 18351da177e4SLinus Torvalds xfs_buf_t *bp; 18361da177e4SLinus Torvalds 18371da177e4SLinus Torvalds ASSERT(mp->m_sb_bp != NULL); 18381da177e4SLinus Torvalds bp = mp->m_sb_bp; 18391da177e4SLinus Torvalds if (flags & XFS_BUF_TRYLOCK) { 18401da177e4SLinus Torvalds if (!XFS_BUF_CPSEMA(bp)) { 18411da177e4SLinus Torvalds return NULL; 18421da177e4SLinus Torvalds } 18431da177e4SLinus Torvalds } else { 18441da177e4SLinus Torvalds XFS_BUF_PSEMA(bp, PRIBIO); 18451da177e4SLinus Torvalds } 18461da177e4SLinus Torvalds XFS_BUF_HOLD(bp); 18471da177e4SLinus Torvalds ASSERT(XFS_BUF_ISDONE(bp)); 1848014c2544SJesper Juhl return bp; 18491da177e4SLinus Torvalds } 18501da177e4SLinus Torvalds 18511da177e4SLinus Torvalds /* 18521da177e4SLinus Torvalds * Used to free the superblock along various error paths. 18531da177e4SLinus Torvalds */ 18541da177e4SLinus Torvalds void 18551da177e4SLinus Torvalds xfs_freesb( 18561da177e4SLinus Torvalds xfs_mount_t *mp) 18571da177e4SLinus Torvalds { 18581da177e4SLinus Torvalds xfs_buf_t *bp; 18591da177e4SLinus Torvalds 18601da177e4SLinus Torvalds /* 18611da177e4SLinus Torvalds * Use xfs_getsb() so that the buffer will be locked 18621da177e4SLinus Torvalds * when we call xfs_buf_relse(). 18631da177e4SLinus Torvalds */ 18641da177e4SLinus Torvalds bp = xfs_getsb(mp, 0); 18651da177e4SLinus Torvalds XFS_BUF_UNMANAGE(bp); 18661da177e4SLinus Torvalds xfs_buf_relse(bp); 18671da177e4SLinus Torvalds mp->m_sb_bp = NULL; 18681da177e4SLinus Torvalds } 18691da177e4SLinus Torvalds 18701da177e4SLinus Torvalds /* 18711da177e4SLinus Torvalds * See if the UUID is unique among mounted XFS filesystems. 18721da177e4SLinus Torvalds * Mount fails if UUID is nil or a FS with the same UUID is already mounted. 18731da177e4SLinus Torvalds */ 18741da177e4SLinus Torvalds STATIC int 18751da177e4SLinus Torvalds xfs_uuid_mount( 18761da177e4SLinus Torvalds xfs_mount_t *mp) 18771da177e4SLinus Torvalds { 18781da177e4SLinus Torvalds if (uuid_is_nil(&mp->m_sb.sb_uuid)) { 18791da177e4SLinus Torvalds cmn_err(CE_WARN, 18801da177e4SLinus Torvalds "XFS: Filesystem %s has nil UUID - can't mount", 18811da177e4SLinus Torvalds mp->m_fsname); 18821da177e4SLinus Torvalds return -1; 18831da177e4SLinus Torvalds } 18841da177e4SLinus Torvalds if (!uuid_table_insert(&mp->m_sb.sb_uuid)) { 18851da177e4SLinus Torvalds cmn_err(CE_WARN, 18861da177e4SLinus Torvalds "XFS: Filesystem %s has duplicate UUID - can't mount", 18871da177e4SLinus Torvalds mp->m_fsname); 18881da177e4SLinus Torvalds return -1; 18891da177e4SLinus Torvalds } 18901da177e4SLinus Torvalds return 0; 18911da177e4SLinus Torvalds } 18921da177e4SLinus Torvalds 18931da177e4SLinus Torvalds /* 18941da177e4SLinus Torvalds * Remove filesystem from the UUID table. 18951da177e4SLinus Torvalds */ 18961da177e4SLinus Torvalds STATIC void 18971da177e4SLinus Torvalds xfs_uuid_unmount( 18981da177e4SLinus Torvalds xfs_mount_t *mp) 18991da177e4SLinus Torvalds { 19001da177e4SLinus Torvalds uuid_table_remove(&mp->m_sb.sb_uuid); 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds /* 19041da177e4SLinus Torvalds * Used to log changes to the superblock unit and width fields which could 1905e6957ea4SEric Sandeen * be altered by the mount options, as well as any potential sb_features2 1906e6957ea4SEric Sandeen * fixup. Only the first superblock is updated. 19071da177e4SLinus Torvalds */ 19081da177e4SLinus Torvalds STATIC void 1909ee1c0908SDavid Chinner xfs_mount_log_sb( 19101da177e4SLinus Torvalds xfs_mount_t *mp, 19111da177e4SLinus Torvalds __int64_t fields) 19121da177e4SLinus Torvalds { 19131da177e4SLinus Torvalds xfs_trans_t *tp; 19141da177e4SLinus Torvalds 1915ee1c0908SDavid Chinner ASSERT(fields & (XFS_SB_UNIT | XFS_SB_WIDTH | XFS_SB_UUID | 1916ee1c0908SDavid Chinner XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2)); 19171da177e4SLinus Torvalds 19181da177e4SLinus Torvalds tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT); 19191da177e4SLinus Torvalds if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0, 19201da177e4SLinus Torvalds XFS_DEFAULT_LOG_COUNT)) { 19211da177e4SLinus Torvalds xfs_trans_cancel(tp, 0); 19221da177e4SLinus Torvalds return; 19231da177e4SLinus Torvalds } 19241da177e4SLinus Torvalds xfs_mod_sb(tp, fields); 19251c72bf90SEric Sandeen xfs_trans_commit(tp, 0); 19261da177e4SLinus Torvalds } 19278d280b98SDavid Chinner 19288d280b98SDavid Chinner 19298d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 19308d280b98SDavid Chinner /* 19318d280b98SDavid Chinner * Per-cpu incore superblock counters 19328d280b98SDavid Chinner * 19338d280b98SDavid Chinner * Simple concept, difficult implementation 19348d280b98SDavid Chinner * 19358d280b98SDavid Chinner * Basically, replace the incore superblock counters with a distributed per cpu 19368d280b98SDavid Chinner * counter for contended fields (e.g. free block count). 19378d280b98SDavid Chinner * 19388d280b98SDavid Chinner * Difficulties arise in that the incore sb is used for ENOSPC checking, and 19398d280b98SDavid Chinner * hence needs to be accurately read when we are running low on space. Hence 19408d280b98SDavid Chinner * there is a method to enable and disable the per-cpu counters based on how 19418d280b98SDavid Chinner * much "stuff" is available in them. 19428d280b98SDavid Chinner * 19438d280b98SDavid Chinner * Basically, a counter is enabled if there is enough free resource to justify 19448d280b98SDavid Chinner * running a per-cpu fast-path. If the per-cpu counter runs out (i.e. a local 19458d280b98SDavid Chinner * ENOSPC), then we disable the counters to synchronise all callers and 19468d280b98SDavid Chinner * re-distribute the available resources. 19478d280b98SDavid Chinner * 19488d280b98SDavid Chinner * If, once we redistributed the available resources, we still get a failure, 19498d280b98SDavid Chinner * we disable the per-cpu counter and go through the slow path. 19508d280b98SDavid Chinner * 19518d280b98SDavid Chinner * The slow path is the current xfs_mod_incore_sb() function. This means that 19528d280b98SDavid Chinner * when we disable a per-cpu counter, we need to drain it's resources back to 19538d280b98SDavid Chinner * the global superblock. We do this after disabling the counter to prevent 19548d280b98SDavid Chinner * more threads from queueing up on the counter. 19558d280b98SDavid Chinner * 19568d280b98SDavid Chinner * Essentially, this means that we still need a lock in the fast path to enable 19578d280b98SDavid Chinner * synchronisation between the global counters and the per-cpu counters. This 19588d280b98SDavid Chinner * is not a problem because the lock will be local to a CPU almost all the time 19598d280b98SDavid Chinner * and have little contention except when we get to ENOSPC conditions. 19608d280b98SDavid Chinner * 19618d280b98SDavid Chinner * Basically, this lock becomes a barrier that enables us to lock out the fast 19628d280b98SDavid Chinner * path while we do things like enabling and disabling counters and 19638d280b98SDavid Chinner * synchronising the counters. 19648d280b98SDavid Chinner * 19658d280b98SDavid Chinner * Locking rules: 19668d280b98SDavid Chinner * 19673685c2a1SEric Sandeen * 1. m_sb_lock before picking up per-cpu locks 19688d280b98SDavid Chinner * 2. per-cpu locks always picked up via for_each_online_cpu() order 19693685c2a1SEric Sandeen * 3. accurate counter sync requires m_sb_lock + per cpu locks 19708d280b98SDavid Chinner * 4. modifying per-cpu counters requires holding per-cpu lock 19713685c2a1SEric Sandeen * 5. modifying global counters requires holding m_sb_lock 19723685c2a1SEric Sandeen * 6. enabling or disabling a counter requires holding the m_sb_lock 19738d280b98SDavid Chinner * and _none_ of the per-cpu locks. 19748d280b98SDavid Chinner * 19758d280b98SDavid Chinner * Disabled counters are only ever re-enabled by a balance operation 19768d280b98SDavid Chinner * that results in more free resources per CPU than a given threshold. 19778d280b98SDavid Chinner * To ensure counters don't remain disabled, they are rebalanced when 19788d280b98SDavid Chinner * the global resource goes above a higher threshold (i.e. some hysteresis 19798d280b98SDavid Chinner * is present to prevent thrashing). 19808d280b98SDavid Chinner */ 1981e8234a68SDavid Chinner 19825a67e4c5SChandra Seetharaman #ifdef CONFIG_HOTPLUG_CPU 1983e8234a68SDavid Chinner /* 1984e8234a68SDavid Chinner * hot-plug CPU notifier support. 1985e8234a68SDavid Chinner * 19865a67e4c5SChandra Seetharaman * We need a notifier per filesystem as we need to be able to identify 19875a67e4c5SChandra Seetharaman * the filesystem to balance the counters out. This is achieved by 19885a67e4c5SChandra Seetharaman * having a notifier block embedded in the xfs_mount_t and doing pointer 19895a67e4c5SChandra Seetharaman * magic to get the mount pointer from the notifier block address. 1990e8234a68SDavid Chinner */ 1991e8234a68SDavid Chinner STATIC int 1992e8234a68SDavid Chinner xfs_icsb_cpu_notify( 1993e8234a68SDavid Chinner struct notifier_block *nfb, 1994e8234a68SDavid Chinner unsigned long action, 1995e8234a68SDavid Chinner void *hcpu) 1996e8234a68SDavid Chinner { 1997e8234a68SDavid Chinner xfs_icsb_cnts_t *cntp; 1998e8234a68SDavid Chinner xfs_mount_t *mp; 1999e8234a68SDavid Chinner 2000e8234a68SDavid Chinner mp = (xfs_mount_t *)container_of(nfb, xfs_mount_t, m_icsb_notifier); 2001e8234a68SDavid Chinner cntp = (xfs_icsb_cnts_t *) 2002e8234a68SDavid Chinner per_cpu_ptr(mp->m_sb_cnts, (unsigned long)hcpu); 2003e8234a68SDavid Chinner switch (action) { 2004e8234a68SDavid Chinner case CPU_UP_PREPARE: 20058bb78442SRafael J. Wysocki case CPU_UP_PREPARE_FROZEN: 2006e8234a68SDavid Chinner /* Easy Case - initialize the area and locks, and 2007e8234a68SDavid Chinner * then rebalance when online does everything else for us. */ 200801e1b69cSDavid Chinner memset(cntp, 0, sizeof(xfs_icsb_cnts_t)); 2009e8234a68SDavid Chinner break; 2010e8234a68SDavid Chinner case CPU_ONLINE: 20118bb78442SRafael J. Wysocki case CPU_ONLINE_FROZEN: 201203135cf7SDavid Chinner xfs_icsb_lock(mp); 201320b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0, 0); 201420b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0, 0); 201520b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0, 0); 201603135cf7SDavid Chinner xfs_icsb_unlock(mp); 2017e8234a68SDavid Chinner break; 2018e8234a68SDavid Chinner case CPU_DEAD: 20198bb78442SRafael J. Wysocki case CPU_DEAD_FROZEN: 2020e8234a68SDavid Chinner /* Disable all the counters, then fold the dead cpu's 2021e8234a68SDavid Chinner * count into the total on the global superblock and 2022e8234a68SDavid Chinner * re-enable the counters. */ 202303135cf7SDavid Chinner xfs_icsb_lock(mp); 20243685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 2025e8234a68SDavid Chinner xfs_icsb_disable_counter(mp, XFS_SBS_ICOUNT); 2026e8234a68SDavid Chinner xfs_icsb_disable_counter(mp, XFS_SBS_IFREE); 2027e8234a68SDavid Chinner xfs_icsb_disable_counter(mp, XFS_SBS_FDBLOCKS); 2028e8234a68SDavid Chinner 2029e8234a68SDavid Chinner mp->m_sb.sb_icount += cntp->icsb_icount; 2030e8234a68SDavid Chinner mp->m_sb.sb_ifree += cntp->icsb_ifree; 2031e8234a68SDavid Chinner mp->m_sb.sb_fdblocks += cntp->icsb_fdblocks; 2032e8234a68SDavid Chinner 203301e1b69cSDavid Chinner memset(cntp, 0, sizeof(xfs_icsb_cnts_t)); 2034e8234a68SDavid Chinner 203520b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 203620b64285SDavid Chinner XFS_ICSB_SB_LOCKED, 0); 203720b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 203820b64285SDavid Chinner XFS_ICSB_SB_LOCKED, 0); 203920b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 204020b64285SDavid Chinner XFS_ICSB_SB_LOCKED, 0); 20413685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 204203135cf7SDavid Chinner xfs_icsb_unlock(mp); 2043e8234a68SDavid Chinner break; 2044e8234a68SDavid Chinner } 2045e8234a68SDavid Chinner 2046e8234a68SDavid Chinner return NOTIFY_OK; 2047e8234a68SDavid Chinner } 20485a67e4c5SChandra Seetharaman #endif /* CONFIG_HOTPLUG_CPU */ 2049e8234a68SDavid Chinner 20508d280b98SDavid Chinner int 20518d280b98SDavid Chinner xfs_icsb_init_counters( 20528d280b98SDavid Chinner xfs_mount_t *mp) 20538d280b98SDavid Chinner { 20548d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 20558d280b98SDavid Chinner int i; 20568d280b98SDavid Chinner 20578d280b98SDavid Chinner mp->m_sb_cnts = alloc_percpu(xfs_icsb_cnts_t); 20588d280b98SDavid Chinner if (mp->m_sb_cnts == NULL) 20598d280b98SDavid Chinner return -ENOMEM; 20608d280b98SDavid Chinner 20615a67e4c5SChandra Seetharaman #ifdef CONFIG_HOTPLUG_CPU 2062e8234a68SDavid Chinner mp->m_icsb_notifier.notifier_call = xfs_icsb_cpu_notify; 2063e8234a68SDavid Chinner mp->m_icsb_notifier.priority = 0; 20645a67e4c5SChandra Seetharaman register_hotcpu_notifier(&mp->m_icsb_notifier); 20655a67e4c5SChandra Seetharaman #endif /* CONFIG_HOTPLUG_CPU */ 2066e8234a68SDavid Chinner 20678d280b98SDavid Chinner for_each_online_cpu(i) { 20688d280b98SDavid Chinner cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 206901e1b69cSDavid Chinner memset(cntp, 0, sizeof(xfs_icsb_cnts_t)); 20708d280b98SDavid Chinner } 207120b64285SDavid Chinner 207220b64285SDavid Chinner mutex_init(&mp->m_icsb_mutex); 207320b64285SDavid Chinner 20748d280b98SDavid Chinner /* 20758d280b98SDavid Chinner * start with all counters disabled so that the 20768d280b98SDavid Chinner * initial balance kicks us off correctly 20778d280b98SDavid Chinner */ 20788d280b98SDavid Chinner mp->m_icsb_counters = -1; 20798d280b98SDavid Chinner return 0; 20808d280b98SDavid Chinner } 20818d280b98SDavid Chinner 20825478eeadSLachlan McIlroy void 20835478eeadSLachlan McIlroy xfs_icsb_reinit_counters( 20845478eeadSLachlan McIlroy xfs_mount_t *mp) 20855478eeadSLachlan McIlroy { 20865478eeadSLachlan McIlroy xfs_icsb_lock(mp); 20875478eeadSLachlan McIlroy /* 20885478eeadSLachlan McIlroy * start with all counters disabled so that the 20895478eeadSLachlan McIlroy * initial balance kicks us off correctly 20905478eeadSLachlan McIlroy */ 20915478eeadSLachlan McIlroy mp->m_icsb_counters = -1; 20925478eeadSLachlan McIlroy xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0, 0); 20935478eeadSLachlan McIlroy xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0, 0); 20945478eeadSLachlan McIlroy xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0, 0); 20955478eeadSLachlan McIlroy xfs_icsb_unlock(mp); 20965478eeadSLachlan McIlroy } 20975478eeadSLachlan McIlroy 20988d280b98SDavid Chinner STATIC void 20998d280b98SDavid Chinner xfs_icsb_destroy_counters( 21008d280b98SDavid Chinner xfs_mount_t *mp) 21018d280b98SDavid Chinner { 2102e8234a68SDavid Chinner if (mp->m_sb_cnts) { 21035a67e4c5SChandra Seetharaman unregister_hotcpu_notifier(&mp->m_icsb_notifier); 21048d280b98SDavid Chinner free_percpu(mp->m_sb_cnts); 21058d280b98SDavid Chinner } 210603135cf7SDavid Chinner mutex_destroy(&mp->m_icsb_mutex); 2107e8234a68SDavid Chinner } 21088d280b98SDavid Chinner 21097989cb8eSDavid Chinner STATIC_INLINE void 211001e1b69cSDavid Chinner xfs_icsb_lock_cntr( 211101e1b69cSDavid Chinner xfs_icsb_cnts_t *icsbp) 211201e1b69cSDavid Chinner { 211301e1b69cSDavid Chinner while (test_and_set_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags)) { 211401e1b69cSDavid Chinner ndelay(1000); 211501e1b69cSDavid Chinner } 211601e1b69cSDavid Chinner } 211701e1b69cSDavid Chinner 21187989cb8eSDavid Chinner STATIC_INLINE void 211901e1b69cSDavid Chinner xfs_icsb_unlock_cntr( 212001e1b69cSDavid Chinner xfs_icsb_cnts_t *icsbp) 212101e1b69cSDavid Chinner { 212201e1b69cSDavid Chinner clear_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags); 212301e1b69cSDavid Chinner } 212401e1b69cSDavid Chinner 21258d280b98SDavid Chinner 21267989cb8eSDavid Chinner STATIC_INLINE void 21278d280b98SDavid Chinner xfs_icsb_lock_all_counters( 21288d280b98SDavid Chinner xfs_mount_t *mp) 21298d280b98SDavid Chinner { 21308d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 21318d280b98SDavid Chinner int i; 21328d280b98SDavid Chinner 21338d280b98SDavid Chinner for_each_online_cpu(i) { 21348d280b98SDavid Chinner cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 213501e1b69cSDavid Chinner xfs_icsb_lock_cntr(cntp); 21368d280b98SDavid Chinner } 21378d280b98SDavid Chinner } 21388d280b98SDavid Chinner 21397989cb8eSDavid Chinner STATIC_INLINE void 21408d280b98SDavid Chinner xfs_icsb_unlock_all_counters( 21418d280b98SDavid Chinner xfs_mount_t *mp) 21428d280b98SDavid Chinner { 21438d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 21448d280b98SDavid Chinner int i; 21458d280b98SDavid Chinner 21468d280b98SDavid Chinner for_each_online_cpu(i) { 21478d280b98SDavid Chinner cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 214801e1b69cSDavid Chinner xfs_icsb_unlock_cntr(cntp); 21498d280b98SDavid Chinner } 21508d280b98SDavid Chinner } 21518d280b98SDavid Chinner 21528d280b98SDavid Chinner STATIC void 21538d280b98SDavid Chinner xfs_icsb_count( 21548d280b98SDavid Chinner xfs_mount_t *mp, 21558d280b98SDavid Chinner xfs_icsb_cnts_t *cnt, 21568d280b98SDavid Chinner int flags) 21578d280b98SDavid Chinner { 21588d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 21598d280b98SDavid Chinner int i; 21608d280b98SDavid Chinner 21618d280b98SDavid Chinner memset(cnt, 0, sizeof(xfs_icsb_cnts_t)); 21628d280b98SDavid Chinner 21638d280b98SDavid Chinner if (!(flags & XFS_ICSB_LAZY_COUNT)) 21648d280b98SDavid Chinner xfs_icsb_lock_all_counters(mp); 21658d280b98SDavid Chinner 21668d280b98SDavid Chinner for_each_online_cpu(i) { 21678d280b98SDavid Chinner cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 21688d280b98SDavid Chinner cnt->icsb_icount += cntp->icsb_icount; 21698d280b98SDavid Chinner cnt->icsb_ifree += cntp->icsb_ifree; 21708d280b98SDavid Chinner cnt->icsb_fdblocks += cntp->icsb_fdblocks; 21718d280b98SDavid Chinner } 21728d280b98SDavid Chinner 21738d280b98SDavid Chinner if (!(flags & XFS_ICSB_LAZY_COUNT)) 21748d280b98SDavid Chinner xfs_icsb_unlock_all_counters(mp); 21758d280b98SDavid Chinner } 21768d280b98SDavid Chinner 21778d280b98SDavid Chinner STATIC int 21788d280b98SDavid Chinner xfs_icsb_counter_disabled( 21798d280b98SDavid Chinner xfs_mount_t *mp, 21808d280b98SDavid Chinner xfs_sb_field_t field) 21818d280b98SDavid Chinner { 21828d280b98SDavid Chinner ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS)); 21838d280b98SDavid Chinner return test_bit(field, &mp->m_icsb_counters); 21848d280b98SDavid Chinner } 21858d280b98SDavid Chinner 2186*36fbe6e6SDavid Chinner STATIC void 21878d280b98SDavid Chinner xfs_icsb_disable_counter( 21888d280b98SDavid Chinner xfs_mount_t *mp, 21898d280b98SDavid Chinner xfs_sb_field_t field) 21908d280b98SDavid Chinner { 21918d280b98SDavid Chinner xfs_icsb_cnts_t cnt; 21928d280b98SDavid Chinner 21938d280b98SDavid Chinner ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS)); 21948d280b98SDavid Chinner 219520b64285SDavid Chinner /* 219620b64285SDavid Chinner * If we are already disabled, then there is nothing to do 219720b64285SDavid Chinner * here. We check before locking all the counters to avoid 219820b64285SDavid Chinner * the expensive lock operation when being called in the 219920b64285SDavid Chinner * slow path and the counter is already disabled. This is 220020b64285SDavid Chinner * safe because the only time we set or clear this state is under 220120b64285SDavid Chinner * the m_icsb_mutex. 220220b64285SDavid Chinner */ 220320b64285SDavid Chinner if (xfs_icsb_counter_disabled(mp, field)) 2204*36fbe6e6SDavid Chinner return; 220520b64285SDavid Chinner 22068d280b98SDavid Chinner xfs_icsb_lock_all_counters(mp); 22078d280b98SDavid Chinner if (!test_and_set_bit(field, &mp->m_icsb_counters)) { 22088d280b98SDavid Chinner /* drain back to superblock */ 22098d280b98SDavid Chinner 22108d280b98SDavid Chinner xfs_icsb_count(mp, &cnt, XFS_ICSB_SB_LOCKED|XFS_ICSB_LAZY_COUNT); 22118d280b98SDavid Chinner switch(field) { 22128d280b98SDavid Chinner case XFS_SBS_ICOUNT: 22138d280b98SDavid Chinner mp->m_sb.sb_icount = cnt.icsb_icount; 22148d280b98SDavid Chinner break; 22158d280b98SDavid Chinner case XFS_SBS_IFREE: 22168d280b98SDavid Chinner mp->m_sb.sb_ifree = cnt.icsb_ifree; 22178d280b98SDavid Chinner break; 22188d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 22198d280b98SDavid Chinner mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks; 22208d280b98SDavid Chinner break; 22218d280b98SDavid Chinner default: 22228d280b98SDavid Chinner BUG(); 22238d280b98SDavid Chinner } 22248d280b98SDavid Chinner } 22258d280b98SDavid Chinner 22268d280b98SDavid Chinner xfs_icsb_unlock_all_counters(mp); 22278d280b98SDavid Chinner } 22288d280b98SDavid Chinner 22298d280b98SDavid Chinner STATIC void 22308d280b98SDavid Chinner xfs_icsb_enable_counter( 22318d280b98SDavid Chinner xfs_mount_t *mp, 22328d280b98SDavid Chinner xfs_sb_field_t field, 22338d280b98SDavid Chinner uint64_t count, 22348d280b98SDavid Chinner uint64_t resid) 22358d280b98SDavid Chinner { 22368d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 22378d280b98SDavid Chinner int i; 22388d280b98SDavid Chinner 22398d280b98SDavid Chinner ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS)); 22408d280b98SDavid Chinner 22418d280b98SDavid Chinner xfs_icsb_lock_all_counters(mp); 22428d280b98SDavid Chinner for_each_online_cpu(i) { 22438d280b98SDavid Chinner cntp = per_cpu_ptr(mp->m_sb_cnts, i); 22448d280b98SDavid Chinner switch (field) { 22458d280b98SDavid Chinner case XFS_SBS_ICOUNT: 22468d280b98SDavid Chinner cntp->icsb_icount = count + resid; 22478d280b98SDavid Chinner break; 22488d280b98SDavid Chinner case XFS_SBS_IFREE: 22498d280b98SDavid Chinner cntp->icsb_ifree = count + resid; 22508d280b98SDavid Chinner break; 22518d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 22528d280b98SDavid Chinner cntp->icsb_fdblocks = count + resid; 22538d280b98SDavid Chinner break; 22548d280b98SDavid Chinner default: 22558d280b98SDavid Chinner BUG(); 22568d280b98SDavid Chinner break; 22578d280b98SDavid Chinner } 22588d280b98SDavid Chinner resid = 0; 22598d280b98SDavid Chinner } 22608d280b98SDavid Chinner clear_bit(field, &mp->m_icsb_counters); 22618d280b98SDavid Chinner xfs_icsb_unlock_all_counters(mp); 22628d280b98SDavid Chinner } 22638d280b98SDavid Chinner 2264dbcabad1SDavid Chinner void 2265dbcabad1SDavid Chinner xfs_icsb_sync_counters_flags( 22668d280b98SDavid Chinner xfs_mount_t *mp, 22678d280b98SDavid Chinner int flags) 22688d280b98SDavid Chinner { 22698d280b98SDavid Chinner xfs_icsb_cnts_t cnt; 22708d280b98SDavid Chinner 22718d280b98SDavid Chinner /* Pass 1: lock all counters */ 22728d280b98SDavid Chinner if ((flags & XFS_ICSB_SB_LOCKED) == 0) 22733685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 22748d280b98SDavid Chinner 22758d280b98SDavid Chinner xfs_icsb_count(mp, &cnt, flags); 22768d280b98SDavid Chinner 22778d280b98SDavid Chinner /* Step 3: update mp->m_sb fields */ 22788d280b98SDavid Chinner if (!xfs_icsb_counter_disabled(mp, XFS_SBS_ICOUNT)) 22798d280b98SDavid Chinner mp->m_sb.sb_icount = cnt.icsb_icount; 22808d280b98SDavid Chinner if (!xfs_icsb_counter_disabled(mp, XFS_SBS_IFREE)) 22818d280b98SDavid Chinner mp->m_sb.sb_ifree = cnt.icsb_ifree; 22828d280b98SDavid Chinner if (!xfs_icsb_counter_disabled(mp, XFS_SBS_FDBLOCKS)) 22838d280b98SDavid Chinner mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks; 22848d280b98SDavid Chinner 22858d280b98SDavid Chinner if ((flags & XFS_ICSB_SB_LOCKED) == 0) 22863685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 22878d280b98SDavid Chinner } 22888d280b98SDavid Chinner 22898d280b98SDavid Chinner /* 22908d280b98SDavid Chinner * Accurate update of per-cpu counters to incore superblock 22918d280b98SDavid Chinner */ 22928d280b98SDavid Chinner STATIC void 22938d280b98SDavid Chinner xfs_icsb_sync_counters( 22948d280b98SDavid Chinner xfs_mount_t *mp) 22958d280b98SDavid Chinner { 2296dbcabad1SDavid Chinner xfs_icsb_sync_counters_flags(mp, 0); 22978d280b98SDavid Chinner } 22988d280b98SDavid Chinner 22998d280b98SDavid Chinner /* 23008d280b98SDavid Chinner * Balance and enable/disable counters as necessary. 23018d280b98SDavid Chinner * 230220b64285SDavid Chinner * Thresholds for re-enabling counters are somewhat magic. inode counts are 230320b64285SDavid Chinner * chosen to be the same number as single on disk allocation chunk per CPU, and 230420b64285SDavid Chinner * free blocks is something far enough zero that we aren't going thrash when we 230520b64285SDavid Chinner * get near ENOSPC. We also need to supply a minimum we require per cpu to 230620b64285SDavid Chinner * prevent looping endlessly when xfs_alloc_space asks for more than will 230720b64285SDavid Chinner * be distributed to a single CPU but each CPU has enough blocks to be 230820b64285SDavid Chinner * reenabled. 230920b64285SDavid Chinner * 231020b64285SDavid Chinner * Note that we can be called when counters are already disabled. 231120b64285SDavid Chinner * xfs_icsb_disable_counter() optimises the counter locking in this case to 231220b64285SDavid Chinner * prevent locking every per-cpu counter needlessly. 23138d280b98SDavid Chinner */ 231420b64285SDavid Chinner 231520b64285SDavid Chinner #define XFS_ICSB_INO_CNTR_REENABLE (uint64_t)64 23164be536deSDavid Chinner #define XFS_ICSB_FDBLK_CNTR_REENABLE(mp) \ 231720b64285SDavid Chinner (uint64_t)(512 + XFS_ALLOC_SET_ASIDE(mp)) 23188d280b98SDavid Chinner STATIC void 23198d280b98SDavid Chinner xfs_icsb_balance_counter( 23208d280b98SDavid Chinner xfs_mount_t *mp, 23218d280b98SDavid Chinner xfs_sb_field_t field, 232220b64285SDavid Chinner int flags, 232320b64285SDavid Chinner int min_per_cpu) 23248d280b98SDavid Chinner { 23256fdf8cccSNathan Scott uint64_t count, resid; 23268d280b98SDavid Chinner int weight = num_online_cpus(); 232720b64285SDavid Chinner uint64_t min = (uint64_t)min_per_cpu; 23288d280b98SDavid Chinner 23298d280b98SDavid Chinner if (!(flags & XFS_ICSB_SB_LOCKED)) 23303685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 23318d280b98SDavid Chinner 23328d280b98SDavid Chinner /* disable counter and sync counter */ 23338d280b98SDavid Chinner xfs_icsb_disable_counter(mp, field); 23348d280b98SDavid Chinner 23358d280b98SDavid Chinner /* update counters - first CPU gets residual*/ 23368d280b98SDavid Chinner switch (field) { 23378d280b98SDavid Chinner case XFS_SBS_ICOUNT: 23388d280b98SDavid Chinner count = mp->m_sb.sb_icount; 23398d280b98SDavid Chinner resid = do_div(count, weight); 234020b64285SDavid Chinner if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE)) 23418d280b98SDavid Chinner goto out; 23428d280b98SDavid Chinner break; 23438d280b98SDavid Chinner case XFS_SBS_IFREE: 23448d280b98SDavid Chinner count = mp->m_sb.sb_ifree; 23458d280b98SDavid Chinner resid = do_div(count, weight); 234620b64285SDavid Chinner if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE)) 23478d280b98SDavid Chinner goto out; 23488d280b98SDavid Chinner break; 23498d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 23508d280b98SDavid Chinner count = mp->m_sb.sb_fdblocks; 23518d280b98SDavid Chinner resid = do_div(count, weight); 235220b64285SDavid Chinner if (count < max(min, XFS_ICSB_FDBLK_CNTR_REENABLE(mp))) 23538d280b98SDavid Chinner goto out; 23548d280b98SDavid Chinner break; 23558d280b98SDavid Chinner default: 23568d280b98SDavid Chinner BUG(); 23576fdf8cccSNathan Scott count = resid = 0; /* quiet, gcc */ 23588d280b98SDavid Chinner break; 23598d280b98SDavid Chinner } 23608d280b98SDavid Chinner 23618d280b98SDavid Chinner xfs_icsb_enable_counter(mp, field, count, resid); 23628d280b98SDavid Chinner out: 23638d280b98SDavid Chinner if (!(flags & XFS_ICSB_SB_LOCKED)) 23643685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 23658d280b98SDavid Chinner } 23668d280b98SDavid Chinner 2367a8272ce0SDavid Chinner STATIC int 236820b64285SDavid Chinner xfs_icsb_modify_counters( 23698d280b98SDavid Chinner xfs_mount_t *mp, 23708d280b98SDavid Chinner xfs_sb_field_t field, 237120f4ebf2SDavid Chinner int64_t delta, 237220b64285SDavid Chinner int rsvd) 23738d280b98SDavid Chinner { 23748d280b98SDavid Chinner xfs_icsb_cnts_t *icsbp; 23758d280b98SDavid Chinner long long lcounter; /* long counter for 64 bit fields */ 2376007c61c6SEric Sandeen int cpu, ret = 0; 23778d280b98SDavid Chinner 237820b64285SDavid Chinner might_sleep(); 23798d280b98SDavid Chinner again: 23808d280b98SDavid Chinner cpu = get_cpu(); 238120b64285SDavid Chinner icsbp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, cpu); 238220b64285SDavid Chinner 238320b64285SDavid Chinner /* 238420b64285SDavid Chinner * if the counter is disabled, go to slow path 238520b64285SDavid Chinner */ 23868d280b98SDavid Chinner if (unlikely(xfs_icsb_counter_disabled(mp, field))) 23878d280b98SDavid Chinner goto slow_path; 238820b64285SDavid Chinner xfs_icsb_lock_cntr(icsbp); 238920b64285SDavid Chinner if (unlikely(xfs_icsb_counter_disabled(mp, field))) { 239020b64285SDavid Chinner xfs_icsb_unlock_cntr(icsbp); 239120b64285SDavid Chinner goto slow_path; 239220b64285SDavid Chinner } 23938d280b98SDavid Chinner 23948d280b98SDavid Chinner switch (field) { 23958d280b98SDavid Chinner case XFS_SBS_ICOUNT: 23968d280b98SDavid Chinner lcounter = icsbp->icsb_icount; 23978d280b98SDavid Chinner lcounter += delta; 23988d280b98SDavid Chinner if (unlikely(lcounter < 0)) 239920b64285SDavid Chinner goto balance_counter; 24008d280b98SDavid Chinner icsbp->icsb_icount = lcounter; 24018d280b98SDavid Chinner break; 24028d280b98SDavid Chinner 24038d280b98SDavid Chinner case XFS_SBS_IFREE: 24048d280b98SDavid Chinner lcounter = icsbp->icsb_ifree; 24058d280b98SDavid Chinner lcounter += delta; 24068d280b98SDavid Chinner if (unlikely(lcounter < 0)) 240720b64285SDavid Chinner goto balance_counter; 24088d280b98SDavid Chinner icsbp->icsb_ifree = lcounter; 24098d280b98SDavid Chinner break; 24108d280b98SDavid Chinner 24118d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 24128d280b98SDavid Chinner BUG_ON((mp->m_resblks - mp->m_resblks_avail) != 0); 24138d280b98SDavid Chinner 24144be536deSDavid Chinner lcounter = icsbp->icsb_fdblocks - XFS_ALLOC_SET_ASIDE(mp); 24158d280b98SDavid Chinner lcounter += delta; 24168d280b98SDavid Chinner if (unlikely(lcounter < 0)) 241720b64285SDavid Chinner goto balance_counter; 24184be536deSDavid Chinner icsbp->icsb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp); 24198d280b98SDavid Chinner break; 24208d280b98SDavid Chinner default: 24218d280b98SDavid Chinner BUG(); 24228d280b98SDavid Chinner break; 24238d280b98SDavid Chinner } 242401e1b69cSDavid Chinner xfs_icsb_unlock_cntr(icsbp); 24258d280b98SDavid Chinner put_cpu(); 24268d280b98SDavid Chinner return 0; 24278d280b98SDavid Chinner 24288d280b98SDavid Chinner slow_path: 242920b64285SDavid Chinner put_cpu(); 243020b64285SDavid Chinner 243120b64285SDavid Chinner /* 243220b64285SDavid Chinner * serialise with a mutex so we don't burn lots of cpu on 243320b64285SDavid Chinner * the superblock lock. We still need to hold the superblock 243420b64285SDavid Chinner * lock, however, when we modify the global structures. 243520b64285SDavid Chinner */ 243603135cf7SDavid Chinner xfs_icsb_lock(mp); 243720b64285SDavid Chinner 243820b64285SDavid Chinner /* 243920b64285SDavid Chinner * Now running atomically. 244020b64285SDavid Chinner * 244120b64285SDavid Chinner * If the counter is enabled, someone has beaten us to rebalancing. 244220b64285SDavid Chinner * Drop the lock and try again in the fast path.... 244320b64285SDavid Chinner */ 244420b64285SDavid Chinner if (!(xfs_icsb_counter_disabled(mp, field))) { 244503135cf7SDavid Chinner xfs_icsb_unlock(mp); 244620b64285SDavid Chinner goto again; 244720b64285SDavid Chinner } 244820b64285SDavid Chinner 244920b64285SDavid Chinner /* 245020b64285SDavid Chinner * The counter is currently disabled. Because we are 245120b64285SDavid Chinner * running atomically here, we know a rebalance cannot 245220b64285SDavid Chinner * be in progress. Hence we can go straight to operating 245320b64285SDavid Chinner * on the global superblock. We do not call xfs_mod_incore_sb() 24543685c2a1SEric Sandeen * here even though we need to get the m_sb_lock. Doing so 245520b64285SDavid Chinner * will cause us to re-enter this function and deadlock. 24563685c2a1SEric Sandeen * Hence we get the m_sb_lock ourselves and then call 245720b64285SDavid Chinner * xfs_mod_incore_sb_unlocked() as the unlocked path operates 245820b64285SDavid Chinner * directly on the global counters. 245920b64285SDavid Chinner */ 24603685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 246120b64285SDavid Chinner ret = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd); 24623685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 246320b64285SDavid Chinner 246420b64285SDavid Chinner /* 246520b64285SDavid Chinner * Now that we've modified the global superblock, we 246620b64285SDavid Chinner * may be able to re-enable the distributed counters 246720b64285SDavid Chinner * (e.g. lots of space just got freed). After that 246820b64285SDavid Chinner * we are done. 246920b64285SDavid Chinner */ 247020b64285SDavid Chinner if (ret != ENOSPC) 247120b64285SDavid Chinner xfs_icsb_balance_counter(mp, field, 0, 0); 247203135cf7SDavid Chinner xfs_icsb_unlock(mp); 247320b64285SDavid Chinner return ret; 247420b64285SDavid Chinner 247520b64285SDavid Chinner balance_counter: 247601e1b69cSDavid Chinner xfs_icsb_unlock_cntr(icsbp); 24778d280b98SDavid Chinner put_cpu(); 24788d280b98SDavid Chinner 247920b64285SDavid Chinner /* 248020b64285SDavid Chinner * We may have multiple threads here if multiple per-cpu 248120b64285SDavid Chinner * counters run dry at the same time. This will mean we can 248220b64285SDavid Chinner * do more balances than strictly necessary but it is not 248320b64285SDavid Chinner * the common slowpath case. 248420b64285SDavid Chinner */ 248503135cf7SDavid Chinner xfs_icsb_lock(mp); 248620b64285SDavid Chinner 248720b64285SDavid Chinner /* 248820b64285SDavid Chinner * running atomically. 248920b64285SDavid Chinner * 249020b64285SDavid Chinner * This will leave the counter in the correct state for future 249120b64285SDavid Chinner * accesses. After the rebalance, we simply try again and our retry 249220b64285SDavid Chinner * will either succeed through the fast path or slow path without 249320b64285SDavid Chinner * another balance operation being required. 249420b64285SDavid Chinner */ 249520b64285SDavid Chinner xfs_icsb_balance_counter(mp, field, 0, delta); 249603135cf7SDavid Chinner xfs_icsb_unlock(mp); 24978d280b98SDavid Chinner goto again; 24988d280b98SDavid Chinner } 24998d280b98SDavid Chinner 25008d280b98SDavid Chinner #endif 2501