1 files changed, 38 insertions, 80 deletions

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index da3988453b71..6c5d1325e7f6 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -47,12 +47,10 @@
 
 STATIC int      xfs_mount_log_sb(xfs_mount_t *, __int64_t);
 STATIC int      xfs_uuid_mount(xfs_mount_t *);
-STATIC void     xfs_uuid_unmount(xfs_mount_t *mp);
 STATIC void     xfs_unmountfs_wait(xfs_mount_t *);
 
 
 #ifdef HAVE_PERCPU_SB
-STATIC void     xfs_icsb_destroy_counters(xfs_mount_t *);
 STATIC void     xfs_icsb_balance_counter(xfs_mount_t *, xfs_sb_field_t,
                                                 int);
 STATIC void     xfs_icsb_balance_counter_locked(xfs_mount_t *, xfs_sb_field_t,
@@ -63,7 +61,6 @@ STATIC void	xfs_icsb_disable_counter(xfs_mount_t *, xfs_sb_field_t);
 
 #else
 
-#define xfs_icsb_destroy_counters(mp)                   do { } while (0)
 #define xfs_icsb_balance_counter(mp, a, b)              do { } while (0)
 #define xfs_icsb_balance_counter_locked(mp, a, b)       do { } while (0)
 #define xfs_icsb_modify_counters(mp, a, b, c)           do { } while (0)
@@ -126,33 +123,11 @@ static const struct {
 };
 
 /*
- * Return a pointer to an initialized xfs_mount structure.
- */
-xfs_mount_t *
-xfs_mount_init(void)
-{
-        xfs_mount_t *mp;
-
-        mp = kmem_zalloc(sizeof(xfs_mount_t), KM_SLEEP);
-
-        if (xfs_icsb_init_counters(mp)) {
-                mp->m_flags |= XFS_MOUNT_NO_PERCPU_SB;
-        }
-
-        spin_lock_init(&mp->m_sb_lock);
-        mutex_init(&mp->m_ilock);
-        mutex_init(&mp->m_growlock);
-        atomic_set(&mp->m_active_trans, 0);
-
-        return mp;
-}
-
-/*
  * Free up the resources associated with a mount structure.  Assume that
  * the structure was initially zeroed, so we can tell which fields got
  * initialized.
  */
-void
+STATIC void
 xfs_mount_free(
         xfs_mount_t     *mp)
 {
@@ -161,11 +136,8 @@ xfs_mount_free(
 
                 for (agno = 0; agno < mp->m_maxagi; agno++)
                         if (mp->m_perag[agno].pagb_list)
-                                kmem_free(mp->m_perag[agno].pagb_list,
-                                                sizeof(xfs_perag_busy_t) *
-                                                        XFS_PAGB_NUM_SLOTS);
-                kmem_free(mp->m_perag,
-                          sizeof(xfs_perag_t) * mp->m_sb.sb_agcount);
+                                kmem_free(mp->m_perag[agno].pagb_list);
+                kmem_free(mp->m_perag);
         }
 
         spinlock_destroy(&mp->m_ail_lock);
@@ -176,13 +148,11 @@ xfs_mount_free(
                 XFS_QM_DONE(mp);
 
         if (mp->m_fsname != NULL)
-                kmem_free(mp->m_fsname, mp->m_fsname_len);
+                kmem_free(mp->m_fsname);
         if (mp->m_rtname != NULL)
-                kmem_free(mp->m_rtname, strlen(mp->m_rtname) + 1);
+                kmem_free(mp->m_rtname);
         if (mp->m_logname != NULL)
-                kmem_free(mp->m_logname, strlen(mp->m_logname) + 1);
-
-        xfs_icsb_destroy_counters(mp);
+                kmem_free(mp->m_logname);
 }
 
 /*
@@ -288,6 +258,19 @@ xfs_mount_validate_sb(
                 return XFS_ERROR(EFSCORRUPTED);
         }
 
+        /*
+         * Until this is fixed only page-sized or smaller data blocks work.
+         */
+        if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) {
+                xfs_fs_mount_cmn_err(flags,
+                        "file system with blocksize %d bytes",
+                        sbp->sb_blocksize);
+                xfs_fs_mount_cmn_err(flags,
+                        "only pagesize (%ld) or less will currently work.",
+                        PAGE_SIZE);
+                return XFS_ERROR(ENOSYS);
+        }
+
         if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) ||
             xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) {
                 xfs_fs_mount_cmn_err(flags,
@@ -309,19 +292,6 @@ xfs_mount_validate_sb(
                 return XFS_ERROR(ENOSYS);
         }
 
-        /*
-         * Until this is fixed only page-sized or smaller data blocks work.
-         */
-        if (unlikely(sbp->sb_blocksize > PAGE_SIZE)) {
-                xfs_fs_mount_cmn_err(flags,
-                        "file system with blocksize %d bytes",
-                        sbp->sb_blocksize);
-                xfs_fs_mount_cmn_err(flags,
-                        "only pagesize (%ld) or less will currently work.",
-                        PAGE_SIZE);
-                return XFS_ERROR(ENOSYS);
-        }
-
         return 0;
 }
 
@@ -994,9 +964,19 @@ xfs_mountfs(
                  * Re-check for ATTR2 in case it was found in bad_features2
                  * slot.
                  */
-                if (xfs_sb_version_hasattr2(&mp->m_sb))
+                if (xfs_sb_version_hasattr2(&mp->m_sb) &&
+                   !(mp->m_flags & XFS_MOUNT_NOATTR2))
                         mp->m_flags |= XFS_MOUNT_ATTR2;
+        }
+
+        if (xfs_sb_version_hasattr2(&mp->m_sb) &&
+           (mp->m_flags & XFS_MOUNT_NOATTR2)) {
+                xfs_sb_version_removeattr2(&mp->m_sb);
+                update_flags |= XFS_SB_FEATURES2;
 
+                /* update sb_versionnum for the clearing of the morebits */
+                if (!sbp->sb_features2)
+                        update_flags |= XFS_SB_VERSIONNUM;
         }
 
         /*
@@ -1255,15 +1235,13 @@ xfs_mountfs(
  error2:
         for (agno = 0; agno < sbp->sb_agcount; agno++)
                 if (mp->m_perag[agno].pagb_list)
-                        kmem_free(mp->m_perag[agno].pagb_list,
-                          sizeof(xfs_perag_busy_t) * XFS_PAGB_NUM_SLOTS);
-        kmem_free(mp->m_perag, sbp->sb_agcount * sizeof(xfs_perag_t));
+                        kmem_free(mp->m_perag[agno].pagb_list);
+        kmem_free(mp->m_perag);
         mp->m_perag = NULL;
         /* FALLTHROUGH */
  error1:
         if (uuid_mounted)
-                xfs_uuid_unmount(mp);
-        xfs_freesb(mp);
+                uuid_table_remove(&mp->m_sb.sb_uuid);
         return error;
 }
 
@@ -1274,7 +1252,7 @@ xfs_mountfs(
  * log and makes sure that incore structures are freed.
  */
 int
-xfs_unmountfs(xfs_mount_t *mp, struct cred *cr)
+xfs_unmountfs(xfs_mount_t *mp)
 {
         __uint64_t      resblks;
         int             error = 0;
@@ -1341,9 +1319,8 @@ xfs_unmountfs(xfs_mount_t *mp, struct cred *cr)
          */
         ASSERT(mp->m_inodes == NULL);
 
-        xfs_unmountfs_close(mp, cr);
         if ((mp->m_flags & XFS_MOUNT_NOUUID) == 0)
-                xfs_uuid_unmount(mp);
+                uuid_table_remove(&mp->m_sb.sb_uuid);
 
 #if defined(DEBUG) || defined(INDUCE_IO_ERROR)
         xfs_errortag_clearall(mp, 0);
@@ -1352,16 +1329,6 @@ xfs_unmountfs(xfs_mount_t *mp, struct cred *cr)
         return 0;
 }
 
-void
-xfs_unmountfs_close(xfs_mount_t *mp, struct cred *cr)
-{
-        if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp)
-                xfs_free_buftarg(mp->m_logdev_targp, 1);
-        if (mp->m_rtdev_targp)
-                xfs_free_buftarg(mp->m_rtdev_targp, 1);
-        xfs_free_buftarg(mp->m_ddev_targp, 0);
-}
-
 STATIC void
 xfs_unmountfs_wait(xfs_mount_t *mp)
 {
@@ -1905,16 +1872,6 @@ xfs_uuid_mount(
 }
 
 /*
- * Remove filesystem from the UUID table.
- */
-STATIC void
-xfs_uuid_unmount(
-        xfs_mount_t     *mp)
-{
-        uuid_table_remove(&mp->m_sb.sb_uuid);
-}
-
-/*
  * Used to log changes to the superblock unit and width fields which could
  * be altered by the mount options, as well as any potential sb_features2
  * fixup. Only the first superblock is updated.
@@ -1928,7 +1885,8 @@ xfs_mount_log_sb(
         int             error;
 
         ASSERT(fields & (XFS_SB_UNIT | XFS_SB_WIDTH | XFS_SB_UUID |
-                         XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2));
+                         XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2 |
+                         XFS_SB_VERSIONNUM));
 
         tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT);
         error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
@@ -2109,7 +2067,7 @@ xfs_icsb_reinit_counters(
         xfs_icsb_unlock(mp);
 }
 
-STATIC void
+void
 xfs_icsb_destroy_counters(
         xfs_mount_t     *mp)
 {