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" 461da177e4SLinus Torvalds 471da177e4SLinus Torvalds STATIC void xfs_mount_log_sbunit(xfs_mount_t *, __int64_t); 481da177e4SLinus Torvalds STATIC int xfs_uuid_mount(xfs_mount_t *); 491da177e4SLinus Torvalds STATIC void xfs_uuid_unmount(xfs_mount_t *mp); 50ba0f32d4SChristoph Hellwig STATIC void xfs_unmountfs_wait(xfs_mount_t *); 511da177e4SLinus Torvalds 528d280b98SDavid Chinner 538d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 548d280b98SDavid Chinner STATIC void xfs_icsb_destroy_counters(xfs_mount_t *); 5520f4ebf2SDavid Chinner STATIC void xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t, 5620f4ebf2SDavid Chinner int, int); 578d280b98SDavid Chinner STATIC void xfs_icsb_sync_counters(xfs_mount_t *); 588d280b98SDavid Chinner STATIC int xfs_icsb_modify_counters(xfs_mount_t *, xfs_sb_field_t, 5920f4ebf2SDavid Chinner int64_t, int); 60e8234a68SDavid Chinner STATIC int xfs_icsb_disable_counter(xfs_mount_t *, xfs_sb_field_t); 618d280b98SDavid Chinner 628d280b98SDavid Chinner #else 638d280b98SDavid Chinner 648d280b98SDavid Chinner #define xfs_icsb_destroy_counters(mp) do { } while (0) 6520b64285SDavid Chinner #define xfs_icsb_balance_counter(mp, a, b, c) do { } while (0) 668d280b98SDavid Chinner #define xfs_icsb_sync_counters(mp) do { } while (0) 678d280b98SDavid Chinner #define xfs_icsb_modify_counters(mp, a, b, c) do { } while (0) 688d280b98SDavid Chinner 698d280b98SDavid Chinner #endif 708d280b98SDavid Chinner 711df84c93SChristoph Hellwig static const struct { 721da177e4SLinus Torvalds short offset; 731da177e4SLinus Torvalds short type; /* 0 = integer 741da177e4SLinus Torvalds * 1 = binary / string (no translation) 751da177e4SLinus Torvalds */ 761da177e4SLinus Torvalds } xfs_sb_info[] = { 771da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_magicnum), 0 }, 781da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_blocksize), 0 }, 791da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_dblocks), 0 }, 801da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rblocks), 0 }, 811da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rextents), 0 }, 821da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_uuid), 1 }, 831da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logstart), 0 }, 841da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rootino), 0 }, 851da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rbmino), 0 }, 861da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rsumino), 0 }, 871da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rextsize), 0 }, 881da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_agblocks), 0 }, 891da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_agcount), 0 }, 901da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rbmblocks), 0 }, 911da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logblocks), 0 }, 921da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_versionnum), 0 }, 931da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_sectsize), 0 }, 941da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inodesize), 0 }, 951da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inopblock), 0 }, 961da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_fname[0]), 1 }, 971da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_blocklog), 0 }, 981da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_sectlog), 0 }, 991da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inodelog), 0 }, 1001da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inopblog), 0 }, 1011da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_agblklog), 0 }, 1021da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_rextslog), 0 }, 1031da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inprogress), 0 }, 1041da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_imax_pct), 0 }, 1051da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_icount), 0 }, 1061da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_ifree), 0 }, 1071da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_fdblocks), 0 }, 1081da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_frextents), 0 }, 1091da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_uquotino), 0 }, 1101da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_gquotino), 0 }, 1111da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_qflags), 0 }, 1121da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_flags), 0 }, 1131da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_shared_vn), 0 }, 1141da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_inoalignmt), 0 }, 1151da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_unit), 0 }, 1161da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_width), 0 }, 1171da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_dirblklog), 0 }, 1181da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logsectlog), 0 }, 1191da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logsectsize),0 }, 1201da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_logsunit), 0 }, 1211da177e4SLinus Torvalds { offsetof(xfs_sb_t, sb_features2), 0 }, 1221da177e4SLinus Torvalds { sizeof(xfs_sb_t), 0 } 1231da177e4SLinus Torvalds }; 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds /* 1261da177e4SLinus Torvalds * Return a pointer to an initialized xfs_mount structure. 1271da177e4SLinus Torvalds */ 1281da177e4SLinus Torvalds xfs_mount_t * 1291da177e4SLinus Torvalds xfs_mount_init(void) 1301da177e4SLinus Torvalds { 1311da177e4SLinus Torvalds xfs_mount_t *mp; 1321da177e4SLinus Torvalds 1338d280b98SDavid Chinner mp = kmem_zalloc(sizeof(xfs_mount_t), KM_SLEEP); 1348d280b98SDavid Chinner 1358d280b98SDavid Chinner if (xfs_icsb_init_counters(mp)) { 1368d280b98SDavid Chinner mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB; 1378d280b98SDavid Chinner } 1381da177e4SLinus Torvalds 139007c61c6SEric Sandeen spin_lock_init(&mp->m_sb_lock); 140794ee1baSJes Sorensen mutex_init(&mp->m_ilock); 141cc92e7acSChristoph Hellwig mutex_init(&mp->m_growlock); 1421da177e4SLinus Torvalds atomic_set(&mp->m_active_trans, 0); 1431da177e4SLinus Torvalds 1441da177e4SLinus Torvalds return mp; 1451da177e4SLinus Torvalds } 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds /* 1481da177e4SLinus Torvalds * Free up the resources associated with a mount structure. Assume that 1491da177e4SLinus Torvalds * the structure was initially zeroed, so we can tell which fields got 1501da177e4SLinus Torvalds * initialized. 1511da177e4SLinus Torvalds */ 1521da177e4SLinus Torvalds void 1531da177e4SLinus Torvalds xfs_mount_free( 154745f6919SChristoph Hellwig xfs_mount_t *mp) 1551da177e4SLinus Torvalds { 1561da177e4SLinus Torvalds if (mp->m_perag) { 1571da177e4SLinus Torvalds int agno; 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds for (agno = 0; agno < mp->m_maxagi; agno++) 1601da177e4SLinus Torvalds if (mp->m_perag[agno].pagb_list) 1611da177e4SLinus Torvalds kmem_free(mp->m_perag[agno].pagb_list, 1621da177e4SLinus Torvalds sizeof(xfs_perag_busy_t) * 1631da177e4SLinus Torvalds XFS_PAGB_NUM_SLOTS); 1641da177e4SLinus Torvalds kmem_free(mp->m_perag, 1651da177e4SLinus Torvalds sizeof(xfs_perag_t) * mp->m_sb.sb_agcount); 1661da177e4SLinus Torvalds } 1671da177e4SLinus Torvalds 168287f3dadSDonald Douwsma spinlock_destroy(&mp->m_ail_lock); 1691da177e4SLinus Torvalds spinlock_destroy(&mp->m_sb_lock); 1701da177e4SLinus Torvalds mutex_destroy(&mp->m_ilock); 171cc92e7acSChristoph Hellwig mutex_destroy(&mp->m_growlock); 1721da177e4SLinus Torvalds if (mp->m_quotainfo) 1731da177e4SLinus Torvalds XFS_QM_DONE(mp); 1741da177e4SLinus Torvalds 1751da177e4SLinus Torvalds if (mp->m_fsname != NULL) 1761da177e4SLinus Torvalds kmem_free(mp->m_fsname, mp->m_fsname_len); 177fc1f8c1cSNathan Scott if (mp->m_rtname != NULL) 178fc1f8c1cSNathan Scott kmem_free(mp->m_rtname, strlen(mp->m_rtname) + 1); 179fc1f8c1cSNathan Scott if (mp->m_logname != NULL) 180fc1f8c1cSNathan Scott kmem_free(mp->m_logname, strlen(mp->m_logname) + 1); 1811da177e4SLinus Torvalds 1828d280b98SDavid Chinner xfs_icsb_destroy_counters(mp); 1831da177e4SLinus Torvalds } 1841da177e4SLinus Torvalds 1854cc929eeSNathan Scott /* 1864cc929eeSNathan Scott * Check size of device based on the (data/realtime) block count. 1874cc929eeSNathan Scott * Note: this check is used by the growfs code as well as mount. 1884cc929eeSNathan Scott */ 1894cc929eeSNathan Scott int 1904cc929eeSNathan Scott xfs_sb_validate_fsb_count( 1914cc929eeSNathan Scott xfs_sb_t *sbp, 1924cc929eeSNathan Scott __uint64_t nblocks) 1934cc929eeSNathan Scott { 1944cc929eeSNathan Scott ASSERT(PAGE_SHIFT >= sbp->sb_blocklog); 1954cc929eeSNathan Scott ASSERT(sbp->sb_blocklog >= BBSHIFT); 1964cc929eeSNathan Scott 1974cc929eeSNathan Scott #if XFS_BIG_BLKNOS /* Limited by ULONG_MAX of page cache index */ 1984cc929eeSNathan Scott if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX) 1994cc929eeSNathan Scott return E2BIG; 2004cc929eeSNathan Scott #else /* Limited by UINT_MAX of sectors */ 2014cc929eeSNathan Scott if (nblocks << (sbp->sb_blocklog - BBSHIFT) > UINT_MAX) 2024cc929eeSNathan Scott return E2BIG; 2034cc929eeSNathan Scott #endif 2044cc929eeSNathan Scott return 0; 2054cc929eeSNathan Scott } 2061da177e4SLinus Torvalds 2071da177e4SLinus Torvalds /* 2081da177e4SLinus Torvalds * Check the validity of the SB found. 2091da177e4SLinus Torvalds */ 2101da177e4SLinus Torvalds STATIC int 2111da177e4SLinus Torvalds xfs_mount_validate_sb( 2121da177e4SLinus Torvalds xfs_mount_t *mp, 213764d1f89SNathan Scott xfs_sb_t *sbp, 214764d1f89SNathan Scott int flags) 2151da177e4SLinus Torvalds { 2161da177e4SLinus Torvalds /* 2171da177e4SLinus Torvalds * If the log device and data device have the 2181da177e4SLinus Torvalds * same device number, the log is internal. 2191da177e4SLinus Torvalds * Consequently, the sb_logstart should be non-zero. If 2201da177e4SLinus Torvalds * we have a zero sb_logstart in this case, we may be trying to mount 2211da177e4SLinus Torvalds * a volume filesystem in a non-volume manner. 2221da177e4SLinus Torvalds */ 2231da177e4SLinus Torvalds if (sbp->sb_magicnum != XFS_SB_MAGIC) { 224764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "bad magic number"); 2251da177e4SLinus Torvalds return XFS_ERROR(EWRONGFS); 2261da177e4SLinus Torvalds } 2271da177e4SLinus Torvalds 228*62118709SEric Sandeen if (!xfs_sb_good_version(sbp)) { 229764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "bad version"); 2301da177e4SLinus Torvalds return XFS_ERROR(EWRONGFS); 2311da177e4SLinus Torvalds } 2321da177e4SLinus Torvalds 2331da177e4SLinus Torvalds if (unlikely( 2341da177e4SLinus Torvalds sbp->sb_logstart == 0 && mp->m_logdev_targp == mp->m_ddev_targp)) { 235764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 236764d1f89SNathan Scott "filesystem is marked as having an external log; " 2371da177e4SLinus Torvalds "specify logdev on the\nmount command line."); 238764d1f89SNathan Scott return XFS_ERROR(EINVAL); 2391da177e4SLinus Torvalds } 2401da177e4SLinus Torvalds 2411da177e4SLinus Torvalds if (unlikely( 2421da177e4SLinus Torvalds sbp->sb_logstart != 0 && mp->m_logdev_targp != mp->m_ddev_targp)) { 243764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 244764d1f89SNathan Scott "filesystem is marked as having an internal log; " 245764d1f89SNathan Scott "do not specify logdev on\nthe mount command line."); 246764d1f89SNathan Scott return XFS_ERROR(EINVAL); 2471da177e4SLinus Torvalds } 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds /* 2501da177e4SLinus Torvalds * More sanity checking. These were stolen directly from 2511da177e4SLinus Torvalds * xfs_repair. 2521da177e4SLinus Torvalds */ 2531da177e4SLinus Torvalds if (unlikely( 2541da177e4SLinus Torvalds sbp->sb_agcount <= 0 || 2551da177e4SLinus Torvalds sbp->sb_sectsize < XFS_MIN_SECTORSIZE || 2561da177e4SLinus Torvalds sbp->sb_sectsize > XFS_MAX_SECTORSIZE || 2571da177e4SLinus Torvalds sbp->sb_sectlog < XFS_MIN_SECTORSIZE_LOG || 2581da177e4SLinus Torvalds sbp->sb_sectlog > XFS_MAX_SECTORSIZE_LOG || 2591da177e4SLinus Torvalds sbp->sb_blocksize < XFS_MIN_BLOCKSIZE || 2601da177e4SLinus Torvalds sbp->sb_blocksize > XFS_MAX_BLOCKSIZE || 2611da177e4SLinus Torvalds sbp->sb_blocklog < XFS_MIN_BLOCKSIZE_LOG || 2621da177e4SLinus Torvalds sbp->sb_blocklog > XFS_MAX_BLOCKSIZE_LOG || 2631da177e4SLinus Torvalds sbp->sb_inodesize < XFS_DINODE_MIN_SIZE || 2641da177e4SLinus Torvalds sbp->sb_inodesize > XFS_DINODE_MAX_SIZE || 2659f989c94SNathan Scott sbp->sb_inodelog < XFS_DINODE_MIN_LOG || 2669f989c94SNathan Scott sbp->sb_inodelog > XFS_DINODE_MAX_LOG || 2679f989c94SNathan Scott (sbp->sb_blocklog - sbp->sb_inodelog != sbp->sb_inopblog) || 2681da177e4SLinus Torvalds (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE) || 2691da177e4SLinus Torvalds (sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE) || 270e50bd16fSNathan Scott (sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */))) { 271764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB sanity check 1 failed"); 2721da177e4SLinus Torvalds return XFS_ERROR(EFSCORRUPTED); 2731da177e4SLinus Torvalds } 2741da177e4SLinus Torvalds 2751da177e4SLinus Torvalds /* 2761da177e4SLinus Torvalds * Sanity check AG count, size fields against data size field 2771da177e4SLinus Torvalds */ 2781da177e4SLinus Torvalds if (unlikely( 2791da177e4SLinus Torvalds sbp->sb_dblocks == 0 || 2801da177e4SLinus Torvalds sbp->sb_dblocks > 2811da177e4SLinus Torvalds (xfs_drfsbno_t)sbp->sb_agcount * sbp->sb_agblocks || 2821da177e4SLinus Torvalds sbp->sb_dblocks < (xfs_drfsbno_t)(sbp->sb_agcount - 1) * 2831da177e4SLinus Torvalds sbp->sb_agblocks + XFS_MIN_AG_BLOCKS)) { 284764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB sanity check 2 failed"); 2851da177e4SLinus Torvalds return XFS_ERROR(EFSCORRUPTED); 2861da177e4SLinus Torvalds } 2871da177e4SLinus Torvalds 2884cc929eeSNathan Scott if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) || 2894cc929eeSNathan Scott xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) { 290764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 291764d1f89SNathan Scott "file system too large to be mounted on this system."); 2921da177e4SLinus Torvalds return XFS_ERROR(E2BIG); 2931da177e4SLinus Torvalds } 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds if (unlikely(sbp->sb_inprogress)) { 296764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "file system busy"); 2971da177e4SLinus Torvalds return XFS_ERROR(EFSCORRUPTED); 2981da177e4SLinus Torvalds } 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds /* 301de20614bSNathan Scott * Version 1 directory format has never worked on Linux. 302de20614bSNathan Scott */ 303*62118709SEric Sandeen if (unlikely(!xfs_sb_version_hasdirv2(sbp))) { 304764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 305764d1f89SNathan Scott "file system using version 1 directory format"); 306de20614bSNathan Scott return XFS_ERROR(ENOSYS); 307de20614bSNathan Scott } 308de20614bSNathan Scott 309de20614bSNathan Scott /* 3101da177e4SLinus Torvalds * Until this is fixed only page-sized or smaller data blocks work. 3111da177e4SLinus Torvalds */ 3121da177e4SLinus Torvalds if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) { 313764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 314764d1f89SNathan Scott "file system with blocksize %d bytes", 3151da177e4SLinus Torvalds sbp->sb_blocksize); 316764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 317764d1f89SNathan Scott "only pagesize (%ld) or less will currently work.", 3181da177e4SLinus Torvalds PAGE_SIZE); 3191da177e4SLinus Torvalds return XFS_ERROR(ENOSYS); 3201da177e4SLinus Torvalds } 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds return 0; 3231da177e4SLinus Torvalds } 3241da177e4SLinus Torvalds 325da353b0dSDavid Chinner STATIC void 326da353b0dSDavid Chinner xfs_initialize_perag_icache( 327da353b0dSDavid Chinner xfs_perag_t *pag) 328da353b0dSDavid Chinner { 329da353b0dSDavid Chinner if (!pag->pag_ici_init) { 330da353b0dSDavid Chinner rwlock_init(&pag->pag_ici_lock); 331da353b0dSDavid Chinner INIT_RADIX_TREE(&pag->pag_ici_root, GFP_ATOMIC); 332da353b0dSDavid Chinner pag->pag_ici_init = 1; 333da353b0dSDavid Chinner } 334da353b0dSDavid Chinner } 335da353b0dSDavid Chinner 3361da177e4SLinus Torvalds xfs_agnumber_t 337c11e2c36SNathan Scott xfs_initialize_perag( 338c11e2c36SNathan Scott xfs_mount_t *mp, 339c11e2c36SNathan Scott xfs_agnumber_t agcount) 3401da177e4SLinus Torvalds { 3411da177e4SLinus Torvalds xfs_agnumber_t index, max_metadata; 3421da177e4SLinus Torvalds xfs_perag_t *pag; 3431da177e4SLinus Torvalds xfs_agino_t agino; 3441da177e4SLinus Torvalds xfs_ino_t ino; 3451da177e4SLinus Torvalds xfs_sb_t *sbp = &mp->m_sb; 3461da177e4SLinus Torvalds xfs_ino_t max_inum = XFS_MAXINUMBER_32; 3471da177e4SLinus Torvalds 3481da177e4SLinus Torvalds /* Check to see if the filesystem can overflow 32 bit inodes */ 3491da177e4SLinus Torvalds agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0); 3501da177e4SLinus Torvalds ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino); 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds /* Clear the mount flag if no inode can overflow 32 bits 3531da177e4SLinus Torvalds * on this filesystem, or if specifically requested.. 3541da177e4SLinus Torvalds */ 355bd186aa9SChristoph Hellwig if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > max_inum) { 3561da177e4SLinus Torvalds mp->m_flags |= XFS_MOUNT_32BITINODES; 3571da177e4SLinus Torvalds } else { 3581da177e4SLinus Torvalds mp->m_flags &= ~XFS_MOUNT_32BITINODES; 3591da177e4SLinus Torvalds } 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds /* If we can overflow then setup the ag headers accordingly */ 3621da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_32BITINODES) { 3631da177e4SLinus Torvalds /* Calculate how much should be reserved for inodes to 3641da177e4SLinus Torvalds * meet the max inode percentage. 3651da177e4SLinus Torvalds */ 3661da177e4SLinus Torvalds if (mp->m_maxicount) { 3671da177e4SLinus Torvalds __uint64_t icount; 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds icount = sbp->sb_dblocks * sbp->sb_imax_pct; 3701da177e4SLinus Torvalds do_div(icount, 100); 3711da177e4SLinus Torvalds icount += sbp->sb_agblocks - 1; 372a749ee86SEric Sandeen do_div(icount, sbp->sb_agblocks); 3731da177e4SLinus Torvalds max_metadata = icount; 3741da177e4SLinus Torvalds } else { 3751da177e4SLinus Torvalds max_metadata = agcount; 3761da177e4SLinus Torvalds } 3771da177e4SLinus Torvalds for (index = 0; index < agcount; index++) { 3781da177e4SLinus Torvalds ino = XFS_AGINO_TO_INO(mp, index, agino); 3791da177e4SLinus Torvalds if (ino > max_inum) { 3801da177e4SLinus Torvalds index++; 3811da177e4SLinus Torvalds break; 3821da177e4SLinus Torvalds } 3831da177e4SLinus Torvalds 384c41564b5SNathan Scott /* This ag is preferred for inodes */ 3851da177e4SLinus Torvalds pag = &mp->m_perag[index]; 3861da177e4SLinus Torvalds pag->pagi_inodeok = 1; 3871da177e4SLinus Torvalds if (index < max_metadata) 3881da177e4SLinus Torvalds pag->pagf_metadata = 1; 389da353b0dSDavid Chinner xfs_initialize_perag_icache(pag); 3901da177e4SLinus Torvalds } 3911da177e4SLinus Torvalds } else { 3921da177e4SLinus Torvalds /* Setup default behavior for smaller filesystems */ 3931da177e4SLinus Torvalds for (index = 0; index < agcount; index++) { 3941da177e4SLinus Torvalds pag = &mp->m_perag[index]; 3951da177e4SLinus Torvalds pag->pagi_inodeok = 1; 396da353b0dSDavid Chinner xfs_initialize_perag_icache(pag); 3971da177e4SLinus Torvalds } 3981da177e4SLinus Torvalds } 3991da177e4SLinus Torvalds return index; 4001da177e4SLinus Torvalds } 4011da177e4SLinus Torvalds 4022bdf7cd0SChristoph Hellwig void 4032bdf7cd0SChristoph Hellwig xfs_sb_from_disk( 4042bdf7cd0SChristoph Hellwig xfs_sb_t *to, 4052bdf7cd0SChristoph Hellwig xfs_dsb_t *from) 4062bdf7cd0SChristoph Hellwig { 4072bdf7cd0SChristoph Hellwig to->sb_magicnum = be32_to_cpu(from->sb_magicnum); 4082bdf7cd0SChristoph Hellwig to->sb_blocksize = be32_to_cpu(from->sb_blocksize); 4092bdf7cd0SChristoph Hellwig to->sb_dblocks = be64_to_cpu(from->sb_dblocks); 4102bdf7cd0SChristoph Hellwig to->sb_rblocks = be64_to_cpu(from->sb_rblocks); 4112bdf7cd0SChristoph Hellwig to->sb_rextents = be64_to_cpu(from->sb_rextents); 4122bdf7cd0SChristoph Hellwig memcpy(&to->sb_uuid, &from->sb_uuid, sizeof(to->sb_uuid)); 4132bdf7cd0SChristoph Hellwig to->sb_logstart = be64_to_cpu(from->sb_logstart); 4142bdf7cd0SChristoph Hellwig to->sb_rootino = be64_to_cpu(from->sb_rootino); 4152bdf7cd0SChristoph Hellwig to->sb_rbmino = be64_to_cpu(from->sb_rbmino); 4162bdf7cd0SChristoph Hellwig to->sb_rsumino = be64_to_cpu(from->sb_rsumino); 4172bdf7cd0SChristoph Hellwig to->sb_rextsize = be32_to_cpu(from->sb_rextsize); 4182bdf7cd0SChristoph Hellwig to->sb_agblocks = be32_to_cpu(from->sb_agblocks); 4192bdf7cd0SChristoph Hellwig to->sb_agcount = be32_to_cpu(from->sb_agcount); 4202bdf7cd0SChristoph Hellwig to->sb_rbmblocks = be32_to_cpu(from->sb_rbmblocks); 4212bdf7cd0SChristoph Hellwig to->sb_logblocks = be32_to_cpu(from->sb_logblocks); 4222bdf7cd0SChristoph Hellwig to->sb_versionnum = be16_to_cpu(from->sb_versionnum); 4232bdf7cd0SChristoph Hellwig to->sb_sectsize = be16_to_cpu(from->sb_sectsize); 4242bdf7cd0SChristoph Hellwig to->sb_inodesize = be16_to_cpu(from->sb_inodesize); 4252bdf7cd0SChristoph Hellwig to->sb_inopblock = be16_to_cpu(from->sb_inopblock); 4262bdf7cd0SChristoph Hellwig memcpy(&to->sb_fname, &from->sb_fname, sizeof(to->sb_fname)); 4272bdf7cd0SChristoph Hellwig to->sb_blocklog = from->sb_blocklog; 4282bdf7cd0SChristoph Hellwig to->sb_sectlog = from->sb_sectlog; 4292bdf7cd0SChristoph Hellwig to->sb_inodelog = from->sb_inodelog; 4302bdf7cd0SChristoph Hellwig to->sb_inopblog = from->sb_inopblog; 4312bdf7cd0SChristoph Hellwig to->sb_agblklog = from->sb_agblklog; 4322bdf7cd0SChristoph Hellwig to->sb_rextslog = from->sb_rextslog; 4332bdf7cd0SChristoph Hellwig to->sb_inprogress = from->sb_inprogress; 4342bdf7cd0SChristoph Hellwig to->sb_imax_pct = from->sb_imax_pct; 4352bdf7cd0SChristoph Hellwig to->sb_icount = be64_to_cpu(from->sb_icount); 4362bdf7cd0SChristoph Hellwig to->sb_ifree = be64_to_cpu(from->sb_ifree); 4372bdf7cd0SChristoph Hellwig to->sb_fdblocks = be64_to_cpu(from->sb_fdblocks); 4382bdf7cd0SChristoph Hellwig to->sb_frextents = be64_to_cpu(from->sb_frextents); 4392bdf7cd0SChristoph Hellwig to->sb_uquotino = be64_to_cpu(from->sb_uquotino); 4402bdf7cd0SChristoph Hellwig to->sb_gquotino = be64_to_cpu(from->sb_gquotino); 4412bdf7cd0SChristoph Hellwig to->sb_qflags = be16_to_cpu(from->sb_qflags); 4422bdf7cd0SChristoph Hellwig to->sb_flags = from->sb_flags; 4432bdf7cd0SChristoph Hellwig to->sb_shared_vn = from->sb_shared_vn; 4442bdf7cd0SChristoph Hellwig to->sb_inoalignmt = be32_to_cpu(from->sb_inoalignmt); 4452bdf7cd0SChristoph Hellwig to->sb_unit = be32_to_cpu(from->sb_unit); 4462bdf7cd0SChristoph Hellwig to->sb_width = be32_to_cpu(from->sb_width); 4472bdf7cd0SChristoph Hellwig to->sb_dirblklog = from->sb_dirblklog; 4482bdf7cd0SChristoph Hellwig to->sb_logsectlog = from->sb_logsectlog; 4492bdf7cd0SChristoph Hellwig to->sb_logsectsize = be16_to_cpu(from->sb_logsectsize); 4502bdf7cd0SChristoph Hellwig to->sb_logsunit = be32_to_cpu(from->sb_logsunit); 4512bdf7cd0SChristoph Hellwig to->sb_features2 = be32_to_cpu(from->sb_features2); 4522bdf7cd0SChristoph Hellwig } 4532bdf7cd0SChristoph Hellwig 4541da177e4SLinus Torvalds /* 4552bdf7cd0SChristoph Hellwig * Copy in core superblock to ondisk one. 4561da177e4SLinus Torvalds * 4572bdf7cd0SChristoph Hellwig * The fields argument is mask of superblock fields to copy. 4581da177e4SLinus Torvalds */ 4591da177e4SLinus Torvalds void 4602bdf7cd0SChristoph Hellwig xfs_sb_to_disk( 4612bdf7cd0SChristoph Hellwig xfs_dsb_t *to, 4622bdf7cd0SChristoph Hellwig xfs_sb_t *from, 4631da177e4SLinus Torvalds __int64_t fields) 4641da177e4SLinus Torvalds { 4652bdf7cd0SChristoph Hellwig xfs_caddr_t to_ptr = (xfs_caddr_t)to; 4662bdf7cd0SChristoph Hellwig xfs_caddr_t from_ptr = (xfs_caddr_t)from; 4671da177e4SLinus Torvalds xfs_sb_field_t f; 4681da177e4SLinus Torvalds int first; 4691da177e4SLinus Torvalds int size; 4701da177e4SLinus Torvalds 4711da177e4SLinus Torvalds ASSERT(fields); 4721da177e4SLinus Torvalds if (!fields) 4731da177e4SLinus Torvalds return; 4741da177e4SLinus Torvalds 4751da177e4SLinus Torvalds while (fields) { 4761da177e4SLinus Torvalds f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields); 4771da177e4SLinus Torvalds first = xfs_sb_info[f].offset; 4781da177e4SLinus Torvalds size = xfs_sb_info[f + 1].offset - first; 4791da177e4SLinus Torvalds 4801da177e4SLinus Torvalds ASSERT(xfs_sb_info[f].type == 0 || xfs_sb_info[f].type == 1); 4811da177e4SLinus Torvalds 4821da177e4SLinus Torvalds if (size == 1 || xfs_sb_info[f].type == 1) { 4832bdf7cd0SChristoph Hellwig memcpy(to_ptr + first, from_ptr + first, size); 4841da177e4SLinus Torvalds } else { 4851da177e4SLinus Torvalds switch (size) { 4861da177e4SLinus Torvalds case 2: 4872bdf7cd0SChristoph Hellwig *(__be16 *)(to_ptr + first) = 4882bdf7cd0SChristoph Hellwig cpu_to_be16(*(__u16 *)(from_ptr + first)); 4891da177e4SLinus Torvalds break; 4901da177e4SLinus Torvalds case 4: 4912bdf7cd0SChristoph Hellwig *(__be32 *)(to_ptr + first) = 4922bdf7cd0SChristoph Hellwig cpu_to_be32(*(__u32 *)(from_ptr + first)); 4931da177e4SLinus Torvalds break; 4941da177e4SLinus Torvalds case 8: 4952bdf7cd0SChristoph Hellwig *(__be64 *)(to_ptr + first) = 4962bdf7cd0SChristoph Hellwig cpu_to_be64(*(__u64 *)(from_ptr + first)); 4971da177e4SLinus Torvalds break; 4981da177e4SLinus Torvalds default: 4991da177e4SLinus Torvalds ASSERT(0); 5001da177e4SLinus Torvalds } 5011da177e4SLinus Torvalds } 5021da177e4SLinus Torvalds 5031da177e4SLinus Torvalds fields &= ~(1LL << f); 5041da177e4SLinus Torvalds } 5051da177e4SLinus Torvalds } 5061da177e4SLinus Torvalds 5071da177e4SLinus Torvalds /* 5081da177e4SLinus Torvalds * xfs_readsb 5091da177e4SLinus Torvalds * 5101da177e4SLinus Torvalds * Does the initial read of the superblock. 5111da177e4SLinus Torvalds */ 5121da177e4SLinus Torvalds int 513764d1f89SNathan Scott xfs_readsb(xfs_mount_t *mp, int flags) 5141da177e4SLinus Torvalds { 5151da177e4SLinus Torvalds unsigned int sector_size; 5161da177e4SLinus Torvalds unsigned int extra_flags; 5171da177e4SLinus Torvalds xfs_buf_t *bp; 5181da177e4SLinus Torvalds int error; 5191da177e4SLinus Torvalds 5201da177e4SLinus Torvalds ASSERT(mp->m_sb_bp == NULL); 5211da177e4SLinus Torvalds ASSERT(mp->m_ddev_targp != NULL); 5221da177e4SLinus Torvalds 5231da177e4SLinus Torvalds /* 5241da177e4SLinus Torvalds * Allocate a (locked) buffer to hold the superblock. 5251da177e4SLinus Torvalds * This will be kept around at all times to optimize 5261da177e4SLinus Torvalds * access to the superblock. 5271da177e4SLinus Torvalds */ 5281da177e4SLinus Torvalds sector_size = xfs_getsize_buftarg(mp->m_ddev_targp); 5291da177e4SLinus Torvalds extra_flags = XFS_BUF_LOCK | XFS_BUF_MANAGE | XFS_BUF_MAPPED; 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR, 5321da177e4SLinus Torvalds BTOBB(sector_size), extra_flags); 5331da177e4SLinus Torvalds if (!bp || XFS_BUF_ISERROR(bp)) { 534764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB read failed"); 5351da177e4SLinus Torvalds error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM; 5361da177e4SLinus Torvalds goto fail; 5371da177e4SLinus Torvalds } 5381da177e4SLinus Torvalds ASSERT(XFS_BUF_ISBUSY(bp)); 5391da177e4SLinus Torvalds ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); 5401da177e4SLinus Torvalds 5411da177e4SLinus Torvalds /* 5421da177e4SLinus Torvalds * Initialize the mount structure from the superblock. 5431da177e4SLinus Torvalds * But first do some basic consistency checking. 5441da177e4SLinus Torvalds */ 5452bdf7cd0SChristoph Hellwig xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp)); 5461da177e4SLinus Torvalds 547764d1f89SNathan Scott error = xfs_mount_validate_sb(mp, &(mp->m_sb), flags); 5481da177e4SLinus Torvalds if (error) { 549764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB validate failed"); 5501da177e4SLinus Torvalds goto fail; 5511da177e4SLinus Torvalds } 5521da177e4SLinus Torvalds 5531da177e4SLinus Torvalds /* 5541da177e4SLinus Torvalds * We must be able to do sector-sized and sector-aligned IO. 5551da177e4SLinus Torvalds */ 5561da177e4SLinus Torvalds if (sector_size > mp->m_sb.sb_sectsize) { 557764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, 558764d1f89SNathan Scott "device supports only %u byte sectors (not %u)", 5591da177e4SLinus Torvalds sector_size, mp->m_sb.sb_sectsize); 5601da177e4SLinus Torvalds error = ENOSYS; 5611da177e4SLinus Torvalds goto fail; 5621da177e4SLinus Torvalds } 5631da177e4SLinus Torvalds 5641da177e4SLinus Torvalds /* 5651da177e4SLinus Torvalds * If device sector size is smaller than the superblock size, 5661da177e4SLinus Torvalds * re-read the superblock so the buffer is correctly sized. 5671da177e4SLinus Torvalds */ 5681da177e4SLinus Torvalds if (sector_size < mp->m_sb.sb_sectsize) { 5691da177e4SLinus Torvalds XFS_BUF_UNMANAGE(bp); 5701da177e4SLinus Torvalds xfs_buf_relse(bp); 5711da177e4SLinus Torvalds sector_size = mp->m_sb.sb_sectsize; 5721da177e4SLinus Torvalds bp = xfs_buf_read_flags(mp->m_ddev_targp, XFS_SB_DADDR, 5731da177e4SLinus Torvalds BTOBB(sector_size), extra_flags); 5741da177e4SLinus Torvalds if (!bp || XFS_BUF_ISERROR(bp)) { 575764d1f89SNathan Scott xfs_fs_mount_cmn_err(flags, "SB re-read failed"); 5761da177e4SLinus Torvalds error = bp ? XFS_BUF_GETERROR(bp) : ENOMEM; 5771da177e4SLinus Torvalds goto fail; 5781da177e4SLinus Torvalds } 5791da177e4SLinus Torvalds ASSERT(XFS_BUF_ISBUSY(bp)); 5801da177e4SLinus Torvalds ASSERT(XFS_BUF_VALUSEMA(bp) <= 0); 5811da177e4SLinus Torvalds } 5821da177e4SLinus Torvalds 5835478eeadSLachlan McIlroy /* Initialize per-cpu counters */ 5845478eeadSLachlan McIlroy xfs_icsb_reinit_counters(mp); 5858d280b98SDavid Chinner 5861da177e4SLinus Torvalds mp->m_sb_bp = bp; 5871da177e4SLinus Torvalds xfs_buf_relse(bp); 5881da177e4SLinus Torvalds ASSERT(XFS_BUF_VALUSEMA(bp) > 0); 5891da177e4SLinus Torvalds return 0; 5901da177e4SLinus Torvalds 5911da177e4SLinus Torvalds fail: 5921da177e4SLinus Torvalds if (bp) { 5931da177e4SLinus Torvalds XFS_BUF_UNMANAGE(bp); 5941da177e4SLinus Torvalds xfs_buf_relse(bp); 5951da177e4SLinus Torvalds } 5961da177e4SLinus Torvalds return error; 5971da177e4SLinus Torvalds } 5981da177e4SLinus Torvalds 5991da177e4SLinus Torvalds 6001da177e4SLinus Torvalds /* 6011da177e4SLinus Torvalds * xfs_mount_common 6021da177e4SLinus Torvalds * 6031da177e4SLinus Torvalds * Mount initialization code establishing various mount 6041da177e4SLinus Torvalds * fields from the superblock associated with the given 6051da177e4SLinus Torvalds * mount structure 6061da177e4SLinus Torvalds */ 607ba0f32d4SChristoph Hellwig STATIC void 6081da177e4SLinus Torvalds xfs_mount_common(xfs_mount_t *mp, xfs_sb_t *sbp) 6091da177e4SLinus Torvalds { 6101da177e4SLinus Torvalds int i; 6111da177e4SLinus Torvalds 6121da177e4SLinus Torvalds mp->m_agfrotor = mp->m_agirotor = 0; 613007c61c6SEric Sandeen spin_lock_init(&mp->m_agirotor_lock); 6141da177e4SLinus Torvalds mp->m_maxagi = mp->m_sb.sb_agcount; 6151da177e4SLinus Torvalds mp->m_blkbit_log = sbp->sb_blocklog + XFS_NBBYLOG; 6161da177e4SLinus Torvalds mp->m_blkbb_log = sbp->sb_blocklog - BBSHIFT; 6171da177e4SLinus Torvalds mp->m_sectbb_log = sbp->sb_sectlog - BBSHIFT; 6181da177e4SLinus Torvalds mp->m_agno_log = xfs_highbit32(sbp->sb_agcount - 1) + 1; 6191da177e4SLinus Torvalds mp->m_agino_log = sbp->sb_inopblog + sbp->sb_agblklog; 6201da177e4SLinus Torvalds mp->m_litino = sbp->sb_inodesize - 6211da177e4SLinus Torvalds ((uint)sizeof(xfs_dinode_core_t) + (uint)sizeof(xfs_agino_t)); 6221da177e4SLinus Torvalds mp->m_blockmask = sbp->sb_blocksize - 1; 6231da177e4SLinus Torvalds mp->m_blockwsize = sbp->sb_blocksize >> XFS_WORDLOG; 6241da177e4SLinus Torvalds mp->m_blockwmask = mp->m_blockwsize - 1; 6251da177e4SLinus Torvalds INIT_LIST_HEAD(&mp->m_del_inodes); 6261da177e4SLinus Torvalds 6271da177e4SLinus Torvalds /* 6281da177e4SLinus Torvalds * Setup for attributes, in case they get created. 6291da177e4SLinus Torvalds * This value is for inodes getting attributes for the first time, 6301da177e4SLinus Torvalds * the per-inode value is for old attribute values. 6311da177e4SLinus Torvalds */ 6321da177e4SLinus Torvalds ASSERT(sbp->sb_inodesize >= 256 && sbp->sb_inodesize <= 2048); 6331da177e4SLinus Torvalds switch (sbp->sb_inodesize) { 6341da177e4SLinus Torvalds case 256: 635d8cc890dSNathan Scott mp->m_attroffset = XFS_LITINO(mp) - 636d8cc890dSNathan Scott XFS_BMDR_SPACE_CALC(MINABTPTRS); 6371da177e4SLinus Torvalds break; 6381da177e4SLinus Torvalds case 512: 6391da177e4SLinus Torvalds case 1024: 6401da177e4SLinus Torvalds case 2048: 641d8cc890dSNathan Scott mp->m_attroffset = XFS_BMDR_SPACE_CALC(6 * MINABTPTRS); 6421da177e4SLinus Torvalds break; 6431da177e4SLinus Torvalds default: 6441da177e4SLinus Torvalds ASSERT(0); 6451da177e4SLinus Torvalds } 6461da177e4SLinus Torvalds ASSERT(mp->m_attroffset < XFS_LITINO(mp)); 6471da177e4SLinus Torvalds 6481da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 6491da177e4SLinus Torvalds mp->m_alloc_mxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize, 6501da177e4SLinus Torvalds xfs_alloc, i == 0); 6511da177e4SLinus Torvalds mp->m_alloc_mnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize, 6521da177e4SLinus Torvalds xfs_alloc, i == 0); 6531da177e4SLinus Torvalds } 6541da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 6551da177e4SLinus Torvalds mp->m_bmap_dmxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize, 6561da177e4SLinus Torvalds xfs_bmbt, i == 0); 6571da177e4SLinus Torvalds mp->m_bmap_dmnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize, 6581da177e4SLinus Torvalds xfs_bmbt, i == 0); 6591da177e4SLinus Torvalds } 6601da177e4SLinus Torvalds for (i = 0; i < 2; i++) { 6611da177e4SLinus Torvalds mp->m_inobt_mxr[i] = XFS_BTREE_BLOCK_MAXRECS(sbp->sb_blocksize, 6621da177e4SLinus Torvalds xfs_inobt, i == 0); 6631da177e4SLinus Torvalds mp->m_inobt_mnr[i] = XFS_BTREE_BLOCK_MINRECS(sbp->sb_blocksize, 6641da177e4SLinus Torvalds xfs_inobt, i == 0); 6651da177e4SLinus Torvalds } 6661da177e4SLinus Torvalds 6671da177e4SLinus Torvalds mp->m_bsize = XFS_FSB_TO_BB(mp, 1); 6681da177e4SLinus Torvalds mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK, 6691da177e4SLinus Torvalds sbp->sb_inopblock); 6701da177e4SLinus Torvalds mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog; 6711da177e4SLinus Torvalds } 67292821e2bSDavid Chinner 67392821e2bSDavid Chinner /* 67492821e2bSDavid Chinner * xfs_initialize_perag_data 67592821e2bSDavid Chinner * 67692821e2bSDavid Chinner * Read in each per-ag structure so we can count up the number of 67792821e2bSDavid Chinner * allocated inodes, free inodes and used filesystem blocks as this 67892821e2bSDavid Chinner * information is no longer persistent in the superblock. Once we have 67992821e2bSDavid Chinner * this information, write it into the in-core superblock structure. 68092821e2bSDavid Chinner */ 68192821e2bSDavid Chinner STATIC int 68292821e2bSDavid Chinner xfs_initialize_perag_data(xfs_mount_t *mp, xfs_agnumber_t agcount) 68392821e2bSDavid Chinner { 68492821e2bSDavid Chinner xfs_agnumber_t index; 68592821e2bSDavid Chinner xfs_perag_t *pag; 68692821e2bSDavid Chinner xfs_sb_t *sbp = &mp->m_sb; 68792821e2bSDavid Chinner uint64_t ifree = 0; 68892821e2bSDavid Chinner uint64_t ialloc = 0; 68992821e2bSDavid Chinner uint64_t bfree = 0; 69092821e2bSDavid Chinner uint64_t bfreelst = 0; 69192821e2bSDavid Chinner uint64_t btree = 0; 69292821e2bSDavid Chinner int error; 69392821e2bSDavid Chinner 69492821e2bSDavid Chinner for (index = 0; index < agcount; index++) { 69592821e2bSDavid Chinner /* 69692821e2bSDavid Chinner * read the agf, then the agi. This gets us 69792821e2bSDavid Chinner * all the inforamtion we need and populates the 69892821e2bSDavid Chinner * per-ag structures for us. 69992821e2bSDavid Chinner */ 70092821e2bSDavid Chinner error = xfs_alloc_pagf_init(mp, NULL, index, 0); 70192821e2bSDavid Chinner if (error) 70292821e2bSDavid Chinner return error; 70392821e2bSDavid Chinner 70492821e2bSDavid Chinner error = xfs_ialloc_pagi_init(mp, NULL, index); 70592821e2bSDavid Chinner if (error) 70692821e2bSDavid Chinner return error; 70792821e2bSDavid Chinner pag = &mp->m_perag[index]; 70892821e2bSDavid Chinner ifree += pag->pagi_freecount; 70992821e2bSDavid Chinner ialloc += pag->pagi_count; 71092821e2bSDavid Chinner bfree += pag->pagf_freeblks; 71192821e2bSDavid Chinner bfreelst += pag->pagf_flcount; 71292821e2bSDavid Chinner btree += pag->pagf_btreeblks; 71392821e2bSDavid Chinner } 71492821e2bSDavid Chinner /* 71592821e2bSDavid Chinner * Overwrite incore superblock counters with just-read data 71692821e2bSDavid Chinner */ 7173685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 71892821e2bSDavid Chinner sbp->sb_ifree = ifree; 71992821e2bSDavid Chinner sbp->sb_icount = ialloc; 72092821e2bSDavid Chinner sbp->sb_fdblocks = bfree + bfreelst + btree; 7213685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 72292821e2bSDavid Chinner 72392821e2bSDavid Chinner /* Fixup the per-cpu counters as well. */ 72492821e2bSDavid Chinner xfs_icsb_reinit_counters(mp); 72592821e2bSDavid Chinner 72692821e2bSDavid Chinner return 0; 72792821e2bSDavid Chinner } 72892821e2bSDavid Chinner 7291da177e4SLinus Torvalds /* 7300771fb45SEric Sandeen * Update alignment values based on mount options and sb values 7311da177e4SLinus Torvalds */ 7320771fb45SEric Sandeen STATIC int 7330771fb45SEric Sandeen xfs_update_alignment(xfs_mount_t *mp, int mfsi_flags, __uint64_t *update_flags) 7341da177e4SLinus Torvalds { 7351da177e4SLinus Torvalds xfs_sb_t *sbp = &(mp->m_sb); 7361da177e4SLinus Torvalds 7371da177e4SLinus Torvalds if (mp->m_dalign && !(mfsi_flags & XFS_MFSI_SECOND)) { 7381da177e4SLinus Torvalds /* 7391da177e4SLinus Torvalds * If stripe unit and stripe width are not multiples 7401da177e4SLinus Torvalds * of the fs blocksize turn off alignment. 7411da177e4SLinus Torvalds */ 7421da177e4SLinus Torvalds if ((BBTOB(mp->m_dalign) & mp->m_blockmask) || 7431da177e4SLinus Torvalds (BBTOB(mp->m_swidth) & mp->m_blockmask)) { 7441da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_RETERR) { 7451da177e4SLinus Torvalds cmn_err(CE_WARN, 7461da177e4SLinus Torvalds "XFS: alignment check 1 failed"); 7470771fb45SEric Sandeen return XFS_ERROR(EINVAL); 7481da177e4SLinus Torvalds } 7491da177e4SLinus Torvalds mp->m_dalign = mp->m_swidth = 0; 7501da177e4SLinus Torvalds } else { 7511da177e4SLinus Torvalds /* 7521da177e4SLinus Torvalds * Convert the stripe unit and width to FSBs. 7531da177e4SLinus Torvalds */ 7541da177e4SLinus Torvalds mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign); 7551da177e4SLinus Torvalds if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) { 7561da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_RETERR) { 7570771fb45SEric Sandeen return XFS_ERROR(EINVAL); 7581da177e4SLinus Torvalds } 7591da177e4SLinus Torvalds xfs_fs_cmn_err(CE_WARN, mp, 7601da177e4SLinus Torvalds "stripe alignment turned off: sunit(%d)/swidth(%d) incompatible with agsize(%d)", 7611da177e4SLinus Torvalds mp->m_dalign, mp->m_swidth, 7621da177e4SLinus Torvalds sbp->sb_agblocks); 7631da177e4SLinus Torvalds 7641da177e4SLinus Torvalds mp->m_dalign = 0; 7651da177e4SLinus Torvalds mp->m_swidth = 0; 7661da177e4SLinus Torvalds } else if (mp->m_dalign) { 7671da177e4SLinus Torvalds mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth); 7681da177e4SLinus Torvalds } else { 7691da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_RETERR) { 7701da177e4SLinus Torvalds xfs_fs_cmn_err(CE_WARN, mp, 7711da177e4SLinus Torvalds "stripe alignment turned off: sunit(%d) less than bsize(%d)", 7721da177e4SLinus Torvalds mp->m_dalign, 7731da177e4SLinus Torvalds mp->m_blockmask +1); 7740771fb45SEric Sandeen return XFS_ERROR(EINVAL); 7751da177e4SLinus Torvalds } 7761da177e4SLinus Torvalds mp->m_swidth = 0; 7771da177e4SLinus Torvalds } 7781da177e4SLinus Torvalds } 7791da177e4SLinus Torvalds 7801da177e4SLinus Torvalds /* 7811da177e4SLinus Torvalds * Update superblock with new values 7821da177e4SLinus Torvalds * and log changes 7831da177e4SLinus Torvalds */ 784*62118709SEric Sandeen if (xfs_sb_version_hasdalign(sbp)) { 7851da177e4SLinus Torvalds if (sbp->sb_unit != mp->m_dalign) { 7861da177e4SLinus Torvalds sbp->sb_unit = mp->m_dalign; 7870771fb45SEric Sandeen *update_flags |= XFS_SB_UNIT; 7881da177e4SLinus Torvalds } 7891da177e4SLinus Torvalds if (sbp->sb_width != mp->m_swidth) { 7901da177e4SLinus Torvalds sbp->sb_width = mp->m_swidth; 7910771fb45SEric Sandeen *update_flags |= XFS_SB_WIDTH; 7921da177e4SLinus Torvalds } 7931da177e4SLinus Torvalds } 7941da177e4SLinus Torvalds } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN && 795*62118709SEric Sandeen xfs_sb_version_hasdalign(&mp->m_sb)) { 7961da177e4SLinus Torvalds mp->m_dalign = sbp->sb_unit; 7971da177e4SLinus Torvalds mp->m_swidth = sbp->sb_width; 7981da177e4SLinus Torvalds } 7991da177e4SLinus Torvalds 8000771fb45SEric Sandeen return 0; 8010771fb45SEric Sandeen } 8021da177e4SLinus Torvalds 8030771fb45SEric Sandeen /* 8040771fb45SEric Sandeen * Set the maximum inode count for this filesystem 8050771fb45SEric Sandeen */ 8060771fb45SEric Sandeen STATIC void 8070771fb45SEric Sandeen xfs_set_maxicount(xfs_mount_t *mp) 8080771fb45SEric Sandeen { 8090771fb45SEric Sandeen xfs_sb_t *sbp = &(mp->m_sb); 8101da177e4SLinus Torvalds __uint64_t icount; 8111da177e4SLinus Torvalds 8120771fb45SEric Sandeen if (sbp->sb_imax_pct) { 8130771fb45SEric Sandeen /* 8140771fb45SEric Sandeen * Make sure the maximum inode count is a multiple 8150771fb45SEric Sandeen * of the units we allocate inodes in. 8161da177e4SLinus Torvalds */ 8171da177e4SLinus Torvalds icount = sbp->sb_dblocks * sbp->sb_imax_pct; 8181da177e4SLinus Torvalds do_div(icount, 100); 8191da177e4SLinus Torvalds do_div(icount, mp->m_ialloc_blks); 8201da177e4SLinus Torvalds mp->m_maxicount = (icount * mp->m_ialloc_blks) << 8211da177e4SLinus Torvalds sbp->sb_inopblog; 8220771fb45SEric Sandeen } else { 8231da177e4SLinus Torvalds mp->m_maxicount = 0; 8241da177e4SLinus Torvalds } 8251da177e4SLinus Torvalds } 8261da177e4SLinus Torvalds 8271da177e4SLinus Torvalds /* 8281da177e4SLinus Torvalds * Set the default minimum read and write sizes unless 8291da177e4SLinus Torvalds * already specified in a mount option. 8301da177e4SLinus Torvalds * We use smaller I/O sizes when the file system 8311da177e4SLinus Torvalds * is being used for NFS service (wsync mount option). 8321da177e4SLinus Torvalds */ 8330771fb45SEric Sandeen STATIC void 8340771fb45SEric Sandeen xfs_set_rw_sizes(xfs_mount_t *mp) 8350771fb45SEric Sandeen { 8360771fb45SEric Sandeen xfs_sb_t *sbp = &(mp->m_sb); 8370771fb45SEric Sandeen int readio_log, writeio_log; 8380771fb45SEric Sandeen 8391da177e4SLinus Torvalds if (!(mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)) { 8401da177e4SLinus Torvalds if (mp->m_flags & XFS_MOUNT_WSYNC) { 8411da177e4SLinus Torvalds readio_log = XFS_WSYNC_READIO_LOG; 8421da177e4SLinus Torvalds writeio_log = XFS_WSYNC_WRITEIO_LOG; 8431da177e4SLinus Torvalds } else { 8441da177e4SLinus Torvalds readio_log = XFS_READIO_LOG_LARGE; 8451da177e4SLinus Torvalds writeio_log = XFS_WRITEIO_LOG_LARGE; 8461da177e4SLinus Torvalds } 8471da177e4SLinus Torvalds } else { 8481da177e4SLinus Torvalds readio_log = mp->m_readio_log; 8491da177e4SLinus Torvalds writeio_log = mp->m_writeio_log; 8501da177e4SLinus Torvalds } 8511da177e4SLinus Torvalds 8521da177e4SLinus Torvalds if (sbp->sb_blocklog > readio_log) { 8531da177e4SLinus Torvalds mp->m_readio_log = sbp->sb_blocklog; 8541da177e4SLinus Torvalds } else { 8551da177e4SLinus Torvalds mp->m_readio_log = readio_log; 8561da177e4SLinus Torvalds } 8571da177e4SLinus Torvalds mp->m_readio_blocks = 1 << (mp->m_readio_log - sbp->sb_blocklog); 8581da177e4SLinus Torvalds if (sbp->sb_blocklog > writeio_log) { 8591da177e4SLinus Torvalds mp->m_writeio_log = sbp->sb_blocklog; 8601da177e4SLinus Torvalds } else { 8611da177e4SLinus Torvalds mp->m_writeio_log = writeio_log; 8621da177e4SLinus Torvalds } 8631da177e4SLinus Torvalds mp->m_writeio_blocks = 1 << (mp->m_writeio_log - sbp->sb_blocklog); 8640771fb45SEric Sandeen } 865425f9dddSEric Sandeen 8661da177e4SLinus Torvalds /* 8671da177e4SLinus Torvalds * Set whether we're using inode alignment. 8681da177e4SLinus Torvalds */ 8690771fb45SEric Sandeen STATIC void 8700771fb45SEric Sandeen xfs_set_inoalignment(xfs_mount_t *mp) 8710771fb45SEric Sandeen { 872*62118709SEric Sandeen if (xfs_sb_version_hasalign(&mp->m_sb) && 8731da177e4SLinus Torvalds mp->m_sb.sb_inoalignmt >= 8741da177e4SLinus Torvalds XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size)) 8751da177e4SLinus Torvalds mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1; 8761da177e4SLinus Torvalds else 8771da177e4SLinus Torvalds mp->m_inoalign_mask = 0; 8781da177e4SLinus Torvalds /* 8791da177e4SLinus Torvalds * If we are using stripe alignment, check whether 8801da177e4SLinus Torvalds * the stripe unit is a multiple of the inode alignment 8811da177e4SLinus Torvalds */ 8821da177e4SLinus Torvalds if (mp->m_dalign && mp->m_inoalign_mask && 8831da177e4SLinus Torvalds !(mp->m_dalign & mp->m_inoalign_mask)) 8841da177e4SLinus Torvalds mp->m_sinoalign = mp->m_dalign; 8851da177e4SLinus Torvalds else 8861da177e4SLinus Torvalds mp->m_sinoalign = 0; 8870771fb45SEric Sandeen } 8880771fb45SEric Sandeen 8891da177e4SLinus Torvalds /* 8901da177e4SLinus Torvalds * Check that the data (and log if separate) are an ok size. 8911da177e4SLinus Torvalds */ 8920771fb45SEric Sandeen STATIC int 8930771fb45SEric Sandeen xfs_check_sizes(xfs_mount_t *mp, int mfsi_flags) 8940771fb45SEric Sandeen { 8950771fb45SEric Sandeen xfs_buf_t *bp; 8960771fb45SEric Sandeen xfs_daddr_t d; 8970771fb45SEric Sandeen int error; 8980771fb45SEric Sandeen 8991da177e4SLinus Torvalds d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks); 9001da177e4SLinus Torvalds if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_dblocks) { 9011da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: size check 1 failed"); 9020771fb45SEric Sandeen return XFS_ERROR(E2BIG); 9031da177e4SLinus Torvalds } 9041da177e4SLinus Torvalds error = xfs_read_buf(mp, mp->m_ddev_targp, 9051da177e4SLinus Torvalds d - XFS_FSS_TO_BB(mp, 1), 9061da177e4SLinus Torvalds XFS_FSS_TO_BB(mp, 1), 0, &bp); 9071da177e4SLinus Torvalds if (!error) { 9081da177e4SLinus Torvalds xfs_buf_relse(bp); 9091da177e4SLinus Torvalds } else { 9101da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: size check 2 failed"); 9110771fb45SEric Sandeen if (error == ENOSPC) 9121da177e4SLinus Torvalds error = XFS_ERROR(E2BIG); 9130771fb45SEric Sandeen return error; 9141da177e4SLinus Torvalds } 9151da177e4SLinus Torvalds 9161da177e4SLinus Torvalds if (((mfsi_flags & XFS_MFSI_CLIENT) == 0) && 9171da177e4SLinus Torvalds mp->m_logdev_targp != mp->m_ddev_targp) { 9181da177e4SLinus Torvalds d = (xfs_daddr_t)XFS_FSB_TO_BB(mp, mp->m_sb.sb_logblocks); 9191da177e4SLinus Torvalds if (XFS_BB_TO_FSB(mp, d) != mp->m_sb.sb_logblocks) { 9201da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: size check 3 failed"); 9210771fb45SEric Sandeen return XFS_ERROR(E2BIG); 9221da177e4SLinus Torvalds } 9231da177e4SLinus Torvalds error = xfs_read_buf(mp, mp->m_logdev_targp, 9241da177e4SLinus Torvalds d - XFS_FSB_TO_BB(mp, 1), 9251da177e4SLinus Torvalds XFS_FSB_TO_BB(mp, 1), 0, &bp); 9261da177e4SLinus Torvalds if (!error) { 9271da177e4SLinus Torvalds xfs_buf_relse(bp); 9281da177e4SLinus Torvalds } else { 9291da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: size check 3 failed"); 9300771fb45SEric Sandeen if (error == ENOSPC) 9311da177e4SLinus Torvalds error = XFS_ERROR(E2BIG); 9320771fb45SEric Sandeen return error; 9331da177e4SLinus Torvalds } 9340771fb45SEric Sandeen } 9350771fb45SEric Sandeen return 0; 9360771fb45SEric Sandeen } 9370771fb45SEric Sandeen 9380771fb45SEric Sandeen /* 9390771fb45SEric Sandeen * xfs_mountfs 9400771fb45SEric Sandeen * 9410771fb45SEric Sandeen * This function does the following on an initial mount of a file system: 9420771fb45SEric Sandeen * - reads the superblock from disk and init the mount struct 9430771fb45SEric Sandeen * - if we're a 32-bit kernel, do a size check on the superblock 9440771fb45SEric Sandeen * so we don't mount terabyte filesystems 9450771fb45SEric Sandeen * - init mount struct realtime fields 9460771fb45SEric Sandeen * - allocate inode hash table for fs 9470771fb45SEric Sandeen * - init directory manager 9480771fb45SEric Sandeen * - perform recovery and init the log manager 9490771fb45SEric Sandeen */ 9500771fb45SEric Sandeen int 9510771fb45SEric Sandeen xfs_mountfs( 9520771fb45SEric Sandeen xfs_mount_t *mp, 9530771fb45SEric Sandeen int mfsi_flags) 9540771fb45SEric Sandeen { 9550771fb45SEric Sandeen xfs_sb_t *sbp = &(mp->m_sb); 9560771fb45SEric Sandeen xfs_inode_t *rip; 9570771fb45SEric Sandeen bhv_vnode_t *rvp = NULL; 9580771fb45SEric Sandeen __uint64_t resblks; 9590771fb45SEric Sandeen __int64_t update_flags = 0LL; 9600771fb45SEric Sandeen uint quotamount, quotaflags; 9610771fb45SEric Sandeen int agno; 9620771fb45SEric Sandeen int uuid_mounted = 0; 9630771fb45SEric Sandeen int error = 0; 9640771fb45SEric Sandeen 9650771fb45SEric Sandeen if (mp->m_sb_bp == NULL) { 9660771fb45SEric Sandeen error = xfs_readsb(mp, mfsi_flags); 9670771fb45SEric Sandeen if (error) 9680771fb45SEric Sandeen return error; 9690771fb45SEric Sandeen } 9700771fb45SEric Sandeen xfs_mount_common(mp, sbp); 9710771fb45SEric Sandeen 9720771fb45SEric Sandeen /* 9730771fb45SEric Sandeen * Check if sb_agblocks is aligned at stripe boundary 9740771fb45SEric Sandeen * If sb_agblocks is NOT aligned turn off m_dalign since 9750771fb45SEric Sandeen * allocator alignment is within an ag, therefore ag has 9760771fb45SEric Sandeen * to be aligned at stripe boundary. 9770771fb45SEric Sandeen */ 9780771fb45SEric Sandeen error = xfs_update_alignment(mp, mfsi_flags, &update_flags); 9790771fb45SEric Sandeen if (error) 9800771fb45SEric Sandeen goto error1; 9810771fb45SEric Sandeen 9820771fb45SEric Sandeen xfs_alloc_compute_maxlevels(mp); 9830771fb45SEric Sandeen xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK); 9840771fb45SEric Sandeen xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK); 9850771fb45SEric Sandeen xfs_ialloc_compute_maxlevels(mp); 9860771fb45SEric Sandeen 9870771fb45SEric Sandeen xfs_set_maxicount(mp); 9880771fb45SEric Sandeen 9890771fb45SEric Sandeen mp->m_maxioffset = xfs_max_file_offset(sbp->sb_blocklog); 9900771fb45SEric Sandeen 9910771fb45SEric Sandeen /* 9920771fb45SEric Sandeen * XFS uses the uuid from the superblock as the unique 9930771fb45SEric Sandeen * identifier for fsid. We can not use the uuid from the volume 9940771fb45SEric Sandeen * since a single partition filesystem is identical to a single 9950771fb45SEric Sandeen * partition volume/filesystem. 9960771fb45SEric Sandeen */ 9970771fb45SEric Sandeen if ((mfsi_flags & XFS_MFSI_SECOND) == 0 && 9980771fb45SEric Sandeen (mp->m_flags & XFS_MOUNT_NOUUID) == 0) { 9990771fb45SEric Sandeen if (xfs_uuid_mount(mp)) { 10000771fb45SEric Sandeen error = XFS_ERROR(EINVAL); 10011da177e4SLinus Torvalds goto error1; 10021da177e4SLinus Torvalds } 10030771fb45SEric Sandeen uuid_mounted=1; 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds 10061da177e4SLinus Torvalds /* 10070771fb45SEric Sandeen * Set the minimum read and write sizes 10080771fb45SEric Sandeen */ 10090771fb45SEric Sandeen xfs_set_rw_sizes(mp); 10100771fb45SEric Sandeen 10110771fb45SEric Sandeen /* 10120771fb45SEric Sandeen * Set the inode cluster size. 10130771fb45SEric Sandeen * This may still be overridden by the file system 10140771fb45SEric Sandeen * block size if it is larger than the chosen cluster size. 10150771fb45SEric Sandeen */ 10160771fb45SEric Sandeen mp->m_inode_cluster_size = XFS_INODE_BIG_CLUSTER_SIZE; 10170771fb45SEric Sandeen 10180771fb45SEric Sandeen /* 10190771fb45SEric Sandeen * Set inode alignment fields 10200771fb45SEric Sandeen */ 10210771fb45SEric Sandeen xfs_set_inoalignment(mp); 10220771fb45SEric Sandeen 10230771fb45SEric Sandeen /* 10240771fb45SEric Sandeen * Check that the data (and log if separate) are an ok size. 10250771fb45SEric Sandeen */ 10260771fb45SEric Sandeen error = xfs_check_sizes(mp, mfsi_flags); 10270771fb45SEric Sandeen if (error) 10280771fb45SEric Sandeen goto error1; 10290771fb45SEric Sandeen 10300771fb45SEric Sandeen /* 10311da177e4SLinus Torvalds * Initialize realtime fields in the mount structure 10321da177e4SLinus Torvalds */ 10330771fb45SEric Sandeen error = xfs_rtmount_init(mp); 10340771fb45SEric Sandeen if (error) { 10351da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: RT mount failed"); 10361da177e4SLinus Torvalds goto error1; 10371da177e4SLinus Torvalds } 10381da177e4SLinus Torvalds 10391da177e4SLinus Torvalds /* 10401da177e4SLinus Torvalds * For client case we are done now 10411da177e4SLinus Torvalds */ 10421da177e4SLinus Torvalds if (mfsi_flags & XFS_MFSI_CLIENT) { 1043014c2544SJesper Juhl return 0; 10441da177e4SLinus Torvalds } 10451da177e4SLinus Torvalds 10461da177e4SLinus Torvalds /* 10471da177e4SLinus Torvalds * Copies the low order bits of the timestamp and the randomly 10481da177e4SLinus Torvalds * set "sequence" number out of a UUID. 10491da177e4SLinus Torvalds */ 10501da177e4SLinus Torvalds uuid_getnodeuniq(&sbp->sb_uuid, mp->m_fixedfsid); 10511da177e4SLinus Torvalds 10521da177e4SLinus Torvalds mp->m_dmevmask = 0; /* not persistent; set after each mount */ 10531da177e4SLinus Torvalds 1054f6c2d1faSNathan Scott xfs_dir_mount(mp); 10551da177e4SLinus Torvalds 10561da177e4SLinus Torvalds /* 10571da177e4SLinus Torvalds * Initialize the attribute manager's entries. 10581da177e4SLinus Torvalds */ 10591da177e4SLinus Torvalds mp->m_attr_magicpct = (mp->m_sb.sb_blocksize * 37) / 100; 10601da177e4SLinus Torvalds 10611da177e4SLinus Torvalds /* 10621da177e4SLinus Torvalds * Initialize the precomputed transaction reservations values. 10631da177e4SLinus Torvalds */ 10641da177e4SLinus Torvalds xfs_trans_init(mp); 10651da177e4SLinus Torvalds 10661da177e4SLinus Torvalds /* 10671da177e4SLinus Torvalds * Allocate and initialize the per-ag data. 10681da177e4SLinus Torvalds */ 10691da177e4SLinus Torvalds init_rwsem(&mp->m_peraglock); 10701da177e4SLinus Torvalds mp->m_perag = 10711da177e4SLinus Torvalds kmem_zalloc(sbp->sb_agcount * sizeof(xfs_perag_t), KM_SLEEP); 10721da177e4SLinus Torvalds 1073b267ce99SChristoph Hellwig mp->m_maxagi = xfs_initialize_perag(mp, sbp->sb_agcount); 10741da177e4SLinus Torvalds 10751da177e4SLinus Torvalds /* 10761da177e4SLinus Torvalds * log's mount-time initialization. Perform 1st part recovery if needed 10771da177e4SLinus Torvalds */ 10781da177e4SLinus Torvalds if (likely(sbp->sb_logblocks > 0)) { /* check for volume case */ 10791da177e4SLinus Torvalds error = xfs_log_mount(mp, mp->m_logdev_targp, 10801da177e4SLinus Torvalds XFS_FSB_TO_DADDR(mp, sbp->sb_logstart), 10811da177e4SLinus Torvalds XFS_FSB_TO_BB(mp, sbp->sb_logblocks)); 10821da177e4SLinus Torvalds if (error) { 10831da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: log mount failed"); 10841da177e4SLinus Torvalds goto error2; 10851da177e4SLinus Torvalds } 10861da177e4SLinus Torvalds } else { /* No log has been defined */ 10871da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: no log defined"); 10881da177e4SLinus Torvalds XFS_ERROR_REPORT("xfs_mountfs_int(1)", XFS_ERRLEVEL_LOW, mp); 10891da177e4SLinus Torvalds error = XFS_ERROR(EFSCORRUPTED); 10901da177e4SLinus Torvalds goto error2; 10911da177e4SLinus Torvalds } 10921da177e4SLinus Torvalds 10931da177e4SLinus Torvalds /* 109492821e2bSDavid Chinner * Now the log is mounted, we know if it was an unclean shutdown or 109592821e2bSDavid Chinner * not. If it was, with the first phase of recovery has completed, we 109692821e2bSDavid Chinner * have consistent AG blocks on disk. We have not recovered EFIs yet, 109792821e2bSDavid Chinner * but they are recovered transactionally in the second recovery phase 109892821e2bSDavid Chinner * later. 109992821e2bSDavid Chinner * 110092821e2bSDavid Chinner * Hence we can safely re-initialise incore superblock counters from 110192821e2bSDavid Chinner * the per-ag data. These may not be correct if the filesystem was not 110292821e2bSDavid Chinner * cleanly unmounted, so we need to wait for recovery to finish before 110392821e2bSDavid Chinner * doing this. 110492821e2bSDavid Chinner * 110592821e2bSDavid Chinner * If the filesystem was cleanly unmounted, then we can trust the 110692821e2bSDavid Chinner * values in the superblock to be correct and we don't need to do 110792821e2bSDavid Chinner * anything here. 110892821e2bSDavid Chinner * 110992821e2bSDavid Chinner * If we are currently making the filesystem, the initialisation will 111092821e2bSDavid Chinner * fail as the perag data is in an undefined state. 111192821e2bSDavid Chinner */ 111292821e2bSDavid Chinner 111392821e2bSDavid Chinner if (xfs_sb_version_haslazysbcount(&mp->m_sb) && 111492821e2bSDavid Chinner !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) && 111592821e2bSDavid Chinner !mp->m_sb.sb_inprogress) { 111692821e2bSDavid Chinner error = xfs_initialize_perag_data(mp, sbp->sb_agcount); 111792821e2bSDavid Chinner if (error) { 111892821e2bSDavid Chinner goto error2; 111992821e2bSDavid Chinner } 112092821e2bSDavid Chinner } 112192821e2bSDavid Chinner /* 11221da177e4SLinus Torvalds * Get and sanity-check the root inode. 11231da177e4SLinus Torvalds * Save the pointer to it in the mount structure. 11241da177e4SLinus Torvalds */ 11251da177e4SLinus Torvalds error = xfs_iget(mp, NULL, sbp->sb_rootino, 0, XFS_ILOCK_EXCL, &rip, 0); 11261da177e4SLinus Torvalds if (error) { 11271da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: failed to read root inode"); 11281da177e4SLinus Torvalds goto error3; 11291da177e4SLinus Torvalds } 11301da177e4SLinus Torvalds 11311da177e4SLinus Torvalds ASSERT(rip != NULL); 11321da177e4SLinus Torvalds rvp = XFS_ITOV(rip); 11331da177e4SLinus Torvalds 11341da177e4SLinus Torvalds if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) { 11351da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: corrupted root inode"); 1136b6574520SNathan Scott cmn_err(CE_WARN, "Device %s - root %llu is not a directory", 1137b6574520SNathan Scott XFS_BUFTARG_NAME(mp->m_ddev_targp), 1138b6574520SNathan Scott (unsigned long long)rip->i_ino); 11391da177e4SLinus Torvalds xfs_iunlock(rip, XFS_ILOCK_EXCL); 11401da177e4SLinus Torvalds XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW, 11411da177e4SLinus Torvalds mp); 11421da177e4SLinus Torvalds error = XFS_ERROR(EFSCORRUPTED); 11431da177e4SLinus Torvalds goto error4; 11441da177e4SLinus Torvalds } 11451da177e4SLinus Torvalds mp->m_rootip = rip; /* save it */ 11461da177e4SLinus Torvalds 11471da177e4SLinus Torvalds xfs_iunlock(rip, XFS_ILOCK_EXCL); 11481da177e4SLinus Torvalds 11491da177e4SLinus Torvalds /* 11501da177e4SLinus Torvalds * Initialize realtime inode pointers in the mount structure 11511da177e4SLinus Torvalds */ 11520771fb45SEric Sandeen error = xfs_rtmount_inodes(mp); 11530771fb45SEric Sandeen if (error) { 11541da177e4SLinus Torvalds /* 11551da177e4SLinus Torvalds * Free up the root inode. 11561da177e4SLinus Torvalds */ 11571da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: failed to read RT inodes"); 11581da177e4SLinus Torvalds goto error4; 11591da177e4SLinus Torvalds } 11601da177e4SLinus Torvalds 11611da177e4SLinus Torvalds /* 11621da177e4SLinus Torvalds * If fs is not mounted readonly, then update the superblock 11631da177e4SLinus Torvalds * unit and width changes. 11641da177e4SLinus Torvalds */ 1165bd186aa9SChristoph Hellwig if (update_flags && !(mp->m_flags & XFS_MOUNT_RDONLY)) 11661da177e4SLinus Torvalds xfs_mount_log_sbunit(mp, update_flags); 11671da177e4SLinus Torvalds 11681da177e4SLinus Torvalds /* 11691da177e4SLinus Torvalds * Initialise the XFS quota management subsystem for this mount 11701da177e4SLinus Torvalds */ 11710771fb45SEric Sandeen error = XFS_QM_INIT(mp, "amount, "aflags); 11720771fb45SEric Sandeen if (error) 11731da177e4SLinus Torvalds goto error4; 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds /* 11761da177e4SLinus Torvalds * Finish recovering the file system. This part needed to be 11771da177e4SLinus Torvalds * delayed until after the root and real-time bitmap inodes 11781da177e4SLinus Torvalds * were consistently read in. 11791da177e4SLinus Torvalds */ 11801da177e4SLinus Torvalds error = xfs_log_mount_finish(mp, mfsi_flags); 11811da177e4SLinus Torvalds if (error) { 11821da177e4SLinus Torvalds cmn_err(CE_WARN, "XFS: log mount finish failed"); 11831da177e4SLinus Torvalds goto error4; 11841da177e4SLinus Torvalds } 11851da177e4SLinus Torvalds 11861da177e4SLinus Torvalds /* 11871da177e4SLinus Torvalds * Complete the quota initialisation, post-log-replay component. 11881da177e4SLinus Torvalds */ 11890771fb45SEric Sandeen error = XFS_QM_MOUNT(mp, quotamount, quotaflags, mfsi_flags); 11900771fb45SEric Sandeen if (error) 11911da177e4SLinus Torvalds goto error4; 11921da177e4SLinus Torvalds 119384e1e99fSDavid Chinner /* 119484e1e99fSDavid Chinner * Now we are mounted, reserve a small amount of unused space for 119584e1e99fSDavid Chinner * privileged transactions. This is needed so that transaction 119684e1e99fSDavid Chinner * space required for critical operations can dip into this pool 119784e1e99fSDavid Chinner * when at ENOSPC. This is needed for operations like create with 119884e1e99fSDavid Chinner * attr, unwritten extent conversion at ENOSPC, etc. Data allocations 119984e1e99fSDavid Chinner * are not allowed to use this reserved space. 120084e1e99fSDavid Chinner * 120184e1e99fSDavid Chinner * We default to 5% or 1024 fsbs of space reserved, whichever is smaller. 120284e1e99fSDavid Chinner * This may drive us straight to ENOSPC on mount, but that implies 120384e1e99fSDavid Chinner * we were already there on the last unmount. 120484e1e99fSDavid Chinner */ 120539726be2SChristoph Hellwig resblks = mp->m_sb.sb_dblocks; 120639726be2SChristoph Hellwig do_div(resblks, 20); 120739726be2SChristoph Hellwig resblks = min_t(__uint64_t, resblks, 1024); 120884e1e99fSDavid Chinner xfs_reserve_blocks(mp, &resblks, NULL); 120984e1e99fSDavid Chinner 12101da177e4SLinus Torvalds return 0; 12111da177e4SLinus Torvalds 12121da177e4SLinus Torvalds error4: 12131da177e4SLinus Torvalds /* 12141da177e4SLinus Torvalds * Free up the root inode. 12151da177e4SLinus Torvalds */ 12161da177e4SLinus Torvalds VN_RELE(rvp); 12171da177e4SLinus Torvalds error3: 12181da177e4SLinus Torvalds xfs_log_unmount_dealloc(mp); 12191da177e4SLinus Torvalds error2: 12201da177e4SLinus Torvalds for (agno = 0; agno < sbp->sb_agcount; agno++) 12211da177e4SLinus Torvalds if (mp->m_perag[agno].pagb_list) 12221da177e4SLinus Torvalds kmem_free(mp->m_perag[agno].pagb_list, 12231da177e4SLinus Torvalds sizeof(xfs_perag_busy_t) * XFS_PAGB_NUM_SLOTS); 12241da177e4SLinus Torvalds kmem_free(mp->m_perag, sbp->sb_agcount * sizeof(xfs_perag_t)); 12251da177e4SLinus Torvalds mp->m_perag = NULL; 12261da177e4SLinus Torvalds /* FALLTHROUGH */ 12271da177e4SLinus Torvalds error1: 12281da177e4SLinus Torvalds if (uuid_mounted) 12291da177e4SLinus Torvalds xfs_uuid_unmount(mp); 12301da177e4SLinus Torvalds xfs_freesb(mp); 12311da177e4SLinus Torvalds return error; 12321da177e4SLinus Torvalds } 12331da177e4SLinus Torvalds 12341da177e4SLinus Torvalds /* 12351da177e4SLinus Torvalds * xfs_unmountfs 12361da177e4SLinus Torvalds * 12371da177e4SLinus Torvalds * This flushes out the inodes,dquots and the superblock, unmounts the 12381da177e4SLinus Torvalds * log and makes sure that incore structures are freed. 12391da177e4SLinus Torvalds */ 12401da177e4SLinus Torvalds int 12411da177e4SLinus Torvalds xfs_unmountfs(xfs_mount_t *mp, struct cred *cr) 12421da177e4SLinus Torvalds { 124384e1e99fSDavid Chinner __uint64_t resblks; 12441da177e4SLinus Torvalds 1245641c56fbSDavid Chinner /* 1246641c56fbSDavid Chinner * We can potentially deadlock here if we have an inode cluster 1247641c56fbSDavid Chinner * that has been freed has it's buffer still pinned in memory because 1248641c56fbSDavid Chinner * the transaction is still sitting in a iclog. The stale inodes 1249641c56fbSDavid Chinner * on that buffer will have their flush locks held until the 1250641c56fbSDavid Chinner * transaction hits the disk and the callbacks run. the inode 1251641c56fbSDavid Chinner * flush takes the flush lock unconditionally and with nothing to 1252641c56fbSDavid Chinner * push out the iclog we will never get that unlocked. hence we 1253641c56fbSDavid Chinner * need to force the log first. 1254641c56fbSDavid Chinner */ 1255641c56fbSDavid Chinner xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC); 1256efa80278SChristoph Hellwig xfs_iflush_all(mp); 12571da177e4SLinus Torvalds 1258ee2a4f7cSNathan Scott XFS_QM_DQPURGEALL(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_UMOUNTING); 12591da177e4SLinus Torvalds 12601da177e4SLinus Torvalds /* 12611da177e4SLinus Torvalds * Flush out the log synchronously so that we know for sure 12621da177e4SLinus Torvalds * that nothing is pinned. This is important because bflush() 12631da177e4SLinus Torvalds * will skip pinned buffers. 12641da177e4SLinus Torvalds */ 12651da177e4SLinus Torvalds xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC); 12661da177e4SLinus Torvalds 12671da177e4SLinus Torvalds xfs_binval(mp->m_ddev_targp); 12681da177e4SLinus Torvalds if (mp->m_rtdev_targp) { 12691da177e4SLinus Torvalds xfs_binval(mp->m_rtdev_targp); 12701da177e4SLinus Torvalds } 12711da177e4SLinus Torvalds 127284e1e99fSDavid Chinner /* 127384e1e99fSDavid Chinner * Unreserve any blocks we have so that when we unmount we don't account 127484e1e99fSDavid Chinner * the reserved free space as used. This is really only necessary for 127584e1e99fSDavid Chinner * lazy superblock counting because it trusts the incore superblock 127684e1e99fSDavid Chinner * counters to be aboslutely correct on clean unmount. 127784e1e99fSDavid Chinner * 127884e1e99fSDavid Chinner * We don't bother correcting this elsewhere for lazy superblock 127984e1e99fSDavid Chinner * counting because on mount of an unclean filesystem we reconstruct the 128084e1e99fSDavid Chinner * correct counter value and this is irrelevant. 128184e1e99fSDavid Chinner * 128284e1e99fSDavid Chinner * For non-lazy counter filesystems, this doesn't matter at all because 128384e1e99fSDavid Chinner * we only every apply deltas to the superblock and hence the incore 128484e1e99fSDavid Chinner * value does not matter.... 128584e1e99fSDavid Chinner */ 128684e1e99fSDavid Chinner resblks = 0; 128784e1e99fSDavid Chinner xfs_reserve_blocks(mp, &resblks, NULL); 128884e1e99fSDavid Chinner 128992821e2bSDavid Chinner xfs_log_sbcount(mp, 1); 12901da177e4SLinus Torvalds xfs_unmountfs_writesb(mp); 12911da177e4SLinus Torvalds xfs_unmountfs_wait(mp); /* wait for async bufs */ 12921da177e4SLinus Torvalds xfs_log_unmount(mp); /* Done! No more fs ops. */ 12931da177e4SLinus Torvalds 12941da177e4SLinus Torvalds xfs_freesb(mp); 12951da177e4SLinus Torvalds 12961da177e4SLinus Torvalds /* 12971da177e4SLinus Torvalds * All inodes from this mount point should be freed. 12981da177e4SLinus Torvalds */ 12991da177e4SLinus Torvalds ASSERT(mp->m_inodes == NULL); 13001da177e4SLinus Torvalds 13011da177e4SLinus Torvalds xfs_unmountfs_close(mp, cr); 13021da177e4SLinus Torvalds if ((mp->m_flags & XFS_MOUNT_NOUUID) == 0) 13031da177e4SLinus Torvalds xfs_uuid_unmount(mp); 13041da177e4SLinus Torvalds 13051da177e4SLinus Torvalds #if defined(DEBUG) || defined(INDUCE_IO_ERROR) 13060ce4cfd4SChristoph Hellwig xfs_errortag_clearall(mp, 0); 13071da177e4SLinus Torvalds #endif 1308745f6919SChristoph Hellwig xfs_mount_free(mp); 13091da177e4SLinus Torvalds return 0; 13101da177e4SLinus Torvalds } 13111da177e4SLinus Torvalds 13121da177e4SLinus Torvalds void 13131da177e4SLinus Torvalds xfs_unmountfs_close(xfs_mount_t *mp, struct cred *cr) 13141da177e4SLinus Torvalds { 131549ee6c91SJesper Juhl if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) 13161da177e4SLinus Torvalds xfs_free_buftarg(mp->m_logdev_targp, 1); 13171da177e4SLinus Torvalds if (mp->m_rtdev_targp) 13181da177e4SLinus Torvalds xfs_free_buftarg(mp->m_rtdev_targp, 1); 13191da177e4SLinus Torvalds xfs_free_buftarg(mp->m_ddev_targp, 0); 13201da177e4SLinus Torvalds } 13211da177e4SLinus Torvalds 1322ba0f32d4SChristoph Hellwig STATIC void 13231da177e4SLinus Torvalds xfs_unmountfs_wait(xfs_mount_t *mp) 13241da177e4SLinus Torvalds { 13251da177e4SLinus Torvalds if (mp->m_logdev_targp != mp->m_ddev_targp) 13261da177e4SLinus Torvalds xfs_wait_buftarg(mp->m_logdev_targp); 13271da177e4SLinus Torvalds if (mp->m_rtdev_targp) 13281da177e4SLinus Torvalds xfs_wait_buftarg(mp->m_rtdev_targp); 13291da177e4SLinus Torvalds xfs_wait_buftarg(mp->m_ddev_targp); 13301da177e4SLinus Torvalds } 13311da177e4SLinus Torvalds 13321da177e4SLinus Torvalds int 133392821e2bSDavid Chinner xfs_fs_writable(xfs_mount_t *mp) 133492821e2bSDavid Chinner { 1335b267ce99SChristoph Hellwig return !(xfs_test_for_freeze(mp) || XFS_FORCED_SHUTDOWN(mp) || 1336bd186aa9SChristoph Hellwig (mp->m_flags & XFS_MOUNT_RDONLY)); 133792821e2bSDavid Chinner } 133892821e2bSDavid Chinner 133992821e2bSDavid Chinner /* 134092821e2bSDavid Chinner * xfs_log_sbcount 134192821e2bSDavid Chinner * 134292821e2bSDavid Chinner * Called either periodically to keep the on disk superblock values 134392821e2bSDavid Chinner * roughly up to date or from unmount to make sure the values are 134492821e2bSDavid Chinner * correct on a clean unmount. 134592821e2bSDavid Chinner * 134692821e2bSDavid Chinner * Note this code can be called during the process of freezing, so 134792821e2bSDavid Chinner * we may need to use the transaction allocator which does not not 134892821e2bSDavid Chinner * block when the transaction subsystem is in its frozen state. 134992821e2bSDavid Chinner */ 135092821e2bSDavid Chinner int 135192821e2bSDavid Chinner xfs_log_sbcount( 135292821e2bSDavid Chinner xfs_mount_t *mp, 135392821e2bSDavid Chinner uint sync) 135492821e2bSDavid Chinner { 135592821e2bSDavid Chinner xfs_trans_t *tp; 135692821e2bSDavid Chinner int error; 135792821e2bSDavid Chinner 135892821e2bSDavid Chinner if (!xfs_fs_writable(mp)) 135992821e2bSDavid Chinner return 0; 136092821e2bSDavid Chinner 136192821e2bSDavid Chinner xfs_icsb_sync_counters(mp); 136292821e2bSDavid Chinner 136392821e2bSDavid Chinner /* 136492821e2bSDavid Chinner * we don't need to do this if we are updating the superblock 136592821e2bSDavid Chinner * counters on every modification. 136692821e2bSDavid Chinner */ 136792821e2bSDavid Chinner if (!xfs_sb_version_haslazysbcount(&mp->m_sb)) 136892821e2bSDavid Chinner return 0; 136992821e2bSDavid Chinner 137092821e2bSDavid Chinner tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT); 137192821e2bSDavid Chinner error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0, 137292821e2bSDavid Chinner XFS_DEFAULT_LOG_COUNT); 137392821e2bSDavid Chinner if (error) { 137492821e2bSDavid Chinner xfs_trans_cancel(tp, 0); 137592821e2bSDavid Chinner return error; 137692821e2bSDavid Chinner } 137792821e2bSDavid Chinner 137892821e2bSDavid Chinner xfs_mod_sb(tp, XFS_SB_IFREE | XFS_SB_ICOUNT | XFS_SB_FDBLOCKS); 137992821e2bSDavid Chinner if (sync) 138092821e2bSDavid Chinner xfs_trans_set_sync(tp); 138192821e2bSDavid Chinner xfs_trans_commit(tp, 0); 138292821e2bSDavid Chinner 138392821e2bSDavid Chinner return 0; 138492821e2bSDavid Chinner } 138592821e2bSDavid Chinner 13862bdf7cd0SChristoph Hellwig STATIC void 13872bdf7cd0SChristoph Hellwig xfs_mark_shared_ro( 13882bdf7cd0SChristoph Hellwig xfs_mount_t *mp, 13892bdf7cd0SChristoph Hellwig xfs_buf_t *bp) 13902bdf7cd0SChristoph Hellwig { 13912bdf7cd0SChristoph Hellwig xfs_dsb_t *sb = XFS_BUF_TO_SBP(bp); 13922bdf7cd0SChristoph Hellwig __uint16_t version; 13932bdf7cd0SChristoph Hellwig 13942bdf7cd0SChristoph Hellwig if (!(sb->sb_flags & XFS_SBF_READONLY)) 13952bdf7cd0SChristoph Hellwig sb->sb_flags |= XFS_SBF_READONLY; 13962bdf7cd0SChristoph Hellwig 13972bdf7cd0SChristoph Hellwig version = be16_to_cpu(sb->sb_versionnum); 13982bdf7cd0SChristoph Hellwig if ((version & XFS_SB_VERSION_NUMBITS) != XFS_SB_VERSION_4 || 13992bdf7cd0SChristoph Hellwig !(version & XFS_SB_VERSION_SHAREDBIT)) 14002bdf7cd0SChristoph Hellwig version |= XFS_SB_VERSION_SHAREDBIT; 14012bdf7cd0SChristoph Hellwig sb->sb_versionnum = cpu_to_be16(version); 14022bdf7cd0SChristoph Hellwig } 14032bdf7cd0SChristoph Hellwig 140492821e2bSDavid Chinner int 14051da177e4SLinus Torvalds xfs_unmountfs_writesb(xfs_mount_t *mp) 14061da177e4SLinus Torvalds { 14071da177e4SLinus Torvalds xfs_buf_t *sbp; 14081da177e4SLinus Torvalds int error = 0; 14091da177e4SLinus Torvalds 14101da177e4SLinus Torvalds /* 14111da177e4SLinus Torvalds * skip superblock write if fs is read-only, or 14121da177e4SLinus Torvalds * if we are doing a forced umount. 14131da177e4SLinus Torvalds */ 1414bd186aa9SChristoph Hellwig if (!((mp->m_flags & XFS_MOUNT_RDONLY) || 14151da177e4SLinus Torvalds XFS_FORCED_SHUTDOWN(mp))) { 14168d280b98SDavid Chinner 141792821e2bSDavid Chinner sbp = xfs_getsb(mp, 0); 14188d280b98SDavid Chinner 14191da177e4SLinus Torvalds /* 14201da177e4SLinus Torvalds * mark shared-readonly if desired 14211da177e4SLinus Torvalds */ 14222bdf7cd0SChristoph Hellwig if (mp->m_mk_sharedro) 14232bdf7cd0SChristoph Hellwig xfs_mark_shared_ro(mp, sbp); 142492821e2bSDavid Chinner 14251da177e4SLinus Torvalds XFS_BUF_UNDONE(sbp); 14261da177e4SLinus Torvalds XFS_BUF_UNREAD(sbp); 14271da177e4SLinus Torvalds XFS_BUF_UNDELAYWRITE(sbp); 14281da177e4SLinus Torvalds XFS_BUF_WRITE(sbp); 14291da177e4SLinus Torvalds XFS_BUF_UNASYNC(sbp); 14301da177e4SLinus Torvalds ASSERT(XFS_BUF_TARGET(sbp) == mp->m_ddev_targp); 14311da177e4SLinus Torvalds xfsbdstrat(mp, sbp); 14321da177e4SLinus Torvalds /* Nevermind errors we might get here. */ 14331da177e4SLinus Torvalds error = xfs_iowait(sbp); 14341da177e4SLinus Torvalds if (error) 14351da177e4SLinus Torvalds xfs_ioerror_alert("xfs_unmountfs_writesb", 14361da177e4SLinus Torvalds mp, sbp, XFS_BUF_ADDR(sbp)); 14371da177e4SLinus Torvalds if (error && mp->m_mk_sharedro) 14381da177e4SLinus Torvalds xfs_fs_cmn_err(CE_ALERT, mp, "Superblock write error detected while unmounting. Filesystem may not be marked shared readonly"); 14391da177e4SLinus Torvalds xfs_buf_relse(sbp); 144092821e2bSDavid Chinner } 1441014c2544SJesper Juhl return error; 14421da177e4SLinus Torvalds } 14431da177e4SLinus Torvalds 14441da177e4SLinus Torvalds /* 14451da177e4SLinus Torvalds * xfs_mod_sb() can be used to copy arbitrary changes to the 14461da177e4SLinus Torvalds * in-core superblock into the superblock buffer to be logged. 14471da177e4SLinus Torvalds * It does not provide the higher level of locking that is 14481da177e4SLinus Torvalds * needed to protect the in-core superblock from concurrent 14491da177e4SLinus Torvalds * access. 14501da177e4SLinus Torvalds */ 14511da177e4SLinus Torvalds void 14521da177e4SLinus Torvalds xfs_mod_sb(xfs_trans_t *tp, __int64_t fields) 14531da177e4SLinus Torvalds { 14541da177e4SLinus Torvalds xfs_buf_t *bp; 14551da177e4SLinus Torvalds int first; 14561da177e4SLinus Torvalds int last; 14571da177e4SLinus Torvalds xfs_mount_t *mp; 14581da177e4SLinus Torvalds xfs_sb_field_t f; 14591da177e4SLinus Torvalds 14601da177e4SLinus Torvalds ASSERT(fields); 14611da177e4SLinus Torvalds if (!fields) 14621da177e4SLinus Torvalds return; 14631da177e4SLinus Torvalds mp = tp->t_mountp; 14641da177e4SLinus Torvalds bp = xfs_trans_getsb(tp, mp, 0); 14651da177e4SLinus Torvalds first = sizeof(xfs_sb_t); 14661da177e4SLinus Torvalds last = 0; 14671da177e4SLinus Torvalds 14681da177e4SLinus Torvalds /* translate/copy */ 14691da177e4SLinus Torvalds 14702bdf7cd0SChristoph Hellwig xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, fields); 14711da177e4SLinus Torvalds 14721da177e4SLinus Torvalds /* find modified range */ 14731da177e4SLinus Torvalds 14741da177e4SLinus Torvalds f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields); 14751da177e4SLinus Torvalds ASSERT((1LL << f) & XFS_SB_MOD_BITS); 14761da177e4SLinus Torvalds first = xfs_sb_info[f].offset; 14771da177e4SLinus Torvalds 14781da177e4SLinus Torvalds f = (xfs_sb_field_t)xfs_highbit64((__uint64_t)fields); 14791da177e4SLinus Torvalds ASSERT((1LL << f) & XFS_SB_MOD_BITS); 14801da177e4SLinus Torvalds last = xfs_sb_info[f + 1].offset - 1; 14811da177e4SLinus Torvalds 14821da177e4SLinus Torvalds xfs_trans_log_buf(tp, bp, first, last); 14831da177e4SLinus Torvalds } 1484d210a28cSYingping Lu 1485d210a28cSYingping Lu 14861da177e4SLinus Torvalds /* 14871da177e4SLinus Torvalds * xfs_mod_incore_sb_unlocked() is a utility routine common used to apply 14881da177e4SLinus Torvalds * a delta to a specified field in the in-core superblock. Simply 14891da177e4SLinus Torvalds * switch on the field indicated and apply the delta to that field. 14901da177e4SLinus Torvalds * Fields are not allowed to dip below zero, so if the delta would 14911da177e4SLinus Torvalds * do this do not apply it and return EINVAL. 14921da177e4SLinus Torvalds * 14933685c2a1SEric Sandeen * The m_sb_lock must be held when this routine is called. 14941da177e4SLinus Torvalds */ 14958d280b98SDavid Chinner int 149620f4ebf2SDavid Chinner xfs_mod_incore_sb_unlocked( 149720f4ebf2SDavid Chinner xfs_mount_t *mp, 149820f4ebf2SDavid Chinner xfs_sb_field_t field, 149920f4ebf2SDavid Chinner int64_t delta, 150020f4ebf2SDavid Chinner int rsvd) 15011da177e4SLinus Torvalds { 15021da177e4SLinus Torvalds int scounter; /* short counter for 32 bit fields */ 15031da177e4SLinus Torvalds long long lcounter; /* long counter for 64 bit fields */ 15041da177e4SLinus Torvalds long long res_used, rem; 15051da177e4SLinus Torvalds 15061da177e4SLinus Torvalds /* 15071da177e4SLinus Torvalds * With the in-core superblock spin lock held, switch 15081da177e4SLinus Torvalds * on the indicated field. Apply the delta to the 15091da177e4SLinus Torvalds * proper field. If the fields value would dip below 15101da177e4SLinus Torvalds * 0, then do not apply the delta and return EINVAL. 15111da177e4SLinus Torvalds */ 15121da177e4SLinus Torvalds switch (field) { 15131da177e4SLinus Torvalds case XFS_SBS_ICOUNT: 15141da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_icount; 15151da177e4SLinus Torvalds lcounter += delta; 15161da177e4SLinus Torvalds if (lcounter < 0) { 15171da177e4SLinus Torvalds ASSERT(0); 1518014c2544SJesper Juhl return XFS_ERROR(EINVAL); 15191da177e4SLinus Torvalds } 15201da177e4SLinus Torvalds mp->m_sb.sb_icount = lcounter; 1521014c2544SJesper Juhl return 0; 15221da177e4SLinus Torvalds case XFS_SBS_IFREE: 15231da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_ifree; 15241da177e4SLinus Torvalds lcounter += delta; 15251da177e4SLinus Torvalds if (lcounter < 0) { 15261da177e4SLinus Torvalds ASSERT(0); 1527014c2544SJesper Juhl return XFS_ERROR(EINVAL); 15281da177e4SLinus Torvalds } 15291da177e4SLinus Torvalds mp->m_sb.sb_ifree = lcounter; 1530014c2544SJesper Juhl return 0; 15311da177e4SLinus Torvalds case XFS_SBS_FDBLOCKS: 15324be536deSDavid Chinner lcounter = (long long) 15334be536deSDavid Chinner mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp); 15341da177e4SLinus Torvalds res_used = (long long)(mp->m_resblks - mp->m_resblks_avail); 15351da177e4SLinus Torvalds 15361da177e4SLinus Torvalds if (delta > 0) { /* Putting blocks back */ 15371da177e4SLinus Torvalds if (res_used > delta) { 15381da177e4SLinus Torvalds mp->m_resblks_avail += delta; 15391da177e4SLinus Torvalds } else { 15401da177e4SLinus Torvalds rem = delta - res_used; 15411da177e4SLinus Torvalds mp->m_resblks_avail = mp->m_resblks; 15421da177e4SLinus Torvalds lcounter += rem; 15431da177e4SLinus Torvalds } 15441da177e4SLinus Torvalds } else { /* Taking blocks away */ 15451da177e4SLinus Torvalds 15461da177e4SLinus Torvalds lcounter += delta; 15471da177e4SLinus Torvalds 15481da177e4SLinus Torvalds /* 15491da177e4SLinus Torvalds * If were out of blocks, use any available reserved blocks if 15501da177e4SLinus Torvalds * were allowed to. 15511da177e4SLinus Torvalds */ 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds if (lcounter < 0) { 15541da177e4SLinus Torvalds if (rsvd) { 15551da177e4SLinus Torvalds lcounter = (long long)mp->m_resblks_avail + delta; 15561da177e4SLinus Torvalds if (lcounter < 0) { 1557014c2544SJesper Juhl return XFS_ERROR(ENOSPC); 15581da177e4SLinus Torvalds } 15591da177e4SLinus Torvalds mp->m_resblks_avail = lcounter; 1560014c2544SJesper Juhl return 0; 15611da177e4SLinus Torvalds } else { /* not reserved */ 1562014c2544SJesper Juhl return XFS_ERROR(ENOSPC); 15631da177e4SLinus Torvalds } 15641da177e4SLinus Torvalds } 15651da177e4SLinus Torvalds } 15661da177e4SLinus Torvalds 15674be536deSDavid Chinner mp->m_sb.sb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp); 1568014c2544SJesper Juhl return 0; 15691da177e4SLinus Torvalds case XFS_SBS_FREXTENTS: 15701da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_frextents; 15711da177e4SLinus Torvalds lcounter += delta; 15721da177e4SLinus Torvalds if (lcounter < 0) { 1573014c2544SJesper Juhl return XFS_ERROR(ENOSPC); 15741da177e4SLinus Torvalds } 15751da177e4SLinus Torvalds mp->m_sb.sb_frextents = lcounter; 1576014c2544SJesper Juhl return 0; 15771da177e4SLinus Torvalds case XFS_SBS_DBLOCKS: 15781da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_dblocks; 15791da177e4SLinus Torvalds lcounter += delta; 15801da177e4SLinus Torvalds if (lcounter < 0) { 15811da177e4SLinus Torvalds ASSERT(0); 1582014c2544SJesper Juhl return XFS_ERROR(EINVAL); 15831da177e4SLinus Torvalds } 15841da177e4SLinus Torvalds mp->m_sb.sb_dblocks = lcounter; 1585014c2544SJesper Juhl return 0; 15861da177e4SLinus Torvalds case XFS_SBS_AGCOUNT: 15871da177e4SLinus Torvalds scounter = mp->m_sb.sb_agcount; 15881da177e4SLinus Torvalds scounter += delta; 15891da177e4SLinus Torvalds if (scounter < 0) { 15901da177e4SLinus Torvalds ASSERT(0); 1591014c2544SJesper Juhl return XFS_ERROR(EINVAL); 15921da177e4SLinus Torvalds } 15931da177e4SLinus Torvalds mp->m_sb.sb_agcount = scounter; 1594014c2544SJesper Juhl return 0; 15951da177e4SLinus Torvalds case XFS_SBS_IMAX_PCT: 15961da177e4SLinus Torvalds scounter = mp->m_sb.sb_imax_pct; 15971da177e4SLinus Torvalds scounter += delta; 15981da177e4SLinus Torvalds if (scounter < 0) { 15991da177e4SLinus Torvalds ASSERT(0); 1600014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16011da177e4SLinus Torvalds } 16021da177e4SLinus Torvalds mp->m_sb.sb_imax_pct = scounter; 1603014c2544SJesper Juhl return 0; 16041da177e4SLinus Torvalds case XFS_SBS_REXTSIZE: 16051da177e4SLinus Torvalds scounter = mp->m_sb.sb_rextsize; 16061da177e4SLinus Torvalds scounter += delta; 16071da177e4SLinus Torvalds if (scounter < 0) { 16081da177e4SLinus Torvalds ASSERT(0); 1609014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16101da177e4SLinus Torvalds } 16111da177e4SLinus Torvalds mp->m_sb.sb_rextsize = scounter; 1612014c2544SJesper Juhl return 0; 16131da177e4SLinus Torvalds case XFS_SBS_RBMBLOCKS: 16141da177e4SLinus Torvalds scounter = mp->m_sb.sb_rbmblocks; 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_rbmblocks = scounter; 1621014c2544SJesper Juhl return 0; 16221da177e4SLinus Torvalds case XFS_SBS_RBLOCKS: 16231da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_rblocks; 16241da177e4SLinus Torvalds lcounter += delta; 16251da177e4SLinus Torvalds if (lcounter < 0) { 16261da177e4SLinus Torvalds ASSERT(0); 1627014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16281da177e4SLinus Torvalds } 16291da177e4SLinus Torvalds mp->m_sb.sb_rblocks = lcounter; 1630014c2544SJesper Juhl return 0; 16311da177e4SLinus Torvalds case XFS_SBS_REXTENTS: 16321da177e4SLinus Torvalds lcounter = (long long)mp->m_sb.sb_rextents; 16331da177e4SLinus Torvalds lcounter += delta; 16341da177e4SLinus Torvalds if (lcounter < 0) { 16351da177e4SLinus Torvalds ASSERT(0); 1636014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16371da177e4SLinus Torvalds } 16381da177e4SLinus Torvalds mp->m_sb.sb_rextents = lcounter; 1639014c2544SJesper Juhl return 0; 16401da177e4SLinus Torvalds case XFS_SBS_REXTSLOG: 16411da177e4SLinus Torvalds scounter = mp->m_sb.sb_rextslog; 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_rextslog = scounter; 1648014c2544SJesper Juhl return 0; 16491da177e4SLinus Torvalds default: 16501da177e4SLinus Torvalds ASSERT(0); 1651014c2544SJesper Juhl return XFS_ERROR(EINVAL); 16521da177e4SLinus Torvalds } 16531da177e4SLinus Torvalds } 16541da177e4SLinus Torvalds 16551da177e4SLinus Torvalds /* 16561da177e4SLinus Torvalds * xfs_mod_incore_sb() is used to change a field in the in-core 16571da177e4SLinus Torvalds * superblock structure by the specified delta. This modification 16583685c2a1SEric Sandeen * is protected by the m_sb_lock. Just use the xfs_mod_incore_sb_unlocked() 16591da177e4SLinus Torvalds * routine to do the work. 16601da177e4SLinus Torvalds */ 16611da177e4SLinus Torvalds int 166220f4ebf2SDavid Chinner xfs_mod_incore_sb( 166320f4ebf2SDavid Chinner xfs_mount_t *mp, 166420f4ebf2SDavid Chinner xfs_sb_field_t field, 166520f4ebf2SDavid Chinner int64_t delta, 166620f4ebf2SDavid Chinner int rsvd) 16671da177e4SLinus Torvalds { 16681da177e4SLinus Torvalds int status; 16691da177e4SLinus Torvalds 16708d280b98SDavid Chinner /* check for per-cpu counters */ 16718d280b98SDavid Chinner switch (field) { 16728d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 16738d280b98SDavid Chinner case XFS_SBS_ICOUNT: 16748d280b98SDavid Chinner case XFS_SBS_IFREE: 16758d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 16768d280b98SDavid Chinner if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) { 16778d280b98SDavid Chinner status = xfs_icsb_modify_counters(mp, field, 16788d280b98SDavid Chinner delta, rsvd); 16798d280b98SDavid Chinner break; 16808d280b98SDavid Chinner } 16818d280b98SDavid Chinner /* FALLTHROUGH */ 16828d280b98SDavid Chinner #endif 16838d280b98SDavid Chinner default: 16843685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 16851da177e4SLinus Torvalds status = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd); 16863685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 16878d280b98SDavid Chinner break; 16888d280b98SDavid Chinner } 16898d280b98SDavid Chinner 1690014c2544SJesper Juhl return status; 16911da177e4SLinus Torvalds } 16921da177e4SLinus Torvalds 16931da177e4SLinus Torvalds /* 16941da177e4SLinus Torvalds * xfs_mod_incore_sb_batch() is used to change more than one field 16951da177e4SLinus Torvalds * in the in-core superblock structure at a time. This modification 16961da177e4SLinus Torvalds * is protected by a lock internal to this module. The fields and 16971da177e4SLinus Torvalds * changes to those fields are specified in the array of xfs_mod_sb 16981da177e4SLinus Torvalds * structures passed in. 16991da177e4SLinus Torvalds * 17001da177e4SLinus Torvalds * Either all of the specified deltas will be applied or none of 17011da177e4SLinus Torvalds * them will. If any modified field dips below 0, then all modifications 17021da177e4SLinus Torvalds * will be backed out and EINVAL will be returned. 17031da177e4SLinus Torvalds */ 17041da177e4SLinus Torvalds int 17051da177e4SLinus Torvalds xfs_mod_incore_sb_batch(xfs_mount_t *mp, xfs_mod_sb_t *msb, uint nmsb, int rsvd) 17061da177e4SLinus Torvalds { 17071da177e4SLinus Torvalds int status=0; 17081da177e4SLinus Torvalds xfs_mod_sb_t *msbp; 17091da177e4SLinus Torvalds 17101da177e4SLinus Torvalds /* 17111da177e4SLinus Torvalds * Loop through the array of mod structures and apply each 17121da177e4SLinus Torvalds * individually. If any fail, then back out all those 17131da177e4SLinus Torvalds * which have already been applied. Do all of this within 17143685c2a1SEric Sandeen * the scope of the m_sb_lock so that all of the changes will 17151da177e4SLinus Torvalds * be atomic. 17161da177e4SLinus Torvalds */ 17173685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 17181da177e4SLinus Torvalds msbp = &msb[0]; 17191da177e4SLinus Torvalds for (msbp = &msbp[0]; msbp < (msb + nmsb); msbp++) { 17201da177e4SLinus Torvalds /* 17211da177e4SLinus Torvalds * Apply the delta at index n. If it fails, break 17221da177e4SLinus Torvalds * from the loop so we'll fall into the undo loop 17231da177e4SLinus Torvalds * below. 17241da177e4SLinus Torvalds */ 17258d280b98SDavid Chinner switch (msbp->msb_field) { 17268d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 17278d280b98SDavid Chinner case XFS_SBS_ICOUNT: 17288d280b98SDavid Chinner case XFS_SBS_IFREE: 17298d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 17308d280b98SDavid Chinner if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) { 17313685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 173220b64285SDavid Chinner status = xfs_icsb_modify_counters(mp, 17338d280b98SDavid Chinner msbp->msb_field, 17341da177e4SLinus Torvalds msbp->msb_delta, rsvd); 17353685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 17368d280b98SDavid Chinner break; 17378d280b98SDavid Chinner } 17388d280b98SDavid Chinner /* FALLTHROUGH */ 17398d280b98SDavid Chinner #endif 17408d280b98SDavid Chinner default: 17418d280b98SDavid Chinner status = xfs_mod_incore_sb_unlocked(mp, 17428d280b98SDavid Chinner msbp->msb_field, 17438d280b98SDavid Chinner msbp->msb_delta, rsvd); 17448d280b98SDavid Chinner break; 17458d280b98SDavid Chinner } 17468d280b98SDavid Chinner 17471da177e4SLinus Torvalds if (status != 0) { 17481da177e4SLinus Torvalds break; 17491da177e4SLinus Torvalds } 17501da177e4SLinus Torvalds } 17511da177e4SLinus Torvalds 17521da177e4SLinus Torvalds /* 17531da177e4SLinus Torvalds * If we didn't complete the loop above, then back out 17541da177e4SLinus Torvalds * any changes made to the superblock. If you add code 17551da177e4SLinus Torvalds * between the loop above and here, make sure that you 17561da177e4SLinus Torvalds * preserve the value of status. Loop back until 17571da177e4SLinus Torvalds * we step below the beginning of the array. Make sure 17581da177e4SLinus Torvalds * we don't touch anything back there. 17591da177e4SLinus Torvalds */ 17601da177e4SLinus Torvalds if (status != 0) { 17611da177e4SLinus Torvalds msbp--; 17621da177e4SLinus Torvalds while (msbp >= msb) { 17638d280b98SDavid Chinner switch (msbp->msb_field) { 17648d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 17658d280b98SDavid Chinner case XFS_SBS_ICOUNT: 17668d280b98SDavid Chinner case XFS_SBS_IFREE: 17678d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 17688d280b98SDavid Chinner if (!(mp->m_flags & XFS_MOUNT_NO_PERCPU_SB)) { 17693685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 177020b64285SDavid Chinner status = xfs_icsb_modify_counters(mp, 17718d280b98SDavid Chinner msbp->msb_field, 17728d280b98SDavid Chinner -(msbp->msb_delta), 17738d280b98SDavid Chinner rsvd); 17743685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 17758d280b98SDavid Chinner break; 17768d280b98SDavid Chinner } 17778d280b98SDavid Chinner /* FALLTHROUGH */ 17788d280b98SDavid Chinner #endif 17798d280b98SDavid Chinner default: 17801da177e4SLinus Torvalds status = xfs_mod_incore_sb_unlocked(mp, 17818d280b98SDavid Chinner msbp->msb_field, 17828d280b98SDavid Chinner -(msbp->msb_delta), 17838d280b98SDavid Chinner rsvd); 17848d280b98SDavid Chinner break; 17858d280b98SDavid Chinner } 17861da177e4SLinus Torvalds ASSERT(status == 0); 17871da177e4SLinus Torvalds msbp--; 17881da177e4SLinus Torvalds } 17891da177e4SLinus Torvalds } 17903685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 1791014c2544SJesper Juhl return status; 17921da177e4SLinus Torvalds } 17931da177e4SLinus Torvalds 17941da177e4SLinus Torvalds /* 17951da177e4SLinus Torvalds * xfs_getsb() is called to obtain the buffer for the superblock. 17961da177e4SLinus Torvalds * The buffer is returned locked and read in from disk. 17971da177e4SLinus Torvalds * The buffer should be released with a call to xfs_brelse(). 17981da177e4SLinus Torvalds * 17991da177e4SLinus Torvalds * If the flags parameter is BUF_TRYLOCK, then we'll only return 18001da177e4SLinus Torvalds * the superblock buffer if it can be locked without sleeping. 18011da177e4SLinus Torvalds * If it can't then we'll return NULL. 18021da177e4SLinus Torvalds */ 18031da177e4SLinus Torvalds xfs_buf_t * 18041da177e4SLinus Torvalds xfs_getsb( 18051da177e4SLinus Torvalds xfs_mount_t *mp, 18061da177e4SLinus Torvalds int flags) 18071da177e4SLinus Torvalds { 18081da177e4SLinus Torvalds xfs_buf_t *bp; 18091da177e4SLinus Torvalds 18101da177e4SLinus Torvalds ASSERT(mp->m_sb_bp != NULL); 18111da177e4SLinus Torvalds bp = mp->m_sb_bp; 18121da177e4SLinus Torvalds if (flags & XFS_BUF_TRYLOCK) { 18131da177e4SLinus Torvalds if (!XFS_BUF_CPSEMA(bp)) { 18141da177e4SLinus Torvalds return NULL; 18151da177e4SLinus Torvalds } 18161da177e4SLinus Torvalds } else { 18171da177e4SLinus Torvalds XFS_BUF_PSEMA(bp, PRIBIO); 18181da177e4SLinus Torvalds } 18191da177e4SLinus Torvalds XFS_BUF_HOLD(bp); 18201da177e4SLinus Torvalds ASSERT(XFS_BUF_ISDONE(bp)); 1821014c2544SJesper Juhl return bp; 18221da177e4SLinus Torvalds } 18231da177e4SLinus Torvalds 18241da177e4SLinus Torvalds /* 18251da177e4SLinus Torvalds * Used to free the superblock along various error paths. 18261da177e4SLinus Torvalds */ 18271da177e4SLinus Torvalds void 18281da177e4SLinus Torvalds xfs_freesb( 18291da177e4SLinus Torvalds xfs_mount_t *mp) 18301da177e4SLinus Torvalds { 18311da177e4SLinus Torvalds xfs_buf_t *bp; 18321da177e4SLinus Torvalds 18331da177e4SLinus Torvalds /* 18341da177e4SLinus Torvalds * Use xfs_getsb() so that the buffer will be locked 18351da177e4SLinus Torvalds * when we call xfs_buf_relse(). 18361da177e4SLinus Torvalds */ 18371da177e4SLinus Torvalds bp = xfs_getsb(mp, 0); 18381da177e4SLinus Torvalds XFS_BUF_UNMANAGE(bp); 18391da177e4SLinus Torvalds xfs_buf_relse(bp); 18401da177e4SLinus Torvalds mp->m_sb_bp = NULL; 18411da177e4SLinus Torvalds } 18421da177e4SLinus Torvalds 18431da177e4SLinus Torvalds /* 18441da177e4SLinus Torvalds * See if the UUID is unique among mounted XFS filesystems. 18451da177e4SLinus Torvalds * Mount fails if UUID is nil or a FS with the same UUID is already mounted. 18461da177e4SLinus Torvalds */ 18471da177e4SLinus Torvalds STATIC int 18481da177e4SLinus Torvalds xfs_uuid_mount( 18491da177e4SLinus Torvalds xfs_mount_t *mp) 18501da177e4SLinus Torvalds { 18511da177e4SLinus Torvalds if (uuid_is_nil(&mp->m_sb.sb_uuid)) { 18521da177e4SLinus Torvalds cmn_err(CE_WARN, 18531da177e4SLinus Torvalds "XFS: Filesystem %s has nil UUID - can't mount", 18541da177e4SLinus Torvalds mp->m_fsname); 18551da177e4SLinus Torvalds return -1; 18561da177e4SLinus Torvalds } 18571da177e4SLinus Torvalds if (!uuid_table_insert(&mp->m_sb.sb_uuid)) { 18581da177e4SLinus Torvalds cmn_err(CE_WARN, 18591da177e4SLinus Torvalds "XFS: Filesystem %s has duplicate UUID - can't mount", 18601da177e4SLinus Torvalds mp->m_fsname); 18611da177e4SLinus Torvalds return -1; 18621da177e4SLinus Torvalds } 18631da177e4SLinus Torvalds return 0; 18641da177e4SLinus Torvalds } 18651da177e4SLinus Torvalds 18661da177e4SLinus Torvalds /* 18671da177e4SLinus Torvalds * Remove filesystem from the UUID table. 18681da177e4SLinus Torvalds */ 18691da177e4SLinus Torvalds STATIC void 18701da177e4SLinus Torvalds xfs_uuid_unmount( 18711da177e4SLinus Torvalds xfs_mount_t *mp) 18721da177e4SLinus Torvalds { 18731da177e4SLinus Torvalds uuid_table_remove(&mp->m_sb.sb_uuid); 18741da177e4SLinus Torvalds } 18751da177e4SLinus Torvalds 18761da177e4SLinus Torvalds /* 18771da177e4SLinus Torvalds * Used to log changes to the superblock unit and width fields which could 18781da177e4SLinus Torvalds * be altered by the mount options. Only the first superblock is updated. 18791da177e4SLinus Torvalds */ 18801da177e4SLinus Torvalds STATIC void 18811da177e4SLinus Torvalds xfs_mount_log_sbunit( 18821da177e4SLinus Torvalds xfs_mount_t *mp, 18831da177e4SLinus Torvalds __int64_t fields) 18841da177e4SLinus Torvalds { 18851da177e4SLinus Torvalds xfs_trans_t *tp; 18861da177e4SLinus Torvalds 18871da177e4SLinus Torvalds ASSERT(fields & (XFS_SB_UNIT|XFS_SB_WIDTH|XFS_SB_UUID)); 18881da177e4SLinus Torvalds 18891da177e4SLinus Torvalds tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT); 18901da177e4SLinus Torvalds if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0, 18911da177e4SLinus Torvalds XFS_DEFAULT_LOG_COUNT)) { 18921da177e4SLinus Torvalds xfs_trans_cancel(tp, 0); 18931da177e4SLinus Torvalds return; 18941da177e4SLinus Torvalds } 18951da177e4SLinus Torvalds xfs_mod_sb(tp, fields); 18961c72bf90SEric Sandeen xfs_trans_commit(tp, 0); 18971da177e4SLinus Torvalds } 18988d280b98SDavid Chinner 18998d280b98SDavid Chinner 19008d280b98SDavid Chinner #ifdef HAVE_PERCPU_SB 19018d280b98SDavid Chinner /* 19028d280b98SDavid Chinner * Per-cpu incore superblock counters 19038d280b98SDavid Chinner * 19048d280b98SDavid Chinner * Simple concept, difficult implementation 19058d280b98SDavid Chinner * 19068d280b98SDavid Chinner * Basically, replace the incore superblock counters with a distributed per cpu 19078d280b98SDavid Chinner * counter for contended fields (e.g. free block count). 19088d280b98SDavid Chinner * 19098d280b98SDavid Chinner * Difficulties arise in that the incore sb is used for ENOSPC checking, and 19108d280b98SDavid Chinner * hence needs to be accurately read when we are running low on space. Hence 19118d280b98SDavid Chinner * there is a method to enable and disable the per-cpu counters based on how 19128d280b98SDavid Chinner * much "stuff" is available in them. 19138d280b98SDavid Chinner * 19148d280b98SDavid Chinner * Basically, a counter is enabled if there is enough free resource to justify 19158d280b98SDavid Chinner * running a per-cpu fast-path. If the per-cpu counter runs out (i.e. a local 19168d280b98SDavid Chinner * ENOSPC), then we disable the counters to synchronise all callers and 19178d280b98SDavid Chinner * re-distribute the available resources. 19188d280b98SDavid Chinner * 19198d280b98SDavid Chinner * If, once we redistributed the available resources, we still get a failure, 19208d280b98SDavid Chinner * we disable the per-cpu counter and go through the slow path. 19218d280b98SDavid Chinner * 19228d280b98SDavid Chinner * The slow path is the current xfs_mod_incore_sb() function. This means that 19238d280b98SDavid Chinner * when we disable a per-cpu counter, we need to drain it's resources back to 19248d280b98SDavid Chinner * the global superblock. We do this after disabling the counter to prevent 19258d280b98SDavid Chinner * more threads from queueing up on the counter. 19268d280b98SDavid Chinner * 19278d280b98SDavid Chinner * Essentially, this means that we still need a lock in the fast path to enable 19288d280b98SDavid Chinner * synchronisation between the global counters and the per-cpu counters. This 19298d280b98SDavid Chinner * is not a problem because the lock will be local to a CPU almost all the time 19308d280b98SDavid Chinner * and have little contention except when we get to ENOSPC conditions. 19318d280b98SDavid Chinner * 19328d280b98SDavid Chinner * Basically, this lock becomes a barrier that enables us to lock out the fast 19338d280b98SDavid Chinner * path while we do things like enabling and disabling counters and 19348d280b98SDavid Chinner * synchronising the counters. 19358d280b98SDavid Chinner * 19368d280b98SDavid Chinner * Locking rules: 19378d280b98SDavid Chinner * 19383685c2a1SEric Sandeen * 1. m_sb_lock before picking up per-cpu locks 19398d280b98SDavid Chinner * 2. per-cpu locks always picked up via for_each_online_cpu() order 19403685c2a1SEric Sandeen * 3. accurate counter sync requires m_sb_lock + per cpu locks 19418d280b98SDavid Chinner * 4. modifying per-cpu counters requires holding per-cpu lock 19423685c2a1SEric Sandeen * 5. modifying global counters requires holding m_sb_lock 19433685c2a1SEric Sandeen * 6. enabling or disabling a counter requires holding the m_sb_lock 19448d280b98SDavid Chinner * and _none_ of the per-cpu locks. 19458d280b98SDavid Chinner * 19468d280b98SDavid Chinner * Disabled counters are only ever re-enabled by a balance operation 19478d280b98SDavid Chinner * that results in more free resources per CPU than a given threshold. 19488d280b98SDavid Chinner * To ensure counters don't remain disabled, they are rebalanced when 19498d280b98SDavid Chinner * the global resource goes above a higher threshold (i.e. some hysteresis 19508d280b98SDavid Chinner * is present to prevent thrashing). 19518d280b98SDavid Chinner */ 1952e8234a68SDavid Chinner 19535a67e4c5SChandra Seetharaman #ifdef CONFIG_HOTPLUG_CPU 1954e8234a68SDavid Chinner /* 1955e8234a68SDavid Chinner * hot-plug CPU notifier support. 1956e8234a68SDavid Chinner * 19575a67e4c5SChandra Seetharaman * We need a notifier per filesystem as we need to be able to identify 19585a67e4c5SChandra Seetharaman * the filesystem to balance the counters out. This is achieved by 19595a67e4c5SChandra Seetharaman * having a notifier block embedded in the xfs_mount_t and doing pointer 19605a67e4c5SChandra Seetharaman * magic to get the mount pointer from the notifier block address. 1961e8234a68SDavid Chinner */ 1962e8234a68SDavid Chinner STATIC int 1963e8234a68SDavid Chinner xfs_icsb_cpu_notify( 1964e8234a68SDavid Chinner struct notifier_block *nfb, 1965e8234a68SDavid Chinner unsigned long action, 1966e8234a68SDavid Chinner void *hcpu) 1967e8234a68SDavid Chinner { 1968e8234a68SDavid Chinner xfs_icsb_cnts_t *cntp; 1969e8234a68SDavid Chinner xfs_mount_t *mp; 1970e8234a68SDavid Chinner 1971e8234a68SDavid Chinner mp = (xfs_mount_t *)container_of(nfb, xfs_mount_t, m_icsb_notifier); 1972e8234a68SDavid Chinner cntp = (xfs_icsb_cnts_t *) 1973e8234a68SDavid Chinner per_cpu_ptr(mp->m_sb_cnts, (unsigned long)hcpu); 1974e8234a68SDavid Chinner switch (action) { 1975e8234a68SDavid Chinner case CPU_UP_PREPARE: 19768bb78442SRafael J. Wysocki case CPU_UP_PREPARE_FROZEN: 1977e8234a68SDavid Chinner /* Easy Case - initialize the area and locks, and 1978e8234a68SDavid Chinner * then rebalance when online does everything else for us. */ 197901e1b69cSDavid Chinner memset(cntp, 0, sizeof(xfs_icsb_cnts_t)); 1980e8234a68SDavid Chinner break; 1981e8234a68SDavid Chinner case CPU_ONLINE: 19828bb78442SRafael J. Wysocki case CPU_ONLINE_FROZEN: 198303135cf7SDavid Chinner xfs_icsb_lock(mp); 198420b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0, 0); 198520b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0, 0); 198620b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0, 0); 198703135cf7SDavid Chinner xfs_icsb_unlock(mp); 1988e8234a68SDavid Chinner break; 1989e8234a68SDavid Chinner case CPU_DEAD: 19908bb78442SRafael J. Wysocki case CPU_DEAD_FROZEN: 1991e8234a68SDavid Chinner /* Disable all the counters, then fold the dead cpu's 1992e8234a68SDavid Chinner * count into the total on the global superblock and 1993e8234a68SDavid Chinner * re-enable the counters. */ 199403135cf7SDavid Chinner xfs_icsb_lock(mp); 19953685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 1996e8234a68SDavid Chinner xfs_icsb_disable_counter(mp, XFS_SBS_ICOUNT); 1997e8234a68SDavid Chinner xfs_icsb_disable_counter(mp, XFS_SBS_IFREE); 1998e8234a68SDavid Chinner xfs_icsb_disable_counter(mp, XFS_SBS_FDBLOCKS); 1999e8234a68SDavid Chinner 2000e8234a68SDavid Chinner mp->m_sb.sb_icount += cntp->icsb_icount; 2001e8234a68SDavid Chinner mp->m_sb.sb_ifree += cntp->icsb_ifree; 2002e8234a68SDavid Chinner mp->m_sb.sb_fdblocks += cntp->icsb_fdblocks; 2003e8234a68SDavid Chinner 200401e1b69cSDavid Chinner memset(cntp, 0, sizeof(xfs_icsb_cnts_t)); 2005e8234a68SDavid Chinner 200620b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 200720b64285SDavid Chinner XFS_ICSB_SB_LOCKED, 0); 200820b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 200920b64285SDavid Chinner XFS_ICSB_SB_LOCKED, 0); 201020b64285SDavid Chinner xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 201120b64285SDavid Chinner XFS_ICSB_SB_LOCKED, 0); 20123685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 201303135cf7SDavid Chinner xfs_icsb_unlock(mp); 2014e8234a68SDavid Chinner break; 2015e8234a68SDavid Chinner } 2016e8234a68SDavid Chinner 2017e8234a68SDavid Chinner return NOTIFY_OK; 2018e8234a68SDavid Chinner } 20195a67e4c5SChandra Seetharaman #endif /* CONFIG_HOTPLUG_CPU */ 2020e8234a68SDavid Chinner 20218d280b98SDavid Chinner int 20228d280b98SDavid Chinner xfs_icsb_init_counters( 20238d280b98SDavid Chinner xfs_mount_t *mp) 20248d280b98SDavid Chinner { 20258d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 20268d280b98SDavid Chinner int i; 20278d280b98SDavid Chinner 20288d280b98SDavid Chinner mp->m_sb_cnts = alloc_percpu(xfs_icsb_cnts_t); 20298d280b98SDavid Chinner if (mp->m_sb_cnts == NULL) 20308d280b98SDavid Chinner return -ENOMEM; 20318d280b98SDavid Chinner 20325a67e4c5SChandra Seetharaman #ifdef CONFIG_HOTPLUG_CPU 2033e8234a68SDavid Chinner mp->m_icsb_notifier.notifier_call = xfs_icsb_cpu_notify; 2034e8234a68SDavid Chinner mp->m_icsb_notifier.priority = 0; 20355a67e4c5SChandra Seetharaman register_hotcpu_notifier(&mp->m_icsb_notifier); 20365a67e4c5SChandra Seetharaman #endif /* CONFIG_HOTPLUG_CPU */ 2037e8234a68SDavid Chinner 20388d280b98SDavid Chinner for_each_online_cpu(i) { 20398d280b98SDavid Chinner cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 204001e1b69cSDavid Chinner memset(cntp, 0, sizeof(xfs_icsb_cnts_t)); 20418d280b98SDavid Chinner } 204220b64285SDavid Chinner 204320b64285SDavid Chinner mutex_init(&mp->m_icsb_mutex); 204420b64285SDavid Chinner 20458d280b98SDavid Chinner /* 20468d280b98SDavid Chinner * start with all counters disabled so that the 20478d280b98SDavid Chinner * initial balance kicks us off correctly 20488d280b98SDavid Chinner */ 20498d280b98SDavid Chinner mp->m_icsb_counters = -1; 20508d280b98SDavid Chinner return 0; 20518d280b98SDavid Chinner } 20528d280b98SDavid Chinner 20535478eeadSLachlan McIlroy void 20545478eeadSLachlan McIlroy xfs_icsb_reinit_counters( 20555478eeadSLachlan McIlroy xfs_mount_t *mp) 20565478eeadSLachlan McIlroy { 20575478eeadSLachlan McIlroy xfs_icsb_lock(mp); 20585478eeadSLachlan McIlroy /* 20595478eeadSLachlan McIlroy * start with all counters disabled so that the 20605478eeadSLachlan McIlroy * initial balance kicks us off correctly 20615478eeadSLachlan McIlroy */ 20625478eeadSLachlan McIlroy mp->m_icsb_counters = -1; 20635478eeadSLachlan McIlroy xfs_icsb_balance_counter(mp, XFS_SBS_ICOUNT, 0, 0); 20645478eeadSLachlan McIlroy xfs_icsb_balance_counter(mp, XFS_SBS_IFREE, 0, 0); 20655478eeadSLachlan McIlroy xfs_icsb_balance_counter(mp, XFS_SBS_FDBLOCKS, 0, 0); 20665478eeadSLachlan McIlroy xfs_icsb_unlock(mp); 20675478eeadSLachlan McIlroy } 20685478eeadSLachlan McIlroy 20698d280b98SDavid Chinner STATIC void 20708d280b98SDavid Chinner xfs_icsb_destroy_counters( 20718d280b98SDavid Chinner xfs_mount_t *mp) 20728d280b98SDavid Chinner { 2073e8234a68SDavid Chinner if (mp->m_sb_cnts) { 20745a67e4c5SChandra Seetharaman unregister_hotcpu_notifier(&mp->m_icsb_notifier); 20758d280b98SDavid Chinner free_percpu(mp->m_sb_cnts); 20768d280b98SDavid Chinner } 207703135cf7SDavid Chinner mutex_destroy(&mp->m_icsb_mutex); 2078e8234a68SDavid Chinner } 20798d280b98SDavid Chinner 20807989cb8eSDavid Chinner STATIC_INLINE void 208101e1b69cSDavid Chinner xfs_icsb_lock_cntr( 208201e1b69cSDavid Chinner xfs_icsb_cnts_t *icsbp) 208301e1b69cSDavid Chinner { 208401e1b69cSDavid Chinner while (test_and_set_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags)) { 208501e1b69cSDavid Chinner ndelay(1000); 208601e1b69cSDavid Chinner } 208701e1b69cSDavid Chinner } 208801e1b69cSDavid Chinner 20897989cb8eSDavid Chinner STATIC_INLINE void 209001e1b69cSDavid Chinner xfs_icsb_unlock_cntr( 209101e1b69cSDavid Chinner xfs_icsb_cnts_t *icsbp) 209201e1b69cSDavid Chinner { 209301e1b69cSDavid Chinner clear_bit(XFS_ICSB_FLAG_LOCK, &icsbp->icsb_flags); 209401e1b69cSDavid Chinner } 209501e1b69cSDavid Chinner 20968d280b98SDavid Chinner 20977989cb8eSDavid Chinner STATIC_INLINE void 20988d280b98SDavid Chinner xfs_icsb_lock_all_counters( 20998d280b98SDavid Chinner xfs_mount_t *mp) 21008d280b98SDavid Chinner { 21018d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 21028d280b98SDavid Chinner int i; 21038d280b98SDavid Chinner 21048d280b98SDavid Chinner for_each_online_cpu(i) { 21058d280b98SDavid Chinner cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 210601e1b69cSDavid Chinner xfs_icsb_lock_cntr(cntp); 21078d280b98SDavid Chinner } 21088d280b98SDavid Chinner } 21098d280b98SDavid Chinner 21107989cb8eSDavid Chinner STATIC_INLINE void 21118d280b98SDavid Chinner xfs_icsb_unlock_all_counters( 21128d280b98SDavid Chinner xfs_mount_t *mp) 21138d280b98SDavid Chinner { 21148d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 21158d280b98SDavid Chinner int i; 21168d280b98SDavid Chinner 21178d280b98SDavid Chinner for_each_online_cpu(i) { 21188d280b98SDavid Chinner cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 211901e1b69cSDavid Chinner xfs_icsb_unlock_cntr(cntp); 21208d280b98SDavid Chinner } 21218d280b98SDavid Chinner } 21228d280b98SDavid Chinner 21238d280b98SDavid Chinner STATIC void 21248d280b98SDavid Chinner xfs_icsb_count( 21258d280b98SDavid Chinner xfs_mount_t *mp, 21268d280b98SDavid Chinner xfs_icsb_cnts_t *cnt, 21278d280b98SDavid Chinner int flags) 21288d280b98SDavid Chinner { 21298d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 21308d280b98SDavid Chinner int i; 21318d280b98SDavid Chinner 21328d280b98SDavid Chinner memset(cnt, 0, sizeof(xfs_icsb_cnts_t)); 21338d280b98SDavid Chinner 21348d280b98SDavid Chinner if (!(flags & XFS_ICSB_LAZY_COUNT)) 21358d280b98SDavid Chinner xfs_icsb_lock_all_counters(mp); 21368d280b98SDavid Chinner 21378d280b98SDavid Chinner for_each_online_cpu(i) { 21388d280b98SDavid Chinner cntp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, i); 21398d280b98SDavid Chinner cnt->icsb_icount += cntp->icsb_icount; 21408d280b98SDavid Chinner cnt->icsb_ifree += cntp->icsb_ifree; 21418d280b98SDavid Chinner cnt->icsb_fdblocks += cntp->icsb_fdblocks; 21428d280b98SDavid Chinner } 21438d280b98SDavid Chinner 21448d280b98SDavid Chinner if (!(flags & XFS_ICSB_LAZY_COUNT)) 21458d280b98SDavid Chinner xfs_icsb_unlock_all_counters(mp); 21468d280b98SDavid Chinner } 21478d280b98SDavid Chinner 21488d280b98SDavid Chinner STATIC int 21498d280b98SDavid Chinner xfs_icsb_counter_disabled( 21508d280b98SDavid Chinner xfs_mount_t *mp, 21518d280b98SDavid Chinner xfs_sb_field_t field) 21528d280b98SDavid Chinner { 21538d280b98SDavid Chinner ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS)); 21548d280b98SDavid Chinner return test_bit(field, &mp->m_icsb_counters); 21558d280b98SDavid Chinner } 21568d280b98SDavid Chinner 21578d280b98SDavid Chinner STATIC int 21588d280b98SDavid Chinner xfs_icsb_disable_counter( 21598d280b98SDavid Chinner xfs_mount_t *mp, 21608d280b98SDavid Chinner xfs_sb_field_t field) 21618d280b98SDavid Chinner { 21628d280b98SDavid Chinner xfs_icsb_cnts_t cnt; 21638d280b98SDavid Chinner 21648d280b98SDavid Chinner ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS)); 21658d280b98SDavid Chinner 216620b64285SDavid Chinner /* 216720b64285SDavid Chinner * If we are already disabled, then there is nothing to do 216820b64285SDavid Chinner * here. We check before locking all the counters to avoid 216920b64285SDavid Chinner * the expensive lock operation when being called in the 217020b64285SDavid Chinner * slow path and the counter is already disabled. This is 217120b64285SDavid Chinner * safe because the only time we set or clear this state is under 217220b64285SDavid Chinner * the m_icsb_mutex. 217320b64285SDavid Chinner */ 217420b64285SDavid Chinner if (xfs_icsb_counter_disabled(mp, field)) 217520b64285SDavid Chinner return 0; 217620b64285SDavid Chinner 21778d280b98SDavid Chinner xfs_icsb_lock_all_counters(mp); 21788d280b98SDavid Chinner if (!test_and_set_bit(field, &mp->m_icsb_counters)) { 21798d280b98SDavid Chinner /* drain back to superblock */ 21808d280b98SDavid Chinner 21818d280b98SDavid Chinner xfs_icsb_count(mp, &cnt, XFS_ICSB_SB_LOCKED|XFS_ICSB_LAZY_COUNT); 21828d280b98SDavid Chinner switch(field) { 21838d280b98SDavid Chinner case XFS_SBS_ICOUNT: 21848d280b98SDavid Chinner mp->m_sb.sb_icount = cnt.icsb_icount; 21858d280b98SDavid Chinner break; 21868d280b98SDavid Chinner case XFS_SBS_IFREE: 21878d280b98SDavid Chinner mp->m_sb.sb_ifree = cnt.icsb_ifree; 21888d280b98SDavid Chinner break; 21898d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 21908d280b98SDavid Chinner mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks; 21918d280b98SDavid Chinner break; 21928d280b98SDavid Chinner default: 21938d280b98SDavid Chinner BUG(); 21948d280b98SDavid Chinner } 21958d280b98SDavid Chinner } 21968d280b98SDavid Chinner 21978d280b98SDavid Chinner xfs_icsb_unlock_all_counters(mp); 21988d280b98SDavid Chinner 21998d280b98SDavid Chinner return 0; 22008d280b98SDavid Chinner } 22018d280b98SDavid Chinner 22028d280b98SDavid Chinner STATIC void 22038d280b98SDavid Chinner xfs_icsb_enable_counter( 22048d280b98SDavid Chinner xfs_mount_t *mp, 22058d280b98SDavid Chinner xfs_sb_field_t field, 22068d280b98SDavid Chinner uint64_t count, 22078d280b98SDavid Chinner uint64_t resid) 22088d280b98SDavid Chinner { 22098d280b98SDavid Chinner xfs_icsb_cnts_t *cntp; 22108d280b98SDavid Chinner int i; 22118d280b98SDavid Chinner 22128d280b98SDavid Chinner ASSERT((field >= XFS_SBS_ICOUNT) && (field <= XFS_SBS_FDBLOCKS)); 22138d280b98SDavid Chinner 22148d280b98SDavid Chinner xfs_icsb_lock_all_counters(mp); 22158d280b98SDavid Chinner for_each_online_cpu(i) { 22168d280b98SDavid Chinner cntp = per_cpu_ptr(mp->m_sb_cnts, i); 22178d280b98SDavid Chinner switch (field) { 22188d280b98SDavid Chinner case XFS_SBS_ICOUNT: 22198d280b98SDavid Chinner cntp->icsb_icount = count + resid; 22208d280b98SDavid Chinner break; 22218d280b98SDavid Chinner case XFS_SBS_IFREE: 22228d280b98SDavid Chinner cntp->icsb_ifree = count + resid; 22238d280b98SDavid Chinner break; 22248d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 22258d280b98SDavid Chinner cntp->icsb_fdblocks = count + resid; 22268d280b98SDavid Chinner break; 22278d280b98SDavid Chinner default: 22288d280b98SDavid Chinner BUG(); 22298d280b98SDavid Chinner break; 22308d280b98SDavid Chinner } 22318d280b98SDavid Chinner resid = 0; 22328d280b98SDavid Chinner } 22338d280b98SDavid Chinner clear_bit(field, &mp->m_icsb_counters); 22348d280b98SDavid Chinner xfs_icsb_unlock_all_counters(mp); 22358d280b98SDavid Chinner } 22368d280b98SDavid Chinner 2237dbcabad1SDavid Chinner void 2238dbcabad1SDavid Chinner xfs_icsb_sync_counters_flags( 22398d280b98SDavid Chinner xfs_mount_t *mp, 22408d280b98SDavid Chinner int flags) 22418d280b98SDavid Chinner { 22428d280b98SDavid Chinner xfs_icsb_cnts_t cnt; 22438d280b98SDavid Chinner 22448d280b98SDavid Chinner /* Pass 1: lock all counters */ 22458d280b98SDavid Chinner if ((flags & XFS_ICSB_SB_LOCKED) == 0) 22463685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 22478d280b98SDavid Chinner 22488d280b98SDavid Chinner xfs_icsb_count(mp, &cnt, flags); 22498d280b98SDavid Chinner 22508d280b98SDavid Chinner /* Step 3: update mp->m_sb fields */ 22518d280b98SDavid Chinner if (!xfs_icsb_counter_disabled(mp, XFS_SBS_ICOUNT)) 22528d280b98SDavid Chinner mp->m_sb.sb_icount = cnt.icsb_icount; 22538d280b98SDavid Chinner if (!xfs_icsb_counter_disabled(mp, XFS_SBS_IFREE)) 22548d280b98SDavid Chinner mp->m_sb.sb_ifree = cnt.icsb_ifree; 22558d280b98SDavid Chinner if (!xfs_icsb_counter_disabled(mp, XFS_SBS_FDBLOCKS)) 22568d280b98SDavid Chinner mp->m_sb.sb_fdblocks = cnt.icsb_fdblocks; 22578d280b98SDavid Chinner 22588d280b98SDavid Chinner if ((flags & XFS_ICSB_SB_LOCKED) == 0) 22593685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 22608d280b98SDavid Chinner } 22618d280b98SDavid Chinner 22628d280b98SDavid Chinner /* 22638d280b98SDavid Chinner * Accurate update of per-cpu counters to incore superblock 22648d280b98SDavid Chinner */ 22658d280b98SDavid Chinner STATIC void 22668d280b98SDavid Chinner xfs_icsb_sync_counters( 22678d280b98SDavid Chinner xfs_mount_t *mp) 22688d280b98SDavid Chinner { 2269dbcabad1SDavid Chinner xfs_icsb_sync_counters_flags(mp, 0); 22708d280b98SDavid Chinner } 22718d280b98SDavid Chinner 22728d280b98SDavid Chinner /* 22738d280b98SDavid Chinner * Balance and enable/disable counters as necessary. 22748d280b98SDavid Chinner * 227520b64285SDavid Chinner * Thresholds for re-enabling counters are somewhat magic. inode counts are 227620b64285SDavid Chinner * chosen to be the same number as single on disk allocation chunk per CPU, and 227720b64285SDavid Chinner * free blocks is something far enough zero that we aren't going thrash when we 227820b64285SDavid Chinner * get near ENOSPC. We also need to supply a minimum we require per cpu to 227920b64285SDavid Chinner * prevent looping endlessly when xfs_alloc_space asks for more than will 228020b64285SDavid Chinner * be distributed to a single CPU but each CPU has enough blocks to be 228120b64285SDavid Chinner * reenabled. 228220b64285SDavid Chinner * 228320b64285SDavid Chinner * Note that we can be called when counters are already disabled. 228420b64285SDavid Chinner * xfs_icsb_disable_counter() optimises the counter locking in this case to 228520b64285SDavid Chinner * prevent locking every per-cpu counter needlessly. 22868d280b98SDavid Chinner */ 228720b64285SDavid Chinner 228820b64285SDavid Chinner #define XFS_ICSB_INO_CNTR_REENABLE (uint64_t)64 22894be536deSDavid Chinner #define XFS_ICSB_FDBLK_CNTR_REENABLE(mp) \ 229020b64285SDavid Chinner (uint64_t)(512 + XFS_ALLOC_SET_ASIDE(mp)) 22918d280b98SDavid Chinner STATIC void 22928d280b98SDavid Chinner xfs_icsb_balance_counter( 22938d280b98SDavid Chinner xfs_mount_t *mp, 22948d280b98SDavid Chinner xfs_sb_field_t field, 229520b64285SDavid Chinner int flags, 229620b64285SDavid Chinner int min_per_cpu) 22978d280b98SDavid Chinner { 22986fdf8cccSNathan Scott uint64_t count, resid; 22998d280b98SDavid Chinner int weight = num_online_cpus(); 230020b64285SDavid Chinner uint64_t min = (uint64_t)min_per_cpu; 23018d280b98SDavid Chinner 23028d280b98SDavid Chinner if (!(flags & XFS_ICSB_SB_LOCKED)) 23033685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 23048d280b98SDavid Chinner 23058d280b98SDavid Chinner /* disable counter and sync counter */ 23068d280b98SDavid Chinner xfs_icsb_disable_counter(mp, field); 23078d280b98SDavid Chinner 23088d280b98SDavid Chinner /* update counters - first CPU gets residual*/ 23098d280b98SDavid Chinner switch (field) { 23108d280b98SDavid Chinner case XFS_SBS_ICOUNT: 23118d280b98SDavid Chinner count = mp->m_sb.sb_icount; 23128d280b98SDavid Chinner resid = do_div(count, weight); 231320b64285SDavid Chinner if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE)) 23148d280b98SDavid Chinner goto out; 23158d280b98SDavid Chinner break; 23168d280b98SDavid Chinner case XFS_SBS_IFREE: 23178d280b98SDavid Chinner count = mp->m_sb.sb_ifree; 23188d280b98SDavid Chinner resid = do_div(count, weight); 231920b64285SDavid Chinner if (count < max(min, XFS_ICSB_INO_CNTR_REENABLE)) 23208d280b98SDavid Chinner goto out; 23218d280b98SDavid Chinner break; 23228d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 23238d280b98SDavid Chinner count = mp->m_sb.sb_fdblocks; 23248d280b98SDavid Chinner resid = do_div(count, weight); 232520b64285SDavid Chinner if (count < max(min, XFS_ICSB_FDBLK_CNTR_REENABLE(mp))) 23268d280b98SDavid Chinner goto out; 23278d280b98SDavid Chinner break; 23288d280b98SDavid Chinner default: 23298d280b98SDavid Chinner BUG(); 23306fdf8cccSNathan Scott count = resid = 0; /* quiet, gcc */ 23318d280b98SDavid Chinner break; 23328d280b98SDavid Chinner } 23338d280b98SDavid Chinner 23348d280b98SDavid Chinner xfs_icsb_enable_counter(mp, field, count, resid); 23358d280b98SDavid Chinner out: 23368d280b98SDavid Chinner if (!(flags & XFS_ICSB_SB_LOCKED)) 23373685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 23388d280b98SDavid Chinner } 23398d280b98SDavid Chinner 2340a8272ce0SDavid Chinner STATIC int 234120b64285SDavid Chinner xfs_icsb_modify_counters( 23428d280b98SDavid Chinner xfs_mount_t *mp, 23438d280b98SDavid Chinner xfs_sb_field_t field, 234420f4ebf2SDavid Chinner int64_t delta, 234520b64285SDavid Chinner int rsvd) 23468d280b98SDavid Chinner { 23478d280b98SDavid Chinner xfs_icsb_cnts_t *icsbp; 23488d280b98SDavid Chinner long long lcounter; /* long counter for 64 bit fields */ 2349007c61c6SEric Sandeen int cpu, ret = 0; 23508d280b98SDavid Chinner 235120b64285SDavid Chinner might_sleep(); 23528d280b98SDavid Chinner again: 23538d280b98SDavid Chinner cpu = get_cpu(); 235420b64285SDavid Chinner icsbp = (xfs_icsb_cnts_t *)per_cpu_ptr(mp->m_sb_cnts, cpu); 235520b64285SDavid Chinner 235620b64285SDavid Chinner /* 235720b64285SDavid Chinner * if the counter is disabled, go to slow path 235820b64285SDavid Chinner */ 23598d280b98SDavid Chinner if (unlikely(xfs_icsb_counter_disabled(mp, field))) 23608d280b98SDavid Chinner goto slow_path; 236120b64285SDavid Chinner xfs_icsb_lock_cntr(icsbp); 236220b64285SDavid Chinner if (unlikely(xfs_icsb_counter_disabled(mp, field))) { 236320b64285SDavid Chinner xfs_icsb_unlock_cntr(icsbp); 236420b64285SDavid Chinner goto slow_path; 236520b64285SDavid Chinner } 23668d280b98SDavid Chinner 23678d280b98SDavid Chinner switch (field) { 23688d280b98SDavid Chinner case XFS_SBS_ICOUNT: 23698d280b98SDavid Chinner lcounter = icsbp->icsb_icount; 23708d280b98SDavid Chinner lcounter += delta; 23718d280b98SDavid Chinner if (unlikely(lcounter < 0)) 237220b64285SDavid Chinner goto balance_counter; 23738d280b98SDavid Chinner icsbp->icsb_icount = lcounter; 23748d280b98SDavid Chinner break; 23758d280b98SDavid Chinner 23768d280b98SDavid Chinner case XFS_SBS_IFREE: 23778d280b98SDavid Chinner lcounter = icsbp->icsb_ifree; 23788d280b98SDavid Chinner lcounter += delta; 23798d280b98SDavid Chinner if (unlikely(lcounter < 0)) 238020b64285SDavid Chinner goto balance_counter; 23818d280b98SDavid Chinner icsbp->icsb_ifree = lcounter; 23828d280b98SDavid Chinner break; 23838d280b98SDavid Chinner 23848d280b98SDavid Chinner case XFS_SBS_FDBLOCKS: 23858d280b98SDavid Chinner BUG_ON((mp->m_resblks - mp->m_resblks_avail) != 0); 23868d280b98SDavid Chinner 23874be536deSDavid Chinner lcounter = icsbp->icsb_fdblocks - XFS_ALLOC_SET_ASIDE(mp); 23888d280b98SDavid Chinner lcounter += delta; 23898d280b98SDavid Chinner if (unlikely(lcounter < 0)) 239020b64285SDavid Chinner goto balance_counter; 23914be536deSDavid Chinner icsbp->icsb_fdblocks = lcounter + XFS_ALLOC_SET_ASIDE(mp); 23928d280b98SDavid Chinner break; 23938d280b98SDavid Chinner default: 23948d280b98SDavid Chinner BUG(); 23958d280b98SDavid Chinner break; 23968d280b98SDavid Chinner } 239701e1b69cSDavid Chinner xfs_icsb_unlock_cntr(icsbp); 23988d280b98SDavid Chinner put_cpu(); 23998d280b98SDavid Chinner return 0; 24008d280b98SDavid Chinner 24018d280b98SDavid Chinner slow_path: 240220b64285SDavid Chinner put_cpu(); 240320b64285SDavid Chinner 240420b64285SDavid Chinner /* 240520b64285SDavid Chinner * serialise with a mutex so we don't burn lots of cpu on 240620b64285SDavid Chinner * the superblock lock. We still need to hold the superblock 240720b64285SDavid Chinner * lock, however, when we modify the global structures. 240820b64285SDavid Chinner */ 240903135cf7SDavid Chinner xfs_icsb_lock(mp); 241020b64285SDavid Chinner 241120b64285SDavid Chinner /* 241220b64285SDavid Chinner * Now running atomically. 241320b64285SDavid Chinner * 241420b64285SDavid Chinner * If the counter is enabled, someone has beaten us to rebalancing. 241520b64285SDavid Chinner * Drop the lock and try again in the fast path.... 241620b64285SDavid Chinner */ 241720b64285SDavid Chinner if (!(xfs_icsb_counter_disabled(mp, field))) { 241803135cf7SDavid Chinner xfs_icsb_unlock(mp); 241920b64285SDavid Chinner goto again; 242020b64285SDavid Chinner } 242120b64285SDavid Chinner 242220b64285SDavid Chinner /* 242320b64285SDavid Chinner * The counter is currently disabled. Because we are 242420b64285SDavid Chinner * running atomically here, we know a rebalance cannot 242520b64285SDavid Chinner * be in progress. Hence we can go straight to operating 242620b64285SDavid Chinner * on the global superblock. We do not call xfs_mod_incore_sb() 24273685c2a1SEric Sandeen * here even though we need to get the m_sb_lock. Doing so 242820b64285SDavid Chinner * will cause us to re-enter this function and deadlock. 24293685c2a1SEric Sandeen * Hence we get the m_sb_lock ourselves and then call 243020b64285SDavid Chinner * xfs_mod_incore_sb_unlocked() as the unlocked path operates 243120b64285SDavid Chinner * directly on the global counters. 243220b64285SDavid Chinner */ 24333685c2a1SEric Sandeen spin_lock(&mp->m_sb_lock); 243420b64285SDavid Chinner ret = xfs_mod_incore_sb_unlocked(mp, field, delta, rsvd); 24353685c2a1SEric Sandeen spin_unlock(&mp->m_sb_lock); 243620b64285SDavid Chinner 243720b64285SDavid Chinner /* 243820b64285SDavid Chinner * Now that we've modified the global superblock, we 243920b64285SDavid Chinner * may be able to re-enable the distributed counters 244020b64285SDavid Chinner * (e.g. lots of space just got freed). After that 244120b64285SDavid Chinner * we are done. 244220b64285SDavid Chinner */ 244320b64285SDavid Chinner if (ret != ENOSPC) 244420b64285SDavid Chinner xfs_icsb_balance_counter(mp, field, 0, 0); 244503135cf7SDavid Chinner xfs_icsb_unlock(mp); 244620b64285SDavid Chinner return ret; 244720b64285SDavid Chinner 244820b64285SDavid Chinner balance_counter: 244901e1b69cSDavid Chinner xfs_icsb_unlock_cntr(icsbp); 24508d280b98SDavid Chinner put_cpu(); 24518d280b98SDavid Chinner 245220b64285SDavid Chinner /* 245320b64285SDavid Chinner * We may have multiple threads here if multiple per-cpu 245420b64285SDavid Chinner * counters run dry at the same time. This will mean we can 245520b64285SDavid Chinner * do more balances than strictly necessary but it is not 245620b64285SDavid Chinner * the common slowpath case. 245720b64285SDavid Chinner */ 245803135cf7SDavid Chinner xfs_icsb_lock(mp); 245920b64285SDavid Chinner 246020b64285SDavid Chinner /* 246120b64285SDavid Chinner * running atomically. 246220b64285SDavid Chinner * 246320b64285SDavid Chinner * This will leave the counter in the correct state for future 246420b64285SDavid Chinner * accesses. After the rebalance, we simply try again and our retry 246520b64285SDavid Chinner * will either succeed through the fast path or slow path without 246620b64285SDavid Chinner * another balance operation being required. 246720b64285SDavid Chinner */ 246820b64285SDavid Chinner xfs_icsb_balance_counter(mp, field, 0, delta); 246903135cf7SDavid Chinner xfs_icsb_unlock(mp); 24708d280b98SDavid Chinner goto again; 24718d280b98SDavid Chinner } 24728d280b98SDavid Chinner 24738d280b98SDavid Chinner #endif 2474