[XFS] streamline init/exit path

Currently the xfs module init/exit code is a mess. It's farmed out over a
lot of function with very little error checking. This patch makes sure we
propagate all initialization failures properly and clean up after them.
Various runtime initializations are replaced with compile-time
initializations where possible to make this easier. The exit path is
similarly consolidated.

There's now split out function to create/destroy the kmem zones and
alloc/free the trace buffers. I've also changed the ktrace allocations to
KM_MAYFAIL and handled errors resulting from that.

And yes, we really should replace the XFS_*_TRACE ifdefs with a single
XFS_TRACE..

SGI-PV: 976035

SGI-Modid: xfs-linux-melb:xfs-kern:31354a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Niv Sardi <xaiki@sgi.com>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>

5 files changed, 305 insertions, 63 deletions

diff --git a/fs/xfs/linux-2.6/xfs_stats.c b/fs/xfs/linux-2.6/xfs_stats.c
index e480b6102051..3d5b67c075c7 100644
--- a/fs/xfs/linux-2.6/xfs_stats.c
+++ b/fs/xfs/linux-2.6/xfs_stats.c
@@ -98,12 +98,21 @@ xfs_read_xfsstats(
         return len;
 }
 
-void
+int
 xfs_init_procfs(void)
 {
         if (!proc_mkdir("fs/xfs", NULL))
-                return;
-        create_proc_read_entry("fs/xfs/stat", 0, NULL, xfs_read_xfsstats, NULL);
+                goto out;
+
+        if (!create_proc_read_entry("fs/xfs/stat", 0, NULL,
+                        xfs_read_xfsstats, NULL))
+                goto out_remove_entry;
+        return 0;
+
+ out_remove_entry:
+        remove_proc_entry("fs/xfs", NULL);
+ out:
+        return -ENOMEM;
 }
 
 void
diff --git a/fs/xfs/linux-2.6/xfs_stats.h b/fs/xfs/linux-2.6/xfs_stats.h
index afd0b0d5fdb2..3fa753d7b700 100644
--- a/fs/xfs/linux-2.6/xfs_stats.h
+++ b/fs/xfs/linux-2.6/xfs_stats.h
@@ -134,7 +134,7 @@ DECLARE_PER_CPU(struct xfsstats, xfsstats);
 #define XFS_STATS_DEC(v)        (per_cpu(xfsstats, current_cpu()).v--)
 #define XFS_STATS_ADD(v, inc)   (per_cpu(xfsstats, current_cpu()).v += (inc))
 
-extern void xfs_init_procfs(void);
+extern int xfs_init_procfs(void);
 extern void xfs_cleanup_procfs(void);
 
 
@@ -144,8 +144,13 @@ extern void xfs_cleanup_procfs(void);
 # define XFS_STATS_DEC(count)
 # define XFS_STATS_ADD(count, inc)
 
-static inline void xfs_init_procfs(void) { };
-static inline void xfs_cleanup_procfs(void) { };
+static inline int xfs_init_procfs(void)
+{
+        return 0
+};
+static inline void xfs_cleanup_procfs(void)
+{
+};
 
 #endif  /* !CONFIG_PROC_FS */
 
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 967603c46998..7c621dfee73d 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -53,6 +53,11 @@
 #include "xfs_log_priv.h"
 #include "xfs_trans_priv.h"
 #include "xfs_filestream.h"
+#include "xfs_da_btree.h"
+#include "xfs_dir2_trace.h"
+#include "xfs_extfree_item.h"
+#include "xfs_mru_cache.h"
+#include "xfs_inode_item.h"
 
 #include <linux/namei.h>
 #include <linux/init.h>
@@ -987,42 +992,6 @@ xfs_fs_inode_init_once(
         inode_init_once(vn_to_inode((bhv_vnode_t *)vnode));
 }
 
-STATIC int __init
-xfs_init_zones(void)
-{
-        xfs_vnode_zone = kmem_zone_init_flags(sizeof(bhv_vnode_t), "xfs_vnode",
-                                        KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
-                                        KM_ZONE_SPREAD,
-                                        xfs_fs_inode_init_once);
-        if (!xfs_vnode_zone)
-                goto out;
-
-        xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
-        if (!xfs_ioend_zone)
-                goto out_destroy_vnode_zone;
-
-        xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
-                                                  xfs_ioend_zone);
-        if (!xfs_ioend_pool)
-                goto out_free_ioend_zone;
-        return 0;
-
- out_free_ioend_zone:
-        kmem_zone_destroy(xfs_ioend_zone);
- out_destroy_vnode_zone:
-        kmem_zone_destroy(xfs_vnode_zone);
- out:
-        return -ENOMEM;
-}
-
-STATIC void
-xfs_destroy_zones(void)
-{
-        mempool_destroy(xfs_ioend_pool);
-        kmem_zone_destroy(xfs_vnode_zone);
-        kmem_zone_destroy(xfs_ioend_zone);
-}
-
 /*
  * Attempt to flush the inode, this will actually fail
  * if the inode is pinned, but we dirty the inode again
@@ -1939,9 +1908,235 @@ static struct file_system_type xfs_fs_type = {
         .fs_flags               = FS_REQUIRES_DEV,
 };
 
+STATIC int __init
+xfs_alloc_trace_bufs(void)
+{
+#ifdef XFS_ALLOC_TRACE
+        xfs_alloc_trace_buf = ktrace_alloc(XFS_ALLOC_TRACE_SIZE, KM_MAYFAIL);
+        if (!xfs_alloc_trace_buf)
+                goto out;
+#endif
+#ifdef XFS_BMAP_TRACE
+        xfs_bmap_trace_buf = ktrace_alloc(XFS_BMAP_TRACE_SIZE, KM_MAYFAIL);
+        if (!xfs_bmap_trace_buf)
+                goto out_free_alloc_trace;
+#endif
+#ifdef XFS_BMBT_TRACE
+        xfs_bmbt_trace_buf = ktrace_alloc(XFS_BMBT_TRACE_SIZE, KM_MAYFAIL);
+        if (!xfs_bmbt_trace_buf)
+                goto out_free_bmap_trace;
+#endif
+#ifdef XFS_ATTR_TRACE
+        xfs_attr_trace_buf = ktrace_alloc(XFS_ATTR_TRACE_SIZE, KM_MAYFAIL);
+        if (!xfs_attr_trace_buf)
+                goto out_free_bmbt_trace;
+#endif
+#ifdef XFS_DIR2_TRACE
+        xfs_dir2_trace_buf = ktrace_alloc(XFS_DIR2_GTRACE_SIZE, KM_MAYFAIL);
+        if (!xfs_dir2_trace_buf)
+                goto out_free_attr_trace;
+#endif
+
+        return 0;
+
+#ifdef XFS_DIR2_TRACE
+ out_free_attr_trace:
+#endif
+#ifdef XFS_ATTR_TRACE
+        ktrace_free(xfs_attr_trace_buf);
+ out_free_bmbt_trace:
+#endif
+#ifdef XFS_BMBT_TRACE
+        ktrace_free(xfs_bmbt_trace_buf);
+ out_free_bmap_trace:
+#endif
+#ifdef XFS_BMAP_TRACE
+        ktrace_free(xfs_bmap_trace_buf);
+ out_free_alloc_trace:
+#endif
+#ifdef XFS_ALLOC_TRACE
+        ktrace_free(xfs_alloc_trace_buf);
+ out:
+#endif
+        return -ENOMEM;
+}
+
+STATIC void
+xfs_free_trace_bufs(void)
+{
+#ifdef XFS_DIR2_TRACE
+        ktrace_free(xfs_dir2_trace_buf);
+#endif
+#ifdef XFS_ATTR_TRACE
+        ktrace_free(xfs_attr_trace_buf);
+#endif
+#ifdef XFS_BMBT_TRACE
+        ktrace_free(xfs_bmbt_trace_buf);
+#endif
+#ifdef XFS_BMAP_TRACE
+        ktrace_free(xfs_bmap_trace_buf);
+#endif
+#ifdef XFS_ALLOC_TRACE
+        ktrace_free(xfs_alloc_trace_buf);
+#endif
+}
+
+STATIC int __init
+xfs_init_zones(void)
+{
+        xfs_vnode_zone = kmem_zone_init_flags(sizeof(bhv_vnode_t), "xfs_vnode",
+                                        KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
+                                        KM_ZONE_SPREAD,
+                                        xfs_fs_inode_init_once);
+        if (!xfs_vnode_zone)
+                goto out;
+
+        xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
+        if (!xfs_ioend_zone)
+                goto out_destroy_vnode_zone;
+
+        xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
+                                                  xfs_ioend_zone);
+        if (!xfs_ioend_pool)
+                goto out_destroy_ioend_zone;
+
+        xfs_log_ticket_zone = kmem_zone_init(sizeof(xlog_ticket_t),
+                                                "xfs_log_ticket");
+        if (!xfs_log_ticket_zone)
+                goto out_destroy_ioend_pool;
+
+        xfs_bmap_free_item_zone = kmem_zone_init(sizeof(xfs_bmap_free_item_t),
+                                                "xfs_bmap_free_item");
+        if (!xfs_bmap_free_item_zone)
+                goto out_destroy_log_ticket_zone;
+        xfs_btree_cur_zone = kmem_zone_init(sizeof(xfs_btree_cur_t),
+                                                "xfs_btree_cur");
+        if (!xfs_btree_cur_zone)
+                goto out_destroy_bmap_free_item_zone;
+
+        xfs_da_state_zone = kmem_zone_init(sizeof(xfs_da_state_t),
+                                                "xfs_da_state");
+        if (!xfs_da_state_zone)
+                goto out_destroy_btree_cur_zone;
+
+        xfs_dabuf_zone = kmem_zone_init(sizeof(xfs_dabuf_t), "xfs_dabuf");
+        if (!xfs_dabuf_zone)
+                goto out_destroy_da_state_zone;
+
+        xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
+        if (!xfs_ifork_zone)
+                goto out_destroy_dabuf_zone;
+
+        xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans");
+        if (!xfs_trans_zone)
+                goto out_destroy_ifork_zone;
+
+        /*
+         * The size of the zone allocated buf log item is the maximum
+         * size possible under XFS.  This wastes a little bit of memory,
+         * but it is much faster.
+         */
+        xfs_buf_item_zone = kmem_zone_init((sizeof(xfs_buf_log_item_t) +
+                                (((XFS_MAX_BLOCKSIZE / XFS_BLI_CHUNK) /
+                                  NBWORD) * sizeof(int))), "xfs_buf_item");
+        if (!xfs_buf_item_zone)
+                goto out_destroy_trans_zone;
+
+        xfs_efd_zone = kmem_zone_init((sizeof(xfs_efd_log_item_t) +
+                        ((XFS_EFD_MAX_FAST_EXTENTS - 1) *
+                                 sizeof(xfs_extent_t))), "xfs_efd_item");
+        if (!xfs_efd_zone)
+                goto out_destroy_buf_item_zone;
+
+        xfs_efi_zone = kmem_zone_init((sizeof(xfs_efi_log_item_t) +
+                        ((XFS_EFI_MAX_FAST_EXTENTS - 1) *
+                                sizeof(xfs_extent_t))), "xfs_efi_item");
+        if (!xfs_efi_zone)
+                goto out_destroy_efd_zone;
+
+        xfs_inode_zone =
+                kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode",
+                                        KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
+                                        KM_ZONE_SPREAD, NULL);
+        if (!xfs_inode_zone)
+                goto out_destroy_efi_zone;
+
+        xfs_ili_zone =
+                kmem_zone_init_flags(sizeof(xfs_inode_log_item_t), "xfs_ili",
+                                        KM_ZONE_SPREAD, NULL);
+        if (!xfs_ili_zone)
+                goto out_destroy_inode_zone;
+
+#ifdef CONFIG_XFS_POSIX_ACL
+        xfs_acl_zone = kmem_zone_init(sizeof(xfs_acl_t), "xfs_acl");
+        if (!xfs_acl_zone)
+                goto out_destroy_ili_zone;
+#endif
+
+        return 0;
+
+#ifdef CONFIG_XFS_POSIX_ACL
+ out_destroy_ili_zone:
+#endif
+        kmem_zone_destroy(xfs_ili_zone);
+ out_destroy_inode_zone:
+        kmem_zone_destroy(xfs_inode_zone);
+ out_destroy_efi_zone:
+        kmem_zone_destroy(xfs_efi_zone);
+ out_destroy_efd_zone:
+        kmem_zone_destroy(xfs_efd_zone);
+ out_destroy_buf_item_zone:
+        kmem_zone_destroy(xfs_buf_item_zone);
+ out_destroy_trans_zone:
+        kmem_zone_destroy(xfs_trans_zone);
+ out_destroy_ifork_zone:
+        kmem_zone_destroy(xfs_ifork_zone);
+ out_destroy_dabuf_zone:
+        kmem_zone_destroy(xfs_dabuf_zone);
+ out_destroy_da_state_zone:
+        kmem_zone_destroy(xfs_da_state_zone);
+ out_destroy_btree_cur_zone:
+        kmem_zone_destroy(xfs_btree_cur_zone);
+ out_destroy_bmap_free_item_zone:
+        kmem_zone_destroy(xfs_bmap_free_item_zone);
+ out_destroy_log_ticket_zone:
+        kmem_zone_destroy(xfs_log_ticket_zone);
+ out_destroy_ioend_pool:
+        mempool_destroy(xfs_ioend_pool);
+ out_destroy_ioend_zone:
+        kmem_zone_destroy(xfs_ioend_zone);
+ out_destroy_vnode_zone:
+        kmem_zone_destroy(xfs_vnode_zone);
+ out:
+        return -ENOMEM;
+}
+
+STATIC void
+xfs_destroy_zones(void)
+{
+#ifdef CONFIG_XFS_POSIX_ACL
+        kmem_zone_destroy(xfs_acl_zone);
+#endif
+        kmem_zone_destroy(xfs_ili_zone);
+        kmem_zone_destroy(xfs_inode_zone);
+        kmem_zone_destroy(xfs_efi_zone);
+        kmem_zone_destroy(xfs_efd_zone);
+        kmem_zone_destroy(xfs_buf_item_zone);
+        kmem_zone_destroy(xfs_trans_zone);
+        kmem_zone_destroy(xfs_ifork_zone);
+        kmem_zone_destroy(xfs_dabuf_zone);
+        kmem_zone_destroy(xfs_da_state_zone);
+        kmem_zone_destroy(xfs_btree_cur_zone);
+        kmem_zone_destroy(xfs_bmap_free_item_zone);
+        kmem_zone_destroy(xfs_log_ticket_zone);
+        mempool_destroy(xfs_ioend_pool);
+        kmem_zone_destroy(xfs_ioend_zone);
+        kmem_zone_destroy(xfs_vnode_zone);
+
+}
 
 STATIC int __init
-init_xfs_fs( void )
+init_xfs_fs(void)
 {
         int                     error;
         static char             message[] __initdata = KERN_INFO \
@@ -1950,42 +2145,73 @@ init_xfs_fs( void )
         printk(message);
 
         ktrace_init(64);
+        vn_init();
+        xfs_dir_startup();
 
         error = xfs_init_zones();
-        if (error < 0)
-                goto undo_zones;
+        if (error)
+                goto out;
+
+        error = xfs_alloc_trace_bufs();
+        if (error)
+                goto out_destroy_zones;
+
+        error = xfs_mru_cache_init();
+        if (error)
+                goto out_free_trace_buffers;
+
+        error = xfs_filestream_init();
+        if (error)
+                goto out_mru_cache_uninit;
 
         error = xfs_buf_init();
-        if (error < 0)
-                goto undo_buffers;
+        if (error)
+                goto out_filestream_uninit;
+
+        error = xfs_init_procfs();
+        if (error)
+                goto out_buf_terminate;
+
+        error = xfs_sysctl_register();
+        if (error)
+                goto out_cleanup_procfs;
 
-        vn_init();
-        xfs_init();
-        uuid_init();
         vfs_initquota();
 
         error = register_filesystem(&xfs_fs_type);
         if (error)
-                goto undo_register;
+                goto out_sysctl_unregister;
         return 0;
 
-undo_register:
+ out_sysctl_unregister:
+        xfs_sysctl_unregister();
+ out_cleanup_procfs:
+        xfs_cleanup_procfs();
+ out_buf_terminate:
         xfs_buf_terminate();
-
-undo_buffers:
+ out_filestream_uninit:
+        xfs_filestream_uninit();
+ out_mru_cache_uninit:
+        xfs_mru_cache_uninit();
+ out_free_trace_buffers:
+        xfs_free_trace_bufs();
+ out_destroy_zones:
         xfs_destroy_zones();
-
-undo_zones:
+ out:
         return error;
 }
 
 STATIC void __exit
-exit_xfs_fs( void )
+exit_xfs_fs(void)
 {
         vfs_exitquota();
         unregister_filesystem(&xfs_fs_type);
-        xfs_cleanup();
+        xfs_sysctl_unregister();
+        xfs_cleanup_procfs();
         xfs_buf_terminate();
+        xfs_filestream_uninit();
+        xfs_mru_cache_uninit();
+        xfs_free_trace_bufs();
         xfs_destroy_zones();
         ktrace_uninit();
 }
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.c b/fs/xfs/linux-2.6/xfs_sysctl.c
index bb997d75c05c..7dacb5bbde3f 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.c
+++ b/fs/xfs/linux-2.6/xfs_sysctl.c
@@ -259,15 +259,17 @@ static ctl_table xfs_root_table[] = {
         {}
 };
 
-void
+int
 xfs_sysctl_register(void)
 {
         xfs_table_header = register_sysctl_table(xfs_root_table);
+        if (!xfs_table_header)
+                return -ENOMEM;
+        return 0;
 }
 
 void
 xfs_sysctl_unregister(void)
 {
-        if (xfs_table_header)
-                unregister_sysctl_table(xfs_table_header);
+        unregister_sysctl_table(xfs_table_header);
 }
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.h b/fs/xfs/linux-2.6/xfs_sysctl.h
index 98b97e399d6f..4aadb8056c37 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.h
+++ b/fs/xfs/linux-2.6/xfs_sysctl.h
@@ -93,10 +93,10 @@ enum {
 extern xfs_param_t      xfs_params;
 
 #ifdef CONFIG_SYSCTL
-extern void xfs_sysctl_register(void);
+extern int xfs_sysctl_register(void);
 extern void xfs_sysctl_unregister(void);
 #else
-# define xfs_sysctl_register()          do { } while (0)
+# define xfs_sysctl_register()          (0)
 # define xfs_sysctl_unregister()        do { } while (0)
 #endif /* CONFIG_SYSCTL */