93 files changed, 1567 insertions, 3093 deletions
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 7aa398724706..8c05c3c30741 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -29,11 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_trans.h"
@@ -42,13 +43,13 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_alloc.h"
-#include "xfs_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_alloc.h"
+#include "xfs_btree.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
 #include "xfs_iomap.h"
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 3881622bcf08..b0c00eaa79e4 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -29,11 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_trans.h"
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index 6a3326bcd8d0..d880e9c65fcd 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -29,39 +29,38 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_bmap.h"
+#include "xfs_btree.h"
-#include "xfs_bit.h"
+#include "xfs_ialloc.h"
 #include "xfs_rtalloc.h"
-#include "xfs_error.h"
 #include "xfs_itable.h"
+#include "xfs_error.h"
 #include "xfs_rw.h"
 #include "xfs_acl.h"
 #include "xfs_cap.h"
 #include "xfs_mac.h"
 #include "xfs_attr.h"
+#include "xfs_bmap.h"
 #include "xfs_buf_item.h"
 #include "xfs_utils.h"
 #include "xfs_dfrag.h"
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 68c83ec31143..12d2a702c6c3 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -29,11 +29,11 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -43,18 +43,17 @@
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_itable.h"
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index c04f0c063c58..36dc8b0368b7 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -29,16 +29,11 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- *  fs/xfs/linux/xfs_lrw.c (Linux Read Write stuff)
- *
- */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -48,18 +43,17 @@
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_itable.h"
diff --git a/fs/xfs/linux-2.6/xfs_lrw.h b/fs/xfs/linux-2.6/xfs_lrw.h
index 6294dcdb797c..0647e48a8a15 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.h
+++ b/fs/xfs/linux-2.6/xfs_lrw.h
@@ -107,9 +107,4 @@ extern ssize_t xfs_sendfile(struct bhv_desc *, struct file *,
 extern int xfs_dev_is_read_only(struct xfs_mount *, char *);
-#define XFS_FSB_TO_DB_IO(io,fsb) \
-                (((io)->io_flags & XFS_IOCORE_RT) ? \
-                 XFS_FSB_TO_BB((io)->io_mount, (fsb)) : \
-                 XFS_FSB_TO_DADDR((io)->io_mount, (fsb)))
 #endif  /* __XFS_LRW_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index f6f6b6750d4f..fac4862d09a6 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -29,32 +29,31 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_bit.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
 #include "xfs_clnt.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_itable.h"
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.c b/fs/xfs/linux-2.6/xfs_sysctl.c
index 0dc010356f4d..3dbd57fda2d6 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.c
+++ b/fs/xfs/linux-2.6/xfs_sysctl.c
@@ -29,9 +29,7 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_rw.h"
 #include <linux/sysctl.h>
 #include <linux/proc_fs.h>
@@ -76,7 +74,7 @@ xfs_stats_clear_proc_handler(
 STATIC ctl_table xfs_table[] = {
        {XFS_RESTRICT_CHOWN, "restrict_chown", &xfs_params.restrict_chown.val,
        sizeof(int), 0644, NULL, &proc_dointvec_minmax,
-        &sysctl_intvec, NULL, 
+        &sysctl_intvec, NULL,
        &xfs_params.restrict_chown.min, &xfs_params.restrict_chown.max},
        {XFS_SGID_INHERIT, "irix_sgid_inherit", &xfs_params.sgid_inherit.val,
@@ -86,22 +84,22 @@ STATIC ctl_table xfs_table[] = {
        {XFS_SYMLINK_MODE, "irix_symlink_mode", &xfs_params.symlink_mode.val,
        sizeof(int), 0644, NULL, &proc_dointvec_minmax,
-        &sysctl_intvec, NULL, 
+        &sysctl_intvec, NULL,
        &xfs_params.symlink_mode.min, &xfs_params.symlink_mode.max},
        {XFS_PANIC_MASK, "panic_mask", &xfs_params.panic_mask.val,
        sizeof(int), 0644, NULL, &proc_dointvec_minmax,
-        &sysctl_intvec, NULL, 
+        &sysctl_intvec, NULL,
        &xfs_params.panic_mask.min, &xfs_params.panic_mask.max},
        {XFS_ERRLEVEL, "error_level", &xfs_params.error_level.val,
        sizeof(int), 0644, NULL, &proc_dointvec_minmax,
-        &sysctl_intvec, NULL, 
+        &sysctl_intvec, NULL,
        &xfs_params.error_level.min, &xfs_params.error_level.max},
        {XFS_SYNCD_TIMER, "xfssyncd_centisecs", &xfs_params.syncd_timer.val,
        sizeof(int), 0644, NULL, &proc_dointvec_minmax,
-        &sysctl_intvec, NULL, 
+        &sysctl_intvec, NULL,
        &xfs_params.syncd_timer.min, &xfs_params.syncd_timer.max},
        {XFS_INHERIT_SYNC, "inherit_sync", &xfs_params.inherit_sync.val,
@@ -118,7 +116,7 @@ STATIC ctl_table xfs_table[] = {
        sizeof(int), 0644, NULL, &proc_dointvec_minmax,
        &sysctl_intvec, NULL,
        &xfs_params.inherit_noatim.min, &xfs_params.inherit_noatim.max},
-        
        {XFS_BUF_TIMER, "xfsbufd_centisecs", &xfs_params.xfs_buf_timer.val,
        sizeof(int), 0644, NULL, &proc_dointvec_minmax,
        &sysctl_intvec, NULL,
@@ -136,14 +134,14 @@ STATIC ctl_table xfs_table[] = {
        {XFS_ROTORSTEP, "rotorstep", &xfs_params.rotorstep.val,
        sizeof(int), 0644, NULL, &proc_dointvec_minmax,
-        &sysctl_intvec, NULL, 
+        &sysctl_intvec, NULL,
        &xfs_params.rotorstep.min, &xfs_params.rotorstep.max},
        /* please keep this the last entry */
 #ifdef CONFIG_PROC_FS
        {XFS_STATS_CLEAR, "stats_clear", &xfs_params.stats_clear.val,
        sizeof(int), 0644, NULL, &xfs_stats_clear_proc_handler,
-        &sysctl_intvec, NULL, 
+        &sysctl_intvec, NULL,
        &xfs_params.stats_clear.min, &xfs_params.stats_clear.max},
 #endif /* CONFIG_PROC_FS */
diff --git a/fs/xfs/linux-2.6/xfs_vfs.c b/fs/xfs/linux-2.6/xfs_vfs.c
index 34cc902ec119..1a08a1d84252 100644
--- a/fs/xfs/linux-2.6/xfs_vfs.c
+++ b/fs/xfs/linux-2.6/xfs_vfs.c
@@ -29,10 +29,8 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_inum.h"
 #include "xfs_log.h"
 #include "xfs_clnt.h"
diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c
index 9987977a4927..5971f6f6ec78 100644
--- a/fs/xfs/quota/xfs_dquot.c
+++ b/fs/xfs/quota/xfs_dquot.c
@@ -32,8 +32,9 @@
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -43,18 +44,17 @@
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_itable.h"
diff --git a/fs/xfs/quota/xfs_dquot_item.c b/fs/xfs/quota/xfs_dquot_item.c
index e74eaa7dd1bc..86f223032751 100644
--- a/fs/xfs/quota/xfs_dquot_item.c
+++ b/fs/xfs/quota/xfs_dquot_item.c
@@ -32,8 +32,9 @@
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -43,18 +44,17 @@
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_itable.h"
@@ -65,7 +65,6 @@
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_priv.h"
 #include "xfs_qm.h"
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index efde16e0a913..9041ea8452e1 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -32,8 +32,9 @@
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_clnt.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
@@ -44,21 +45,20 @@
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_bmap.h"
+#include "xfs_btree.h"
-#include "xfs_bit.h"
+#include "xfs_ialloc.h"
+#include "xfs_itable.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
+#include "xfs_bmap.h"
 #include "xfs_rw.h"
 #include "xfs_acl.h"
 #include "xfs_cap.h"
@@ -67,7 +67,6 @@
 #include "xfs_buf_item.h"
 #include "xfs_trans_space.h"
 #include "xfs_utils.h"
 #include "xfs_qm.h"
 /*
diff --git a/fs/xfs/quota/xfs_qm_bhv.c b/fs/xfs/quota/xfs_qm_bhv.c
index 8890a18a99d8..dac7cf8d729c 100644
--- a/fs/xfs/quota/xfs_qm_bhv.c
+++ b/fs/xfs/quota/xfs_qm_bhv.c
@@ -32,39 +32,39 @@
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_clnt.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_ialloc.h"
+#include "xfs_itable.h"
+#include "xfs_btree.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
 #include "xfs_rw.h"
 #include "xfs_acl.h"
 #include "xfs_cap.h"
 #include "xfs_mac.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_qm.h"
 #define MNTOPT_QUOTA    "quota"         /* disk quotas (user) */
diff --git a/fs/xfs/quota/xfs_qm_stats.c b/fs/xfs/quota/xfs_qm_stats.c
index 29978e037fee..b8befe1c90ec 100644
--- a/fs/xfs/quota/xfs_qm_stats.c
+++ b/fs/xfs/quota/xfs_qm_stats.c
@@ -32,31 +32,32 @@
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_ialloc.h"
+#include "xfs_itable.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
+#include "xfs_btree.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
 #include "xfs_rw.h"
 #include "xfs_acl.h"
 #include "xfs_cap.h"
diff --git a/fs/xfs/quota/xfs_qm_syscalls.c b/fs/xfs/quota/xfs_qm_syscalls.c
index 485f83d41191..ba320f6431a3 100644
--- a/fs/xfs/quota/xfs_qm_syscalls.c
+++ b/fs/xfs/quota/xfs_qm_syscalls.c
@@ -32,31 +32,32 @@
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_ialloc.h"
+#include "xfs_itable.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
+#include "xfs_btree.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
 #include "xfs_rw.h"
 #include "xfs_acl.h"
 #include "xfs_cap.h"
@@ -64,7 +65,6 @@
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_utils.h"
 #include "xfs_qm.h"
 #ifdef DEBUG
diff --git a/fs/xfs/quota/xfs_trans_dquot.c b/fs/xfs/quota/xfs_trans_dquot.c
index 3b99daf8a640..afa3bb57e5d1 100644
--- a/fs/xfs/quota/xfs_trans_dquot.c
+++ b/fs/xfs/quota/xfs_trans_dquot.c
@@ -32,8 +32,9 @@
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -43,21 +44,20 @@
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_ialloc.h"
+#include "xfs_itable.h"
+#include "xfs_btree.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
 #include "xfs_rw.h"
 #include "xfs_acl.h"
 #include "xfs_cap.h"
diff --git a/fs/xfs/xfs.h b/fs/xfs/xfs.h
index 7e276dcaf4dc..30c4ab4f9c45 100644
--- a/fs/xfs/xfs.h
+++ b/fs/xfs/xfs.h
@@ -34,7 +34,4 @@
 #include <linux-2.6/xfs_linux.h>
-#include <xfs_fs.h> 
-#include <xfs_macros.h>
 #endif  /* __XFS_H__ */
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 49fdc392fc8a..33c5f402b4ed 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -29,21 +29,23 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
+#include "xfs_types.h"
+#include "xfs_bit.h"
 #include "xfs_inum.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
 #include "xfs_acl.h"
 #include "xfs_mac.h"
 #include "xfs_attr.h"
diff --git a/fs/xfs/xfs_ag.h b/fs/xfs/xfs_ag.h
index 96b70f7fba39..7d15ef341a90 100644
--- a/fs/xfs/xfs_ag.h
+++ b/fs/xfs/xfs_ag.h
@@ -46,18 +46,9 @@ struct xfs_trans;
 #define XFS_AGI_MAGIC   0x58414749      /* 'XAGI' */
 #define XFS_AGF_VERSION 1
 #define XFS_AGI_VERSION 1
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGF_GOOD_VERSION)
-int xfs_agf_good_version(unsigned v);
+#define XFS_AGF_GOOD_VERSION(v) ((v) == XFS_AGF_VERSION)
-#define XFS_AGF_GOOD_VERSION(v) xfs_agf_good_version(v)
+#define XFS_AGI_GOOD_VERSION(v) ((v) == XFS_AGI_VERSION)
-#else
-#define XFS_AGF_GOOD_VERSION(v)         ((v) == XFS_AGF_VERSION)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGI_GOOD_VERSION)
-int xfs_agi_good_version(unsigned v);
-#define XFS_AGI_GOOD_VERSION(v) xfs_agi_good_version(v)
-#else
-#define XFS_AGI_GOOD_VERSION(v)         ((v) == XFS_AGI_VERSION)
-#endif
 /*
 * Btree number 0 is bno, 1 is cnt.  This value gives the size of the
@@ -110,12 +101,9 @@ typedef struct xfs_agf
 /* disk block (xfs_daddr_t) in the AG */
 #define XFS_AGF_DADDR(mp)       ((xfs_daddr_t)(1 << (mp)->m_sectbb_log))
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGF_BLOCK)
+#define XFS_AGF_BLOCK(mp)       XFS_HDR_BLOCK(mp, XFS_AGF_DADDR(mp))
-xfs_agblock_t xfs_agf_block(struct xfs_mount *mp);
+#define XFS_BUF_TO_AGF(bp)      ((xfs_agf_t *)XFS_BUF_PTR(bp))
-#define XFS_AGF_BLOCK(mp)       xfs_agf_block(mp)
-#else
-#define XFS_AGF_BLOCK(mp)       XFS_HDR_BLOCK(mp, XFS_AGF_DADDR(mp))
-#endif
 /*
 * Size of the unlinked inode hash table in the agi.
@@ -165,25 +153,17 @@ typedef struct xfs_agi
 /* disk block (xfs_daddr_t) in the AG */
 #define XFS_AGI_DADDR(mp)       ((xfs_daddr_t)(2 << (mp)->m_sectbb_log))
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGI_BLOCK)
+#define XFS_AGI_BLOCK(mp)       XFS_HDR_BLOCK(mp, XFS_AGI_DADDR(mp))
-xfs_agblock_t xfs_agi_block(struct xfs_mount *mp);
+#define XFS_BUF_TO_AGI(bp)      ((xfs_agi_t *)XFS_BUF_PTR(bp))
-#define XFS_AGI_BLOCK(mp)       xfs_agi_block(mp)
-#else
-#define XFS_AGI_BLOCK(mp)       XFS_HDR_BLOCK(mp, XFS_AGI_DADDR(mp))
-#endif
 /*
 * The third a.g. block contains the a.g. freelist, an array
 * of block pointers to blocks owned by the allocation btree code.
 */
 #define XFS_AGFL_DADDR(mp)      ((xfs_daddr_t)(3 << (mp)->m_sectbb_log))
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGFL_BLOCK)
+#define XFS_AGFL_BLOCK(mp)      XFS_HDR_BLOCK(mp, XFS_AGFL_DADDR(mp))
-xfs_agblock_t xfs_agfl_block(struct xfs_mount *mp);
-#define XFS_AGFL_BLOCK(mp)      xfs_agfl_block(mp)
-#else
-#define XFS_AGFL_BLOCK(mp)      XFS_HDR_BLOCK(mp, XFS_AGFL_DADDR(mp))
-#endif
 #define XFS_AGFL_SIZE(mp)       ((mp)->m_sb.sb_sectsize / sizeof(xfs_agblock_t))
+#define XFS_BUF_TO_AGFL(bp)     ((xfs_agfl_t *)XFS_BUF_PTR(bp))
 typedef struct xfs_agfl {
        xfs_agblock_t   agfl_bno[1];    /* actually XFS_AGFL_SIZE(mp) */
@@ -230,116 +210,38 @@ typedef struct xfs_perag
        xfs_perag_busy_t *pagb_list;    /* unstable blocks */
 } xfs_perag_t;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AG_MAXLEVELS)
+#define XFS_AG_MAXLEVELS(mp)            ((mp)->m_ag_maxlevels)
-int xfs_ag_maxlevels(struct xfs_mount *mp);
+#define XFS_MIN_FREELIST_RAW(bl,cl,mp)  \
-#define XFS_AG_MAXLEVELS(mp)            xfs_ag_maxlevels(mp)
+        (MIN(bl + 1, XFS_AG_MAXLEVELS(mp)) + MIN(cl + 1, XFS_AG_MAXLEVELS(mp)))
-#else
+#define XFS_MIN_FREELIST(a,mp)          \
-#define XFS_AG_MAXLEVELS(mp)    ((mp)->m_ag_maxlevels)
+        (XFS_MIN_FREELIST_RAW(          \
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_MIN_FREELIST)
-int xfs_min_freelist(xfs_agf_t *a, struct xfs_mount *mp);
-#define XFS_MIN_FREELIST(a,mp)          xfs_min_freelist(a,mp)
-#else
-#define XFS_MIN_FREELIST(a,mp)  \
-        XFS_MIN_FREELIST_RAW(   \
                INT_GET((a)->agf_levels[XFS_BTNUM_BNOi], ARCH_CONVERT), \
-                INT_GET((a)->agf_levels[XFS_BTNUM_CNTi], ARCH_CONVERT), mp)
+                INT_GET((a)->agf_levels[XFS_BTNUM_CNTi], ARCH_CONVERT), mp))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_MIN_FREELIST_PAG)
-int xfs_min_freelist_pag(xfs_perag_t *pag, struct xfs_mount *mp);
-#define XFS_MIN_FREELIST_PAG(pag,mp)    xfs_min_freelist_pag(pag,mp)
-#else
 #define XFS_MIN_FREELIST_PAG(pag,mp)    \
-        XFS_MIN_FREELIST_RAW((uint_t)(pag)->pagf_levels[XFS_BTNUM_BNOi], \
+        (XFS_MIN_FREELIST_RAW(          \
-                             (uint_t)(pag)->pagf_levels[XFS_BTNUM_CNTi], mp)
+                (uint_t)(pag)->pagf_levels[XFS_BTNUM_BNOi], \
-#endif
+                (uint_t)(pag)->pagf_levels[XFS_BTNUM_CNTi], mp))
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_MIN_FREELIST_RAW)
-int xfs_min_freelist_raw(int bl, int cl, struct xfs_mount *mp);
-#define XFS_MIN_FREELIST_RAW(bl,cl,mp)  xfs_min_freelist_raw(bl,cl,mp)
-#else
-#define XFS_MIN_FREELIST_RAW(bl,cl,mp)  \
-        (MIN(bl + 1, XFS_AG_MAXLEVELS(mp)) + \
-         MIN(cl + 1, XFS_AG_MAXLEVELS(mp)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGB_TO_FSB)
+#define XFS_AGB_TO_FSB(mp,agno,agbno)   \
-xfs_fsblock_t xfs_agb_to_fsb(struct xfs_mount *mp, xfs_agnumber_t agno,
-                             xfs_agblock_t agbno);
-#define XFS_AGB_TO_FSB(mp,agno,agbno)   xfs_agb_to_fsb(mp,agno,agbno)
-#else
-#define XFS_AGB_TO_FSB(mp,agno,agbno) \
        (((xfs_fsblock_t)(agno) << (mp)->m_sb.sb_agblklog) | (agbno))
-#endif
+#define XFS_FSB_TO_AGNO(mp,fsbno)       \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FSB_TO_AGNO)
-xfs_agnumber_t xfs_fsb_to_agno(struct xfs_mount *mp, xfs_fsblock_t fsbno);
-#define XFS_FSB_TO_AGNO(mp,fsbno)       xfs_fsb_to_agno(mp,fsbno)
-#else
-#define XFS_FSB_TO_AGNO(mp,fsbno) \
        ((xfs_agnumber_t)((fsbno) >> (mp)->m_sb.sb_agblklog))
-#endif
+#define XFS_FSB_TO_AGBNO(mp,fsbno)      \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FSB_TO_AGBNO)
-xfs_agblock_t xfs_fsb_to_agbno(struct xfs_mount *mp, xfs_fsblock_t fsbno);
-#define XFS_FSB_TO_AGBNO(mp,fsbno)      xfs_fsb_to_agbno(mp,fsbno)
-#else
-#define XFS_FSB_TO_AGBNO(mp,fsbno) \
        ((xfs_agblock_t)((fsbno) & XFS_MASK32LO((mp)->m_sb.sb_agblklog)))
-#endif
+#define XFS_AGB_TO_DADDR(mp,agno,agbno) \
+        ((xfs_daddr_t)XFS_FSB_TO_BB(mp, \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGB_TO_DADDR)
+                (xfs_fsblock_t)(agno) * (mp)->m_sb.sb_agblocks + (agbno)))
-xfs_daddr_t xfs_agb_to_daddr(struct xfs_mount *mp, xfs_agnumber_t agno,
+#define XFS_AG_DADDR(mp,agno,d)         (XFS_AGB_TO_DADDR(mp, agno, 0) + (d))
-                                xfs_agblock_t agbno);
-#define XFS_AGB_TO_DADDR(mp,agno,agbno) xfs_agb_to_daddr(mp,agno,agbno)
-#else
-#define XFS_AGB_TO_DADDR(mp,agno,agbno) \
-        ((xfs_daddr_t)(XFS_FSB_TO_BB(mp, \
-                (xfs_fsblock_t)(agno) * (mp)->m_sb.sb_agblocks + (agbno))))
-#endif
-/*
- * XFS_DADDR_TO_AGNO and XFS_DADDR_TO_AGBNO moved to xfs_mount.h
- * to avoid header file ordering change
- */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AG_DADDR)
-xfs_daddr_t xfs_ag_daddr(struct xfs_mount *mp, xfs_agnumber_t agno,
-                                xfs_daddr_t d);
-#define XFS_AG_DADDR(mp,agno,d)         xfs_ag_daddr(mp,agno,d)
-#else
-#define XFS_AG_DADDR(mp,agno,d) (XFS_AGB_TO_DADDR(mp, agno, 0) + (d))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_AGF)
-xfs_agf_t *xfs_buf_to_agf(struct xfs_buf *bp);
-#define XFS_BUF_TO_AGF(bp)              xfs_buf_to_agf(bp)
-#else
-#define XFS_BUF_TO_AGF(bp)      ((xfs_agf_t *)XFS_BUF_PTR(bp))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_AGI)
-xfs_agi_t *xfs_buf_to_agi(struct xfs_buf *bp);
-#define XFS_BUF_TO_AGI(bp)              xfs_buf_to_agi(bp)
-#else
-#define XFS_BUF_TO_AGI(bp)      ((xfs_agi_t *)XFS_BUF_PTR(bp))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_AGFL)
-xfs_agfl_t *xfs_buf_to_agfl(struct xfs_buf *bp);
-#define XFS_BUF_TO_AGFL(bp)             xfs_buf_to_agfl(bp)
-#else
-#define XFS_BUF_TO_AGFL(bp)     ((xfs_agfl_t *)XFS_BUF_PTR(bp))
-#endif
 /*
 * For checking for bad ranges of xfs_daddr_t's, covering multiple
 * allocation groups or a single xfs_daddr_t that's a superblock copy.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AG_CHECK_DADDR)
-void xfs_ag_check_daddr(struct xfs_mount *mp, xfs_daddr_t d, xfs_extlen_t len);
-#define XFS_AG_CHECK_DADDR(mp,d,len)    xfs_ag_check_daddr(mp,d,len)
-#else
 #define XFS_AG_CHECK_DADDR(mp,d,len)    \
        ((len) == 1 ? \
            ASSERT((d) == XFS_SB_DADDR || \
                   XFS_DADDR_TO_AGBNO(mp, d) != XFS_SB_DADDR) : \
            ASSERT(XFS_DADDR_TO_AGNO(mp, d) == \
                   XFS_DADDR_TO_AGNO(mp, (d) + (len) - 1)))
-#endif
 #endif  /* __XFS_AG_H__ */
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index dcfe19703620..c3a30e14bd13 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -29,28 +29,30 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * Free space allocation for XFS.
- */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir.h"
+#include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
+#include "xfs_dir_sf.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_alloc.h"
-#include "xfs_bit.h"
 #include "xfs_error.h"
diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c
index e0355a12d946..ccc421b438ff 100644
--- a/fs/xfs/xfs_alloc_btree.c
+++ b/fs/xfs/xfs_alloc_btree.c
@@ -29,25 +29,27 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * Free space allocation for XFS.
- */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir.h"
+#include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_bmap_btree.h"
+#include "xfs_dir_sf.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_alloc.h"
diff --git a/fs/xfs/xfs_alloc_btree.h b/fs/xfs/xfs_alloc_btree.h
index ed5161a572ef..f857b0f248d3 100644
--- a/fs/xfs/xfs_alloc_btree.h
+++ b/fs/xfs/xfs_alloc_btree.h
@@ -62,38 +62,14 @@ typedef xfs_agblock_t xfs_alloc_ptr_t;	/* btree pointer type */
                                        /* btree block header type */
 typedef struct xfs_btree_sblock xfs_alloc_block_t;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_ALLOC_BLOCK)
+#define XFS_BUF_TO_ALLOC_BLOCK(bp)      ((xfs_alloc_block_t *)XFS_BUF_PTR(bp))
-xfs_alloc_block_t *xfs_buf_to_alloc_block(struct xfs_buf *bp);
-#define XFS_BUF_TO_ALLOC_BLOCK(bp)      xfs_buf_to_alloc_block(bp)
-#else
-#define XFS_BUF_TO_ALLOC_BLOCK(bp) ((xfs_alloc_block_t *)(XFS_BUF_PTR(bp)))
-#endif
 /*
 * Real block structures have a size equal to the disk block size.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ALLOC_BLOCK_SIZE)
-int xfs_alloc_block_size(int lev, struct xfs_btree_cur *cur);
-#define XFS_ALLOC_BLOCK_SIZE(lev,cur)   xfs_alloc_block_size(lev,cur)
-#else
 #define XFS_ALLOC_BLOCK_SIZE(lev,cur)   (1 << (cur)->bc_blocklog)
-#endif
+#define XFS_ALLOC_BLOCK_MAXRECS(lev,cur) ((cur)->bc_mp->m_alloc_mxr[lev != 0])
+#define XFS_ALLOC_BLOCK_MINRECS(lev,cur) ((cur)->bc_mp->m_alloc_mnr[lev != 0])
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ALLOC_BLOCK_MAXRECS)
-int xfs_alloc_block_maxrecs(int lev, struct xfs_btree_cur *cur);
-#define XFS_ALLOC_BLOCK_MAXRECS(lev,cur)        xfs_alloc_block_maxrecs(lev,cur)
-#else
-#define XFS_ALLOC_BLOCK_MAXRECS(lev,cur)        \
-        ((cur)->bc_mp->m_alloc_mxr[lev != 0])
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ALLOC_BLOCK_MINRECS)
-int xfs_alloc_block_minrecs(int lev, struct xfs_btree_cur *cur);
-#define XFS_ALLOC_BLOCK_MINRECS(lev,cur)        xfs_alloc_block_minrecs(lev,cur)
-#else
-#define XFS_ALLOC_BLOCK_MINRECS(lev,cur)        \
-        ((cur)->bc_mp->m_alloc_mnr[lev != 0])
-#endif
 /*
 * Minimum and maximum blocksize and sectorsize.
@@ -113,145 +89,80 @@ int xfs_alloc_block_minrecs(int lev, struct xfs_btree_cur *cur);
 * Block numbers in the AG:
 * SB is sector 0, AGF is sector 1, AGI is sector 2, AGFL is sector 3.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BNO_BLOCK)
-xfs_agblock_t xfs_bno_block(struct xfs_mount *mp);
-#define XFS_BNO_BLOCK(mp)       xfs_bno_block(mp)
-#else
 #define XFS_BNO_BLOCK(mp)       ((xfs_agblock_t)(XFS_AGFL_BLOCK(mp) + 1))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CNT_BLOCK)
-xfs_agblock_t xfs_cnt_block(struct xfs_mount *mp);
-#define XFS_CNT_BLOCK(mp)       xfs_cnt_block(mp)
-#else
 #define XFS_CNT_BLOCK(mp)       ((xfs_agblock_t)(XFS_BNO_BLOCK(mp) + 1))
-#endif
 /*
 * Record, key, and pointer address macros for btree blocks.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ALLOC_REC_ADDR)
-xfs_alloc_rec_t *xfs_alloc_rec_addr(xfs_alloc_block_t *bb, int i,
-                                    struct xfs_btree_cur *cur);
-#define XFS_ALLOC_REC_ADDR(bb,i,cur)    xfs_alloc_rec_addr(bb,i,cur)
-#else
 #define XFS_ALLOC_REC_ADDR(bb,i,cur)    \
-        XFS_BTREE_REC_ADDR(XFS_ALLOC_BLOCK_SIZE(0,cur), xfs_alloc, bb, i, \
+        XFS_BTREE_REC_ADDR(XFS_ALLOC_BLOCK_SIZE(0,cur), xfs_alloc, \
-                XFS_ALLOC_BLOCK_MAXRECS(0, cur))
+                                bb, i, XFS_ALLOC_BLOCK_MAXRECS(0, cur))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ALLOC_KEY_ADDR)
-xfs_alloc_key_t *xfs_alloc_key_addr(xfs_alloc_block_t *bb, int i,
-                                    struct xfs_btree_cur *cur);
-#define XFS_ALLOC_KEY_ADDR(bb,i,cur)    xfs_alloc_key_addr(bb,i,cur)
-#else
 #define XFS_ALLOC_KEY_ADDR(bb,i,cur)    \
-        XFS_BTREE_KEY_ADDR(XFS_ALLOC_BLOCK_SIZE(1,cur), xfs_alloc, bb, i, \
+        XFS_BTREE_KEY_ADDR(XFS_ALLOC_BLOCK_SIZE(1,cur), xfs_alloc, \
-                XFS_ALLOC_BLOCK_MAXRECS(1, cur))
+                                bb, i, XFS_ALLOC_BLOCK_MAXRECS(1, cur))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ALLOC_PTR_ADDR)
-xfs_alloc_ptr_t *xfs_alloc_ptr_addr(xfs_alloc_block_t *bb, int i,
-                                    struct xfs_btree_cur *cur);
-#define XFS_ALLOC_PTR_ADDR(bb,i,cur)    xfs_alloc_ptr_addr(bb,i,cur)
-#else
 #define XFS_ALLOC_PTR_ADDR(bb,i,cur)    \
-        XFS_BTREE_PTR_ADDR(XFS_ALLOC_BLOCK_SIZE(1,cur), xfs_alloc, bb, i, \
+        XFS_BTREE_PTR_ADDR(XFS_ALLOC_BLOCK_SIZE(1,cur), xfs_alloc, \
-                XFS_ALLOC_BLOCK_MAXRECS(1, cur))
+                                bb, i, XFS_ALLOC_BLOCK_MAXRECS(1, cur))
-#endif
-/*
- * Prototypes for externally visible routines.
- */
 /*
 * Decrement cursor by one record at the level.
 * For nonzero levels the leaf-ward information is untouched.
 */
-int                                     /* error */
+extern int xfs_alloc_decrement(struct xfs_btree_cur *cur, int level, int *stat);
-xfs_alloc_decrement(
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        int                     level,  /* level in btree, 0 is leaf */
-        int                     *stat); /* success/failure */
 /*
 * Delete the record pointed to by cur.
 * The cursor refers to the place where the record was (could be inserted)
 * when the operation returns.
 */
-int                                     /* error */
+extern int xfs_alloc_delete(struct xfs_btree_cur *cur, int *stat);
-xfs_alloc_delete(
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        int                     *stat); /* success/failure */
 /*
 * Get the data from the pointed-to record.
 */
-int                                     /* error */
+extern int xfs_alloc_get_rec(struct xfs_btree_cur *cur, xfs_agblock_t *bno,
-xfs_alloc_get_rec(
+                                xfs_extlen_t *len, int *stat);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agblock_t           *bno,   /* output: starting block of extent */
-        xfs_extlen_t            *len,   /* output: length of extent */
-        int                     *stat); /* output: success/failure */
 /*
 * Increment cursor by one record at the level.
 * For nonzero levels the leaf-ward information is untouched.
 */
-int                                     /* error */
+extern int xfs_alloc_increment(struct xfs_btree_cur *cur, int level, int *stat);
-xfs_alloc_increment(
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        int                     level,  /* level in btree, 0 is leaf */
-        int                     *stat); /* success/failure */
 /*
 * Insert the current record at the point referenced by cur.
 * The cursor may be inconsistent on return if splits have been done.
 */
-int                                     /* error */
+extern int xfs_alloc_insert(struct xfs_btree_cur *cur, int *stat);
-xfs_alloc_insert(
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        int                     *stat); /* success/failure */
 /*
 * Lookup the record equal to [bno, len] in the btree given by cur.
 */
-int                                     /* error */
+extern int xfs_alloc_lookup_eq(struct xfs_btree_cur *cur, xfs_agblock_t bno,
-xfs_alloc_lookup_eq(
+                                xfs_extlen_t len, int *stat);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agblock_t           bno,    /* starting block of extent */
-        xfs_extlen_t            len,    /* length of extent */
-        int                     *stat); /* success/failure */
 /*
 * Lookup the first record greater than or equal to [bno, len]
 * in the btree given by cur.
 */
-int                                     /* error */
+extern int xfs_alloc_lookup_ge(struct xfs_btree_cur *cur, xfs_agblock_t bno,
-xfs_alloc_lookup_ge(
+                                xfs_extlen_t len, int *stat);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agblock_t           bno,    /* starting block of extent */
-        xfs_extlen_t            len,    /* length of extent */
-        int                     *stat); /* success/failure */
 /*
 * Lookup the first record less than or equal to [bno, len]
 * in the btree given by cur.
 */
-int                                     /* error */
+extern int xfs_alloc_lookup_le(struct xfs_btree_cur *cur, xfs_agblock_t bno,
-xfs_alloc_lookup_le(
+                                xfs_extlen_t len, int *stat);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agblock_t           bno,    /* starting block of extent */
-        xfs_extlen_t            len,    /* length of extent */
-        int                     *stat); /* success/failure */
 /*
 * Update the record referred to by cur, to the value given by [bno, len].
 * This either works (return 0) or gets an EFSCORRUPTED error.
 */
-int                                     /* error */
+extern int xfs_alloc_update(struct xfs_btree_cur *cur, xfs_agblock_t bno,
-xfs_alloc_update(
+                                xfs_extlen_t len);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agblock_t           bno,    /* starting block of extent */
-        xfs_extlen_t            len);   /* length of extent */
 #endif  /* __XFS_ALLOC_BTREE_H__ */
diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index c2c14b2103f1..7db18e9649df 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -31,11 +31,11 @@
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -43,27 +43,26 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_alloc.h"
-#include "xfs_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_alloc.h"
+#include "xfs_btree.h"
+#include "xfs_inode_item.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"
 #include "xfs_error.h"
-#include "xfs_bit.h"
 #include "xfs_quota.h"
-#include "xfs_rw.h"
 #include "xfs_trans_space.h"
 #include "xfs_acl.h"
+#include "xfs_rw.h"
 /*
 * xfs_attr.c
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c
index 63c473f8d6db..be82014b9522 100644
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/xfs_attr_leaf.c
@@ -29,18 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * xfs_attr_leaf.c
- *
- * GROT: figure out how to recover gracefully when bmap returns ENOSPC.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -48,23 +42,22 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"
 #include "xfs_error.h"
-#include "xfs_bit.h"
 /*
 * xfs_attr_leaf.c
diff --git a/fs/xfs/xfs_attr_leaf.h b/fs/xfs/xfs_attr_leaf.h
index 326802f80d54..ef5f5eaa60d0 100644
--- a/fs/xfs/xfs_attr_leaf.h
+++ b/fs/xfs/xfs_attr_leaf.h
@@ -147,65 +147,58 @@ typedef struct xfs_attr_leaf_name_remote xfs_attr_leaf_name_remote_t;
 /*
 * Cast typed pointers for "local" and "remote" name/value structs.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_LEAF_NAME_REMOTE)
-xfs_attr_leaf_name_remote_t *
-xfs_attr_leaf_name_remote(xfs_attr_leafblock_t *leafp, int idx);
 #define XFS_ATTR_LEAF_NAME_REMOTE(leafp,idx)    \
        xfs_attr_leaf_name_remote(leafp,idx)
-#else
+static inline xfs_attr_leaf_name_remote_t *
-#define XFS_ATTR_LEAF_NAME_REMOTE(leafp,idx)    /* remote name struct ptr */ \
+xfs_attr_leaf_name_remote(xfs_attr_leafblock_t *leafp, int idx)
-        ((xfs_attr_leaf_name_remote_t *)                \
+{
-         &((char *)(leafp))[ INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT) ])
+        return (xfs_attr_leaf_name_remote_t *) &((char *)
-#endif
+                (leafp))[INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT)];
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_LEAF_NAME_LOCAL)
+}
-xfs_attr_leaf_name_local_t *
-xfs_attr_leaf_name_local(xfs_attr_leafblock_t *leafp, int idx);
 #define XFS_ATTR_LEAF_NAME_LOCAL(leafp,idx)     \
        xfs_attr_leaf_name_local(leafp,idx)
-#else
+static inline xfs_attr_leaf_name_local_t *
-#define XFS_ATTR_LEAF_NAME_LOCAL(leafp,idx)     /* local name struct ptr */ \
+xfs_attr_leaf_name_local(xfs_attr_leafblock_t *leafp, int idx)
-        ((xfs_attr_leaf_name_local_t *)         \
+{
-         &((char *)(leafp))[ INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT) ])
+        return (xfs_attr_leaf_name_local_t *) &((char *)
-#endif
+                (leafp))[INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT)];
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_LEAF_NAME)
+}
-char *xfs_attr_leaf_name(xfs_attr_leafblock_t *leafp, int idx);
 #define XFS_ATTR_LEAF_NAME(leafp,idx)           xfs_attr_leaf_name(leafp,idx)
-#else
+static inline char *xfs_attr_leaf_name(xfs_attr_leafblock_t *leafp, int idx)
-#define XFS_ATTR_LEAF_NAME(leafp,idx)           /* generic name struct ptr */ \
+{
-        (&((char *)(leafp))[ INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT) ])
+        return (&((char *)
-#endif
+                (leafp))[INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT)]);
+}
 /*
 * Calculate total bytes used (including trailing pad for alignment) for
 * a "local" name/value structure, a "remote" name/value structure, and
 * a pointer which might be either.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_LEAF_ENTSIZE_REMOTE)
-int xfs_attr_leaf_entsize_remote(int nlen);
 #define XFS_ATTR_LEAF_ENTSIZE_REMOTE(nlen)      \
        xfs_attr_leaf_entsize_remote(nlen)
-#else
+static inline int xfs_attr_leaf_entsize_remote(int nlen)
-#define XFS_ATTR_LEAF_ENTSIZE_REMOTE(nlen)      /* space for remote struct */ \
+{
-        (((uint)sizeof(xfs_attr_leaf_name_remote_t) - 1 + (nlen) + \
+        return ((uint)sizeof(xfs_attr_leaf_name_remote_t) - 1 + (nlen) + \
-          XFS_ATTR_LEAF_NAME_ALIGN - 1) & ~(XFS_ATTR_LEAF_NAME_ALIGN - 1))
+                XFS_ATTR_LEAF_NAME_ALIGN - 1) & ~(XFS_ATTR_LEAF_NAME_ALIGN - 1);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_LEAF_ENTSIZE_LOCAL)
-int xfs_attr_leaf_entsize_local(int nlen, int vlen);
 #define XFS_ATTR_LEAF_ENTSIZE_LOCAL(nlen,vlen)  \
        xfs_attr_leaf_entsize_local(nlen,vlen)
-#else
+static inline int xfs_attr_leaf_entsize_local(int nlen, int vlen)
-#define XFS_ATTR_LEAF_ENTSIZE_LOCAL(nlen,vlen)  /* space for local struct */ \
+{
-        (((uint)sizeof(xfs_attr_leaf_name_local_t) - 1 + (nlen) + (vlen) + \
+        return ((uint)sizeof(xfs_attr_leaf_name_local_t) - 1 + (nlen) + (vlen) +
-          XFS_ATTR_LEAF_NAME_ALIGN - 1) & ~(XFS_ATTR_LEAF_NAME_ALIGN - 1))
+                XFS_ATTR_LEAF_NAME_ALIGN - 1) & ~(XFS_ATTR_LEAF_NAME_ALIGN - 1);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_LEAF_ENTSIZE_LOCAL_MAX)
-int xfs_attr_leaf_entsize_local_max(int bsize);
 #define XFS_ATTR_LEAF_ENTSIZE_LOCAL_MAX(bsize)  \
        xfs_attr_leaf_entsize_local_max(bsize)
-#else
+static inline int xfs_attr_leaf_entsize_local_max(int bsize)
-#define XFS_ATTR_LEAF_ENTSIZE_LOCAL_MAX(bsize)  /* max local struct size */ \
+{
-        (((bsize) >> 1) + ((bsize) >> 2))
+        return (((bsize) >> 1) + ((bsize) >> 2));
-#endif
+}
 /*========================================================================
diff --git a/fs/xfs/xfs_attr_sf.h b/fs/xfs/xfs_attr_sf.h
index ef7d2942d306..c8001929deab 100644
--- a/fs/xfs/xfs_attr_sf.h
+++ b/fs/xfs/xfs_attr_sf.h
@@ -71,38 +71,17 @@ typedef struct xfs_attr_sf_sort {
        char            *name;          /* name value, pointer into buffer */
 } xfs_attr_sf_sort_t;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_SF_ENTSIZE_BYNAME)
-int xfs_attr_sf_entsize_byname(int nlen, int vlen);
-#define XFS_ATTR_SF_ENTSIZE_BYNAME(nlen,vlen)   \
-        xfs_attr_sf_entsize_byname(nlen,vlen)
-#else
 #define XFS_ATTR_SF_ENTSIZE_BYNAME(nlen,vlen)   /* space name/value uses */ \
-        ((int)sizeof(xfs_attr_sf_entry_t)-1 + (nlen)+(vlen))
+        (((int)sizeof(xfs_attr_sf_entry_t)-1 + (nlen)+(vlen)))
-#endif
 #define XFS_ATTR_SF_ENTSIZE_MAX                 /* max space for name&value */ \
        ((1 << (NBBY*(int)sizeof(__uint8_t))) - 1)
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_SF_ENTSIZE)
-int xfs_attr_sf_entsize(xfs_attr_sf_entry_t *sfep);
-#define XFS_ATTR_SF_ENTSIZE(sfep)       xfs_attr_sf_entsize(sfep)
-#else
 #define XFS_ATTR_SF_ENTSIZE(sfep)               /* space an entry uses */ \
        ((int)sizeof(xfs_attr_sf_entry_t)-1 + (sfep)->namelen+(sfep)->valuelen)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_SF_NEXTENTRY)
-xfs_attr_sf_entry_t *xfs_attr_sf_nextentry(xfs_attr_sf_entry_t *sfep);
-#define XFS_ATTR_SF_NEXTENTRY(sfep)     xfs_attr_sf_nextentry(sfep)
-#else
 #define XFS_ATTR_SF_NEXTENTRY(sfep)             /* next entry in struct */ \
-        ((xfs_attr_sf_entry_t *) \
+        ((xfs_attr_sf_entry_t *)((char *)(sfep) + XFS_ATTR_SF_ENTSIZE(sfep)))
-                ((char *)(sfep) + XFS_ATTR_SF_ENTSIZE(sfep)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ATTR_SF_TOTSIZE)
-int xfs_attr_sf_totsize(struct xfs_inode *dp);
-#define XFS_ATTR_SF_TOTSIZE(dp)         xfs_attr_sf_totsize(dp)
-#else
 #define XFS_ATTR_SF_TOTSIZE(dp)                 /* total space in use */ \
-        (INT_GET(((xfs_attr_shortform_t *)((dp)->i_afp->if_u1.if_data))->hdr.totsize, ARCH_CONVERT))
+        (INT_GET(((xfs_attr_shortform_t *)      \
-#endif
+                ((dp)->i_afp->if_u1.if_data))->hdr.totsize, ARCH_CONVERT))
 #if defined(XFS_ATTR_TRACE)
 /*
diff --git a/fs/xfs/xfs_bit.h b/fs/xfs/xfs_bit.h
index 1e7f57ddf7a8..041e82485064 100644
--- a/fs/xfs/xfs_bit.h
+++ b/fs/xfs/xfs_bit.h
@@ -39,30 +39,26 @@
 /*
 * masks with n high/low bits set, 32-bit values & 64-bit values
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_MASK32HI)
-__uint32_t xfs_mask32hi(int n);
 #define XFS_MASK32HI(n)         xfs_mask32hi(n)
-#else
+static inline __uint32_t xfs_mask32hi(int n)
-#define XFS_MASK32HI(n)         ((__uint32_t)-1 << (32 - (n)))
+{
-#endif
+        return (__uint32_t)-1 << (32 - (n));
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_MASK64HI)
+}
-__uint64_t xfs_mask64hi(int n);
 #define XFS_MASK64HI(n)         xfs_mask64hi(n)
-#else
+static inline __uint64_t xfs_mask64hi(int n)
-#define XFS_MASK64HI(n)         ((__uint64_t)-1 << (64 - (n)))
+{
-#endif
+        return (__uint64_t)-1 << (64 - (n));
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_MASK32LO)
+}
-__uint32_t xfs_mask32lo(int n);
 #define XFS_MASK32LO(n)         xfs_mask32lo(n)
-#else
+static inline __uint32_t xfs_mask32lo(int n)
-#define XFS_MASK32LO(n)         (((__uint32_t)1 << (n)) - 1)
+{
-#endif
+        return ((__uint32_t)1 << (n)) - 1;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_MASK64LO)
+}
-__uint64_t xfs_mask64lo(int n);
 #define XFS_MASK64LO(n)         xfs_mask64lo(n)
-#else
+static inline __uint64_t xfs_mask64lo(int n)
-#define XFS_MASK64LO(n)         (((__uint64_t)1 << (n)) - 1)
+{
-#endif
+        return ((__uint64_t)1 << (n)) - 1;
+}
 /* Get high bit set out of 32-bit argument, -1 if none set */
 extern int xfs_highbit32(__uint32_t v);
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 3e013530d00d..f8e3357c1e86 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -29,41 +29,39 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
-#include "xfs_dmapi.h"
+#include "xfs_da_btree.h"
-#include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_dmapi.h"
+#include "xfs_mount.h"
+#include "xfs_ialloc.h"
 #include "xfs_itable.h"
+#include "xfs_inode_item.h"
 #include "xfs_extfree_item.h"
 #include "xfs_alloc.h"
 #include "xfs_bmap.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir_leaf.h"
 #include "xfs_attr_leaf.h"
-#include "xfs_bit.h"
 #include "xfs_rw.h"
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
diff --git a/fs/xfs/xfs_bmap.h b/fs/xfs/xfs_bmap.h
index e42d1b7777e1..51a9c82f0f62 100644
--- a/fs/xfs/xfs_bmap.h
+++ b/fs/xfs/xfs_bmap.h
@@ -77,12 +77,11 @@ typedef	struct xfs_bmap_free
                                        /* combine contig. space */
 #define XFS_BMAPI_CONTIG        0x400   /* must allocate only one extent */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAPI_AFLAG)
-int xfs_bmapi_aflag(int w);
 #define XFS_BMAPI_AFLAG(w)      xfs_bmapi_aflag(w)
-#else
+static inline int xfs_bmapi_aflag(int w)
-#define XFS_BMAPI_AFLAG(w)      ((w) == XFS_ATTR_FORK ? XFS_BMAPI_ATTRFORK : 0)
+{
-#endif
+        return (w == XFS_ATTR_FORK ? XFS_BMAPI_ATTRFORK : 0);
+}
 /*
 * Special values for xfs_bmbt_irec_t br_startblock field.
@@ -90,14 +89,12 @@ int xfs_bmapi_aflag(int w);
 #define DELAYSTARTBLOCK         ((xfs_fsblock_t)-1LL)
 #define HOLESTARTBLOCK          ((xfs_fsblock_t)-2LL)
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_INIT)
-void xfs_bmap_init(xfs_bmap_free_t *flp, xfs_fsblock_t *fbp);
 #define XFS_BMAP_INIT(flp,fbp)  xfs_bmap_init(flp,fbp)
-#else
+static inline void xfs_bmap_init(xfs_bmap_free_t *flp, xfs_fsblock_t *fbp)
-#define XFS_BMAP_INIT(flp,fbp)  \
+{
        ((flp)->xbf_first = NULL, (flp)->xbf_count = 0, \
-         (flp)->xbf_low = 0, *(fbp) = NULLFSBLOCK)
+                (flp)->xbf_low = 0, *(fbp) = NULLFSBLOCK);
-#endif
+}
 /*
 * Argument structure for xfs_bmap_alloc.
diff --git a/fs/xfs/xfs_bmap_btree.c b/fs/xfs/xfs_bmap_btree.c
index 09a77b17565b..cc72f77f9824 100644
--- a/fs/xfs/xfs_bmap_btree.c
+++ b/fs/xfs/xfs_bmap_btree.c
@@ -29,13 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -43,20 +42,19 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_itable.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
 #include "xfs_alloc.h"
-#include "xfs_bit.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
+#include "xfs_itable.h"
 #include "xfs_bmap.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
diff --git a/fs/xfs/xfs_bmap_btree.h b/fs/xfs/xfs_bmap_btree.h
index 2cf4fe45cbcb..ff0102d14918 100644
--- a/fs/xfs/xfs_bmap_btree.h
+++ b/fs/xfs/xfs_bmap_btree.h
@@ -114,31 +114,31 @@ typedef xfs_bmbt_rec_64_t xfs_bmbt_rec_t, xfs_bmdr_rec_t;
        (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
 #define DSTARTBLOCKMASK         \
        (((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_ISNULLSTARTBLOCK)
-int isnullstartblock(xfs_fsblock_t x);
 #define ISNULLSTARTBLOCK(x)     isnullstartblock(x)
-#else
+static inline int isnullstartblock(xfs_fsblock_t x)
-#define ISNULLSTARTBLOCK(x)     (((x) & STARTBLOCKMASK) == STARTBLOCKMASK)
+{
-#endif
+        return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_ISNULLDSTARTBLOCK)
+}
-int isnulldstartblock(xfs_dfsbno_t x);
 #define ISNULLDSTARTBLOCK(x)    isnulldstartblock(x)
-#else
+static inline int isnulldstartblock(xfs_dfsbno_t x)
-#define ISNULLDSTARTBLOCK(x)    (((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK)
+{
-#endif
+        return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_NULLSTARTBLOCK)
+}
-xfs_fsblock_t nullstartblock(int k);
 #define NULLSTARTBLOCK(k)       nullstartblock(k)
-#else
+static inline xfs_fsblock_t nullstartblock(int k)
-#define NULLSTARTBLOCK(k)       \
+{
-        ((ASSERT(k < (1 << STARTBLOCKVALBITS))), (STARTBLOCKMASK | (k)))
+        ASSERT(k < (1 << STARTBLOCKVALBITS));
-#endif
+        return STARTBLOCKMASK | (k);
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_STARTBLOCKVAL)
+}
-xfs_filblks_t startblockval(xfs_fsblock_t x);
 #define STARTBLOCKVAL(x)        startblockval(x)
-#else
+static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
-#define STARTBLOCKVAL(x)        ((xfs_filblks_t)((x) & ~STARTBLOCKMASK))
+{
-#endif
+        return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
+}
 /*
 * Possible extent formats.
@@ -159,14 +159,9 @@ typedef enum {
 /*
 * Extent state and extent format macros.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_EXTFMT_INODE )
+#define XFS_EXTFMT_INODE(x)     \
-xfs_exntfmt_t xfs_extfmt_inode(struct xfs_inode *ip);
+        (XFS_SB_VERSION_HASEXTFLGBIT(&((x)->i_mount->m_sb)) ? \
-#define XFS_EXTFMT_INODE(x)     xfs_extfmt_inode(x)
+                XFS_EXTFMT_HASSTATE : XFS_EXTFMT_NOSTATE)
-#else
-#define XFS_EXTFMT_INODE(x) \
-  (XFS_SB_VERSION_HASEXTFLGBIT(&((x)->i_mount->m_sb)) ? \
-        XFS_EXTFMT_HASSTATE : XFS_EXTFMT_NOSTATE)
-#endif
 #define ISUNWRITTEN(x)  ((x)->br_state == XFS_EXT_UNWRITTEN)
 /*
@@ -192,248 +187,111 @@ typedef xfs_dfsbno_t xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;	/* btree pointer type */
                                        /* btree block header type */
 typedef struct xfs_btree_lblock xfs_bmbt_block_t;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_BMBT_BLOCK)
+#define XFS_BUF_TO_BMBT_BLOCK(bp)       ((xfs_bmbt_block_t *)XFS_BUF_PTR(bp))
-xfs_bmbt_block_t *xfs_buf_to_bmbt_block(struct xfs_buf *bp);
-#define XFS_BUF_TO_BMBT_BLOCK(bp)               xfs_buf_to_bmbt_block(bp)
-#else
-#define XFS_BUF_TO_BMBT_BLOCK(bp) ((xfs_bmbt_block_t *)(XFS_BUF_PTR(bp)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_RBLOCK_DSIZE)
+#define XFS_BMAP_IBLOCK_SIZE(lev,cur)   (1 << (cur)->bc_blocklog)
-int xfs_bmap_rblock_dsize(int lev, struct xfs_btree_cur *cur);
+#define XFS_BMAP_RBLOCK_DSIZE(lev,cur)  ((cur)->bc_private.b.forksize)
-#define XFS_BMAP_RBLOCK_DSIZE(lev,cur)          xfs_bmap_rblock_dsize(lev,cur)
+#define XFS_BMAP_RBLOCK_ISIZE(lev,cur)  \
-#else
-#define XFS_BMAP_RBLOCK_DSIZE(lev,cur) ((cur)->bc_private.b.forksize)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_RBLOCK_ISIZE)
-int xfs_bmap_rblock_isize(int lev, struct xfs_btree_cur *cur);
-#define XFS_BMAP_RBLOCK_ISIZE(lev,cur)          xfs_bmap_rblock_isize(lev,cur)
-#else
-#define XFS_BMAP_RBLOCK_ISIZE(lev,cur) \
        ((int)XFS_IFORK_PTR((cur)->bc_private.b.ip, \
-                            (cur)->bc_private.b.whichfork)->if_broot_bytes)
+                    (cur)->bc_private.b.whichfork)->if_broot_bytes)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_IBLOCK_SIZE)
-int xfs_bmap_iblock_size(int lev, struct xfs_btree_cur *cur);
-#define XFS_BMAP_IBLOCK_SIZE(lev,cur)           xfs_bmap_iblock_size(lev,cur)
-#else
-#define XFS_BMAP_IBLOCK_SIZE(lev,cur) (1 << (cur)->bc_blocklog)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BLOCK_DSIZE)
+#define XFS_BMAP_BLOCK_DSIZE(lev,cur)   \
-int xfs_bmap_block_dsize(int lev, struct xfs_btree_cur *cur);
+        (((lev) == (cur)->bc_nlevels - 1 ? \
-#define XFS_BMAP_BLOCK_DSIZE(lev,cur)           xfs_bmap_block_dsize(lev,cur)
+                XFS_BMAP_RBLOCK_DSIZE(lev,cur) : XFS_BMAP_IBLOCK_SIZE(lev,cur)))
-#else
+#define XFS_BMAP_BLOCK_ISIZE(lev,cur)   \
-#define XFS_BMAP_BLOCK_DSIZE(lev,cur) \
+        (((lev) == (cur)->bc_nlevels - 1 ? \
-        ((lev) == (cur)->bc_nlevels - 1 ? \
+                XFS_BMAP_RBLOCK_ISIZE(lev,cur) : XFS_BMAP_IBLOCK_SIZE(lev,cur)))
-                XFS_BMAP_RBLOCK_DSIZE(lev,cur) : \
-                XFS_BMAP_IBLOCK_SIZE(lev,cur))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BLOCK_ISIZE)
-int xfs_bmap_block_isize(int lev, struct xfs_btree_cur *cur);
-#define XFS_BMAP_BLOCK_ISIZE(lev,cur)           xfs_bmap_block_isize(lev,cur)
-#else
-#define XFS_BMAP_BLOCK_ISIZE(lev,cur) \
-        ((lev) == (cur)->bc_nlevels - 1 ? \
-                XFS_BMAP_RBLOCK_ISIZE(lev,cur) : \
-                XFS_BMAP_IBLOCK_SIZE(lev,cur))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BLOCK_DMAXRECS)
-int xfs_bmap_block_dmaxrecs(int lev, struct xfs_btree_cur *cur);
-#define XFS_BMAP_BLOCK_DMAXRECS(lev,cur)        xfs_bmap_block_dmaxrecs(lev,cur)
-#else
 #define XFS_BMAP_BLOCK_DMAXRECS(lev,cur) \
-        ((lev) == (cur)->bc_nlevels - 1 ? \
+        (((lev) == (cur)->bc_nlevels - 1 ? \
                XFS_BTREE_BLOCK_MAXRECS(XFS_BMAP_RBLOCK_DSIZE(lev,cur), \
                        xfs_bmdr, (lev) == 0) : \
-                ((cur)->bc_mp->m_bmap_dmxr[(lev) != 0]))
+                ((cur)->bc_mp->m_bmap_dmxr[(lev) != 0])))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BLOCK_IMAXRECS)
-int xfs_bmap_block_imaxrecs(int lev, struct xfs_btree_cur *cur);
-#define XFS_BMAP_BLOCK_IMAXRECS(lev,cur)        xfs_bmap_block_imaxrecs(lev,cur)
-#else
 #define XFS_BMAP_BLOCK_IMAXRECS(lev,cur) \
-        ((lev) == (cur)->bc_nlevels - 1 ? \
+        (((lev) == (cur)->bc_nlevels - 1 ? \
-                XFS_BTREE_BLOCK_MAXRECS(XFS_BMAP_RBLOCK_ISIZE(lev,cur), \
+                        XFS_BTREE_BLOCK_MAXRECS(XFS_BMAP_RBLOCK_ISIZE(lev,cur),\
-                        xfs_bmbt, (lev) == 0) : \
+                                xfs_bmbt, (lev) == 0) : \
-                ((cur)->bc_mp->m_bmap_dmxr[(lev) != 0]))
+                        ((cur)->bc_mp->m_bmap_dmxr[(lev) != 0])))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BLOCK_DMINRECS)
-int xfs_bmap_block_dminrecs(int lev, struct xfs_btree_cur *cur);
-#define XFS_BMAP_BLOCK_DMINRECS(lev,cur)        xfs_bmap_block_dminrecs(lev,cur)
-#else
 #define XFS_BMAP_BLOCK_DMINRECS(lev,cur) \
-        ((lev) == (cur)->bc_nlevels - 1 ? \
+        (((lev) == (cur)->bc_nlevels - 1 ? \
-                XFS_BTREE_BLOCK_MINRECS(XFS_BMAP_RBLOCK_DSIZE(lev,cur), \
+                        XFS_BTREE_BLOCK_MINRECS(XFS_BMAP_RBLOCK_DSIZE(lev,cur),\
-                        xfs_bmdr, (lev) == 0) : \
+                                xfs_bmdr, (lev) == 0) : \
-                ((cur)->bc_mp->m_bmap_dmnr[(lev) != 0]))
+                        ((cur)->bc_mp->m_bmap_dmnr[(lev) != 0])))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BLOCK_IMINRECS)
-int xfs_bmap_block_iminrecs(int lev, struct xfs_btree_cur *cur);
-#define XFS_BMAP_BLOCK_IMINRECS(lev,cur)        xfs_bmap_block_iminrecs(lev,cur)
-#else
 #define XFS_BMAP_BLOCK_IMINRECS(lev,cur) \
-        ((lev) == (cur)->bc_nlevels - 1 ? \
+        (((lev) == (cur)->bc_nlevels - 1 ? \
-                XFS_BTREE_BLOCK_MINRECS(XFS_BMAP_RBLOCK_ISIZE(lev,cur), \
+                        XFS_BTREE_BLOCK_MINRECS(XFS_BMAP_RBLOCK_ISIZE(lev,cur),\
-                        xfs_bmbt, (lev) == 0) : \
+                                xfs_bmbt, (lev) == 0) : \
-                ((cur)->bc_mp->m_bmap_dmnr[(lev) != 0]))
+                        ((cur)->bc_mp->m_bmap_dmnr[(lev) != 0])))
-#endif
+#define XFS_BMAP_REC_DADDR(bb,i,cur)    \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_REC_DADDR)
+        (XFS_BTREE_REC_ADDR(XFS_BMAP_BLOCK_DSIZE(                       \
-xfs_bmbt_rec_t *
+                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
-xfs_bmap_rec_daddr(xfs_bmbt_block_t *bb, int i, struct xfs_btree_cur *cur);
+                        xfs_bmbt, bb, i, XFS_BMAP_BLOCK_DMAXRECS(       \
-#define XFS_BMAP_REC_DADDR(bb,i,cur)            xfs_bmap_rec_daddr(bb,i,cur)
+                                INT_GET((bb)->bb_level, ARCH_CONVERT), cur)))
-#else
+#define XFS_BMAP_REC_IADDR(bb,i,cur)    \
-#define XFS_BMAP_REC_DADDR(bb,i,cur) \
+        (XFS_BTREE_REC_ADDR(XFS_BMAP_BLOCK_ISIZE(                       \
-        XFS_BTREE_REC_ADDR(XFS_BMAP_BLOCK_DSIZE(                \
+                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
-                INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
+                        xfs_bmbt, bb, i, XFS_BMAP_BLOCK_IMAXRECS(       \
-                xfs_bmbt, bb, i, XFS_BMAP_BLOCK_DMAXRECS(       \
+                                INT_GET((bb)->bb_level, ARCH_CONVERT), cur)))
-                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur))
-#endif
+#define XFS_BMAP_KEY_DADDR(bb,i,cur)    \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_REC_IADDR)
+        (XFS_BTREE_KEY_ADDR(XFS_BMAP_BLOCK_DSIZE(                       \
-xfs_bmbt_rec_t *
+                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
-xfs_bmap_rec_iaddr(xfs_bmbt_block_t *bb, int i, struct xfs_btree_cur *cur);
+                        xfs_bmbt, bb, i, XFS_BMAP_BLOCK_DMAXRECS(       \
-#define XFS_BMAP_REC_IADDR(bb,i,cur)            xfs_bmap_rec_iaddr(bb,i,cur)
+                                INT_GET((bb)->bb_level, ARCH_CONVERT), cur)))
-#else
+#define XFS_BMAP_KEY_IADDR(bb,i,cur)    \
-#define XFS_BMAP_REC_IADDR(bb,i,cur) \
+        (XFS_BTREE_KEY_ADDR(XFS_BMAP_BLOCK_ISIZE(                       \
-        XFS_BTREE_REC_ADDR(XFS_BMAP_BLOCK_ISIZE(                \
+                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
-                INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
+                        xfs_bmbt, bb, i, XFS_BMAP_BLOCK_IMAXRECS(       \
-                xfs_bmbt, bb, i, XFS_BMAP_BLOCK_IMAXRECS(       \
+                                INT_GET((bb)->bb_level, ARCH_CONVERT), cur)))
-                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur))
-#endif
+#define XFS_BMAP_PTR_DADDR(bb,i,cur)    \
+        (XFS_BTREE_PTR_ADDR(XFS_BMAP_BLOCK_DSIZE(                       \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_KEY_DADDR)
+                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
-xfs_bmbt_key_t *
+                        xfs_bmbt, bb, i, XFS_BMAP_BLOCK_DMAXRECS(       \
-xfs_bmap_key_daddr(xfs_bmbt_block_t *bb, int i, struct xfs_btree_cur *cur);
+                                INT_GET((bb)->bb_level, ARCH_CONVERT), cur)))
-#define XFS_BMAP_KEY_DADDR(bb,i,cur)            xfs_bmap_key_daddr(bb,i,cur)
+#define XFS_BMAP_PTR_IADDR(bb,i,cur)    \
-#else
+        (XFS_BTREE_PTR_ADDR(XFS_BMAP_BLOCK_ISIZE(                       \
-#define XFS_BMAP_KEY_DADDR(bb,i,cur) \
+                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
-        XFS_BTREE_KEY_ADDR(XFS_BMAP_BLOCK_DSIZE(                \
+                        xfs_bmbt, bb, i, XFS_BMAP_BLOCK_IMAXRECS(       \
-                INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
+                                INT_GET((bb)->bb_level, ARCH_CONVERT), cur)))
-                xfs_bmbt, bb, i, XFS_BMAP_BLOCK_DMAXRECS(       \
-                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_KEY_IADDR)
-xfs_bmbt_key_t *
-xfs_bmap_key_iaddr(xfs_bmbt_block_t *bb, int i, struct xfs_btree_cur *cur);
-#define XFS_BMAP_KEY_IADDR(bb,i,cur)            xfs_bmap_key_iaddr(bb,i,cur)
-#else
-#define XFS_BMAP_KEY_IADDR(bb,i,cur) \
-        XFS_BTREE_KEY_ADDR(XFS_BMAP_BLOCK_ISIZE(                \
-                INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
-                xfs_bmbt, bb, i, XFS_BMAP_BLOCK_IMAXRECS(       \
-                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_PTR_DADDR)
-xfs_bmbt_ptr_t *
-xfs_bmap_ptr_daddr(xfs_bmbt_block_t *bb, int i, struct xfs_btree_cur *cur);
-#define XFS_BMAP_PTR_DADDR(bb,i,cur)            xfs_bmap_ptr_daddr(bb,i,cur)
-#else
-#define XFS_BMAP_PTR_DADDR(bb,i,cur) \
-        XFS_BTREE_PTR_ADDR(XFS_BMAP_BLOCK_DSIZE(                \
-                INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
-                xfs_bmbt, bb, i, XFS_BMAP_BLOCK_DMAXRECS(       \
-                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_PTR_IADDR)
-xfs_bmbt_ptr_t *
-xfs_bmap_ptr_iaddr(xfs_bmbt_block_t *bb, int i, struct xfs_btree_cur *cur);
-#define XFS_BMAP_PTR_IADDR(bb,i,cur)            xfs_bmap_ptr_iaddr(bb,i,cur)
-#else
-#define XFS_BMAP_PTR_IADDR(bb,i,cur) \
-        XFS_BTREE_PTR_ADDR(XFS_BMAP_BLOCK_ISIZE(                \
-                INT_GET((bb)->bb_level, ARCH_CONVERT), cur),    \
-                xfs_bmbt, bb, i, XFS_BMAP_BLOCK_IMAXRECS(       \
-                        INT_GET((bb)->bb_level, ARCH_CONVERT), cur))
-#endif
 /*
 * These are to be used when we know the size of the block and
 * we don't have a cursor.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BROOT_REC_ADDR)
-xfs_bmbt_rec_t *xfs_bmap_broot_rec_addr(xfs_bmbt_block_t *bb, int i, int sz);
-#define XFS_BMAP_BROOT_REC_ADDR(bb,i,sz)        xfs_bmap_broot_rec_addr(bb,i,sz)
-#else
 #define XFS_BMAP_BROOT_REC_ADDR(bb,i,sz) \
-        XFS_BTREE_REC_ADDR(sz,xfs_bmbt,bb,i,XFS_BMAP_BROOT_MAXRECS(sz))
+        (XFS_BTREE_REC_ADDR(sz,xfs_bmbt,bb,i,XFS_BMAP_BROOT_MAXRECS(sz)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BROOT_KEY_ADDR)
-xfs_bmbt_key_t *xfs_bmap_broot_key_addr(xfs_bmbt_block_t *bb, int i, int sz);
-#define XFS_BMAP_BROOT_KEY_ADDR(bb,i,sz)        xfs_bmap_broot_key_addr(bb,i,sz)
-#else
 #define XFS_BMAP_BROOT_KEY_ADDR(bb,i,sz) \
-        XFS_BTREE_KEY_ADDR(sz,xfs_bmbt,bb,i,XFS_BMAP_BROOT_MAXRECS(sz))
+        (XFS_BTREE_KEY_ADDR(sz,xfs_bmbt,bb,i,XFS_BMAP_BROOT_MAXRECS(sz)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BROOT_PTR_ADDR)
-xfs_bmbt_ptr_t *xfs_bmap_broot_ptr_addr(xfs_bmbt_block_t *bb, int i, int sz);
-#define XFS_BMAP_BROOT_PTR_ADDR(bb,i,sz)        xfs_bmap_broot_ptr_addr(bb,i,sz)
-#else
 #define XFS_BMAP_BROOT_PTR_ADDR(bb,i,sz) \
-        XFS_BTREE_PTR_ADDR(sz,xfs_bmbt,bb,i,XFS_BMAP_BROOT_MAXRECS(sz))
+        (XFS_BTREE_PTR_ADDR(sz,xfs_bmbt,bb,i,XFS_BMAP_BROOT_MAXRECS(sz)))
-#endif
+#define XFS_BMAP_BROOT_NUMRECS(bb)      INT_GET((bb)->bb_numrecs, ARCH_CONVERT)
+#define XFS_BMAP_BROOT_MAXRECS(sz)      XFS_BTREE_BLOCK_MAXRECS(sz,xfs_bmbt,0)
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BROOT_NUMRECS)
-int xfs_bmap_broot_numrecs(xfs_bmdr_block_t *bb);
-#define XFS_BMAP_BROOT_NUMRECS(bb)              xfs_bmap_broot_numrecs(bb)
-#else
-#define XFS_BMAP_BROOT_NUMRECS(bb) (INT_GET((bb)->bb_numrecs, ARCH_CONVERT))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BROOT_MAXRECS)
-int xfs_bmap_broot_maxrecs(int sz);
-#define XFS_BMAP_BROOT_MAXRECS(sz)              xfs_bmap_broot_maxrecs(sz)
-#else
-#define XFS_BMAP_BROOT_MAXRECS(sz) XFS_BTREE_BLOCK_MAXRECS(sz,xfs_bmbt,0)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BROOT_SPACE_CALC)
-int xfs_bmap_broot_space_calc(int nrecs);
-#define XFS_BMAP_BROOT_SPACE_CALC(nrecs)        xfs_bmap_broot_space_calc(nrecs)
-#else
 #define XFS_BMAP_BROOT_SPACE_CALC(nrecs) \
-        ((int)(sizeof(xfs_bmbt_block_t) + \
+        (int)(sizeof(xfs_bmbt_block_t) + \
-               ((nrecs) * (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t)))))
+               ((nrecs) * (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t))))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_BROOT_SPACE)
-int xfs_bmap_broot_space(xfs_bmdr_block_t *bb);
-#define XFS_BMAP_BROOT_SPACE(bb)                xfs_bmap_broot_space(bb)
-#else
 #define XFS_BMAP_BROOT_SPACE(bb) \
-        XFS_BMAP_BROOT_SPACE_CALC(INT_GET((bb)->bb_numrecs, ARCH_CONVERT))
+        (XFS_BMAP_BROOT_SPACE_CALC(INT_GET((bb)->bb_numrecs, ARCH_CONVERT)))
-#endif
+#define XFS_BMDR_SPACE_CALC(nrecs) \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMDR_SPACE_CALC)
+        (int)(sizeof(xfs_bmdr_block_t) + \
-int xfs_bmdr_space_calc(int nrecs);
+               ((nrecs) * (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t))))
-#define XFS_BMDR_SPACE_CALC(nrecs)              xfs_bmdr_space_calc(nrecs)
-#else
-#define XFS_BMDR_SPACE_CALC(nrecs)      \
-        ((int)(sizeof(xfs_bmdr_block_t) + \
-               ((nrecs) * (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t)))))
-#endif
 /*
 * Maximum number of bmap btree levels.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BM_MAXLEVELS)
+#define XFS_BM_MAXLEVELS(mp,w)          ((mp)->m_bm_maxlevels[(w)])
-int xfs_bm_maxlevels(struct xfs_mount *mp, int w);
-#define XFS_BM_MAXLEVELS(mp,w)                  xfs_bm_maxlevels(mp,w)
-#else
-#define XFS_BM_MAXLEVELS(mp,w)          ((mp)->m_bm_maxlevels[w])
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BMAP_SANITY_CHECK)
+#define XFS_BMAP_SANITY_CHECK(mp,bb,level) \
-int xfs_bmap_sanity_check(struct xfs_mount *mp, xfs_bmbt_block_t *bb,
-        int level);
-#define XFS_BMAP_SANITY_CHECK(mp,bb,level)      \
-        xfs_bmap_sanity_check(mp,bb,level)
-#else
-#define XFS_BMAP_SANITY_CHECK(mp,bb,level)      \
        (INT_GET((bb)->bb_magic, ARCH_CONVERT) == XFS_BMAP_MAGIC && \
         INT_GET((bb)->bb_level, ARCH_CONVERT) == level && \
         INT_GET((bb)->bb_numrecs, ARCH_CONVERT) > 0 && \
-         INT_GET((bb)->bb_numrecs, ARCH_CONVERT) <= (mp)->m_bmap_dmxr[(level) != 0])
+         INT_GET((bb)->bb_numrecs, ARCH_CONVERT) <= \
-#endif
+                         (mp)->m_bmap_dmxr[(level) != 0])
 #ifdef __KERNEL__
@@ -459,234 +317,84 @@ extern ktrace_t	*xfs_bmbt_trace_buf;
 /*
 * Prototypes for xfs_bmap.c to call.
 */
+extern void xfs_bmdr_to_bmbt(xfs_bmdr_block_t *, int, xfs_bmbt_block_t *, int);
-void
+extern int xfs_bmbt_decrement(struct xfs_btree_cur *, int, int *);
-xfs_bmdr_to_bmbt(
+extern int xfs_bmbt_delete(struct xfs_btree_cur *, int *);
-        xfs_bmdr_block_t *,
+extern void xfs_bmbt_get_all(xfs_bmbt_rec_t *r, xfs_bmbt_irec_t *s);
-        int,
+extern xfs_bmbt_block_t *xfs_bmbt_get_block(struct xfs_btree_cur *cur,
-        xfs_bmbt_block_t *,
+                                                int, struct xfs_buf **bpp);
-        int);
+extern xfs_filblks_t xfs_bmbt_get_blockcount(xfs_bmbt_rec_t *r);
+extern xfs_fsblock_t xfs_bmbt_get_startblock(xfs_bmbt_rec_t *r);
-int
+extern xfs_fileoff_t xfs_bmbt_get_startoff(xfs_bmbt_rec_t *r);
-xfs_bmbt_decrement(
+extern xfs_exntst_t xfs_bmbt_get_state(xfs_bmbt_rec_t *r);
-        struct xfs_btree_cur *,
-        int,
-        int *);
-int
-xfs_bmbt_delete(
-        struct xfs_btree_cur *,
-        int *);
-void
-xfs_bmbt_get_all(
-        xfs_bmbt_rec_t  *r,
-        xfs_bmbt_irec_t *s);
-xfs_bmbt_block_t *
-xfs_bmbt_get_block(
-        struct xfs_btree_cur    *cur,
-        int                     level,
-        struct xfs_buf          **bpp);
-xfs_filblks_t
-xfs_bmbt_get_blockcount(
-        xfs_bmbt_rec_t  *r);
-xfs_fsblock_t
-xfs_bmbt_get_startblock(
-        xfs_bmbt_rec_t  *r);
-xfs_fileoff_t
-xfs_bmbt_get_startoff(
-        xfs_bmbt_rec_t  *r);
-xfs_exntst_t
-xfs_bmbt_get_state(
-        xfs_bmbt_rec_t  *r);
 #ifndef XFS_NATIVE_HOST
-void
+extern void xfs_bmbt_disk_get_all(xfs_bmbt_rec_t *r, xfs_bmbt_irec_t *s);
-xfs_bmbt_disk_get_all(
+extern xfs_exntst_t xfs_bmbt_disk_get_state(xfs_bmbt_rec_t *r);
-        xfs_bmbt_rec_t  *r,
+extern xfs_filblks_t xfs_bmbt_disk_get_blockcount(xfs_bmbt_rec_t *r);
-        xfs_bmbt_irec_t *s);
+extern xfs_fsblock_t xfs_bmbt_disk_get_startblock(xfs_bmbt_rec_t *r);
+extern xfs_fileoff_t xfs_bmbt_disk_get_startoff(xfs_bmbt_rec_t *r);
-xfs_exntst_t
+#else
-xfs_bmbt_disk_get_state(
+#define xfs_bmbt_disk_get_all(r, s)     xfs_bmbt_get_all(r, s)
-        xfs_bmbt_rec_t  *r);
+#define xfs_bmbt_disk_get_state(r)      xfs_bmbt_get_state(r)
+#define xfs_bmbt_disk_get_blockcount(r) xfs_bmbt_get_blockcount(r)
-xfs_filblks_t
+#define xfs_bmbt_disk_get_startblock(r) xfs_bmbt_get_blockcount(r)
-xfs_bmbt_disk_get_blockcount(
+#define xfs_bmbt_disk_get_startoff(r)   xfs_bmbt_get_startoff(r)
-        xfs_bmbt_rec_t  *r);
-xfs_fsblock_t
-xfs_bmbt_disk_get_startblock(
-        xfs_bmbt_rec_t  *r);
-xfs_fileoff_t
-xfs_bmbt_disk_get_startoff(
-        xfs_bmbt_rec_t  *r);
-#else
-#define xfs_bmbt_disk_get_all(r, s) \
-        xfs_bmbt_get_all(r, s)
-#define xfs_bmbt_disk_get_state(r) \
-        xfs_bmbt_get_state(r)
-#define xfs_bmbt_disk_get_blockcount(r) \
-        xfs_bmbt_get_blockcount(r)
-#define xfs_bmbt_disk_get_startblock(r) \
-        xfs_bmbt_get_blockcount(r)
-#define xfs_bmbt_disk_get_startoff(r) \
-        xfs_bmbt_get_startoff(r)
 #endif /* XFS_NATIVE_HOST */
-int
+extern int xfs_bmbt_increment(struct xfs_btree_cur *, int, int *);
-xfs_bmbt_increment(
+extern int xfs_bmbt_insert(struct xfs_btree_cur *, int *);
-        struct xfs_btree_cur *,
+extern void xfs_bmbt_log_block(struct xfs_btree_cur *, struct xfs_buf *, int);
-        int,
+extern void xfs_bmbt_log_recs(struct xfs_btree_cur *, struct xfs_buf *, int,
-        int *);
+                                int);
+extern int xfs_bmbt_lookup_eq(struct xfs_btree_cur *, xfs_fileoff_t,
-int
+                                xfs_fsblock_t, xfs_filblks_t, int *);
-xfs_bmbt_insert(
+extern int xfs_bmbt_lookup_ge(struct xfs_btree_cur *, xfs_fileoff_t,
-        struct xfs_btree_cur *,
+                                xfs_fsblock_t, xfs_filblks_t, int *);
-        int *);
-void
-xfs_bmbt_log_block(
-        struct xfs_btree_cur *,
-        struct xfs_buf *,
-        int);
-void
-xfs_bmbt_log_recs(
-        struct xfs_btree_cur *,
-        struct xfs_buf *,
-        int,
-        int);
-int
-xfs_bmbt_lookup_eq(
-        struct xfs_btree_cur *,
-        xfs_fileoff_t,
-        xfs_fsblock_t,
-        xfs_filblks_t,
-        int *);
-int
-xfs_bmbt_lookup_ge(
-        struct xfs_btree_cur *,
-        xfs_fileoff_t,
-        xfs_fsblock_t,
-        xfs_filblks_t,
-        int *);
 /*
 * Give the bmap btree a new root block.  Copy the old broot contents
 * down into a real block and make the broot point to it.
 */
-int                                             /* error */
+extern int xfs_bmbt_newroot(struct xfs_btree_cur *cur, int *lflags, int *stat);
-xfs_bmbt_newroot(
-        struct xfs_btree_cur    *cur,           /* btree cursor */
+extern void xfs_bmbt_set_all(xfs_bmbt_rec_t *r, xfs_bmbt_irec_t *s);
-        int                     *logflags,      /* logging flags for inode */
+extern void xfs_bmbt_set_allf(xfs_bmbt_rec_t *r, xfs_fileoff_t o,
-        int                     *stat);         /* return status - 0 fail */
+                        xfs_fsblock_t b, xfs_filblks_t c, xfs_exntst_t v);
+extern void xfs_bmbt_set_blockcount(xfs_bmbt_rec_t *r, xfs_filblks_t v);
-void
+extern void xfs_bmbt_set_startblock(xfs_bmbt_rec_t *r, xfs_fsblock_t v);
-xfs_bmbt_set_all(
+extern void xfs_bmbt_set_startoff(xfs_bmbt_rec_t *r, xfs_fileoff_t v);
-        xfs_bmbt_rec_t  *r,
+extern void xfs_bmbt_set_state(xfs_bmbt_rec_t *r, xfs_exntst_t v);
-        xfs_bmbt_irec_t *s);
-void
-xfs_bmbt_set_allf(
-        xfs_bmbt_rec_t  *r,
-        xfs_fileoff_t   o,
-        xfs_fsblock_t   b,
-        xfs_filblks_t   c,
-        xfs_exntst_t    v);
-void
-xfs_bmbt_set_blockcount(
-        xfs_bmbt_rec_t  *r,
-        xfs_filblks_t   v);
-void
-xfs_bmbt_set_startblock(
-        xfs_bmbt_rec_t  *r,
-        xfs_fsblock_t   v);
-void
-xfs_bmbt_set_startoff(
-        xfs_bmbt_rec_t  *r,
-        xfs_fileoff_t   v);
-void
-xfs_bmbt_set_state(
-        xfs_bmbt_rec_t  *r,
-        xfs_exntst_t    v);
 #ifndef XFS_NATIVE_HOST
-void
+extern void xfs_bmbt_disk_set_all(xfs_bmbt_rec_t *r, xfs_bmbt_irec_t *s);
-xfs_bmbt_disk_set_all(
+extern void xfs_bmbt_disk_set_allf(xfs_bmbt_rec_t *r, xfs_fileoff_t o,
-        xfs_bmbt_rec_t  *r,
+                        xfs_fsblock_t b, xfs_filblks_t c, xfs_exntst_t v);
-        xfs_bmbt_irec_t *s);
-void
-xfs_bmbt_disk_set_allf(
-        xfs_bmbt_rec_t  *r,
-        xfs_fileoff_t   o,
-        xfs_fsblock_t   b,
-        xfs_filblks_t   c,
-        xfs_exntst_t    v);
 #else
-#define xfs_bmbt_disk_set_all(r, s) \
+#define xfs_bmbt_disk_set_all(r, s)             xfs_bmbt_set_all(r, s)
-        xfs_bmbt_set_all(r, s)
+#define xfs_bmbt_disk_set_allf(r, o, b, c, v)   xfs_bmbt_set_allf(r, o, b, c, v)
-#define xfs_bmbt_disk_set_allf(r, o, b, c, v) \
-        xfs_bmbt_set_allf(r, o, b, c, v)
 #endif /* XFS_NATIVE_HOST */
-void
+extern void xfs_bmbt_to_bmdr(xfs_bmbt_block_t *, int, xfs_bmdr_block_t *, int);
-xfs_bmbt_to_bmdr(
+extern int xfs_bmbt_update(struct xfs_btree_cur *, xfs_fileoff_t,
-        xfs_bmbt_block_t *,
+                                xfs_fsblock_t, xfs_filblks_t, xfs_exntst_t);
-        int,
-        xfs_bmdr_block_t *,
-        int);
-int
-xfs_bmbt_update(
-        struct xfs_btree_cur *,
-        xfs_fileoff_t,
-        xfs_fsblock_t,
-        xfs_filblks_t,
-        xfs_exntst_t);
 #ifdef DEBUG
 /*
 * Get the data from the pointed-to record.
 */
-int
+extern int xfs_bmbt_get_rec(struct xfs_btree_cur *, xfs_fileoff_t *,
-xfs_bmbt_get_rec(
+                                xfs_fsblock_t *, xfs_filblks_t *,
-        struct xfs_btree_cur *,
+                                xfs_exntst_t *, int *);
-        xfs_fileoff_t *,
-        xfs_fsblock_t *,
-        xfs_filblks_t *,
-        xfs_exntst_t *,
-        int *);
 #endif
 /*
 * Search an extent list for the extent which includes block
 * bno.
 */
-xfs_bmbt_rec_t *
+xfs_bmbt_rec_t *xfs_bmap_do_search_extents(xfs_bmbt_rec_t *,
-xfs_bmap_do_search_extents(
+                        xfs_extnum_t, xfs_extnum_t, xfs_fileoff_t, int *,
-        xfs_bmbt_rec_t *,
+                        xfs_extnum_t *, xfs_bmbt_irec_t *, xfs_bmbt_irec_t *);
-        xfs_extnum_t,
-        xfs_extnum_t,
-        xfs_fileoff_t,
-        int *,
-        xfs_extnum_t *,
-        xfs_bmbt_irec_t *,
-        xfs_bmbt_irec_t *);
 #endif  /* __KERNEL__ */
diff --git a/fs/xfs/xfs_btree.c b/fs/xfs/xfs_btree.c
index 0cc63d657a14..4d63f1c490fe 100644
--- a/fs/xfs/xfs_btree.c
+++ b/fs/xfs/xfs_btree.c
@@ -29,17 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * This file contains common code for the space manager's btree implementations.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -47,17 +42,16 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_bit.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_error.h"
 /*
diff --git a/fs/xfs/xfs_btree.h b/fs/xfs/xfs_btree.h
index 09b4e1532a35..30ee83712c79 100644
--- a/fs/xfs/xfs_btree.h
+++ b/fs/xfs/xfs_btree.h
@@ -113,12 +113,7 @@ typedef struct xfs_btree_block
 /*
 * Boolean to select which form of xfs_btree_block_t.bb_u to use.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BTREE_LONG_PTRS)
-int xfs_btree_long_ptrs(xfs_btnum_t btnum);
 #define XFS_BTREE_LONG_PTRS(btnum)      ((btnum) == XFS_BTNUM_BMAP)
-#else
-#define XFS_BTREE_LONG_PTRS(btnum)      ((btnum) == XFS_BTNUM_BMAP)
-#endif
 /*
 * Magic numbers for btree blocks.
@@ -205,24 +200,10 @@ typedef struct xfs_btree_cur
 /*
 * Convert from buffer to btree block header.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_BLOCK)
+#define XFS_BUF_TO_BLOCK(bp)    ((xfs_btree_block_t *)XFS_BUF_PTR(bp))
-xfs_btree_block_t *xfs_buf_to_block(struct xfs_buf *bp);
+#define XFS_BUF_TO_LBLOCK(bp)   ((xfs_btree_lblock_t *)XFS_BUF_PTR(bp))
-#define XFS_BUF_TO_BLOCK(bp)    xfs_buf_to_block(bp)
+#define XFS_BUF_TO_SBLOCK(bp)   ((xfs_btree_sblock_t *)XFS_BUF_PTR(bp))
-#else
-#define XFS_BUF_TO_BLOCK(bp)    ((xfs_btree_block_t *)(XFS_BUF_PTR(bp)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_LBLOCK)
-xfs_btree_lblock_t *xfs_buf_to_lblock(struct xfs_buf *bp);
-#define XFS_BUF_TO_LBLOCK(bp)   xfs_buf_to_lblock(bp)
-#else
-#define XFS_BUF_TO_LBLOCK(bp)   ((xfs_btree_lblock_t *)(XFS_BUF_PTR(bp)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_SBLOCK)
-xfs_btree_sblock_t *xfs_buf_to_sblock(struct xfs_buf *bp);
-#define XFS_BUF_TO_SBLOCK(bp)   xfs_buf_to_sblock(bp)
-#else
-#define XFS_BUF_TO_SBLOCK(bp)   ((xfs_btree_sblock_t *)(XFS_BUF_PTR(bp)))
-#endif
 #ifdef __KERNEL__
@@ -477,106 +458,33 @@ xfs_btree_setbuf(
 /*
 * Min and max functions for extlen, agblock, fileoff, and filblks types.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_EXTLEN_MIN)
-xfs_extlen_t xfs_extlen_min(xfs_extlen_t a, xfs_extlen_t b);
-#define XFS_EXTLEN_MIN(a,b)     xfs_extlen_min(a,b)
-#else
 #define XFS_EXTLEN_MIN(a,b)     \
        ((xfs_extlen_t)(a) < (xfs_extlen_t)(b) ? \
-         (xfs_extlen_t)(a) : (xfs_extlen_t)(b))
+                (xfs_extlen_t)(a) : (xfs_extlen_t)(b))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_EXTLEN_MAX)
-xfs_extlen_t xfs_extlen_max(xfs_extlen_t a, xfs_extlen_t b);
-#define XFS_EXTLEN_MAX(a,b)     xfs_extlen_max(a,b)
-#else
 #define XFS_EXTLEN_MAX(a,b)     \
        ((xfs_extlen_t)(a) > (xfs_extlen_t)(b) ? \
-         (xfs_extlen_t)(a) : (xfs_extlen_t)(b))
+                (xfs_extlen_t)(a) : (xfs_extlen_t)(b))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGBLOCK_MIN)
-xfs_agblock_t xfs_agblock_min(xfs_agblock_t a, xfs_agblock_t b);
-#define XFS_AGBLOCK_MIN(a,b)    xfs_agblock_min(a,b)
-#else
 #define XFS_AGBLOCK_MIN(a,b)    \
        ((xfs_agblock_t)(a) < (xfs_agblock_t)(b) ? \
-         (xfs_agblock_t)(a) : (xfs_agblock_t)(b))
+                (xfs_agblock_t)(a) : (xfs_agblock_t)(b))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGBLOCK_MAX)
-xfs_agblock_t xfs_agblock_max(xfs_agblock_t a, xfs_agblock_t b);
-#define XFS_AGBLOCK_MAX(a,b)    xfs_agblock_max(a,b)
-#else
 #define XFS_AGBLOCK_MAX(a,b)    \
        ((xfs_agblock_t)(a) > (xfs_agblock_t)(b) ? \
-         (xfs_agblock_t)(a) : (xfs_agblock_t)(b))
+                (xfs_agblock_t)(a) : (xfs_agblock_t)(b))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FILEOFF_MIN)
-xfs_fileoff_t xfs_fileoff_min(xfs_fileoff_t a, xfs_fileoff_t b);
-#define XFS_FILEOFF_MIN(a,b)    xfs_fileoff_min(a,b)
-#else
 #define XFS_FILEOFF_MIN(a,b)    \
        ((xfs_fileoff_t)(a) < (xfs_fileoff_t)(b) ? \
-         (xfs_fileoff_t)(a) : (xfs_fileoff_t)(b))
+                (xfs_fileoff_t)(a) : (xfs_fileoff_t)(b))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FILEOFF_MAX)
-xfs_fileoff_t xfs_fileoff_max(xfs_fileoff_t a, xfs_fileoff_t b);
-#define XFS_FILEOFF_MAX(a,b)    xfs_fileoff_max(a,b)
-#else
 #define XFS_FILEOFF_MAX(a,b)    \
        ((xfs_fileoff_t)(a) > (xfs_fileoff_t)(b) ? \
-         (xfs_fileoff_t)(a) : (xfs_fileoff_t)(b))
+                (xfs_fileoff_t)(a) : (xfs_fileoff_t)(b))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FILBLKS_MIN)
-xfs_filblks_t xfs_filblks_min(xfs_filblks_t a, xfs_filblks_t b);
-#define XFS_FILBLKS_MIN(a,b)    xfs_filblks_min(a,b)
-#else
 #define XFS_FILBLKS_MIN(a,b)    \
        ((xfs_filblks_t)(a) < (xfs_filblks_t)(b) ? \
-         (xfs_filblks_t)(a) : (xfs_filblks_t)(b))
+                (xfs_filblks_t)(a) : (xfs_filblks_t)(b))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FILBLKS_MAX)
-xfs_filblks_t xfs_filblks_max(xfs_filblks_t a, xfs_filblks_t b);
-#define XFS_FILBLKS_MAX(a,b)    xfs_filblks_max(a,b)
-#else
 #define XFS_FILBLKS_MAX(a,b)    \
        ((xfs_filblks_t)(a) > (xfs_filblks_t)(b) ? \
-         (xfs_filblks_t)(a) : (xfs_filblks_t)(b))
+                (xfs_filblks_t)(a) : (xfs_filblks_t)(b))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FSB_SANITY_CHECK)
-int xfs_fsb_sanity_check(struct xfs_mount *mp, xfs_fsblock_t fsb);
-#define XFS_FSB_SANITY_CHECK(mp,fsb)    xfs_fsb_sanity_check(mp,fsb)
-#else
 #define XFS_FSB_SANITY_CHECK(mp,fsb)    \
        (XFS_FSB_TO_AGNO(mp, fsb) < mp->m_sb.sb_agcount && \
-         XFS_FSB_TO_AGBNO(mp, fsb) < mp->m_sb.sb_agblocks)
+                XFS_FSB_TO_AGBNO(mp, fsb) < mp->m_sb.sb_agblocks)
-#endif
-/*
- * Macros to set EFSCORRUPTED & return/branch.
- */
-#define XFS_WANT_CORRUPTED_GOTO(x,l)    \
-        { \
-                int fs_is_ok = (x); \
-                ASSERT(fs_is_ok); \
-                if (unlikely(!fs_is_ok)) { \
-                        XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_GOTO", \
-                                         XFS_ERRLEVEL_LOW, NULL); \
-                        error = XFS_ERROR(EFSCORRUPTED); \
-                        goto l; \
-                } \
-        }
-#define XFS_WANT_CORRUPTED_RETURN(x)    \
-        { \
-                int fs_is_ok = (x); \
-                ASSERT(fs_is_ok); \
-                if (unlikely(!fs_is_ok)) { \
-                        XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_RETURN", \
-                                         XFS_ERRLEVEL_LOW, NULL); \
-                        return XFS_ERROR(EFSCORRUPTED); \
-                } \
-        }
 #endif  /* __XFS_BTREE_H__ */
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index a264657acfd9..a37ffc38bb16 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -29,29 +29,19 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * This file contains the implementation of the xfs_buf_log_item.
- * It contains the item operations used to manipulate the buf log
- * items as well as utility routines used by the buffer specific
- * transaction routines.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
-#include "xfs_buf_item.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_buf_item.h"
 #include "xfs_trans_priv.h"
-#include "xfs_rw.h"
-#include "xfs_bit.h"
 #include "xfs_error.h"
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 7e086c60485f..b4075ec75453 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -29,13 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -43,19 +42,19 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_alloc.h"
-#include "xfs_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
+#include "xfs_alloc.h"
+#include "xfs_btree.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"
 #include "xfs_dir_leaf.h"
@@ -64,7 +63,6 @@
 #include "xfs_dir2_block.h"
 #include "xfs_dir2_node.h"
 #include "xfs_error.h"
-#include "xfs_bit.h"
 /*
 * xfs_da_btree.c
diff --git a/fs/xfs/xfs_da_btree.h b/fs/xfs/xfs_da_btree.h
index a2199578b4c0..654956e9787c 100644
--- a/fs/xfs/xfs_da_btree.h
+++ b/fs/xfs/xfs_da_btree.h
@@ -92,72 +92,24 @@ typedef struct xfs_da_node_entry xfs_da_node_entry_t;
 #define XFS_DA_MAXHASH  ((xfs_dahash_t)-1) /* largest valid hash value */
-/*
+#define XFS_LBSIZE(mp)  (mp)->m_sb.sb_blocksize
- * Macros used by directory code to interface to the filesystem.
+#define XFS_LBLOG(mp)   (mp)->m_sb.sb_blocklog
- */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LBSIZE)
-int xfs_lbsize(struct xfs_mount *mp);
-#define XFS_LBSIZE(mp)                  xfs_lbsize(mp)
-#else
-#define XFS_LBSIZE(mp)  ((mp)->m_sb.sb_blocksize)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LBLOG)
-int xfs_lblog(struct xfs_mount *mp);
-#define XFS_LBLOG(mp)                   xfs_lblog(mp)
-#else
-#define XFS_LBLOG(mp)   ((mp)->m_sb.sb_blocklog)
-#endif
-/*
- * Macros used by directory code to interface to the kernel
- */
-/*
- * Macros used to manipulate directory off_t's
- */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DA_MAKE_BNOENTRY)
-__uint32_t xfs_da_make_bnoentry(struct xfs_mount *mp, xfs_dablk_t bno,
-                                int entry);
 #define XFS_DA_MAKE_BNOENTRY(mp,bno,entry)      \
-        xfs_da_make_bnoentry(mp,bno,entry)
-#else
-#define XFS_DA_MAKE_BNOENTRY(mp,bno,entry) \
        (((bno) << (mp)->m_dircook_elog) | (entry))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DA_MAKE_COOKIE)
-xfs_off_t xfs_da_make_cookie(struct xfs_mount *mp, xfs_dablk_t bno, int entry,
-                                xfs_dahash_t hash);
 #define XFS_DA_MAKE_COOKIE(mp,bno,entry,hash)   \
-        xfs_da_make_cookie(mp,bno,entry,hash)
-#else
-#define XFS_DA_MAKE_COOKIE(mp,bno,entry,hash) \
        (((xfs_off_t)XFS_DA_MAKE_BNOENTRY(mp, bno, entry) << 32) | (hash))
-#endif
+#define XFS_DA_COOKIE_HASH(mp,cookie)           ((xfs_dahash_t)cookie)
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DA_COOKIE_HASH)
+#define XFS_DA_COOKIE_BNO(mp,cookie)            \
-xfs_dahash_t xfs_da_cookie_hash(struct xfs_mount *mp, xfs_off_t cookie);
+        ((((xfs_off_t)(cookie) >> 31) == -1LL ? \
-#define XFS_DA_COOKIE_HASH(mp,cookie)           xfs_da_cookie_hash(mp,cookie)
-#else
-#define XFS_DA_COOKIE_HASH(mp,cookie)   ((xfs_dahash_t)(cookie))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DA_COOKIE_BNO)
-xfs_dablk_t xfs_da_cookie_bno(struct xfs_mount *mp, xfs_off_t cookie);
-#define XFS_DA_COOKIE_BNO(mp,cookie)            xfs_da_cookie_bno(mp,cookie)
-#else
-#define XFS_DA_COOKIE_BNO(mp,cookie) \
-        (((xfs_off_t)(cookie) >> 31) == -1LL ? \
                (xfs_dablk_t)0 : \
-                (xfs_dablk_t)((xfs_off_t)(cookie) >> ((mp)->m_dircook_elog + 32)))
+                (xfs_dablk_t)((xfs_off_t)(cookie) >> \
-#endif
+                                ((mp)->m_dircook_elog + 32))))
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DA_COOKIE_ENTRY)
+#define XFS_DA_COOKIE_ENTRY(mp,cookie)          \
-int xfs_da_cookie_entry(struct xfs_mount *mp, xfs_off_t cookie);
+        ((((xfs_off_t)(cookie) >> 31) == -1LL ? \
-#define XFS_DA_COOKIE_ENTRY(mp,cookie)          xfs_da_cookie_entry(mp,cookie)
-#else
-#define XFS_DA_COOKIE_ENTRY(mp,cookie) \
-        (((xfs_off_t)(cookie) >> 31) == -1LL ? \
                (xfs_dablk_t)0 : \
                (xfs_dablk_t)(((xfs_off_t)(cookie) >> 32) & \
-                              ((1 << (mp)->m_dircook_elog) - 1)))
+                                ((1 << (mp)->m_dircook_elog) - 1))))
-#endif
 /*========================================================================
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index 8dd7a3923f64..925b0a22c664 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -29,30 +29,30 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_ag.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
 #include "xfs_bmap.h"
+#include "xfs_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_itable.h"
 #include "xfs_dfrag.h"
diff --git a/fs/xfs/xfs_dinode.h b/fs/xfs/xfs_dinode.h
index f5c932b064e6..9e1fd2323255 100644
--- a/fs/xfs/xfs_dinode.h
+++ b/fs/xfs/xfs_dinode.h
@@ -37,13 +37,8 @@ struct xfs_mount;
 #define XFS_DINODE_VERSION_1    1
 #define XFS_DINODE_VERSION_2    2
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DINODE_GOOD_VERSION)
+#define XFS_DINODE_GOOD_VERSION(v)      \
-int xfs_dinode_good_version(int v);
+        (((v) == XFS_DINODE_VERSION_1 || (v) == XFS_DINODE_VERSION_2))
-#define XFS_DINODE_GOOD_VERSION(v)      xfs_dinode_good_version(v)
-#else
-#define XFS_DINODE_GOOD_VERSION(v)      (((v) == XFS_DINODE_VERSION_1) || \
-                                         ((v) == XFS_DINODE_VERSION_2))
-#endif
 #define XFS_DINODE_MAGIC        0x494e  /* 'IN' */
 /*
@@ -184,75 +179,30 @@ typedef enum xfs_dinode_fmt
 /*
 * Inode size for given fs.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LITINO)
-int xfs_litino(struct xfs_mount *mp);
-#define XFS_LITINO(mp)          xfs_litino(mp)
-#else
 #define XFS_LITINO(mp)  ((mp)->m_litino)
-#endif
 #define XFS_BROOT_SIZE_ADJ      \
        (sizeof(xfs_bmbt_block_t) - sizeof(xfs_bmdr_block_t))
 /*
- * Fork identifiers.  Here so utilities can use them without including
- * xfs_inode.h.
- */
-#define XFS_DATA_FORK   0
-#define XFS_ATTR_FORK   1
-/*
 * Inode data & attribute fork sizes, per inode.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_Q)
-int xfs_cfork_q_disk(xfs_dinode_core_t *dcp);
-int xfs_cfork_q(xfs_dinode_core_t *dcp);
-#define XFS_CFORK_Q_DISK(dcp)               xfs_cfork_q_disk(dcp)
-#define XFS_CFORK_Q(dcp)                    xfs_cfork_q(dcp)
-#else
-#define XFS_CFORK_Q_DISK(dcp)               ((dcp)->di_forkoff != 0)
 #define XFS_CFORK_Q(dcp)                    ((dcp)->di_forkoff != 0)
+#define XFS_CFORK_Q_DISK(dcp)               ((dcp)->di_forkoff != 0)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_BOFF)
-int xfs_cfork_boff_disk(xfs_dinode_core_t *dcp);
-int xfs_cfork_boff(xfs_dinode_core_t *dcp);
-#define XFS_CFORK_BOFF_DISK(dcp)            xfs_cfork_boff_disk(dcp)
-#define XFS_CFORK_BOFF(dcp)                 xfs_cfork_boff(dcp)
-#else
-#define XFS_CFORK_BOFF_DISK(dcp)            ((int)(INT_GET((dcp)->di_forkoff, ARCH_CONVERT) << 3))
 #define XFS_CFORK_BOFF(dcp)                 ((int)((dcp)->di_forkoff << 3))
+#define XFS_CFORK_BOFF_DISK(dcp) \
+        ((int)(INT_GET((dcp)->di_forkoff, ARCH_CONVERT) << 3))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_DSIZE)
-int xfs_cfork_dsize_disk(xfs_dinode_core_t *dcp, struct xfs_mount *mp);
-int xfs_cfork_dsize(xfs_dinode_core_t *dcp, struct xfs_mount *mp);
-#define XFS_CFORK_DSIZE_DISK(dcp,mp)        xfs_cfork_dsize_disk(dcp,mp)
-#define XFS_CFORK_DSIZE(dcp,mp)             xfs_cfork_dsize(dcp,mp)
-#else
 #define XFS_CFORK_DSIZE_DISK(dcp,mp) \
        (XFS_CFORK_Q_DISK(dcp) ? XFS_CFORK_BOFF_DISK(dcp) : XFS_LITINO(mp))
 #define XFS_CFORK_DSIZE(dcp,mp) \
        (XFS_CFORK_Q(dcp) ? XFS_CFORK_BOFF(dcp) : XFS_LITINO(mp))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_ASIZE)
-int xfs_cfork_asize_disk(xfs_dinode_core_t *dcp, struct xfs_mount *mp);
-int xfs_cfork_asize(xfs_dinode_core_t *dcp, struct xfs_mount *mp);
-#define XFS_CFORK_ASIZE_DISK(dcp,mp)        xfs_cfork_asize_disk(dcp,mp)
-#define XFS_CFORK_ASIZE(dcp,mp)             xfs_cfork_asize(dcp,mp)
-#else
 #define XFS_CFORK_ASIZE_DISK(dcp,mp) \
        (XFS_CFORK_Q_DISK(dcp) ? XFS_LITINO(mp) - XFS_CFORK_BOFF_DISK(dcp) : 0)
 #define XFS_CFORK_ASIZE(dcp,mp) \
        (XFS_CFORK_Q(dcp) ? XFS_LITINO(mp) - XFS_CFORK_BOFF(dcp) : 0)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_SIZE)
-int xfs_cfork_size_disk(xfs_dinode_core_t *dcp, struct xfs_mount *mp, int w);
-int xfs_cfork_size(xfs_dinode_core_t *dcp, struct xfs_mount *mp, int w);
-#define XFS_CFORK_SIZE_DISK(dcp,mp,w)       xfs_cfork_size_disk(dcp,mp,w)
-#define XFS_CFORK_SIZE(dcp,mp,w)            xfs_cfork_size(dcp,mp,w)
-#else
 #define XFS_CFORK_SIZE_DISK(dcp,mp,w) \
        ((w) == XFS_DATA_FORK ? \
                XFS_CFORK_DSIZE_DISK(dcp, mp) : \
@@ -261,93 +211,26 @@ int xfs_cfork_size(xfs_dinode_core_t *dcp, struct xfs_mount *mp, int w);
        ((w) == XFS_DATA_FORK ? \
                XFS_CFORK_DSIZE(dcp, mp) : XFS_CFORK_ASIZE(dcp, mp))
-#endif
+#define XFS_DFORK_DSIZE(dip,mp) \
+        XFS_CFORK_DSIZE_DISK(&(dip)->di_core, mp)
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_DSIZE)
+#define XFS_DFORK_ASIZE(dip,mp) \
-int xfs_dfork_dsize(xfs_dinode_t *dip, struct xfs_mount *mp);
+        XFS_CFORK_ASIZE_DISK(&(dip)->di_core, mp)
-#define XFS_DFORK_DSIZE(dip,mp)             xfs_dfork_dsize(dip,mp)
+#define XFS_DFORK_SIZE(dip,mp,w) \
-#else
+        XFS_CFORK_SIZE_DISK(&(dip)->di_core, mp, w)
-#define XFS_DFORK_DSIZE(dip,mp)             XFS_CFORK_DSIZE_DISK(&(dip)->di_core, mp)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_ASIZE)
-int xfs_dfork_asize(xfs_dinode_t *dip, struct xfs_mount *mp);
-#define XFS_DFORK_ASIZE(dip,mp)             xfs_dfork_asize(dip,mp)
-#else
-#define XFS_DFORK_ASIZE(dip,mp)             XFS_CFORK_ASIZE_DISK(&(dip)->di_core, mp)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_SIZE)
-int xfs_dfork_size(xfs_dinode_t *dip, struct xfs_mount *mp, int w);
-#define XFS_DFORK_SIZE(dip,mp,w)            xfs_dfork_size(dip,mp,w)
-#else
-#define XFS_DFORK_SIZE(dip,mp,w)            XFS_CFORK_SIZE_DISK(&(dip)->di_core, mp, w)
-#endif
-/*
- * Macros for accessing per-fork disk inode information.
- */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_Q)
-int xfs_dfork_q(xfs_dinode_t *dip);
-#define XFS_DFORK_Q(dip)                    xfs_dfork_q(dip)
-#else
 #define XFS_DFORK_Q(dip)                    XFS_CFORK_Q_DISK(&(dip)->di_core)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_BOFF)
-int xfs_dfork_boff(xfs_dinode_t *dip);
-#define XFS_DFORK_BOFF(dip)                 xfs_dfork_boff(dip)
-#else
 #define XFS_DFORK_BOFF(dip)                 XFS_CFORK_BOFF_DISK(&(dip)->di_core)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_DPTR)
-char *xfs_dfork_dptr(xfs_dinode_t *dip);
-#define XFS_DFORK_DPTR(dip)                 xfs_dfork_dptr(dip)
-#else
 #define XFS_DFORK_DPTR(dip)                 ((dip)->di_u.di_c)
+#define XFS_DFORK_APTR(dip)     \
-#endif
+        ((dip)->di_u.di_c + XFS_DFORK_BOFF(dip))
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_APTR)
-char *xfs_dfork_aptr(xfs_dinode_t *dip);
-#define XFS_DFORK_APTR(dip)                 xfs_dfork_aptr(dip)
-#else
-#define XFS_DFORK_APTR(dip)                 ((dip)->di_u.di_c + XFS_DFORK_BOFF(dip))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_PTR)
-char *xfs_dfork_ptr(xfs_dinode_t *dip, int w);
-#define XFS_DFORK_PTR(dip,w)                xfs_dfork_ptr(dip,w)
-#else
 #define XFS_DFORK_PTR(dip,w)    \
        ((w) == XFS_DATA_FORK ? XFS_DFORK_DPTR(dip) : XFS_DFORK_APTR(dip))
+#define XFS_CFORK_FORMAT(dcp,w) \
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_FORMAT)
-int xfs_cfork_format(xfs_dinode_core_t *dcp, int w);
-#define XFS_CFORK_FORMAT(dcp,w)             xfs_cfork_format(dcp,w)
-#else
-#define XFS_CFORK_FORMAT(dcp,w) \
        ((w) == XFS_DATA_FORK ? (dcp)->di_format : (dcp)->di_aformat)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_FMT_SET)
-void xfs_cfork_fmt_set(xfs_dinode_core_t *dcp, int w, int n);
-#define XFS_CFORK_FMT_SET(dcp,w,n)           xfs_cfork_fmt_set(dcp,w,n)
-#else
 #define XFS_CFORK_FMT_SET(dcp,w,n) \
        ((w) == XFS_DATA_FORK ? \
-                ((dcp)->di_format = (n)) : \
+                ((dcp)->di_format = (n)) : ((dcp)->di_aformat = (n)))
-                ((dcp)->di_aformat = (n)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_NEXTENTS)
-int xfs_cfork_nextents_disk(xfs_dinode_core_t *dcp, int w);
-int xfs_cfork_nextents(xfs_dinode_core_t *dcp, int w);
-#define XFS_CFORK_NEXTENTS_DISK(dcp,w)       xfs_cfork_nextents_disk(dcp,w)
-#define XFS_CFORK_NEXTENTS(dcp,w)            xfs_cfork_nextents(dcp,w)
-#else
 #define XFS_CFORK_NEXTENTS_DISK(dcp,w) \
        ((w) == XFS_DATA_FORK ? \
                INT_GET((dcp)->di_nextents, ARCH_CONVERT) : \
@@ -355,31 +238,13 @@ int xfs_cfork_nextents(xfs_dinode_core_t *dcp, int w);
 #define XFS_CFORK_NEXTENTS(dcp,w) \
        ((w) == XFS_DATA_FORK ? (dcp)->di_nextents : (dcp)->di_anextents)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_CFORK_NEXT_SET)
-void xfs_cfork_next_set(xfs_dinode_core_t *dcp, int w, int n);
-#define XFS_CFORK_NEXT_SET(dcp,w,n)             xfs_cfork_next_set(dcp,w,n)
-#else
 #define XFS_CFORK_NEXT_SET(dcp,w,n) \
        ((w) == XFS_DATA_FORK ? \
-                ((dcp)->di_nextents = (n)) : \
+                ((dcp)->di_nextents = (n)) : ((dcp)->di_anextents = (n)))
-                ((dcp)->di_anextents = (n)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DFORK_NEXTENTS)
-int xfs_dfork_nextents(xfs_dinode_t *dip, int w);
-#define XFS_DFORK_NEXTENTS(dip,w) xfs_dfork_nextents(dip,w)
-#else
 #define XFS_DFORK_NEXTENTS(dip,w) XFS_CFORK_NEXTENTS_DISK(&(dip)->di_core, w)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_DINODE)
+#define XFS_BUF_TO_DINODE(bp)   ((xfs_dinode_t *)XFS_BUF_PTR(bp))
-xfs_dinode_t *xfs_buf_to_dinode(struct xfs_buf *bp);
-#define XFS_BUF_TO_DINODE(bp)   xfs_buf_to_dinode(bp)
-#else
-#define XFS_BUF_TO_DINODE(bp)   ((xfs_dinode_t *)(XFS_BUF_PTR(bp)))
-#endif
 /*
 * Values for di_flags
diff --git a/fs/xfs/xfs_dir.c b/fs/xfs/xfs_dir.c
index 53787f35338b..d32824e8d86c 100644
--- a/fs/xfs/xfs_dir.c
+++ b/fs/xfs/xfs_dir.c
@@ -29,31 +29,29 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir_leaf.h"
 #include "xfs_error.h"
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index 49fc0a3695ae..40a741c7e5c4 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -29,18 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * XFS v2 directory implmentation.
- * Top-level and utility routines.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -48,16 +42,16 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir_leaf.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
@@ -65,7 +59,6 @@
 #include "xfs_dir2_node.h"
 #include "xfs_dir2_trace.h"
 #include "xfs_error.h"
-#include "xfs_bit.h"
 /*
 * Declarations for interface routines.
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index 088d3bdfac98..47b5d2c4b933 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -29,33 +29,25 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * xfs_dir2_block.c
- * XFS V2 directory implementation, single-block form.
- * See xfs_dir2_block.h for the format.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
-#include "xfs_da_btree.h"
+#include "xfs_inode_item.h"
 #include "xfs_dir_leaf.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
diff --git a/fs/xfs/xfs_dir2_block.h b/fs/xfs/xfs_dir2_block.h
index 5a578b84e246..70dcbe8976f7 100644
--- a/fs/xfs/xfs_dir2_block.h
+++ b/fs/xfs/xfs_dir2_block.h
@@ -74,53 +74,37 @@ typedef struct xfs_dir2_block {
 /*
 * Pointer to the leaf header embedded in a data block (1-block format)
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_BLOCK_TAIL_P)
-xfs_dir2_block_tail_t *
-xfs_dir2_block_tail_p(struct xfs_mount *mp, xfs_dir2_block_t *block);
 #define XFS_DIR2_BLOCK_TAIL_P(mp,block) xfs_dir2_block_tail_p(mp,block)
-#else
+static inline xfs_dir2_block_tail_t *
-#define XFS_DIR2_BLOCK_TAIL_P(mp,block) \
+xfs_dir2_block_tail_p(struct xfs_mount *mp, xfs_dir2_block_t *block)
-        (((xfs_dir2_block_tail_t *)((char *)(block) + (mp)->m_dirblksize)) - 1)
+{
-#endif
+        return (((xfs_dir2_block_tail_t *)
+                ((char *)(block) + (mp)->m_dirblksize)) - 1);
+}
 /*
 * Pointer to the leaf entries embedded in a data block (1-block format)
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_BLOCK_LEAF_P)
+#define XFS_DIR2_BLOCK_LEAF_P(btp)      xfs_dir2_block_leaf_p(btp)
-struct xfs_dir2_leaf_entry *xfs_dir2_block_leaf_p(xfs_dir2_block_tail_t *btp);
+static inline struct xfs_dir2_leaf_entry *
-#define XFS_DIR2_BLOCK_LEAF_P(btp) \
+xfs_dir2_block_leaf_p(xfs_dir2_block_tail_t *btp)
-        xfs_dir2_block_leaf_p(btp)
+{
-#else
+        return (((struct xfs_dir2_leaf_entry *)
-#define XFS_DIR2_BLOCK_LEAF_P(btp)      \
+                (btp)) - INT_GET((btp)->count, ARCH_CONVERT));
-        (((struct xfs_dir2_leaf_entry *)(btp)) - INT_GET((btp)->count, ARCH_CONVERT))
+}
-#endif
 /*
 * Function declarations.
 */
+extern int xfs_dir2_block_addname(struct xfs_da_args *args);
-extern int
+extern int xfs_dir2_block_getdents(struct xfs_trans *tp, struct xfs_inode *dp,
-        xfs_dir2_block_addname(struct xfs_da_args *args);
+                                   struct uio *uio, int *eofp,
+                                   struct xfs_dirent *dbp, xfs_dir2_put_t put);
-extern int
+extern int xfs_dir2_block_lookup(struct xfs_da_args *args);
-        xfs_dir2_block_getdents(struct xfs_trans *tp, struct xfs_inode *dp,
+extern int xfs_dir2_block_removename(struct xfs_da_args *args);
-                                struct uio *uio, int *eofp, struct xfs_dirent *dbp,
+extern int xfs_dir2_block_replace(struct xfs_da_args *args);
-                                xfs_dir2_put_t put);
+extern int xfs_dir2_leaf_to_block(struct xfs_da_args *args,
+                                  struct xfs_dabuf *lbp, struct xfs_dabuf *dbp);
-extern int
+extern int xfs_dir2_sf_to_block(struct xfs_da_args *args);
-        xfs_dir2_block_lookup(struct xfs_da_args *args);
-extern int
-        xfs_dir2_block_removename(struct xfs_da_args *args);
-extern int
-        xfs_dir2_block_replace(struct xfs_da_args *args);
-extern int
-        xfs_dir2_leaf_to_block(struct xfs_da_args *args, struct xfs_dabuf *lbp,
-                               struct xfs_dabuf *dbp);
-extern int
-        xfs_dir2_sf_to_block(struct xfs_da_args *args);
 #endif  /* __XFS_DIR2_BLOCK_H__ */
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c
index a0aa0e44ff9d..4b25f7e7c810 100644
--- a/fs/xfs/xfs_dir2_data.c
+++ b/fs/xfs/xfs_dir2_data.c
@@ -29,32 +29,24 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * xfs_dir2_data.c
- * Core data block handling routines for XFS V2 directories.
- * See xfs_dir2_data.h for data structures.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir_leaf.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
diff --git a/fs/xfs/xfs_dir2_data.h b/fs/xfs/xfs_dir2_data.h
index 476cac920bf5..eeff85570723 100644
--- a/fs/xfs/xfs_dir2_data.h
+++ b/fs/xfs/xfs_dir2_data.h
@@ -137,88 +137,65 @@ typedef struct xfs_dir2_data {
 /*
 * Size of a data entry.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DATA_ENTSIZE)
-int xfs_dir2_data_entsize(int n);
 #define XFS_DIR2_DATA_ENTSIZE(n)        xfs_dir2_data_entsize(n)
-#else
+static inline int xfs_dir2_data_entsize(int n)
-#define XFS_DIR2_DATA_ENTSIZE(n)        \
+{
-        ((int)(roundup(offsetof(xfs_dir2_data_entry_t, name[0]) + (n) + \
+        return (int)roundup(offsetof(xfs_dir2_data_entry_t, name[0]) + (n) + \
-                 (uint)sizeof(xfs_dir2_data_off_t), XFS_DIR2_DATA_ALIGN)))
+                 (uint)sizeof(xfs_dir2_data_off_t), XFS_DIR2_DATA_ALIGN);
-#endif
+}
 /*
 * Pointer to an entry's tag word.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DATA_ENTRY_TAG_P)
-xfs_dir2_data_off_t *xfs_dir2_data_entry_tag_p(xfs_dir2_data_entry_t *dep);
 #define XFS_DIR2_DATA_ENTRY_TAG_P(dep)  xfs_dir2_data_entry_tag_p(dep)
-#else
+static inline xfs_dir2_data_off_t *
-#define XFS_DIR2_DATA_ENTRY_TAG_P(dep)  \
+xfs_dir2_data_entry_tag_p(xfs_dir2_data_entry_t *dep)
-        ((xfs_dir2_data_off_t *)\
+{
-         ((char *)(dep) + XFS_DIR2_DATA_ENTSIZE((dep)->namelen) - \
+        return (xfs_dir2_data_off_t *) \
-          (uint)sizeof(xfs_dir2_data_off_t)))
+                 ((char *)(dep) + XFS_DIR2_DATA_ENTSIZE((dep)->namelen) - \
-#endif
+                  (uint)sizeof(xfs_dir2_data_off_t));
+}
 /*
 * Pointer to a freespace's tag word.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DATA_UNUSED_TAG_P)
-xfs_dir2_data_off_t *xfs_dir2_data_unused_tag_p(xfs_dir2_data_unused_t *dup);
 #define XFS_DIR2_DATA_UNUSED_TAG_P(dup) \
        xfs_dir2_data_unused_tag_p(dup)
-#else
+static inline xfs_dir2_data_off_t *
-#define XFS_DIR2_DATA_UNUSED_TAG_P(dup) \
+xfs_dir2_data_unused_tag_p(xfs_dir2_data_unused_t *dup)
-        ((xfs_dir2_data_off_t *)\
+{
-         ((char *)(dup) + INT_GET((dup)->length, ARCH_CONVERT) \
+        return (xfs_dir2_data_off_t *) \
-                        - (uint)sizeof(xfs_dir2_data_off_t)))
+                 ((char *)(dup) + INT_GET((dup)->length, ARCH_CONVERT) \
-#endif
+                                - (uint)sizeof(xfs_dir2_data_off_t));
+}
 /*
 * Function declarations.
 */
 #ifdef DEBUG
-extern void
+extern void xfs_dir2_data_check(struct xfs_inode *dp, struct xfs_dabuf *bp);
-        xfs_dir2_data_check(struct xfs_inode *dp, struct xfs_dabuf *bp);
 #else
 #define xfs_dir2_data_check(dp,bp)
 #endif
+extern xfs_dir2_data_free_t *xfs_dir2_data_freefind(xfs_dir2_data_t *d,
-extern xfs_dir2_data_free_t *
+                                xfs_dir2_data_unused_t *dup);
-        xfs_dir2_data_freefind(xfs_dir2_data_t *d,
+extern xfs_dir2_data_free_t *xfs_dir2_data_freeinsert(xfs_dir2_data_t *d,
-                               xfs_dir2_data_unused_t *dup);
+                                xfs_dir2_data_unused_t *dup, int *loghead);
+extern void xfs_dir2_data_freescan(struct xfs_mount *mp, xfs_dir2_data_t *d,
-extern xfs_dir2_data_free_t *
+                                int *loghead, char *aendp);
-        xfs_dir2_data_freeinsert(xfs_dir2_data_t *d,
+extern int xfs_dir2_data_init(struct xfs_da_args *args, xfs_dir2_db_t blkno,
-                                 xfs_dir2_data_unused_t *dup, int *loghead);
+                                struct xfs_dabuf **bpp);
+extern void xfs_dir2_data_log_entry(struct xfs_trans *tp, struct xfs_dabuf *bp,
-extern void
-        xfs_dir2_data_freescan(struct xfs_mount *mp, xfs_dir2_data_t *d,
-                               int *loghead, char *aendp);
-extern int
-        xfs_dir2_data_init(struct xfs_da_args *args, xfs_dir2_db_t blkno,
-                           struct xfs_dabuf **bpp);
-extern void
-        xfs_dir2_data_log_entry(struct xfs_trans *tp, struct xfs_dabuf *bp,
                                xfs_dir2_data_entry_t *dep);
+extern void xfs_dir2_data_log_header(struct xfs_trans *tp,
-extern void
+                                struct xfs_dabuf *bp);
-        xfs_dir2_data_log_header(struct xfs_trans *tp, struct xfs_dabuf *bp);
+extern void xfs_dir2_data_log_unused(struct xfs_trans *tp, struct xfs_dabuf *bp,
+                                xfs_dir2_data_unused_t *dup);
-extern void
+extern void xfs_dir2_data_make_free(struct xfs_trans *tp, struct xfs_dabuf *bp,
-        xfs_dir2_data_log_unused(struct xfs_trans *tp, struct xfs_dabuf *bp,
-                                 xfs_dir2_data_unused_t *dup);
-extern void
-        xfs_dir2_data_make_free(struct xfs_trans *tp, struct xfs_dabuf *bp,
                                xfs_dir2_data_aoff_t offset,
                                xfs_dir2_data_aoff_t len, int *needlogp,
                                int *needscanp);
+extern void xfs_dir2_data_use_free(struct xfs_trans *tp, struct xfs_dabuf *bp,
-extern void
-        xfs_dir2_data_use_free(struct xfs_trans *tp, struct xfs_dabuf *bp,
                               xfs_dir2_data_unused_t *dup,
                               xfs_dir2_data_aoff_t offset,
                               xfs_dir2_data_aoff_t len, int *needlogp,
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index 056f5283904b..89e48877e0ea 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -29,21 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * xfs_dir2_leaf.c
- * XFS directory version 2 implementation - single leaf form
- * see xfs_dir2_leaf.h for data structures.
- * These directories have multiple XFS_DIR2_DATA blocks and one
- * XFS_DIR2_LEAF1 block containing the hash table and freespace map.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -51,6 +42,7 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
@@ -58,14 +50,12 @@
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
 #include "xfs_dir2_block.h"
 #include "xfs_dir2_node.h"
 #include "xfs_dir2_trace.h"
 #include "xfs_error.h"
-#include "xfs_bit.h"
 /*
 * Local function declarations.
diff --git a/fs/xfs/xfs_dir2_leaf.h b/fs/xfs/xfs_dir2_leaf.h
index 3303cd6f4c00..43f0ec2131a9 100644
--- a/fs/xfs/xfs_dir2_leaf.h
+++ b/fs/xfs/xfs_dir2_leaf.h
@@ -44,10 +44,6 @@ struct xfs_mount;
 struct xfs_trans;
 /*
- * Constants.
- */
-/*
 * Offset of the leaf/node space.  First block in this space
 * is the btree root.
 */
@@ -57,10 +53,6 @@ struct xfs_trans;
        XFS_DIR2_BYTE_TO_DB(mp, XFS_DIR2_LEAF_OFFSET)
 /*
- * Types.
- */
-/*
 * Offset in data space of a data entry.
 */
 typedef __uint32_t      xfs_dir2_dataptr_t;
@@ -68,10 +60,6 @@ typedef	__uint32_t	xfs_dir2_dataptr_t;
 #define XFS_DIR2_NULL_DATAPTR   ((xfs_dir2_dataptr_t)0)
 /*
- * Structures.
- */
-/*
 * Leaf block header.
 */
 typedef struct xfs_dir2_leaf_hdr {
@@ -109,245 +97,193 @@ typedef struct xfs_dir2_leaf {
 } xfs_dir2_leaf_t;
 /*
- * Macros.
+ * DB blocks here are logical directory block numbers, not filesystem blocks.
- * The DB blocks are logical directory block numbers, not filesystem blocks.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_MAX_LEAF_ENTS)
+#define XFS_DIR2_MAX_LEAF_ENTS(mp)      xfs_dir2_max_leaf_ents(mp)
-int
+static inline int xfs_dir2_max_leaf_ents(struct xfs_mount *mp)
-xfs_dir2_max_leaf_ents(struct xfs_mount *mp);
+{
-#define XFS_DIR2_MAX_LEAF_ENTS(mp)      \
+        return (int)(((mp)->m_dirblksize - (uint)sizeof(xfs_dir2_leaf_hdr_t)) /
-        xfs_dir2_max_leaf_ents(mp)
+               (uint)sizeof(xfs_dir2_leaf_entry_t));
-#else
+}
-#define XFS_DIR2_MAX_LEAF_ENTS(mp)      \
-        ((int)(((mp)->m_dirblksize - (uint)sizeof(xfs_dir2_leaf_hdr_t)) / \
-               (uint)sizeof(xfs_dir2_leaf_entry_t)))
-#endif
 /*
 * Get address of the bestcount field in the single-leaf block.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_LEAF_TAIL_P)
+#define XFS_DIR2_LEAF_TAIL_P(mp,lp)     xfs_dir2_leaf_tail_p(mp, lp)
-xfs_dir2_leaf_tail_t *
+static inline xfs_dir2_leaf_tail_t *
-xfs_dir2_leaf_tail_p(struct xfs_mount *mp, xfs_dir2_leaf_t *lp);
+xfs_dir2_leaf_tail_p(struct xfs_mount *mp, xfs_dir2_leaf_t *lp)
-#define XFS_DIR2_LEAF_TAIL_P(mp,lp)     \
+{
-        xfs_dir2_leaf_tail_p(mp, lp)
+        return (xfs_dir2_leaf_tail_t *)
-#else
+                ((char *)(lp) + (mp)->m_dirblksize - 
-#define XFS_DIR2_LEAF_TAIL_P(mp,lp)     \
+                  (uint)sizeof(xfs_dir2_leaf_tail_t));
-        ((xfs_dir2_leaf_tail_t *)\
+}
-         ((char *)(lp) + (mp)->m_dirblksize - \
-          (uint)sizeof(xfs_dir2_leaf_tail_t)))
-#endif
 /*
 * Get address of the bests array in the single-leaf block.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_LEAF_BESTS_P)
-xfs_dir2_data_off_t *
-xfs_dir2_leaf_bests_p(xfs_dir2_leaf_tail_t *ltp);
 #define XFS_DIR2_LEAF_BESTS_P(ltp)      xfs_dir2_leaf_bests_p(ltp)
-#else
+static inline xfs_dir2_data_off_t *
-#define XFS_DIR2_LEAF_BESTS_P(ltp)      \
+xfs_dir2_leaf_bests_p(xfs_dir2_leaf_tail_t *ltp)
-        ((xfs_dir2_data_off_t *)(ltp) - INT_GET((ltp)->bestcount, ARCH_CONVERT))
+{
-#endif
+        return (xfs_dir2_data_off_t *)
+                (ltp) - INT_GET((ltp)->bestcount, ARCH_CONVERT);
+}
 /*
 * Convert dataptr to byte in file space
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DATAPTR_TO_BYTE)
-xfs_dir2_off_t
-xfs_dir2_dataptr_to_byte(struct xfs_mount *mp, xfs_dir2_dataptr_t dp);
 #define XFS_DIR2_DATAPTR_TO_BYTE(mp,dp) xfs_dir2_dataptr_to_byte(mp, dp)
-#else
+static inline xfs_dir2_off_t
-#define XFS_DIR2_DATAPTR_TO_BYTE(mp,dp) \
+xfs_dir2_dataptr_to_byte(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
-        ((xfs_dir2_off_t)(dp) << XFS_DIR2_DATA_ALIGN_LOG)
+{
-#endif
+        return (xfs_dir2_off_t)(dp) << XFS_DIR2_DATA_ALIGN_LOG;
+}
 /*
 * Convert byte in file space to dataptr.  It had better be aligned.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_BYTE_TO_DATAPTR)
-xfs_dir2_dataptr_t
-xfs_dir2_byte_to_dataptr(struct xfs_mount *mp, xfs_dir2_off_t by);
 #define XFS_DIR2_BYTE_TO_DATAPTR(mp,by) xfs_dir2_byte_to_dataptr(mp,by)
-#else
+static inline xfs_dir2_dataptr_t
-#define XFS_DIR2_BYTE_TO_DATAPTR(mp,by) \
+xfs_dir2_byte_to_dataptr(struct xfs_mount *mp, xfs_dir2_off_t by)
-        ((xfs_dir2_dataptr_t)((by) >> XFS_DIR2_DATA_ALIGN_LOG))
+{
-#endif
+        return (xfs_dir2_dataptr_t)((by) >> XFS_DIR2_DATA_ALIGN_LOG);
+}
+/*
+ * Convert byte in space to (DB) block
+ */
+#define XFS_DIR2_BYTE_TO_DB(mp,by)      xfs_dir2_byte_to_db(mp, by)
+static inline xfs_dir2_db_t
+xfs_dir2_byte_to_db(struct xfs_mount *mp, xfs_dir2_off_t by)
+{
+        return (xfs_dir2_db_t)((by) >> \
+                 ((mp)->m_sb.sb_blocklog + (mp)->m_sb.sb_dirblklog));
+}
 /*
 * Convert dataptr to a block number
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DATAPTR_TO_DB)
-xfs_dir2_db_t
-xfs_dir2_dataptr_to_db(struct xfs_mount *mp, xfs_dir2_dataptr_t dp);
 #define XFS_DIR2_DATAPTR_TO_DB(mp,dp)   xfs_dir2_dataptr_to_db(mp, dp)
-#else
+static inline xfs_dir2_db_t
-#define XFS_DIR2_DATAPTR_TO_DB(mp,dp)   \
+xfs_dir2_dataptr_to_db(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
-        XFS_DIR2_BYTE_TO_DB(mp, XFS_DIR2_DATAPTR_TO_BYTE(mp, dp))
+{
-#endif
+        return XFS_DIR2_BYTE_TO_DB(mp, XFS_DIR2_DATAPTR_TO_BYTE(mp, dp));
+}
+/*
+ * Convert byte in space to offset in a block
+ */
+#define XFS_DIR2_BYTE_TO_OFF(mp,by)     xfs_dir2_byte_to_off(mp, by)
+static inline xfs_dir2_data_aoff_t
+xfs_dir2_byte_to_off(struct xfs_mount *mp, xfs_dir2_off_t by)
+{
+        return (xfs_dir2_data_aoff_t)((by) & \
+                ((1 << ((mp)->m_sb.sb_blocklog + (mp)->m_sb.sb_dirblklog)) - 1));
+}
 /*
 * Convert dataptr to a byte offset in a block
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DATAPTR_TO_OFF)
-xfs_dir2_data_aoff_t
-xfs_dir2_dataptr_to_off(struct xfs_mount *mp, xfs_dir2_dataptr_t dp);
 #define XFS_DIR2_DATAPTR_TO_OFF(mp,dp)  xfs_dir2_dataptr_to_off(mp, dp)
-#else
+static inline xfs_dir2_data_aoff_t
-#define XFS_DIR2_DATAPTR_TO_OFF(mp,dp)  \
+xfs_dir2_dataptr_to_off(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
-        XFS_DIR2_BYTE_TO_OFF(mp, XFS_DIR2_DATAPTR_TO_BYTE(mp, dp))
+{
-#endif
+        return XFS_DIR2_BYTE_TO_OFF(mp, XFS_DIR2_DATAPTR_TO_BYTE(mp, dp));
+}
 /*
 * Convert block and offset to byte in space
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DB_OFF_TO_BYTE)
-xfs_dir2_off_t
-xfs_dir2_db_off_to_byte(struct xfs_mount *mp, xfs_dir2_db_t db,
-                        xfs_dir2_data_aoff_t o);
 #define XFS_DIR2_DB_OFF_TO_BYTE(mp,db,o)        \
        xfs_dir2_db_off_to_byte(mp, db, o)
-#else
+static inline xfs_dir2_off_t
-#define XFS_DIR2_DB_OFF_TO_BYTE(mp,db,o)        \
+xfs_dir2_db_off_to_byte(struct xfs_mount *mp, xfs_dir2_db_t db,
-        (((xfs_dir2_off_t)(db) << \
+                        xfs_dir2_data_aoff_t o)
-         ((mp)->m_sb.sb_blocklog + (mp)->m_sb.sb_dirblklog)) + (o))
+{
-#endif
+        return ((xfs_dir2_off_t)(db) << \
+                ((mp)->m_sb.sb_blocklog + (mp)->m_sb.sb_dirblklog)) + (o);
+}
 /*
- * Convert byte in space to (DB) block
+ * Convert block (DB) to block (dablk)
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_BYTE_TO_DB)
+#define XFS_DIR2_DB_TO_DA(mp,db)        xfs_dir2_db_to_da(mp, db)
-xfs_dir2_db_t xfs_dir2_byte_to_db(struct xfs_mount *mp, xfs_dir2_off_t by);
+static inline xfs_dablk_t
-#define XFS_DIR2_BYTE_TO_DB(mp,by)      xfs_dir2_byte_to_db(mp, by)
+xfs_dir2_db_to_da(struct xfs_mount *mp, xfs_dir2_db_t db)
-#else
+{
-#define XFS_DIR2_BYTE_TO_DB(mp,by)      \
+        return (xfs_dablk_t)((db) << (mp)->m_sb.sb_dirblklog);
-        ((xfs_dir2_db_t)((by) >> \
+}
-                         ((mp)->m_sb.sb_blocklog + (mp)->m_sb.sb_dirblklog)))
-#endif
 /*
 * Convert byte in space to (DA) block
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_BYTE_TO_DA)
-xfs_dablk_t xfs_dir2_byte_to_da(struct xfs_mount *mp, xfs_dir2_off_t by);
 #define XFS_DIR2_BYTE_TO_DA(mp,by)      xfs_dir2_byte_to_da(mp, by)
-#else
+static inline xfs_dablk_t
-#define XFS_DIR2_BYTE_TO_DA(mp,by)      \
+xfs_dir2_byte_to_da(struct xfs_mount *mp, xfs_dir2_off_t by)
-        XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_BYTE_TO_DB(mp, by))
+{
-#endif
+        return XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_BYTE_TO_DB(mp, by));
+}
-/*
- * Convert byte in space to offset in a block
- */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_BYTE_TO_OFF)
-xfs_dir2_data_aoff_t
-xfs_dir2_byte_to_off(struct xfs_mount *mp, xfs_dir2_off_t by);
-#define XFS_DIR2_BYTE_TO_OFF(mp,by)     xfs_dir2_byte_to_off(mp, by)
-#else
-#define XFS_DIR2_BYTE_TO_OFF(mp,by)     \
-        ((xfs_dir2_data_aoff_t)((by) & \
-                                ((1 << ((mp)->m_sb.sb_blocklog + \
-                                        (mp)->m_sb.sb_dirblklog)) - 1)))
-#endif
 /*
 * Convert block and offset to dataptr
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DB_OFF_TO_DATAPTR)
-xfs_dir2_dataptr_t
-xfs_dir2_db_off_to_dataptr(struct xfs_mount *mp, xfs_dir2_db_t db,
-                           xfs_dir2_data_aoff_t o);
 #define XFS_DIR2_DB_OFF_TO_DATAPTR(mp,db,o)     \
        xfs_dir2_db_off_to_dataptr(mp, db, o)
-#else
+static inline xfs_dir2_dataptr_t
-#define XFS_DIR2_DB_OFF_TO_DATAPTR(mp,db,o)     \
+xfs_dir2_db_off_to_dataptr(struct xfs_mount *mp, xfs_dir2_db_t db,
-        XFS_DIR2_BYTE_TO_DATAPTR(mp, XFS_DIR2_DB_OFF_TO_BYTE(mp, db, o))
+                           xfs_dir2_data_aoff_t o)
-#endif
+{
+        return XFS_DIR2_BYTE_TO_DATAPTR(mp, XFS_DIR2_DB_OFF_TO_BYTE(mp, db, o));
-/*
+}
- * Convert block (DB) to block (dablk)
- */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DB_TO_DA)
-xfs_dablk_t xfs_dir2_db_to_da(struct xfs_mount *mp, xfs_dir2_db_t db);
-#define XFS_DIR2_DB_TO_DA(mp,db)        xfs_dir2_db_to_da(mp, db)
-#else
-#define XFS_DIR2_DB_TO_DA(mp,db)        \
-        ((xfs_dablk_t)((db) << (mp)->m_sb.sb_dirblklog))
-#endif
 /*
 * Convert block (dablk) to block (DB)
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DA_TO_DB)
-xfs_dir2_db_t xfs_dir2_da_to_db(struct xfs_mount *mp, xfs_dablk_t da);
 #define XFS_DIR2_DA_TO_DB(mp,da)        xfs_dir2_da_to_db(mp, da)
-#else
+static inline xfs_dir2_db_t
-#define XFS_DIR2_DA_TO_DB(mp,da)        \
+xfs_dir2_da_to_db(struct xfs_mount *mp, xfs_dablk_t da)
-        ((xfs_dir2_db_t)((da) >> (mp)->m_sb.sb_dirblklog))
+{
-#endif
+        return (xfs_dir2_db_t)((da) >> (mp)->m_sb.sb_dirblklog);
+}
 /*
 * Convert block (dablk) to byte offset in space
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DA_TO_BYTE)
-xfs_dir2_off_t xfs_dir2_da_to_byte(struct xfs_mount *mp, xfs_dablk_t da);
 #define XFS_DIR2_DA_TO_BYTE(mp,da)      xfs_dir2_da_to_byte(mp, da)
-#else
+static inline xfs_dir2_off_t
-#define XFS_DIR2_DA_TO_BYTE(mp,da)      \
+xfs_dir2_da_to_byte(struct xfs_mount *mp, xfs_dablk_t da)
-        XFS_DIR2_DB_OFF_TO_BYTE(mp, XFS_DIR2_DA_TO_DB(mp, da), 0)
+{
-#endif
+        return XFS_DIR2_DB_OFF_TO_BYTE(mp, XFS_DIR2_DA_TO_DB(mp, da), 0);
+}
 /*
 * Function declarations.
 */
+extern int xfs_dir2_block_to_leaf(struct xfs_da_args *args,
-extern int
+                                  struct xfs_dabuf *dbp);
-        xfs_dir2_block_to_leaf(struct xfs_da_args *args, struct xfs_dabuf *dbp);
+extern int xfs_dir2_leaf_addname(struct xfs_da_args *args);
+extern void xfs_dir2_leaf_compact(struct xfs_da_args *args,
-extern int
+                                  struct xfs_dabuf *bp);
-        xfs_dir2_leaf_addname(struct xfs_da_args *args);
+extern void xfs_dir2_leaf_compact_x1(struct xfs_dabuf *bp, int *indexp,
+                                     int *lowstalep, int *highstalep,
-extern void
+                                     int *lowlogp, int *highlogp);
-        xfs_dir2_leaf_compact(struct xfs_da_args *args, struct xfs_dabuf *bp);
+extern int xfs_dir2_leaf_getdents(struct xfs_trans *tp, struct xfs_inode *dp,
+                                  struct uio *uio, int *eofp,
-extern void
+                                  struct xfs_dirent *dbp, xfs_dir2_put_t put);
-        xfs_dir2_leaf_compact_x1(struct xfs_dabuf *bp, int *indexp,
+extern int xfs_dir2_leaf_init(struct xfs_da_args *args, xfs_dir2_db_t bno,
-                                 int *lowstalep, int *highstalep, int *lowlogp,
+                              struct xfs_dabuf **bpp, int magic);
-                                 int *highlogp);
+extern void xfs_dir2_leaf_log_ents(struct xfs_trans *tp, struct xfs_dabuf *bp,
+                                   int first, int last);
-extern int
+extern void xfs_dir2_leaf_log_header(struct xfs_trans *tp,
-        xfs_dir2_leaf_getdents(struct xfs_trans *tp, struct xfs_inode *dp,
+                                     struct xfs_dabuf *bp);
-                               struct uio *uio, int *eofp, struct xfs_dirent *dbp,
+extern int xfs_dir2_leaf_lookup(struct xfs_da_args *args);
-                               xfs_dir2_put_t put);
+extern int xfs_dir2_leaf_removename(struct xfs_da_args *args);
+extern int xfs_dir2_leaf_replace(struct xfs_da_args *args);
-extern int
+extern int xfs_dir2_leaf_search_hash(struct xfs_da_args *args,
-        xfs_dir2_leaf_init(struct xfs_da_args *args, xfs_dir2_db_t bno,
+                                     struct xfs_dabuf *lbp);
-                           struct xfs_dabuf **bpp, int magic);
+extern int xfs_dir2_leaf_trim_data(struct xfs_da_args *args,
+                                   struct xfs_dabuf *lbp, xfs_dir2_db_t db);
-extern void
+extern int xfs_dir2_node_to_leaf(struct xfs_da_state *state);
-        xfs_dir2_leaf_log_ents(struct xfs_trans *tp, struct xfs_dabuf *bp,
-                               int first, int last);
-extern void
-        xfs_dir2_leaf_log_header(struct xfs_trans *tp, struct xfs_dabuf *bp);
-extern int
-        xfs_dir2_leaf_lookup(struct xfs_da_args *args);
-extern int
-        xfs_dir2_leaf_removename(struct xfs_da_args *args);
-extern int
-        xfs_dir2_leaf_replace(struct xfs_da_args *args);
-extern int
-        xfs_dir2_leaf_search_hash(struct xfs_da_args *args,
-                                  struct xfs_dabuf *lbp);
-extern int
-        xfs_dir2_leaf_trim_data(struct xfs_da_args *args, struct xfs_dabuf *lbp,                                xfs_dir2_db_t db);
-extern int
-        xfs_dir2_node_to_leaf(struct xfs_da_state *state);
 #endif  /* __XFS_DIR2_LEAF_H__ */
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index a7615d86bfb7..2517460430d3 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -29,33 +29,25 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * xfs_dir2_node.c
- * XFS directory implementation, version 2, node form files
- * See data structures in xfs_dir2_node.h and xfs_da_btree.h.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
 #include "xfs_dir2_block.h"
diff --git a/fs/xfs/xfs_dir2_node.h b/fs/xfs/xfs_dir2_node.h
index 96db420c7c5c..70fa0797c207 100644
--- a/fs/xfs/xfs_dir2_node.h
+++ b/fs/xfs/xfs_dir2_node.h
@@ -45,10 +45,6 @@ struct xfs_inode;
 struct xfs_trans;
 /*
- * Constants.
- */
-/*
 * Offset of the freespace index.
 */
 #define XFS_DIR2_FREE_SPACE     2
@@ -58,9 +54,6 @@ struct xfs_trans;
 #define XFS_DIR2_FREE_MAGIC     0x58443246      /* XD2F */
-/*
- * Structures.
- */
 typedef struct xfs_dir2_free_hdr {
        __uint32_t              magic;          /* XFS_DIR2_FREE_MAGIC */
        __int32_t               firstdb;        /* db of first entry */
@@ -73,87 +66,53 @@ typedef struct xfs_dir2_free {
        xfs_dir2_data_off_t     bests[1];       /* best free counts */
                                                /* unused entries are -1 */
 } xfs_dir2_free_t;
 #define XFS_DIR2_MAX_FREE_BESTS(mp)     \
        (((mp)->m_dirblksize - (uint)sizeof(xfs_dir2_free_hdr_t)) / \
         (uint)sizeof(xfs_dir2_data_off_t))
 /*
- * Macros.
- */
-/*
 * Convert data space db to the corresponding free db.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DB_TO_FDB)
-xfs_dir2_db_t
-xfs_dir2_db_to_fdb(struct xfs_mount *mp, xfs_dir2_db_t db);
 #define XFS_DIR2_DB_TO_FDB(mp,db)       xfs_dir2_db_to_fdb(mp, db)
-#else
+static inline xfs_dir2_db_t
-#define XFS_DIR2_DB_TO_FDB(mp,db)       \
+xfs_dir2_db_to_fdb(struct xfs_mount *mp, xfs_dir2_db_t db)
-        (XFS_DIR2_FREE_FIRSTDB(mp) + (db) / XFS_DIR2_MAX_FREE_BESTS(mp))
+{
-#endif
+        return (XFS_DIR2_FREE_FIRSTDB(mp) + (db) / XFS_DIR2_MAX_FREE_BESTS(mp));
+}
 /*
 * Convert data space db to the corresponding index in a free db.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_DB_TO_FDINDEX)
-int
-xfs_dir2_db_to_fdindex(struct xfs_mount *mp, xfs_dir2_db_t db);
 #define XFS_DIR2_DB_TO_FDINDEX(mp,db)   xfs_dir2_db_to_fdindex(mp, db)
-#else
+static inline int
-#define XFS_DIR2_DB_TO_FDINDEX(mp,db)   ((db) % XFS_DIR2_MAX_FREE_BESTS(mp))
+xfs_dir2_db_to_fdindex(struct xfs_mount *mp, xfs_dir2_db_t db)
-#endif
+{
+        return ((db) % XFS_DIR2_MAX_FREE_BESTS(mp));
-/*
+}
- * Functions.
- */
+extern void xfs_dir2_free_log_bests(struct xfs_trans *tp, struct xfs_dabuf *bp,
+                                    int first, int last);
-extern void
+extern int xfs_dir2_leaf_to_node(struct xfs_da_args *args,
-        xfs_dir2_free_log_bests(struct xfs_trans *tp, struct xfs_dabuf *bp,
+                                 struct xfs_dabuf *lbp);
-                                int first, int last);
+extern xfs_dahash_t xfs_dir2_leafn_lasthash(struct xfs_dabuf *bp, int *count);
+extern int xfs_dir2_leafn_lookup_int(struct xfs_dabuf *bp,
-extern int
+                                     struct xfs_da_args *args, int *indexp,
-        xfs_dir2_leaf_to_node(struct xfs_da_args *args, struct xfs_dabuf *lbp);
+                                     struct xfs_da_state *state);
+extern int xfs_dir2_leafn_order(struct xfs_dabuf *leaf1_bp,
-extern xfs_dahash_t
+                                struct xfs_dabuf *leaf2_bp);
-        xfs_dir2_leafn_lasthash(struct xfs_dabuf *bp, int *count);
+extern int xfs_dir2_leafn_split(struct xfs_da_state *state,
+                                struct xfs_da_state_blk *oldblk,
-extern int
+                                struct xfs_da_state_blk *newblk);
-        xfs_dir2_leafn_lookup_int(struct xfs_dabuf *bp,
+extern int xfs_dir2_leafn_toosmall(struct xfs_da_state *state, int *action);
-                                  struct xfs_da_args *args, int *indexp,
+extern void xfs_dir2_leafn_unbalance(struct xfs_da_state *state,
-                                  struct xfs_da_state *state);
+                                     struct xfs_da_state_blk *drop_blk,
+                                     struct xfs_da_state_blk *save_blk);
-extern int
+extern int xfs_dir2_node_addname(struct xfs_da_args *args);
-        xfs_dir2_leafn_order(struct xfs_dabuf *leaf1_bp,
+extern int xfs_dir2_node_lookup(struct xfs_da_args *args);
-                             struct xfs_dabuf *leaf2_bp);
+extern int xfs_dir2_node_removename(struct xfs_da_args *args);
+extern int xfs_dir2_node_replace(struct xfs_da_args *args);
-extern int
+extern int xfs_dir2_node_trim_free(struct xfs_da_args *args, xfs_fileoff_t fo,
-        xfs_dir2_leafn_split(struct xfs_da_state *state,
+                                   int *rvalp);
-                             struct xfs_da_state_blk *oldblk,
-                             struct xfs_da_state_blk *newblk);
-extern int
-        xfs_dir2_leafn_toosmall(struct xfs_da_state *state, int *action);
-extern void
-        xfs_dir2_leafn_unbalance(struct xfs_da_state *state,
-                                 struct xfs_da_state_blk *drop_blk,
-                                 struct xfs_da_state_blk *save_blk);
-extern int
-        xfs_dir2_node_addname(struct xfs_da_args *args);
-extern int
-        xfs_dir2_node_lookup(struct xfs_da_args *args);
-extern int
-        xfs_dir2_node_removename(struct xfs_da_args *args);
-extern int
-        xfs_dir2_node_replace(struct xfs_da_args *args);
-extern int
-        xfs_dir2_node_trim_free(struct xfs_da_args *args, xfs_fileoff_t fo,
-                                int *rvalp);
 #endif  /* __XFS_DIR2_NODE_H__ */
diff --git a/fs/xfs/xfs_dir2_sf.c b/fs/xfs/xfs_dir2_sf.c
index 6bbc61674411..95e703d5bc05 100644
--- a/fs/xfs/xfs_dir2_sf.c
+++ b/fs/xfs/xfs_dir2_sf.c
@@ -29,32 +29,25 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * xfs_dir2_sf.c
- * Shortform directory implementation for v2 directories.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
-#include "xfs_da_btree.h"
+#include "xfs_inode_item.h"
 #include "xfs_dir_leaf.h"
 #include "xfs_error.h"
 #include "xfs_dir2_data.h"
diff --git a/fs/xfs/xfs_dir2_sf.h b/fs/xfs/xfs_dir2_sf.h
index bac6f5a2a312..133464935ef1 100644
--- a/fs/xfs/xfs_dir2_sf.h
+++ b/fs/xfs/xfs_dir2_sf.h
@@ -104,140 +104,106 @@ typedef struct xfs_dir2_sf {
        xfs_dir2_sf_entry_t     list[1];        /* shortform entries */
 } xfs_dir2_sf_t;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_HDR_SIZE)
-int xfs_dir2_sf_hdr_size(int i8count);
 #define XFS_DIR2_SF_HDR_SIZE(i8count)   xfs_dir2_sf_hdr_size(i8count)
-#else
+static inline int xfs_dir2_sf_hdr_size(int i8count)
-#define XFS_DIR2_SF_HDR_SIZE(i8count)   \
+{
-        ((uint)sizeof(xfs_dir2_sf_hdr_t) - \
+        return ((uint)sizeof(xfs_dir2_sf_hdr_t) - \
-         ((i8count) == 0) * \
+                ((i8count) == 0) * \
-         ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t)))
+                ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t)));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_INUMBERP)
-xfs_dir2_inou_t *xfs_dir2_sf_inumberp(xfs_dir2_sf_entry_t *sfep);
 #define XFS_DIR2_SF_INUMBERP(sfep)      xfs_dir2_sf_inumberp(sfep)
-#else
+static inline xfs_dir2_inou_t *xfs_dir2_sf_inumberp(xfs_dir2_sf_entry_t *sfep)
-#define XFS_DIR2_SF_INUMBERP(sfep)      \
+{
-        ((xfs_dir2_inou_t *)&(sfep)->name[(sfep)->namelen])
+        return (xfs_dir2_inou_t *)&(sfep)->name[(sfep)->namelen];
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_GET_INUMBER)
-xfs_intino_t xfs_dir2_sf_get_inumber(xfs_dir2_sf_t *sfp, xfs_dir2_inou_t *from);
-#define XFS_DIR2_SF_GET_INUMBER(sfp, from)      \
-        xfs_dir2_sf_get_inumber(sfp, from)
-#else
+#define XFS_DIR2_SF_GET_INUMBER(sfp, from) \
-#define XFS_DIR2_SF_GET_INUMBER(sfp, from)      \
+        xfs_dir2_sf_get_inumber(sfp, from)
-        ((sfp)->hdr.i8count == 0 ? \
+static inline xfs_intino_t
+xfs_dir2_sf_get_inumber(xfs_dir2_sf_t *sfp, xfs_dir2_inou_t *from)
+{
+        return ((sfp)->hdr.i8count == 0 ? \
                (xfs_intino_t)XFS_GET_DIR_INO4((from)->i4) : \
-                (xfs_intino_t)XFS_GET_DIR_INO8((from)->i8))
+                (xfs_intino_t)XFS_GET_DIR_INO8((from)->i8));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_PUT_INUMBER)
+#define XFS_DIR2_SF_PUT_INUMBER(sfp,from,to) \
-void xfs_dir2_sf_put_inumber(xfs_dir2_sf_t *sfp, xfs_ino_t *from,
-                                     xfs_dir2_inou_t *to);
-#define XFS_DIR2_SF_PUT_INUMBER(sfp,from,to)    \
        xfs_dir2_sf_put_inumber(sfp,from,to)
-#else
+static inline void xfs_dir2_sf_put_inumber(xfs_dir2_sf_t *sfp, xfs_ino_t *from,
-#define XFS_DIR2_SF_PUT_INUMBER(sfp,from,to)    \
+                                                xfs_dir2_inou_t *to)
-        if ((sfp)->hdr.i8count == 0) { \
+{
-                XFS_PUT_DIR_INO4(*(from), (to)->i4); \
+        if ((sfp)->hdr.i8count == 0)
-        } else { \
+                XFS_PUT_DIR_INO4(*(from), (to)->i4);
-                XFS_PUT_DIR_INO8(*(from), (to)->i8); \
+        else
-        }
+                XFS_PUT_DIR_INO8(*(from), (to)->i8);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_GET_OFFSET)
-xfs_dir2_data_aoff_t xfs_dir2_sf_get_offset(xfs_dir2_sf_entry_t *sfep);
 #define XFS_DIR2_SF_GET_OFFSET(sfep)    \
        xfs_dir2_sf_get_offset(sfep)
-#else
+static inline xfs_dir2_data_aoff_t
-#define XFS_DIR2_SF_GET_OFFSET(sfep)    \
+xfs_dir2_sf_get_offset(xfs_dir2_sf_entry_t *sfep)
-        INT_GET_UNALIGNED_16_BE(&(sfep)->offset.i)
+{
-#endif
+        return INT_GET_UNALIGNED_16_BE(&(sfep)->offset.i);
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_PUT_OFFSET)
-void xfs_dir2_sf_put_offset(xfs_dir2_sf_entry_t *sfep,
-                                    xfs_dir2_data_aoff_t off);
 #define XFS_DIR2_SF_PUT_OFFSET(sfep,off) \
        xfs_dir2_sf_put_offset(sfep,off)
-#else
+static inline void
-#define XFS_DIR2_SF_PUT_OFFSET(sfep,off)        \
+xfs_dir2_sf_put_offset(xfs_dir2_sf_entry_t *sfep, xfs_dir2_data_aoff_t off)
-        INT_SET_UNALIGNED_16_BE(&(sfep)->offset.i,off)
+{
-#endif
+        INT_SET_UNALIGNED_16_BE(&(sfep)->offset.i, off);
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_ENTSIZE_BYNAME)
-int xfs_dir2_sf_entsize_byname(xfs_dir2_sf_t *sfp, int len);
 #define XFS_DIR2_SF_ENTSIZE_BYNAME(sfp,len)     \
        xfs_dir2_sf_entsize_byname(sfp,len)
-#else
+static inline int xfs_dir2_sf_entsize_byname(xfs_dir2_sf_t *sfp, int len)
-#define XFS_DIR2_SF_ENTSIZE_BYNAME(sfp,len)     /* space a name uses */ \
+{
-        ((uint)sizeof(xfs_dir2_sf_entry_t) - 1 + (len) - \
+        return ((uint)sizeof(xfs_dir2_sf_entry_t) - 1 + (len) - \
-         ((sfp)->hdr.i8count == 0) * \
+                ((sfp)->hdr.i8count == 0) * \
-         ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t)))
+                ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t)));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_ENTSIZE_BYENTRY)
-int xfs_dir2_sf_entsize_byentry(xfs_dir2_sf_t *sfp, xfs_dir2_sf_entry_t *sfep);
 #define XFS_DIR2_SF_ENTSIZE_BYENTRY(sfp,sfep)   \
        xfs_dir2_sf_entsize_byentry(sfp,sfep)
-#else
+static inline int
-#define XFS_DIR2_SF_ENTSIZE_BYENTRY(sfp,sfep)   /* space an entry uses */ \
+xfs_dir2_sf_entsize_byentry(xfs_dir2_sf_t *sfp, xfs_dir2_sf_entry_t *sfep)
-        ((uint)sizeof(xfs_dir2_sf_entry_t) - 1 + (sfep)->namelen - \
+{
-         ((sfp)->hdr.i8count == 0) * \
+        return ((uint)sizeof(xfs_dir2_sf_entry_t) - 1 + (sfep)->namelen - \
-         ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t)))
+                ((sfp)->hdr.i8count == 0) * \
-#endif
+                ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t)));
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_FIRSTENTRY)
-xfs_dir2_sf_entry_t *xfs_dir2_sf_firstentry(xfs_dir2_sf_t *sfp);
 #define XFS_DIR2_SF_FIRSTENTRY(sfp)     xfs_dir2_sf_firstentry(sfp)
-#else
+static inline xfs_dir2_sf_entry_t *xfs_dir2_sf_firstentry(xfs_dir2_sf_t *sfp)
-#define XFS_DIR2_SF_FIRSTENTRY(sfp)     /* first entry in struct */ \
+{
-        ((xfs_dir2_sf_entry_t *) \
+        return ((xfs_dir2_sf_entry_t *) \
-         ((char *)(sfp) + XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count)))
+                ((char *)(sfp) + XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count)));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR2_SF_NEXTENTRY)
+#define XFS_DIR2_SF_NEXTENTRY(sfp,sfep) xfs_dir2_sf_nextentry(sfp,sfep)
-xfs_dir2_sf_entry_t *xfs_dir2_sf_nextentry(xfs_dir2_sf_t *sfp,
+static inline xfs_dir2_sf_entry_t *
-                                           xfs_dir2_sf_entry_t *sfep);
+xfs_dir2_sf_nextentry(xfs_dir2_sf_t *sfp, xfs_dir2_sf_entry_t *sfep)
-#define XFS_DIR2_SF_NEXTENTRY(sfp,sfep)         xfs_dir2_sf_nextentry(sfp,sfep)
+{
-#else
+        return ((xfs_dir2_sf_entry_t *) \
-#define XFS_DIR2_SF_NEXTENTRY(sfp,sfep)         /* next entry in struct */ \
+                ((char *)(sfep) + XFS_DIR2_SF_ENTSIZE_BYENTRY(sfp,sfep)));
-        ((xfs_dir2_sf_entry_t *) \
+}
-                ((char *)(sfep) + XFS_DIR2_SF_ENTSIZE_BYENTRY(sfp,sfep)))
-#endif
 /*
 * Functions.
 */
+extern int xfs_dir2_block_sfsize(struct xfs_inode *dp,
-extern int
+                                 struct xfs_dir2_block *block,
-        xfs_dir2_block_sfsize(struct xfs_inode *dp,
+                                 xfs_dir2_sf_hdr_t *sfhp);
-                              struct xfs_dir2_block *block,
+extern int xfs_dir2_block_to_sf(struct xfs_da_args *args, struct xfs_dabuf *bp,
-                              xfs_dir2_sf_hdr_t *sfhp);
+                                int size, xfs_dir2_sf_hdr_t *sfhp);
+extern int xfs_dir2_sf_addname(struct xfs_da_args *args);
-extern int
+extern int xfs_dir2_sf_create(struct xfs_da_args *args, xfs_ino_t pino);
-        xfs_dir2_block_to_sf(struct xfs_da_args *args, struct xfs_dabuf *bp,
+extern int xfs_dir2_sf_getdents(struct xfs_inode *dp, struct uio *uio,
-                             int size, xfs_dir2_sf_hdr_t *sfhp);
+                                int *eofp, struct xfs_dirent *dbp,
+                                xfs_dir2_put_t put);
-extern int
+extern int xfs_dir2_sf_lookup(struct xfs_da_args *args);
-        xfs_dir2_sf_addname(struct xfs_da_args *args);
+extern int xfs_dir2_sf_removename(struct xfs_da_args *args);
+extern int xfs_dir2_sf_replace(struct xfs_da_args *args);
-extern int
-        xfs_dir2_sf_create(struct xfs_da_args *args, xfs_ino_t pino);
-extern int
-        xfs_dir2_sf_getdents(struct xfs_inode *dp, struct uio *uio, int *eofp,
-                             struct xfs_dirent *dbp, xfs_dir2_put_t put);
-extern int
-        xfs_dir2_sf_lookup(struct xfs_da_args *args);
-extern int
-        xfs_dir2_sf_removename(struct xfs_da_args *args);
-extern int
-        xfs_dir2_sf_replace(struct xfs_da_args *args);
 #endif  /* __XFS_DIR2_SF_H__ */
diff --git a/fs/xfs/xfs_dir2_trace.c b/fs/xfs/xfs_dir2_trace.c
index 9d6417393140..34e5138c670a 100644
--- a/fs/xfs/xfs_dir2_trace.c
+++ b/fs/xfs/xfs_dir2_trace.c
@@ -29,24 +29,19 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * xfs_dir2_trace.c
- * Tracing for xfs v2 directories.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
 #include "xfs_inum.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir2_trace.h"
 #ifdef XFS_DIR2_TRACE
diff --git a/fs/xfs/xfs_dir_leaf.c b/fs/xfs/xfs_dir_leaf.c
index ca9bc2d9ba08..22997d314cf2 100644
--- a/fs/xfs/xfs_dir_leaf.c
+++ b/fs/xfs/xfs_dir_leaf.c
@@ -29,38 +29,30 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * xfs_dir_leaf.c
- *
- * GROT: figure out how to recover gracefully when bmap returns ENOSPC.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_alloc.h"
-#include "xfs_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
+#include "xfs_alloc.h"
+#include "xfs_btree.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir_leaf.h"
 #include "xfs_error.h"
diff --git a/fs/xfs/xfs_dir_leaf.h b/fs/xfs/xfs_dir_leaf.h
index 480bffc1f29f..216d62693b72 100644
--- a/fs/xfs/xfs_dir_leaf.h
+++ b/fs/xfs/xfs_dir_leaf.h
@@ -152,30 +152,26 @@ typedef struct xfs_dir_put_args
        struct uio      *uio;           /* uio control structure */
 } xfs_dir_put_args_t;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR_LEAF_ENTSIZE_BYNAME)
-int xfs_dir_leaf_entsize_byname(int len);
 #define XFS_DIR_LEAF_ENTSIZE_BYNAME(len)        xfs_dir_leaf_entsize_byname(len)
-#else
+static inline int xfs_dir_leaf_entsize_byname(int len)
-#define XFS_DIR_LEAF_ENTSIZE_BYNAME(len)        /* space a name will use */ \
+{
-        ((uint)sizeof(xfs_dir_leaf_name_t)-1 + len)
+        return (uint)sizeof(xfs_dir_leaf_name_t)-1 + len;
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR_LEAF_ENTSIZE_BYENTRY)
-int xfs_dir_leaf_entsize_byentry(xfs_dir_leaf_entry_t *entry);
 #define XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry)     \
        xfs_dir_leaf_entsize_byentry(entry)
-#else
+static inline int xfs_dir_leaf_entsize_byentry(xfs_dir_leaf_entry_t *entry)
-#define XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry)     /* space an entry will use */ \
+{
-        ((uint)sizeof(xfs_dir_leaf_name_t)-1 + (entry)->namelen)
+        return (uint)sizeof(xfs_dir_leaf_name_t)-1 + (entry)->namelen;
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR_LEAF_NAMESTRUCT)
-xfs_dir_leaf_name_t *
-xfs_dir_leaf_namestruct(xfs_dir_leafblock_t *leafp, int offset);
 #define XFS_DIR_LEAF_NAMESTRUCT(leafp,offset)   \
        xfs_dir_leaf_namestruct(leafp,offset)
-#else
+static inline xfs_dir_leaf_name_t *
-#define XFS_DIR_LEAF_NAMESTRUCT(leafp,offset)   /* point to name struct */ \
+xfs_dir_leaf_namestruct(xfs_dir_leafblock_t *leafp, int offset)
-        ((xfs_dir_leaf_name_t *)&((char *)(leafp))[offset])
+{
-#endif
+        return (xfs_dir_leaf_name_t *)&((char *)(leafp))[offset];
+}
 /*========================================================================
 * Function prototypes for the kernel.
@@ -190,7 +186,7 @@ int xfs_dir_shortform_lookup(struct xfs_da_args *args);
 int xfs_dir_shortform_to_leaf(struct xfs_da_args *args);
 int xfs_dir_shortform_removename(struct xfs_da_args *args);
 int xfs_dir_shortform_getdents(struct xfs_inode *dp, struct uio *uio, int *eofp,
-                                      struct xfs_dirent *dbp, xfs_dir_put_t put);
+                               struct xfs_dirent *dbp, xfs_dir_put_t put);
 int xfs_dir_shortform_replace(struct xfs_da_args *args);
 /*
@@ -237,7 +233,6 @@ int	xfs_dir_put_dirent64_direct(xfs_dir_put_args_t *pa);
 int     xfs_dir_put_dirent64_uio(xfs_dir_put_args_t *pa);
 int     xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino);
 /*
 * Global data.
 */
diff --git a/fs/xfs/xfs_dir_sf.h b/fs/xfs/xfs_dir_sf.h
index a61bcfc2a87d..2b75b767e152 100644
--- a/fs/xfs/xfs_dir_sf.h
+++ b/fs/xfs/xfs_dir_sf.h
@@ -76,49 +76,44 @@ typedef struct xfs_dir_sf_sort {
        char            *name;          /* name value, pointer into buffer */
 } xfs_dir_sf_sort_t;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR_SF_GET_DIRINO)
+#define XFS_DIR_SF_GET_DIRINO(from,to)  xfs_dir_sf_get_dirino(from, to)
-void xfs_dir_sf_get_dirino(xfs_dir_ino_t *from, xfs_ino_t *to);
+static inline void xfs_dir_sf_get_dirino(xfs_dir_ino_t *from, xfs_ino_t *to)
-#define XFS_DIR_SF_GET_DIRINO(from,to)              xfs_dir_sf_get_dirino(from, to)
+{
-#else
+        *(to) = XFS_GET_DIR_INO8(*from);
-#define XFS_DIR_SF_GET_DIRINO(from,to)              (*(to) = XFS_GET_DIR_INO8(*from))
+}
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR_SF_PUT_DIRINO)
+#define XFS_DIR_SF_PUT_DIRINO(from,to)  xfs_dir_sf_put_dirino(from, to)
-void xfs_dir_sf_put_dirino(xfs_ino_t *from, xfs_dir_ino_t *to);
+static inline void xfs_dir_sf_put_dirino(xfs_ino_t *from, xfs_dir_ino_t *to)
-#define XFS_DIR_SF_PUT_DIRINO(from,to)    xfs_dir_sf_put_dirino(from, to)
+{
-#else
+        XFS_PUT_DIR_INO8(*(from), *(to));
-#define XFS_DIR_SF_PUT_DIRINO(from,to)    XFS_PUT_DIR_INO8(*(from), *(to))
+}
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR_SF_ENTSIZE_BYNAME)
+#define XFS_DIR_SF_ENTSIZE_BYNAME(len)  xfs_dir_sf_entsize_byname(len)
-int xfs_dir_sf_entsize_byname(int len);
+static inline int xfs_dir_sf_entsize_byname(int len)
-#define XFS_DIR_SF_ENTSIZE_BYNAME(len)          xfs_dir_sf_entsize_byname(len)
+{
-#else
+        return (uint)sizeof(xfs_dir_sf_entry_t)-1 + (len);
-#define XFS_DIR_SF_ENTSIZE_BYNAME(len)          /* space a name uses */ \
+}
-        ((uint)sizeof(xfs_dir_sf_entry_t)-1 + (len))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR_SF_ENTSIZE_BYENTRY)
-int xfs_dir_sf_entsize_byentry(xfs_dir_sf_entry_t *sfep);
 #define XFS_DIR_SF_ENTSIZE_BYENTRY(sfep)        xfs_dir_sf_entsize_byentry(sfep)
-#else
+static inline int xfs_dir_sf_entsize_byentry(xfs_dir_sf_entry_t *sfep)
-#define XFS_DIR_SF_ENTSIZE_BYENTRY(sfep)        /* space an entry uses */ \
+{
-        ((uint)sizeof(xfs_dir_sf_entry_t)-1 + (sfep)->namelen)
+        return (uint)sizeof(xfs_dir_sf_entry_t)-1 + (sfep)->namelen;
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR_SF_NEXTENTRY)
-xfs_dir_sf_entry_t *xfs_dir_sf_nextentry(xfs_dir_sf_entry_t *sfep);
 #define XFS_DIR_SF_NEXTENTRY(sfep)              xfs_dir_sf_nextentry(sfep)
-#else
+static inline xfs_dir_sf_entry_t *xfs_dir_sf_nextentry(xfs_dir_sf_entry_t *sfep)
-#define XFS_DIR_SF_NEXTENTRY(sfep)              /* next entry in struct */ \
+{
-        ((xfs_dir_sf_entry_t *) \
+        return (xfs_dir_sf_entry_t *) \
-                ((char *)(sfep) + XFS_DIR_SF_ENTSIZE_BYENTRY(sfep)))
+                ((char *)(sfep) + XFS_DIR_SF_ENTSIZE_BYENTRY(sfep));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DIR_SF_ALLFIT)
-int xfs_dir_sf_allfit(int count, int totallen);
 #define XFS_DIR_SF_ALLFIT(count,totallen)       \
        xfs_dir_sf_allfit(count,totallen)
-#else
+static inline int xfs_dir_sf_allfit(int count, int totallen)
-#define XFS_DIR_SF_ALLFIT(count,totallen)       /* will all entries fit? */ \
+{
-        ((uint)sizeof(xfs_dir_sf_hdr_t) + \
+        return ((uint)sizeof(xfs_dir_sf_hdr_t) + \
-               ((uint)sizeof(xfs_dir_sf_entry_t)-1)*(count) + (totallen))
+               ((uint)sizeof(xfs_dir_sf_entry_t)-1)*(count) + (totallen));
-#endif
+}
 #if defined(XFS_DIR_TRACE)
diff --git a/fs/xfs/xfs_dmops.c b/fs/xfs/xfs_dmops.c
index cec54ba800eb..1b99c4dfbab3 100644
--- a/fs/xfs/xfs_dmops.c
+++ b/fs/xfs/xfs_dmops.c
@@ -30,11 +30,10 @@
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
index dcd3fdd5c1f7..5da2738b4538 100644
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -29,23 +29,21 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
-#include "xfs_sb.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
+#include "xfs_sb.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_utils.h"
diff --git a/fs/xfs/xfs_error.h b/fs/xfs/xfs_error.h
index 52ee2b90b5ed..66eef1beb0e5 100644
--- a/fs/xfs/xfs_error.h
+++ b/fs/xfs/xfs_error.h
@@ -54,24 +54,10 @@ extern int	xfs_error_trap(int);
 struct xfs_mount;
-extern void
+extern void xfs_error_report(char *tag, int level, struct xfs_mount *mp,
-xfs_error_report(
+                                char *fname, int linenum, inst_t *ra);
-        char            *tag,
+extern void xfs_corruption_error(char *tag, int level, struct xfs_mount *mp,
-        int             level,
+                                void *p, char *fname, int linenum, inst_t *ra);
-        struct xfs_mount *mp,
-        char            *fname,
-        int             linenum,
-        inst_t          *ra);
-extern void
-xfs_corruption_error(
-        char            *tag,
-        int             level,
-        struct xfs_mount *mp,
-        void            *p,
-        char            *fname,
-        int             linenum,
-        inst_t          *ra);
 #define XFS_ERROR_REPORT(e, lvl, mp)    \
        xfs_error_report(e, lvl, mp, __FILE__, __LINE__, __return_address)
@@ -84,6 +70,32 @@ xfs_corruption_error(
 #define XFS_ERRLEVEL_HIGH       5
 /*
+ * Macros to set EFSCORRUPTED & return/branch.
+ */
+#define XFS_WANT_CORRUPTED_GOTO(x,l)    \
+        { \
+                int fs_is_ok = (x); \
+                ASSERT(fs_is_ok); \
+                if (unlikely(!fs_is_ok)) { \
+                        XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_GOTO", \
+                                         XFS_ERRLEVEL_LOW, NULL); \
+                        error = XFS_ERROR(EFSCORRUPTED); \
+                        goto l; \
+                } \
+        }
+#define XFS_WANT_CORRUPTED_RETURN(x)    \
+        { \
+                int fs_is_ok = (x); \
+                ASSERT(fs_is_ok); \
+                if (unlikely(!fs_is_ok)) { \
+                        XFS_ERROR_REPORT("XFS_WANT_CORRUPTED_RETURN", \
+                                         XFS_ERRLEVEL_LOW, NULL); \
+                        return XFS_ERROR(EFSCORRUPTED); \
+                } \
+        }
+/*
 * error injection tags - the labels can be anything you want
 * but each tag should have its own unique number
 */
@@ -139,8 +151,8 @@ xfs_corruption_error(
 #define XFS_RANDOM_BMAPIFORMAT                          XFS_RANDOM_DEFAULT
 #if (defined(DEBUG) || defined(INDUCE_IO_ERROR))
-extern int      xfs_error_test(int, int *, char *, int, char *, unsigned long);
+extern int xfs_error_test(int, int *, char *, int, char *, unsigned long);
-void xfs_error_test_init(void);
+extern void xfs_error_test_init(void);
 #define XFS_NUM_INJECT_ERROR                            10
@@ -156,12 +168,10 @@ void xfs_error_test_init(void);
                        (rf)))
 #endif /* __ANSI_CPP__ */
-int             xfs_errortag_add(int error_tag, xfs_mount_t *mp);
+extern int xfs_errortag_add(int error_tag, xfs_mount_t *mp);
-int             xfs_errortag_clear(int error_tag, xfs_mount_t *mp);
+extern int xfs_errortag_clear(int error_tag, xfs_mount_t *mp);
+extern int xfs_errortag_clearall(xfs_mount_t *mp);
-int             xfs_errortag_clearall(xfs_mount_t *mp);
+extern int xfs_errortag_clearall_umount(int64_t fsid, char *fsname, int loud);
-int             xfs_errortag_clearall_umount(int64_t fsid, char *fsname,
-                                                int loud);
 #else
 #define XFS_TEST_ERROR(expr, mp, tag, rf)       (expr)
 #define xfs_errortag_add(tag, mp)               (ENOSYS)
@@ -185,9 +195,9 @@ int		xfs_errortag_clearall_umount(int64_t fsid, char *fsname,
 struct xfs_mount;
 /* PRINTFLIKE4 */
-void            xfs_cmn_err(int panic_tag, int level, struct xfs_mount *mp,
+extern void xfs_cmn_err(int panic_tag, int level, struct xfs_mount *mp,
                            char *fmt, ...);
 /* PRINTFLIKE3 */
-void            xfs_fs_cmn_err(int level, struct xfs_mount *mp, char *fmt, ...);
+extern void xfs_fs_cmn_err(int level, struct xfs_mount *mp, char *fmt, ...);
 #endif  /* __XFS_ERROR_H__ */
diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
index cc7d1494a45d..f48cc9a7cd5a 100644
--- a/fs/xfs/xfs_extfree_item.c
+++ b/fs/xfs/xfs_extfree_item.c
@@ -29,18 +29,11 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * This file contains the implementation of the xfs_efi_log_item
- * and xfs_efd_log_item items.
- */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_sb.h"
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 67522f2bcee8..411081c0fd7c 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -29,38 +29,37 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
+#include "xfs_bit.h"
 #include "xfs_inum.h"
 #include "xfs_log.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
+#include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_ag.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
+#include "xfs_dir_sf.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
+#include "xfs_inode_item.h"
 #include "xfs_btree.h"
 #include "xfs_error.h"
 #include "xfs_alloc.h"
 #include "xfs_ialloc.h"
 #include "xfs_fsops.h"
 #include "xfs_itable.h"
-#include "xfs_rw.h"
-#include "xfs_refcache.h"
 #include "xfs_trans_space.h"
 #include "xfs_rtalloc.h"
-#include "xfs_dir2.h"
+#include "xfs_rw.h"
-#include "xfs_attr_sf.h"
-#include "xfs_dir_sf.h"
-#include "xfs_dir2_sf.h"
-#include "xfs_dinode.h"
-#include "xfs_inode.h"
-#include "xfs_inode_item.h"
 /*
 * File system operations
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index 02989691e4ab..4fc0e73fd18f 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -29,13 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -43,18 +42,17 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_alloc.h"
-#include "xfs_bit.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_bmap.h"
diff --git a/fs/xfs/xfs_ialloc.h b/fs/xfs/xfs_ialloc.h
index db6d0015cecf..fab660dd6d1b 100644
--- a/fs/xfs/xfs_ialloc.h
+++ b/fs/xfs/xfs_ialloc.h
@@ -40,18 +40,8 @@ struct xfs_trans;
 /*
 * Allocation parameters for inode allocation.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IALLOC_INODES)
+#define XFS_IALLOC_INODES(mp)   (mp)->m_ialloc_inos
-int xfs_ialloc_inodes(struct xfs_mount *mp);
+#define XFS_IALLOC_BLOCKS(mp)   (mp)->m_ialloc_blks
-#define XFS_IALLOC_INODES(mp)   xfs_ialloc_inodes(mp)
-#else
-#define XFS_IALLOC_INODES(mp)   ((mp)->m_ialloc_inos)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IALLOC_BLOCKS)
-xfs_extlen_t xfs_ialloc_blocks(struct xfs_mount *mp);
-#define XFS_IALLOC_BLOCKS(mp)   xfs_ialloc_blocks(mp)
-#else
-#define XFS_IALLOC_BLOCKS(mp)   ((mp)->m_ialloc_blks)
-#endif
 /*
 * For small block file systems, move inodes in clusters of this size.
@@ -67,31 +57,25 @@ xfs_extlen_t xfs_ialloc_blocks(struct xfs_mount *mp);
 /*
 * Make an inode pointer out of the buffer/offset.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_MAKE_IPTR)
-struct xfs_dinode *xfs_make_iptr(struct xfs_mount *mp, struct xfs_buf *b, int o);
 #define XFS_MAKE_IPTR(mp,b,o)           xfs_make_iptr(mp,b,o)
-#else
+static inline struct xfs_dinode *
-#define XFS_MAKE_IPTR(mp,b,o) \
+xfs_make_iptr(struct xfs_mount *mp, struct xfs_buf *b, int o)
-        ((xfs_dinode_t *)(xfs_buf_offset(b, (o) << (mp)->m_sb.sb_inodelog)))
+{
-#endif
+        return (xfs_dinode_t *)
+                (xfs_buf_offset(b, o << (mp)->m_sb.sb_inodelog));
+}
 /*
 * Find a free (set) bit in the inode bitmask.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IALLOC_FIND_FREE)
-int xfs_ialloc_find_free(xfs_inofree_t *fp);
 #define XFS_IALLOC_FIND_FREE(fp)        xfs_ialloc_find_free(fp)
-#else
+static inline int xfs_ialloc_find_free(xfs_inofree_t *fp)
-#define XFS_IALLOC_FIND_FREE(fp)        xfs_lowbit64(*(fp))
+{
-#endif
+        return xfs_lowbit64(*fp);
+}
 #ifdef __KERNEL__
-/*
- * Prototypes for visible xfs_ialloc.c routines.
- */
 /*
 * Allocate an inode on disk.
 * Mode is used to tell whether the new inode will need space, and whether
diff --git a/fs/xfs/xfs_ialloc_btree.c b/fs/xfs/xfs_ialloc_btree.c
index 2d4daecec990..a49958d21e87 100644
--- a/fs/xfs/xfs_ialloc_btree.c
+++ b/fs/xfs/xfs_ialloc_btree.c
@@ -29,22 +29,27 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir.h"
+#include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
+#include "xfs_dir_sf.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_alloc.h"
diff --git a/fs/xfs/xfs_ialloc_btree.h b/fs/xfs/xfs_ialloc_btree.h
index 44be188674a6..b8c7e72ed837 100644
--- a/fs/xfs/xfs_ialloc_btree.h
+++ b/fs/xfs/xfs_ialloc_btree.h
@@ -51,14 +51,12 @@ typedef	__uint64_t	xfs_inofree_t;
 #define XFS_INODES_PER_CHUNK_LOG        (XFS_NBBYLOG + 3)
 #define XFS_INOBT_ALL_FREE      ((xfs_inofree_t)-1)
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_MASKN)
-xfs_inofree_t xfs_inobt_maskn(int i, int n);
 #define XFS_INOBT_MASKN(i,n)            xfs_inobt_maskn(i,n)
-#else
+static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
-#define XFS_INOBT_MASKN(i,n)    \
+{
-        ((((n) >= XFS_INODES_PER_CHUNK ? \
+        return (((n) >= XFS_INODES_PER_CHUNK ? \
-                (xfs_inofree_t)0 : ((xfs_inofree_t)1 << (n))) - 1) << (i))
+                (xfs_inofree_t)0 : ((xfs_inofree_t)1 << (n))) - 1) << (i);
-#endif
+}
 /*
 * Data record structure
@@ -82,237 +80,110 @@ typedef xfs_agblock_t xfs_inobt_ptr_t;	/* btree pointer type */
                                        /* btree block header type */
 typedef struct xfs_btree_sblock xfs_inobt_block_t;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_INOBT_BLOCK)
+#define XFS_BUF_TO_INOBT_BLOCK(bp)      ((xfs_inobt_block_t *)XFS_BUF_PTR(bp))
-xfs_inobt_block_t *xfs_buf_to_inobt_block(struct xfs_buf *bp);
-#define XFS_BUF_TO_INOBT_BLOCK(bp)      xfs_buf_to_inobt_block(bp)
-#else
-#define XFS_BUF_TO_INOBT_BLOCK(bp) ((xfs_inobt_block_t *)(XFS_BUF_PTR(bp)))
-#endif
 /*
 * Bit manipulations for ir_free.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_MASK)
-xfs_inofree_t xfs_inobt_mask(int i);
-#define XFS_INOBT_MASK(i)               xfs_inobt_mask(i)
-#else
 #define XFS_INOBT_MASK(i)               ((xfs_inofree_t)1 << (i))
-#endif
+#define XFS_INOBT_IS_FREE(rp,i)         \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_IS_FREE)
+                (((rp)->ir_free & XFS_INOBT_MASK(i)) != 0)
-int xfs_inobt_is_free(xfs_inobt_rec_t *rp, int i);
+#define XFS_INOBT_IS_FREE_DISK(rp,i)    \
-#define XFS_INOBT_IS_FREE(rp,i)         xfs_inobt_is_free(rp,i)
+                ((INT_GET((rp)->ir_free,ARCH_CONVERT) & XFS_INOBT_MASK(i)) != 0)
-#define XFS_INOBT_IS_FREE_DISK(rp,i)    xfs_inobt_is_free_disk(rp,i)
-#else
-#define XFS_INOBT_IS_FREE(rp,i) \
-        (((rp)->ir_free & XFS_INOBT_MASK(i)) != 0)
-#define XFS_INOBT_IS_FREE_DISK(rp,i) \
-        ((INT_GET((rp)->ir_free, ARCH_CONVERT) & XFS_INOBT_MASK(i)) != 0)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_SET_FREE)
-void xfs_inobt_set_free(xfs_inobt_rec_t *rp, int i);
-#define XFS_INOBT_SET_FREE(rp,i)        xfs_inobt_set_free(rp,i)
-#else
 #define XFS_INOBT_SET_FREE(rp,i)        ((rp)->ir_free |= XFS_INOBT_MASK(i))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_CLR_FREE)
-void xfs_inobt_clr_free(xfs_inobt_rec_t *rp, int i);
-#define XFS_INOBT_CLR_FREE(rp,i)        xfs_inobt_clr_free(rp,i)
-#else
 #define XFS_INOBT_CLR_FREE(rp,i)        ((rp)->ir_free &= ~XFS_INOBT_MASK(i))
-#endif
 /*
 * Real block structures have a size equal to the disk block size.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_BLOCK_SIZE)
-int xfs_inobt_block_size(int lev, struct xfs_btree_cur *cur);
-#define XFS_INOBT_BLOCK_SIZE(lev,cur)   xfs_inobt_block_size(lev,cur)
-#else
 #define XFS_INOBT_BLOCK_SIZE(lev,cur)   (1 << (cur)->bc_blocklog)
-#endif
+#define XFS_INOBT_BLOCK_MAXRECS(lev,cur) ((cur)->bc_mp->m_inobt_mxr[lev != 0])
+#define XFS_INOBT_BLOCK_MINRECS(lev,cur) ((cur)->bc_mp->m_inobt_mnr[lev != 0])
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_BLOCK_MAXRECS)
-int xfs_inobt_block_maxrecs(int lev, struct xfs_btree_cur *cur);
-#define XFS_INOBT_BLOCK_MAXRECS(lev,cur)        xfs_inobt_block_maxrecs(lev,cur)
-#else
-#define XFS_INOBT_BLOCK_MAXRECS(lev,cur)        \
-        ((cur)->bc_mp->m_inobt_mxr[lev != 0])
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_BLOCK_MINRECS)
-int xfs_inobt_block_minrecs(int lev, struct xfs_btree_cur *cur);
-#define XFS_INOBT_BLOCK_MINRECS(lev,cur)        xfs_inobt_block_minrecs(lev,cur)
-#else
-#define XFS_INOBT_BLOCK_MINRECS(lev,cur)        \
-        ((cur)->bc_mp->m_inobt_mnr[lev != 0])
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_IS_LAST_REC)
-int xfs_inobt_is_last_rec(struct xfs_btree_cur *cur);
-#define XFS_INOBT_IS_LAST_REC(cur)      xfs_inobt_is_last_rec(cur)
-#else
 #define XFS_INOBT_IS_LAST_REC(cur)      \
-        ((cur)->bc_ptrs[0] == \
+        ((cur)->bc_ptrs[0] == INT_GET(XFS_BUF_TO_INOBT_BLOCK((cur)->bc_bufs[0])->bb_numrecs, ARCH_CONVERT))
-                INT_GET(XFS_BUF_TO_INOBT_BLOCK((cur)->bc_bufs[0])->bb_numrecs, ARCH_CONVERT))
-#endif
 /*
 * Maximum number of inode btree levels.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IN_MAXLEVELS)
-int xfs_in_maxlevels(struct xfs_mount *mp);
-#define XFS_IN_MAXLEVELS(mp)            xfs_in_maxlevels(mp)
-#else
 #define XFS_IN_MAXLEVELS(mp)            ((mp)->m_in_maxlevels)
-#endif
 /*
 * block numbers in the AG.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IBT_BLOCK)
+#define XFS_IBT_BLOCK(mp)               ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
-xfs_agblock_t xfs_ibt_block(struct xfs_mount *mp);
+#define XFS_PREALLOC_BLOCKS(mp)         ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
-#define XFS_IBT_BLOCK(mp)               xfs_ibt_block(mp)
-#else
-#define XFS_IBT_BLOCK(mp)       ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_PREALLOC_BLOCKS)
-xfs_agblock_t xfs_prealloc_blocks(struct xfs_mount *mp);
-#define XFS_PREALLOC_BLOCKS(mp)         xfs_prealloc_blocks(mp)
-#else
-#define XFS_PREALLOC_BLOCKS(mp) ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
-#endif
 /*
 * Record, key, and pointer address macros for btree blocks.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_REC_ADDR)
+#define XFS_INOBT_REC_ADDR(bb,i,cur) \
-xfs_inobt_rec_t *
+        (XFS_BTREE_REC_ADDR(XFS_INOBT_BLOCK_SIZE(0,cur), xfs_inobt, bb, \
-xfs_inobt_rec_addr(xfs_inobt_block_t *bb, int i, struct xfs_btree_cur *cur);
+                                i, XFS_INOBT_BLOCK_MAXRECS(0, cur)))
-#define XFS_INOBT_REC_ADDR(bb,i,cur)    xfs_inobt_rec_addr(bb,i,cur)
+#define XFS_INOBT_KEY_ADDR(bb,i,cur) \
-#else
+        (XFS_BTREE_KEY_ADDR(XFS_INOBT_BLOCK_SIZE(1,cur), xfs_inobt, bb, \
-#define XFS_INOBT_REC_ADDR(bb,i,cur)    \
+                                i, XFS_INOBT_BLOCK_MAXRECS(1, cur)))
-        XFS_BTREE_REC_ADDR(XFS_INOBT_BLOCK_SIZE(0,cur), xfs_inobt, bb, i, \
-                XFS_INOBT_BLOCK_MAXRECS(0, cur))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_KEY_ADDR)
-xfs_inobt_key_t *
-xfs_inobt_key_addr(xfs_inobt_block_t *bb, int i, struct xfs_btree_cur *cur);
-#define XFS_INOBT_KEY_ADDR(bb,i,cur)    xfs_inobt_key_addr(bb,i,cur)
-#else
-#define XFS_INOBT_KEY_ADDR(bb,i,cur)    \
-        XFS_BTREE_KEY_ADDR(XFS_INOBT_BLOCK_SIZE(1,cur), xfs_inobt, bb, i, \
-                XFS_INOBT_BLOCK_MAXRECS(1, cur))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INOBT_PTR_ADDR)
+#define XFS_INOBT_PTR_ADDR(bb,i,cur) \
-xfs_inobt_ptr_t *
+        (XFS_BTREE_PTR_ADDR(XFS_INOBT_BLOCK_SIZE(1,cur), xfs_inobt, bb, \
-xfs_inobt_ptr_addr(xfs_inobt_block_t *bb, int i, struct xfs_btree_cur *cur);
+                                i, XFS_INOBT_BLOCK_MAXRECS(1, cur)))
-#define XFS_INOBT_PTR_ADDR(bb,i,cur)    xfs_inobt_ptr_addr(bb,i,cur)
-#else
-#define XFS_INOBT_PTR_ADDR(bb,i,cur)    \
-        XFS_BTREE_PTR_ADDR(XFS_INOBT_BLOCK_SIZE(1,cur), xfs_inobt, bb, i, \
-                XFS_INOBT_BLOCK_MAXRECS(1, cur))
-#endif
-/*
- * Prototypes for externally visible routines.
- */
 /*
 * Decrement cursor by one record at the level.
 * For nonzero levels the leaf-ward information is untouched.
 */
-int                                     /* error */
+extern int xfs_inobt_decrement(struct xfs_btree_cur *cur, int level, int *stat);
-xfs_inobt_decrement(
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        int                     level,  /* level in btree, 0 is leaf */
-        int                     *stat); /* success/failure */
 /*
 * Delete the record pointed to by cur.
 * The cursor refers to the place where the record was (could be inserted)
 * when the operation returns.
 */
-int                                     /* error */
+extern int xfs_inobt_delete(struct xfs_btree_cur *cur, int *stat);
-xfs_inobt_delete(
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        int                     *stat); /* success/failure */
 /*
 * Get the data from the pointed-to record.
 */
-int                                     /* error */
+extern int xfs_inobt_get_rec(struct xfs_btree_cur *cur, xfs_agino_t *ino,
-xfs_inobt_get_rec(
+                             __int32_t *fcnt, xfs_inofree_t *free, int *stat);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agino_t             *ino,   /* output: starting inode of chunk */
-        __int32_t               *fcnt,  /* output: number of free inodes */
-        xfs_inofree_t           *free,  /* output: free inode mask */
-        int                     *stat); /* output: success/failure */
 /*
 * Increment cursor by one record at the level.
 * For nonzero levels the leaf-ward information is untouched.
 */
-int                                     /* error */
+extern int xfs_inobt_increment(struct xfs_btree_cur *cur, int level, int *stat);
-xfs_inobt_increment(
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        int                     level,  /* level in btree, 0 is leaf */
-        int                     *stat); /* success/failure */
 /*
 * Insert the current record at the point referenced by cur.
 * The cursor may be inconsistent on return if splits have been done.
 */
-int                                     /* error */
+extern int xfs_inobt_insert(struct xfs_btree_cur *cur, int *stat);
-xfs_inobt_insert(
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        int                     *stat); /* success/failure */
 /*
 * Lookup the record equal to ino in the btree given by cur.
 */
-int                                     /* error */
+extern int xfs_inobt_lookup_eq(struct xfs_btree_cur *cur, xfs_agino_t ino,
-xfs_inobt_lookup_eq(
+                                __int32_t fcnt, xfs_inofree_t free, int *stat);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agino_t             ino,    /* starting inode of chunk */
-        __int32_t               fcnt,   /* free inode count */
-        xfs_inofree_t           free,   /* free inode mask */
-        int                     *stat); /* success/failure */
 /*
 * Lookup the first record greater than or equal to ino
 * in the btree given by cur.
 */
-int                                     /* error */
+extern int xfs_inobt_lookup_ge(struct xfs_btree_cur *cur, xfs_agino_t ino,
-xfs_inobt_lookup_ge(
+                                __int32_t fcnt, xfs_inofree_t free, int *stat);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agino_t             ino,    /* starting inode of chunk */
-        __int32_t               fcnt,   /* free inode count */
-        xfs_inofree_t           free,   /* free inode mask */
-        int                     *stat); /* success/failure */
 /*
 * Lookup the first record less than or equal to ino
 * in the btree given by cur.
 */
-int                                     /* error */
+extern int xfs_inobt_lookup_le(struct xfs_btree_cur *cur, xfs_agino_t ino,
-xfs_inobt_lookup_le(
+                                __int32_t fcnt, xfs_inofree_t free, int *stat);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agino_t             ino,    /* starting inode of chunk */
-        __int32_t               fcnt,   /* free inode count */
-        xfs_inofree_t           free,   /* free inode mask */
-        int                     *stat); /* success/failure */
 /*
 * Update the record referred to by cur, to the value given
 * by [ino, fcnt, free].
 * This either works (return 0) or gets an EFSCORRUPTED error.
 */
-int                                     /* error */
+extern int xfs_inobt_update(struct xfs_btree_cur *cur, xfs_agino_t ino,
-xfs_inobt_update(
+                                __int32_t fcnt, xfs_inofree_t free);
-        struct xfs_btree_cur    *cur,   /* btree cursor */
-        xfs_agino_t             ino,    /* starting inode of chunk */
-        __int32_t               fcnt,   /* free inode count */
-        xfs_inofree_t           free);  /* free inode mask */
 #endif  /* __XFS_IALLOC_BTREE_H__ */
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index 0d9ae8fb4138..f925335e4553 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -29,15 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-#include <linux/delay.h>
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -45,19 +42,18 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_quota.h"
 #include "xfs_utils.h"
-#include "xfs_bit.h"
 /*
 * Initialize the inode hash table for the newly mounted file system.
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index a648cc8ce96b..edf50b5409fc 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -29,12 +29,13 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
+#include "xfs_imap.h"
 #include "xfs_trans.h"
 #include "xfs_trans_priv.h"
 #include "xfs_sb.h"
@@ -43,24 +44,22 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_imap.h"
-#include "xfs_alloc.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
-#include "xfs_bmap.h"
 #include "xfs_buf_item.h"
+#include "xfs_inode_item.h"
+#include "xfs_btree.h"
+#include "xfs_alloc.h"
+#include "xfs_ialloc.h"
+#include "xfs_bmap.h"
 #include "xfs_rw.h"
 #include "xfs_error.h"
-#include "xfs_bit.h"
 #include "xfs_utils.h"
 #include "xfs_dir2_trace.h"
 #include "xfs_quota.h"
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 6ec8a0dd84a8..11be922698af 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -33,6 +33,12 @@
 #define __XFS_INODE_H__
 /*
+ * Fork identifiers.
+ */
+#define XFS_DATA_FORK   0
+#define XFS_ATTR_FORK   1
+/*
 * File incore extent information, present for each of data & attr forks.
 */
 #define XFS_INLINE_EXTS 2
@@ -311,60 +317,16 @@ typedef struct xfs_inode {
 /*
 * Fork handling.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IFORK_PTR)
+#define XFS_IFORK_PTR(ip,w)             \
-xfs_ifork_t *xfs_ifork_ptr(xfs_inode_t *ip, int w);
+        ((w) == XFS_DATA_FORK ? &(ip)->i_df : (ip)->i_afp)
-#define XFS_IFORK_PTR(ip,w)             xfs_ifork_ptr(ip,w)
-#else
-#define XFS_IFORK_PTR(ip,w)   ((w) == XFS_DATA_FORK ? &(ip)->i_df : (ip)->i_afp)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IFORK_Q)
-int xfs_ifork_q(xfs_inode_t *ip);
-#define XFS_IFORK_Q(ip)                 xfs_ifork_q(ip)
-#else
 #define XFS_IFORK_Q(ip)                 XFS_CFORK_Q(&(ip)->i_d)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IFORK_DSIZE)
-int xfs_ifork_dsize(xfs_inode_t *ip);
-#define XFS_IFORK_DSIZE(ip)             xfs_ifork_dsize(ip)
-#else
 #define XFS_IFORK_DSIZE(ip)             XFS_CFORK_DSIZE(&ip->i_d, ip->i_mount)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IFORK_ASIZE)
-int xfs_ifork_asize(xfs_inode_t *ip);
-#define XFS_IFORK_ASIZE(ip)             xfs_ifork_asize(ip)
-#else
 #define XFS_IFORK_ASIZE(ip)             XFS_CFORK_ASIZE(&ip->i_d, ip->i_mount)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IFORK_SIZE)
-int xfs_ifork_size(xfs_inode_t *ip, int w);
-#define XFS_IFORK_SIZE(ip,w)            xfs_ifork_size(ip,w)
-#else
 #define XFS_IFORK_SIZE(ip,w)            XFS_CFORK_SIZE(&ip->i_d, ip->i_mount, w)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IFORK_FORMAT)
-int xfs_ifork_format(xfs_inode_t *ip, int w);
-#define XFS_IFORK_FORMAT(ip,w)          xfs_ifork_format(ip,w)
-#else
 #define XFS_IFORK_FORMAT(ip,w)          XFS_CFORK_FORMAT(&ip->i_d, w)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IFORK_FMT_SET)
-void xfs_ifork_fmt_set(xfs_inode_t *ip, int w, int n);
-#define XFS_IFORK_FMT_SET(ip,w,n)       xfs_ifork_fmt_set(ip,w,n)
-#else
 #define XFS_IFORK_FMT_SET(ip,w,n)       XFS_CFORK_FMT_SET(&ip->i_d, w, n)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IFORK_NEXTENTS)
-int xfs_ifork_nextents(xfs_inode_t *ip, int w);
-#define XFS_IFORK_NEXTENTS(ip,w)        xfs_ifork_nextents(ip,w)
-#else
 #define XFS_IFORK_NEXTENTS(ip,w)        XFS_CFORK_NEXTENTS(&ip->i_d, w)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_IFORK_NEXT_SET)
-void xfs_ifork_next_set(xfs_inode_t *ip, int w, int n);
-#define XFS_IFORK_NEXT_SET(ip,w,n)      xfs_ifork_next_set(ip,w,n)
-#else
 #define XFS_IFORK_NEXT_SET(ip,w,n)      XFS_CFORK_NEXT_SET(&ip->i_d, w, n)
-#endif
 #ifdef __KERNEL__
@@ -418,28 +380,11 @@ void xfs_ifork_next_set(xfs_inode_t *ip, int w, int n);
 #define XFS_ITRUNC_DEFINITE     0x1
 #define XFS_ITRUNC_MAYBE        0x2
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ITOV)
-struct vnode *xfs_itov(xfs_inode_t *ip);
-#define XFS_ITOV(ip)            xfs_itov(ip)
-#else
 #define XFS_ITOV(ip)            BHV_TO_VNODE(XFS_ITOBHV(ip))
-#endif
 #define XFS_ITOV_NULL(ip)       BHV_TO_VNODE_NULL(XFS_ITOBHV(ip))
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ITOBHV)
-struct bhv_desc *xfs_itobhv(xfs_inode_t *ip);
-#define XFS_ITOBHV(ip)          xfs_itobhv(ip)
-#else
 #define XFS_ITOBHV(ip)          ((struct bhv_desc *)(&((ip)->i_bhv_desc)))
-#endif
+#define XFS_BHVTOI(bhvp)        ((xfs_inode_t *)((char *)(bhvp) - \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BHVTOI)
+                                (char *)&(((xfs_inode_t *)0)->i_bhv_desc)))
-xfs_inode_t *xfs_bhvtoi(struct bhv_desc *bhvp);
-#define XFS_BHVTOI(bhvp)        xfs_bhvtoi(bhvp)
-#else
-#define XFS_BHVTOI(bhvp)        \
-        ((xfs_inode_t *)((char *)(bhvp) - \
-                         (char *)&(((xfs_inode_t *)0)->i_bhv_desc)))
-#endif
 #define BHV_IS_XFS(bdp)         (BHV_OPS(bdp) == &xfs_vnodeops)
 /*
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 50e2cadf9091..cebcc2781bbb 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -29,38 +29,32 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * This file contains the implementation of the xfs_inode_log_item.
- * It contains the item operations used to manipulate the inode log
- * items as well as utility routines used by the inode specific
- * transaction routines.
- */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_trans_priv.h"
-#include "xfs_ag.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_rw.h"
diff --git a/fs/xfs/xfs_inode_item.h b/fs/xfs/xfs_inode_item.h
index d8775e0d6291..61a806ba8fdd 100644
--- a/fs/xfs/xfs_inode_item.h
+++ b/fs/xfs/xfs_inode_item.h
@@ -159,38 +159,33 @@ typedef struct xfs_inode_log_item {
 } xfs_inode_log_item_t;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ILOG_FDATA)
-int xfs_ilog_fdata(int w);
 #define XFS_ILOG_FDATA(w)       xfs_ilog_fdata(w)
-#else
+static inline int xfs_ilog_fdata(int w)
-#define XFS_ILOG_FDATA(w)       \
+{
-        ((w) == XFS_DATA_FORK ? XFS_ILOG_DDATA : XFS_ILOG_ADATA)
+        return (w == XFS_DATA_FORK ? XFS_ILOG_DDATA : XFS_ILOG_ADATA);
-#endif
+}
 #endif  /* __KERNEL__ */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ILOG_FBROOT)
-int xfs_ilog_fbroot(int w);
 #define XFS_ILOG_FBROOT(w)      xfs_ilog_fbroot(w)
-#else
+static inline int xfs_ilog_fbroot(int w)
-#define XFS_ILOG_FBROOT(w)      \
+{
-        ((w) == XFS_DATA_FORK ? XFS_ILOG_DBROOT : XFS_ILOG_ABROOT)
+        return (w == XFS_DATA_FORK ? XFS_ILOG_DBROOT : XFS_ILOG_ABROOT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_ILOG_FEXT)
-int xfs_ilog_fext(int w);
 #define XFS_ILOG_FEXT(w)        xfs_ilog_fext(w)
-#else
+static inline int xfs_ilog_fext(int w)
-#define XFS_ILOG_FEXT(w)        \
+{
-        ((w) == XFS_DATA_FORK ? XFS_ILOG_DEXT : XFS_ILOG_AEXT)
+        return (w == XFS_DATA_FORK ? XFS_ILOG_DEXT : XFS_ILOG_AEXT);
-#endif
+}
 #ifdef __KERNEL__
-void    xfs_inode_item_init(struct xfs_inode *, struct xfs_mount *);
+extern void xfs_inode_item_init(struct xfs_inode *, struct xfs_mount *);
-void    xfs_inode_item_destroy(struct xfs_inode *);
+extern void xfs_inode_item_destroy(struct xfs_inode *);
-void    xfs_iflush_done(struct xfs_buf *, xfs_inode_log_item_t *);
+extern void xfs_iflush_done(struct xfs_buf *, xfs_inode_log_item_t *);
-void    xfs_istale_done(struct xfs_buf *, xfs_inode_log_item_t *);
+extern void xfs_istale_done(struct xfs_buf *, xfs_inode_log_item_t *);
-void    xfs_iflush_abort(struct xfs_inode *);
+extern void xfs_iflush_abort(struct xfs_inode *);
 #endif  /* __KERNEL__ */
diff --git a/fs/xfs/xfs_inum.h b/fs/xfs/xfs_inum.h
index a3af2d5a6eb7..8f70a12d56bc 100644
--- a/fs/xfs/xfs_inum.h
+++ b/fs/xfs/xfs_inum.h
@@ -58,109 +58,31 @@ typedef	__uint32_t	xfs_intino_t;
 struct xfs_mount;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_MASK)
+#define XFS_INO_MASK(k)                 (__uint32_t)((1ULL << (k)) - 1)
-__uint32_t xfs_ino_mask(int k);
+#define XFS_INO_OFFSET_BITS(mp)         (mp)->m_sb.sb_inopblog
-#define XFS_INO_MASK(k)                 xfs_ino_mask(k)
+#define XFS_INO_AGBNO_BITS(mp)          (mp)->m_sb.sb_agblklog
-#else
+#define XFS_INO_AGINO_BITS(mp)          (mp)->m_agino_log
-#define XFS_INO_MASK(k) ((__uint32_t)((1ULL << (k)) - 1))
+#define XFS_INO_AGNO_BITS(mp)           (mp)->m_agno_log
-#endif
+#define XFS_INO_BITS(mp)                \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_OFFSET_BITS)
+        XFS_INO_AGNO_BITS(mp) + XFS_INO_AGINO_BITS(mp)
-int xfs_ino_offset_bits(struct xfs_mount *mp);
+#define XFS_INO_TO_AGNO(mp,i)           \
-#define XFS_INO_OFFSET_BITS(mp)         xfs_ino_offset_bits(mp)
-#else
-#define XFS_INO_OFFSET_BITS(mp) ((mp)->m_sb.sb_inopblog)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_AGBNO_BITS)
-int xfs_ino_agbno_bits(struct xfs_mount *mp);
-#define XFS_INO_AGBNO_BITS(mp)          xfs_ino_agbno_bits(mp)
-#else
-#define XFS_INO_AGBNO_BITS(mp)  ((mp)->m_sb.sb_agblklog)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_AGINO_BITS)
-int xfs_ino_agino_bits(struct xfs_mount *mp);
-#define XFS_INO_AGINO_BITS(mp)          xfs_ino_agino_bits(mp)
-#else
-#define XFS_INO_AGINO_BITS(mp)          ((mp)->m_agino_log)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_AGNO_BITS)
-int xfs_ino_agno_bits(struct xfs_mount *mp);
-#define XFS_INO_AGNO_BITS(mp)           xfs_ino_agno_bits(mp)
-#else
-#define XFS_INO_AGNO_BITS(mp)   ((mp)->m_agno_log)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_BITS)
-int xfs_ino_bits(struct xfs_mount *mp);
-#define XFS_INO_BITS(mp)                xfs_ino_bits(mp)
-#else
-#define XFS_INO_BITS(mp)        (XFS_INO_AGNO_BITS(mp) + XFS_INO_AGINO_BITS(mp))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_TO_AGNO)
-xfs_agnumber_t xfs_ino_to_agno(struct xfs_mount *mp, xfs_ino_t i);
-#define XFS_INO_TO_AGNO(mp,i)           xfs_ino_to_agno(mp,i)
-#else
-#define XFS_INO_TO_AGNO(mp,i)   \
        ((xfs_agnumber_t)((i) >> XFS_INO_AGINO_BITS(mp)))
-#endif
+#define XFS_INO_TO_AGINO(mp,i)          \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_TO_AGINO)
-xfs_agino_t xfs_ino_to_agino(struct xfs_mount *mp, xfs_ino_t i);
-#define XFS_INO_TO_AGINO(mp,i)          xfs_ino_to_agino(mp,i)
-#else
-#define XFS_INO_TO_AGINO(mp,i)  \
        ((xfs_agino_t)(i) & XFS_INO_MASK(XFS_INO_AGINO_BITS(mp)))
-#endif
+#define XFS_INO_TO_AGBNO(mp,i)          \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_TO_AGBNO)
-xfs_agblock_t xfs_ino_to_agbno(struct xfs_mount *mp, xfs_ino_t i);
-#define XFS_INO_TO_AGBNO(mp,i)          xfs_ino_to_agbno(mp,i)
-#else
-#define XFS_INO_TO_AGBNO(mp,i)  \
        (((xfs_agblock_t)(i) >> XFS_INO_OFFSET_BITS(mp)) & \
-         XFS_INO_MASK(XFS_INO_AGBNO_BITS(mp)))
+                XFS_INO_MASK(XFS_INO_AGBNO_BITS(mp)))
-#endif
+#define XFS_INO_TO_OFFSET(mp,i)         \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_TO_OFFSET)
-int xfs_ino_to_offset(struct xfs_mount *mp, xfs_ino_t i);
-#define XFS_INO_TO_OFFSET(mp,i)         xfs_ino_to_offset(mp,i)
-#else
-#define XFS_INO_TO_OFFSET(mp,i) \
        ((int)(i) & XFS_INO_MASK(XFS_INO_OFFSET_BITS(mp)))
-#endif
+#define XFS_INO_TO_FSB(mp,i)            \
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_INO_TO_FSB)
-xfs_fsblock_t xfs_ino_to_fsb(struct xfs_mount *mp, xfs_ino_t i);
-#define XFS_INO_TO_FSB(mp,i)            xfs_ino_to_fsb(mp,i)
-#else
-#define XFS_INO_TO_FSB(mp,i)    \
        XFS_AGB_TO_FSB(mp, XFS_INO_TO_AGNO(mp,i), XFS_INO_TO_AGBNO(mp,i))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGINO_TO_INO)
-xfs_ino_t
-xfs_agino_to_ino(struct xfs_mount *mp, xfs_agnumber_t a, xfs_agino_t i);
-#define XFS_AGINO_TO_INO(mp,a,i)        xfs_agino_to_ino(mp,a,i)
-#else
 #define XFS_AGINO_TO_INO(mp,a,i)        \
        (((xfs_ino_t)(a) << XFS_INO_AGINO_BITS(mp)) | (i))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGINO_TO_AGBNO)
-xfs_agblock_t xfs_agino_to_agbno(struct xfs_mount *mp, xfs_agino_t i);
-#define XFS_AGINO_TO_AGBNO(mp,i)        xfs_agino_to_agbno(mp,i)
-#else
 #define XFS_AGINO_TO_AGBNO(mp,i)        ((i) >> XFS_INO_OFFSET_BITS(mp))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_AGINO_TO_OFFSET)
-int xfs_agino_to_offset(struct xfs_mount *mp, xfs_agino_t i);
-#define XFS_AGINO_TO_OFFSET(mp,i)       xfs_agino_to_offset(mp,i)
-#else
 #define XFS_AGINO_TO_OFFSET(mp,i)       \
        ((i) & XFS_INO_MASK(XFS_INO_OFFSET_BITS(mp)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_OFFBNO_TO_AGINO)
-xfs_agino_t xfs_offbno_to_agino(struct xfs_mount *mp, xfs_agblock_t b, int o);
-#define XFS_OFFBNO_TO_AGINO(mp,b,o)     xfs_offbno_to_agino(mp,b,o)
-#else
 #define XFS_OFFBNO_TO_AGINO(mp,b,o)     \
        ((xfs_agino_t)(((b) << XFS_INO_OFFSET_BITS(mp)) | (o)))
-#endif
 #if XFS_BIG_INUMS
 #define XFS_MAXINUMBER          ((xfs_ino_t)((1ULL << 56) - 1ULL))
diff --git a/fs/xfs/xfs_iocore.c b/fs/xfs/xfs_iocore.c
index 414ec496845f..6bdd0dcbe398 100644
--- a/fs/xfs/xfs_iocore.c
+++ b/fs/xfs/xfs_iocore.c
@@ -29,12 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -42,22 +42,21 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_itable.h"
-#include "xfs_btree.h"
-#include "xfs_alloc.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
+#include "xfs_itable.h"
+#include "xfs_btree.h"
+#include "xfs_alloc.h"
+#include "xfs_ialloc.h"
 #include "xfs_bmap.h"
 #include "xfs_error.h"
-#include "xfs_bit.h"
 #include "xfs_rw.h"
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index d0f5be63cddb..1ba0d71349c8 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -29,12 +29,11 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -44,16 +43,16 @@
 #include "xfs_dmapi.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_ialloc.h"
+#include "xfs_btree.h"
 #include "xfs_bmap.h"
 #include "xfs_bit.h"
 #include "xfs_rtalloc.h"
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index 8fbc8d378188..abac0399ca4b 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -29,31 +29,31 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_ag.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_ialloc.h"
 #include "xfs_itable.h"
 #include "xfs_error.h"
+#include "xfs_btree.h"
 #ifndef HAVE_USERACC
 #define useracc(ubuffer, size, flags, foo) (0)
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index fcde2a2fc457..97e2a3b0ca1f 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -29,30 +29,33 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * High level interface routines for log manager
- */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
-#include "xfs_ag.h"
-#include "xfs_sb.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
+#include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_error.h"
 #include "xfs_log_priv.h"
 #include "xfs_buf_item.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
+#include "xfs_ialloc_btree.h"
 #include "xfs_log_recover.h"
-#include "xfs_bit.h"
-#include "xfs_rw.h"
 #include "xfs_trans_priv.h"
+#include "xfs_dir_sf.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
+#include "xfs_rw.h"
 #define xlog_write_adv_cnt(ptr, len, off, bytes) \
diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index a884cea82fca..bec421a735f3 100644
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -35,6 +35,7 @@
 struct xfs_buf;
 struct ktrace;
 struct log;
+struct xlog_ticket;
 struct xfs_buf_cancel;
 struct xfs_mount;
@@ -120,77 +121,6 @@ struct xfs_mount;
    ((i) >> 24)
 #endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XLOG_GRANT_SUB_SPACE)
-void xlog_grant_sub_space(struct log *log, int bytes, int type);
-#define XLOG_GRANT_SUB_SPACE(log,bytes,type)    \
-        xlog_grant_sub_space(log,bytes,type)
-#else
-#define XLOG_GRANT_SUB_SPACE(log,bytes,type)                            \
-    {                                                                   \
-        if (type == 'w') {                                              \
-                (log)->l_grant_write_bytes -= (bytes);                  \
-                if ((log)->l_grant_write_bytes < 0) {                   \
-                        (log)->l_grant_write_bytes += (log)->l_logsize; \
-                        (log)->l_grant_write_cycle--;                   \
-                }                                                       \
-        } else {                                                        \
-                (log)->l_grant_reserve_bytes -= (bytes);                \
-                if ((log)->l_grant_reserve_bytes < 0) {                 \
-                        (log)->l_grant_reserve_bytes += (log)->l_logsize;\
-                        (log)->l_grant_reserve_cycle--;                 \
-                }                                                       \
-         }                                                              \
-    }
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XLOG_GRANT_ADD_SPACE)
-void xlog_grant_add_space(struct log *log, int bytes, int type);
-#define XLOG_GRANT_ADD_SPACE(log,bytes,type)    \
-        xlog_grant_add_space(log,bytes,type)
-#else
-#define XLOG_GRANT_ADD_SPACE(log,bytes,type)                            \
-    {                                                                   \
-        if (type == 'w') {                                              \
-                (log)->l_grant_write_bytes += (bytes);                  \
-                if ((log)->l_grant_write_bytes > (log)->l_logsize) {    \
-                        (log)->l_grant_write_bytes -= (log)->l_logsize; \
-                        (log)->l_grant_write_cycle++;                   \
-                }                                                       \
-        } else {                                                        \
-                (log)->l_grant_reserve_bytes += (bytes);                \
-                if ((log)->l_grant_reserve_bytes > (log)->l_logsize) {  \
-                        (log)->l_grant_reserve_bytes -= (log)->l_logsize;\
-                        (log)->l_grant_reserve_cycle++;                 \
-                }                                                       \
-         }                                                              \
-    }
-#endif
-#define XLOG_INS_TICKETQ(q,tic)                         \
-    {                                                   \
-        if (q) {                                        \
-                (tic)->t_next       = (q);              \
-                (tic)->t_prev       = (q)->t_prev;      \
-                (q)->t_prev->t_next = (tic);            \
-                (q)->t_prev         = (tic);            \
-        } else {                                        \
-                (tic)->t_prev = (tic)->t_next = (tic);  \
-                (q) = (tic);                            \
-        }                                               \
-        (tic)->t_flags |= XLOG_TIC_IN_Q;                \
-    }
-#define XLOG_DEL_TICKETQ(q,tic)                         \
-    {                                                   \
-        if ((tic) == (tic)->t_next) {                   \
-                (q) = NULL;                             \
-        } else {                                        \
-                (q) = (tic)->t_next;                    \
-                (tic)->t_next->t_prev = (tic)->t_prev;  \
-                (tic)->t_prev->t_next = (tic)->t_next;  \
-        }                                               \
-        (tic)->t_next = (tic)->t_prev = NULL;           \
-        (tic)->t_flags &= ~XLOG_TIC_IN_Q;               \
-    }
 #define GRANT_LOCK(log)         mutex_spinlock(&(log)->l_grant_lock)
 #define GRANT_UNLOCK(log, s)    mutex_spinunlock(&(log)->l_grant_lock, s)
 #define LOG_LOCK(log)           mutex_spinlock(&(log)->l_icloglock)
@@ -576,6 +506,75 @@ typedef struct log {
                                                 * alignment mask */
 } xlog_t;
+#define XLOG_GRANT_SUB_SPACE(log,bytes,type)    \
+        xlog_grant_sub_space(log,bytes,type)
+static inline void xlog_grant_sub_space(struct log *log, int bytes, int type)
+{
+        if (type == 'w') {                                              \
+                (log)->l_grant_write_bytes -= (bytes);                  \
+                if ((log)->l_grant_write_bytes < 0) {                   \
+                        (log)->l_grant_write_bytes += (log)->l_logsize; \
+                        (log)->l_grant_write_cycle--;                   \
+                }                                                       \
+        } else {                                                        \
+                (log)->l_grant_reserve_bytes -= (bytes);                \
+                if ((log)->l_grant_reserve_bytes < 0) {                 \
+                        (log)->l_grant_reserve_bytes += (log)->l_logsize;\
+                        (log)->l_grant_reserve_cycle--;                 \
+                }                                                       \
+         }                                                              \
+}
+#define XLOG_GRANT_ADD_SPACE(log,bytes,type)    \
+        xlog_grant_add_space(log,bytes,type)
+static inline void
+xlog_grant_add_space(struct log *log, int bytes, int type)
+{
+        if (type == 'w') {                                              \
+                (log)->l_grant_write_bytes += (bytes);                  \
+                if ((log)->l_grant_write_bytes > (log)->l_logsize) {    \
+                        (log)->l_grant_write_bytes -= (log)->l_logsize; \
+                        (log)->l_grant_write_cycle++;                   \
+                }                                                       \
+        } else {                                                        \
+                (log)->l_grant_reserve_bytes += (bytes);                \
+                if ((log)->l_grant_reserve_bytes > (log)->l_logsize) {  \
+                        (log)->l_grant_reserve_bytes -= (log)->l_logsize;\
+                        (log)->l_grant_reserve_cycle++;                 \
+                }                                                       \
+         }                                                              \
+}
+#define XLOG_INS_TICKETQ(q, tic)        xlog_ins_ticketq(q, tic)
+static inline void
+xlog_ins_ticketq(struct xlog_ticket *q, struct xlog_ticket *tic)
+{                                                       \
+        if (q) {                                        \
+                (tic)->t_next       = (q);              \
+                (tic)->t_prev       = (q)->t_prev;      \
+                (q)->t_prev->t_next = (tic);            \
+                (q)->t_prev         = (tic);            \
+        } else {                                        \
+                (tic)->t_prev = (tic)->t_next = (tic);  \
+                (q) = (tic);                            \
+        }                                               \
+        (tic)->t_flags |= XLOG_TIC_IN_Q;                \
+}
+#define XLOG_DEL_TICKETQ(q, tic)        xlog_del_ticketq(q, tic)
+static inline void
+xlog_del_ticketq(struct xlog_ticket *q, struct xlog_ticket *tic)
+{                                                       \
+        if ((tic) == (tic)->t_next) {                   \
+                (q) = NULL;                             \
+        } else {                                        \
+                (q) = (tic)->t_next;                    \
+                (tic)->t_next->t_prev = (tic)->t_prev;  \
+                (tic)->t_prev->t_next = (tic)->t_next;  \
+        }                                               \
+        (tic)->t_next = (tic)->t_prev = NULL;           \
+        (tic)->t_flags &= ~XLOG_TIC_IN_Q;               \
+}
 /* common routines */
 extern xfs_lsn_t xlog_assign_tail_lsn(struct xfs_mount *mp);
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 212c5411595e..f61dcd1b8e3b 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -29,38 +29,37 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
-#include "xfs_ag.h"
+#include "xfs_inum.h"
-#include "xfs_sb.h"
 #include "xfs_trans.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_error.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_alloc.h"
+#include "xfs_alloc_btree.h"
-#include "xfs_attr_sf.h"
+#include "xfs_ialloc_btree.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_imap.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
-#include "xfs_ialloc_btree.h"
+#include "xfs_inode_item.h"
+#include "xfs_imap.h"
+#include "xfs_alloc.h"
 #include "xfs_ialloc.h"
 #include "xfs_log_priv.h"
 #include "xfs_buf_item.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_log_recover.h"
 #include "xfs_extfree_item.h"
 #include "xfs_trans_priv.h"
-#include "xfs_bit.h"
 #include "xfs_quota.h"
 #include "xfs_rw.h"
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 4f26172a163e..52542c5d7a32 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -29,12 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -42,21 +42,20 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_alloc.h"
 #include "xfs_rtalloc.h"
 #include "xfs_bmap.h"
 #include "xfs_error.h"
-#include "xfs_bit.h"
 #include "xfs_rw.h"
 #include "xfs_quota.h"
 #include "xfs_fsops.h"
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 7341f4984c08..0567ee2164fa 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -80,6 +80,9 @@ struct xfs_iocore;
 struct xfs_bmbt_irec;
 struct xfs_bmap_free;
+extern struct vfsops xfs_vfsops;
+extern struct vnodeops xfs_vnodeops;
 #define AIL_LOCK_T              lock_t
 #define AIL_LOCKINIT(x,y)       spinlock_init(x,y)
 #define AIL_LOCK_DESTROY(x)     spinlock_destroy(x)
@@ -503,57 +506,41 @@ xfs_preferred_iosize(xfs_mount_t *mp)
 /*
 * Macros for getting from mount to vfs and back.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_MTOVFS)
-struct vfs *xfs_mtovfs(xfs_mount_t *mp);
 #define XFS_MTOVFS(mp)          xfs_mtovfs(mp)
-#else
+static inline struct vfs *xfs_mtovfs(xfs_mount_t *mp)
-#define XFS_MTOVFS(mp)          (bhvtovfs(&(mp)->m_bhv))
+{
-#endif
+        return bhvtovfs(&mp->m_bhv);
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BHVTOM)
+}
-xfs_mount_t *xfs_bhvtom(bhv_desc_t *bdp);
-#define XFS_BHVTOM(bdp) xfs_bhvtom(bdp)
-#else
-#define XFS_BHVTOM(bdp)         ((xfs_mount_t *)BHV_PDATA(bdp))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_VFSTOM)
-xfs_mount_t *xfs_vfstom(vfs_t *vfs);
-#define XFS_VFSTOM(vfs) xfs_vfstom(vfs)
-#else
-#define XFS_VFSTOM(vfs)         \
-        (XFS_BHVTOM(bhv_lookup(VFS_BHVHEAD(vfs), &xfs_vfsops)))
-#endif
+#define XFS_BHVTOM(bdp) xfs_bhvtom(bdp)
+static inline xfs_mount_t *xfs_bhvtom(bhv_desc_t *bdp)
+{
+        return (xfs_mount_t *)BHV_PDATA(bdp);
+}
-/*
+#define XFS_VFSTOM(vfs) xfs_vfstom(vfs)
- * Moved here from xfs_ag.h to avoid reordering header files
+static inline xfs_mount_t *xfs_vfstom(vfs_t *vfs)
- */
+{
+        return XFS_BHVTOM(bhv_lookup(VFS_BHVHEAD(vfs), &xfs_vfsops));
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DADDR_TO_AGNO)
-xfs_agnumber_t xfs_daddr_to_agno(struct xfs_mount *mp, xfs_daddr_t d);
 #define XFS_DADDR_TO_AGNO(mp,d)         xfs_daddr_to_agno(mp,d)
-#else
+static inline xfs_agnumber_t
+xfs_daddr_to_agno(struct xfs_mount *mp, xfs_daddr_t d)
-static inline xfs_agnumber_t XFS_DADDR_TO_AGNO(xfs_mount_t *mp, xfs_daddr_t d)
 {
-        d = XFS_BB_TO_FSBT(mp, d);
+        xfs_daddr_t ld = XFS_BB_TO_FSBT(mp, d);
-        do_div(d, mp->m_sb.sb_agblocks);
+        do_div(ld, mp->m_sb.sb_agblocks);
-        return (xfs_agnumber_t) d;
+        return (xfs_agnumber_t) ld;
 }
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DADDR_TO_AGBNO)
-xfs_agblock_t xfs_daddr_to_agbno(struct xfs_mount *mp, xfs_daddr_t d);
 #define XFS_DADDR_TO_AGBNO(mp,d)        xfs_daddr_to_agbno(mp,d)
-#else
+static inline xfs_agblock_t
+xfs_daddr_to_agbno(struct xfs_mount *mp, xfs_daddr_t d)
-static inline xfs_agblock_t XFS_DADDR_TO_AGBNO(xfs_mount_t *mp, xfs_daddr_t d)
 {
-        d = XFS_BB_TO_FSBT(mp, d);
+        xfs_daddr_t ld = XFS_BB_TO_FSBT(mp, d);
-        return (xfs_agblock_t) do_div(d, mp->m_sb.sb_agblocks);
+        return (xfs_agblock_t) do_div(ld, mp->m_sb.sb_agblocks);
 }
-#endif
 /*
 * This structure is for use by the xfs_mod_incore_sb_batch() routine.
 */
@@ -589,9 +576,6 @@ extern int	xfs_sync_inodes(xfs_mount_t *, int, int, int *);
 extern xfs_agnumber_t   xfs_initialize_perag(xfs_mount_t *, xfs_agnumber_t);
 extern void     xfs_xlatesb(void *, struct xfs_sb *, int, __int64_t);
-extern struct vfsops xfs_vfsops;
-extern struct vnodeops xfs_vnodeops;
 extern struct xfs_dmops xfs_dmcore_stub;
 extern struct xfs_qmops xfs_qmcore_stub;
 extern struct xfs_ioops xfs_iocore_xfs;
diff --git a/fs/xfs/xfs_qmops.c b/fs/xfs/xfs_qmops.c
index a6cd6324e946..ac14d26fa9c4 100644
--- a/fs/xfs/xfs_qmops.c
+++ b/fs/xfs/xfs_qmops.c
@@ -30,11 +30,10 @@
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
+#include "xfs_fs.h"
-#include "xfs_macros.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
diff --git a/fs/xfs/xfs_rename.c b/fs/xfs/xfs_rename.c
index 1c3599df0cc1..135172414582 100644
--- a/fs/xfs/xfs_rename.c
+++ b/fs/xfs/xfs_rename.c
@@ -29,32 +29,31 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
 #include "xfs_bmap.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
 #include "xfs_refcache.h"
 #include "xfs_utils.h"
 #include "xfs_trans_space.h"
-#include "xfs_da_btree.h"
 #include "xfs_dir_leaf.h"
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 2c37822d1012..145f916538a1 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -29,16 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
-/*
- * Free realtime space allocation for XFS.
- */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -46,19 +42,18 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
 #include "xfs_alloc.h"
 #include "xfs_bmap.h"
-#include "xfs_bit.h"
 #include "xfs_rtalloc.h"
 #include "xfs_fsops.h"
 #include "xfs_error.h"
diff --git a/fs/xfs/xfs_rw.c b/fs/xfs/xfs_rw.c
index 31f68cc637b0..075850c999f4 100644
--- a/fs/xfs/xfs_rw.c
+++ b/fs/xfs/xfs_rw.c
@@ -29,12 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -42,20 +42,20 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
+#include "xfs_dir_sf.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
+#include "xfs_inode_item.h"
 #include "xfs_itable.h"
 #include "xfs_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_ialloc.h"
 #include "xfs_attr.h"
-#include "xfs_attr_sf.h"
-#include "xfs_dir_sf.h"
-#include "xfs_dir2_sf.h"
-#include "xfs_dinode.h"
-#include "xfs_inode_item.h"
-#include "xfs_inode.h"
 #include "xfs_bmap.h"
 #include "xfs_acl.h"
 #include "xfs_mac.h"
diff --git a/fs/xfs/xfs_rw.h b/fs/xfs/xfs_rw.h
index c8b10bf8f530..90233037fab1 100644
--- a/fs/xfs/xfs_rw.h
+++ b/fs/xfs/xfs_rw.h
@@ -68,87 +68,44 @@ struct xfs_mount;
 * file is a real time file or not, because the bmap code
 * does.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FSB_TO_DB)
-xfs_daddr_t xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb);
 #define XFS_FSB_TO_DB(ip,fsb)   xfs_fsb_to_db(ip,fsb)
-#else
+static inline xfs_daddr_t
-#define XFS_FSB_TO_DB(ip,fsb) \
+xfs_fsb_to_db(struct xfs_inode *ip, xfs_fsblock_t fsb)
-                (((ip)->i_d.di_flags & XFS_DIFLAG_REALTIME) ? \
+{
+        return (((ip)->i_d.di_flags & XFS_DIFLAG_REALTIME) ? \
                 (xfs_daddr_t)XFS_FSB_TO_BB((ip)->i_mount, (fsb)) : \
-                 XFS_FSB_TO_DADDR((ip)->i_mount, (fsb)))
+                 XFS_FSB_TO_DADDR((ip)->i_mount, (fsb)));
-#endif
+}
+#define XFS_FSB_TO_DB_IO(io,fsb) xfs_fsb_to_db_io(io,fsb)
-#define XFS_FSB_TO_DB_IO(io,fsb) \
+static inline xfs_daddr_t
-                (((io)->io_flags & XFS_IOCORE_RT) ? \
+xfs_fsb_to_db_io(struct xfs_iocore *io, xfs_fsblock_t fsb)
+{
+        return (((io)->io_flags & XFS_IOCORE_RT) ? \
                 XFS_FSB_TO_BB((io)->io_mount, (fsb)) : \
-                 XFS_FSB_TO_DADDR((io)->io_mount, (fsb)))
+                 XFS_FSB_TO_DADDR((io)->io_mount, (fsb)));
+}
 /*
 * Prototypes for functions in xfs_rw.c.
 */
+extern int xfs_write_clear_setuid(struct xfs_inode *ip);
-int
+extern int xfs_bwrite(struct xfs_mount *mp, struct xfs_buf *bp);
-xfs_write_clear_setuid(
+extern int xfs_bioerror(struct xfs_buf *bp);
-        struct xfs_inode        *ip);
+extern int xfs_bioerror_relse(struct xfs_buf *bp);
+extern int xfs_read_buf(struct xfs_mount *mp, xfs_buftarg_t *btp,
-int
+                        xfs_daddr_t blkno, int len, uint flags,
-xfs_bwrite(
+                        struct xfs_buf **bpp);
-        struct xfs_mount        *mp,
+extern void xfs_ioerror_alert(char *func, struct xfs_mount *mp,
-        struct xfs_buf          *bp);
+                                xfs_buf_t *bp, xfs_daddr_t blkno);
-int
-xfs_bioerror(
-        struct xfs_buf          *b);
-int
-xfs_bioerror_relse(
-        struct xfs_buf          *b);
-int
-xfs_read_buf(
-        struct xfs_mount        *mp,
-        xfs_buftarg_t           *target,
-        xfs_daddr_t             blkno,
-        int                     len,
-        uint                    flags,
-        struct xfs_buf          **bpp);
-void
-xfs_ioerror_alert(
-        char                    *func,
-        struct xfs_mount        *mp,
-        xfs_buf_t               *bp,
-        xfs_daddr_t             blkno);
 /*
 * Prototypes for functions in xfs_vnodeops.c.
 */
+extern int xfs_rwlock(bhv_desc_t *bdp, vrwlock_t write_lock);
-int
+extern void xfs_rwunlock(bhv_desc_t *bdp, vrwlock_t write_lock);
-xfs_rwlock(
+extern int xfs_change_file_space(bhv_desc_t *bdp, int cmd, xfs_flock64_t *bf,
-        bhv_desc_t              *bdp,
+                                 xfs_off_t offset, cred_t *credp, int flags);
-        vrwlock_t               write_lock);
+extern int xfs_set_dmattrs(bhv_desc_t *bdp, u_int evmask, u_int16_t state,
+                           cred_t *credp);
-void
-xfs_rwunlock(
-        bhv_desc_t              *bdp,
-        vrwlock_t               write_lock);
-int
-xfs_change_file_space(
-        bhv_desc_t              *bdp,
-        int                     cmd,
-        xfs_flock64_t           *bf,
-        xfs_off_t               offset,
-        cred_t                  *credp,
-        int                     flags);
-int
-xfs_set_dmattrs(
-        bhv_desc_t              *bdp,
-        u_int                   evmask,
-        u_int16_t               state,
-        cred_t                  *credp);
 #endif /* __XFS_RW_H__ */
diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h
index 01c5a5ff230e..a7b2542fd7ba 100644
--- a/fs/xfs/xfs_sb.h
+++ b/fs/xfs/xfs_sb.h
@@ -241,42 +241,33 @@ typedef enum {
 */
 #define XFS_SB_MAX_SHARED_VN    0
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_NUM)
-int xfs_sb_version_num(xfs_sb_t *sbp);
-#define XFS_SB_VERSION_NUM(sbp) xfs_sb_version_num(sbp)
-#else
 #define XFS_SB_VERSION_NUM(sbp) ((sbp)->sb_versionnum & XFS_SB_VERSION_NUMBITS)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_GOOD_VERSION)
-int xfs_sb_good_version(xfs_sb_t *sbp);
 #define XFS_SB_GOOD_VERSION(sbp)        xfs_sb_good_version(sbp)
-#else
-#define XFS_SB_GOOD_VERSION_INT(sbp)    \
-        ((((sbp)->sb_versionnum >= XFS_SB_VERSION_1) && \
-          ((sbp)->sb_versionnum <= XFS_SB_VERSION_3)) || \
-           ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-            !(((sbp)->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
-              (((sbp)->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
-               ((sbp)->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS)))
 #ifdef __KERNEL__
-#define XFS_SB_GOOD_VERSION(sbp)        \
+static inline int xfs_sb_good_version(xfs_sb_t *sbp)
-        (XFS_SB_GOOD_VERSION_INT(sbp) && \
+{
-          (sbp)->sb_shared_vn <= XFS_SB_MAX_SHARED_VN) ))
+        return (((sbp->sb_versionnum >= XFS_SB_VERSION_1) && \
-#else
+                  (sbp->sb_versionnum <= XFS_SB_VERSION_3)) || \
-/*
+                   ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
- * extra 2 paren's here (( to unconfuse paren-matching editors
+                    !((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
- * like vi because XFS_SB_GOOD_VERSION_INT is a partial expression
+                      ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
- * and the two XFS_SB_GOOD_VERSION's each 2 more close paren's to
+                       (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS))) && \
- * complete the expression.
+                    (sbp->sb_shared_vn <= XFS_SB_MAX_SHARED_VN)));
- */
+}
-#define XFS_SB_GOOD_VERSION(sbp)        \
+#else
-        (XFS_SB_GOOD_VERSION_INT(sbp) && \
+static inline int xfs_sb_good_version(xfs_sb_t *sbp)
-          (!((sbp)->sb_versionnum & XFS_SB_VERSION_SHAREDBIT) || \
+{
-           (sbp)->sb_shared_vn <= XFS_SB_MAX_SHARED_VN)) ))
+        return (((sbp->sb_versionnum >= XFS_SB_VERSION_1) && \
+                  (sbp->sb_versionnum <= XFS_SB_VERSION_3)) || \
+                   ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+                    !((sbp->sb_versionnum & ~XFS_SB_VERSION_OKREALBITS) || \
+                      ((sbp->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT) && \
+                       (sbp->sb_features2 & ~XFS_SB_VERSION2_OKREALBITS))) && \
+                  (!(sbp->sb_versionnum & XFS_SB_VERSION_SHAREDBIT) || \
+                   (sbp->sb_shared_vn <= XFS_SB_MAX_SHARED_VN))));
+}
 #endif /* __KERNEL__ */
-#endif
 #define XFS_SB_GOOD_SASH_VERSION(sbp)   \
        ((((sbp)->sb_versionnum >= XFS_SB_VERSION_1) && \
@@ -284,224 +275,178 @@ int xfs_sb_good_version(xfs_sb_t *sbp);
         ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
          !((sbp)->sb_versionnum & ~XFS_SB_VERSION_OKSASHBITS)))
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_TONEW)
-unsigned xfs_sb_version_tonew(unsigned v);
 #define XFS_SB_VERSION_TONEW(v) xfs_sb_version_tonew(v)
-#else
+static inline unsigned xfs_sb_version_tonew(unsigned v)
-#define XFS_SB_VERSION_TONEW(v) \
+{
-        ((((v) == XFS_SB_VERSION_1) ? \
+        return ((((v) == XFS_SB_VERSION_1) ? \
                0 : \
                (((v) == XFS_SB_VERSION_2) ? \
                        XFS_SB_VERSION_ATTRBIT : \
                        (XFS_SB_VERSION_ATTRBIT | XFS_SB_VERSION_NLINKBIT))) | \
-         XFS_SB_VERSION_4)
+                XFS_SB_VERSION_4);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_TOOLD)
-unsigned xfs_sb_version_toold(unsigned v);
 #define XFS_SB_VERSION_TOOLD(v) xfs_sb_version_toold(v)
-#else
+static inline unsigned xfs_sb_version_toold(unsigned v)
-#define XFS_SB_VERSION_TOOLD(v) \
+{
-        (((v) & (XFS_SB_VERSION_QUOTABIT | XFS_SB_VERSION_ALIGNBIT)) ? \
+        return (((v) & (XFS_SB_VERSION_QUOTABIT | XFS_SB_VERSION_ALIGNBIT)) ? \
                0 : \
                (((v) & XFS_SB_VERSION_NLINKBIT) ? \
                        XFS_SB_VERSION_3 : \
                        (((v) & XFS_SB_VERSION_ATTRBIT) ?  \
                                XFS_SB_VERSION_2 : \
-                                XFS_SB_VERSION_1)))
+                                XFS_SB_VERSION_1)));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASATTR)
-int xfs_sb_version_hasattr(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASATTR(sbp)     xfs_sb_version_hasattr(sbp)
-#else
+static inline int xfs_sb_version_hasattr(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASATTR(sbp)     \
+{
-        (((sbp)->sb_versionnum == XFS_SB_VERSION_2) || \
+        return ((sbp)->sb_versionnum == XFS_SB_VERSION_2) || \
-         ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
+                 ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
-         ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+                 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-          ((sbp)->sb_versionnum & XFS_SB_VERSION_ATTRBIT)))
+                  ((sbp)->sb_versionnum & XFS_SB_VERSION_ATTRBIT));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDATTR)
-void xfs_sb_version_addattr(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_ADDATTR(sbp)     xfs_sb_version_addattr(sbp)
-#else
+static inline void xfs_sb_version_addattr(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_ADDATTR(sbp)     \
+{
-        ((sbp)->sb_versionnum = \
+        (sbp)->sb_versionnum = (((sbp)->sb_versionnum == XFS_SB_VERSION_1) ? \
-         (((sbp)->sb_versionnum == XFS_SB_VERSION_1) ? \
                XFS_SB_VERSION_2 : \
                ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) ? \
                        ((sbp)->sb_versionnum | XFS_SB_VERSION_ATTRBIT) : \
-                        (XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT))))
+                        (XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT)));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASNLINK)
-int xfs_sb_version_hasnlink(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASNLINK(sbp)    xfs_sb_version_hasnlink(sbp)
-#else
+static inline int xfs_sb_version_hasnlink(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASNLINK(sbp)    \
+{
-        (((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
+        return ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
-         ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+                 ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-          ((sbp)->sb_versionnum & XFS_SB_VERSION_NLINKBIT)))
+                  ((sbp)->sb_versionnum & XFS_SB_VERSION_NLINKBIT));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDNLINK)
-void xfs_sb_version_addnlink(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_ADDNLINK(sbp)    xfs_sb_version_addnlink(sbp)
-#else
+static inline void xfs_sb_version_addnlink(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_ADDNLINK(sbp)    \
+{
-        ((sbp)->sb_versionnum = \
+        (sbp)->sb_versionnum = ((sbp)->sb_versionnum <= XFS_SB_VERSION_2 ? \
-         ((sbp)->sb_versionnum <= XFS_SB_VERSION_2 ? \
                XFS_SB_VERSION_3 : \
-                ((sbp)->sb_versionnum | XFS_SB_VERSION_NLINKBIT)))
+                ((sbp)->sb_versionnum | XFS_SB_VERSION_NLINKBIT));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASQUOTA)
-int xfs_sb_version_hasquota(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASQUOTA(sbp)    xfs_sb_version_hasquota(sbp)
-#else
+static inline int xfs_sb_version_hasquota(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASQUOTA(sbp)    \
+{
-        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-         ((sbp)->sb_versionnum & XFS_SB_VERSION_QUOTABIT))
+                ((sbp)->sb_versionnum & XFS_SB_VERSION_QUOTABIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDQUOTA)
-void xfs_sb_version_addquota(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_ADDQUOTA(sbp)    xfs_sb_version_addquota(sbp)
-#else
+static inline void xfs_sb_version_addquota(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_ADDQUOTA(sbp)    \
+{
-        ((sbp)->sb_versionnum = \
+        (sbp)->sb_versionnum = \
-         (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 ? \
+                 (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 ? \
-                ((sbp)->sb_versionnum | XFS_SB_VERSION_QUOTABIT) : \
+                        ((sbp)->sb_versionnum | XFS_SB_VERSION_QUOTABIT) : \
-                (XFS_SB_VERSION_TONEW((sbp)->sb_versionnum) | \
+                        (XFS_SB_VERSION_TONEW((sbp)->sb_versionnum) | \
-                 XFS_SB_VERSION_QUOTABIT)))
+                         XFS_SB_VERSION_QUOTABIT));
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASALIGN)
-int xfs_sb_version_hasalign(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASALIGN(sbp)    xfs_sb_version_hasalign(sbp)
-#else
+static inline int xfs_sb_version_hasalign(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASALIGN(sbp)    \
+{
-        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-         ((sbp)->sb_versionnum & XFS_SB_VERSION_ALIGNBIT))
+                ((sbp)->sb_versionnum & XFS_SB_VERSION_ALIGNBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_SUBALIGN)
-void xfs_sb_version_subalign(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_SUBALIGN(sbp)    xfs_sb_version_subalign(sbp)
-#else
+static inline void xfs_sb_version_subalign(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_SUBALIGN(sbp)    \
+{
-        ((sbp)->sb_versionnum = \
+        (sbp)->sb_versionnum = \
-         XFS_SB_VERSION_TOOLD((sbp)->sb_versionnum & ~XFS_SB_VERSION_ALIGNBIT))
+         XFS_SB_VERSION_TOOLD((sbp)->sb_versionnum & ~XFS_SB_VERSION_ALIGNBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASDALIGN)
-int xfs_sb_version_hasdalign(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASDALIGN(sbp)   xfs_sb_version_hasdalign(sbp)
-#else
+static inline int xfs_sb_version_hasdalign(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASDALIGN(sbp)   \
+{
-        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-         ((sbp)->sb_versionnum & XFS_SB_VERSION_DALIGNBIT))
+                ((sbp)->sb_versionnum & XFS_SB_VERSION_DALIGNBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDDALIGN)
-int xfs_sb_version_adddalign(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_ADDDALIGN(sbp)   xfs_sb_version_adddalign(sbp)
-#else
+static inline int xfs_sb_version_adddalign(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_ADDDALIGN(sbp)   \
+{
-        ((sbp)->sb_versionnum = \
+        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum | XFS_SB_VERSION_DALIGNBIT))
+                ((sbp)->sb_versionnum | XFS_SB_VERSION_DALIGNBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASSHARED)
-int xfs_sb_version_hasshared(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASSHARED(sbp)   xfs_sb_version_hasshared(sbp)
-#else
+static inline int xfs_sb_version_hasshared(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASSHARED(sbp)   \
+{
-        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-         ((sbp)->sb_versionnum & XFS_SB_VERSION_SHAREDBIT))
+                ((sbp)->sb_versionnum & XFS_SB_VERSION_SHAREDBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDSHARED)
-int xfs_sb_version_addshared(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_ADDSHARED(sbp)   xfs_sb_version_addshared(sbp)
-#else
+static inline int xfs_sb_version_addshared(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_ADDSHARED(sbp)   \
+{
-        ((sbp)->sb_versionnum = \
+        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum | XFS_SB_VERSION_SHAREDBIT))
+                ((sbp)->sb_versionnum | XFS_SB_VERSION_SHAREDBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_SUBSHARED)
-int xfs_sb_version_subshared(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_SUBSHARED(sbp)   xfs_sb_version_subshared(sbp)
-#else
+static inline int xfs_sb_version_subshared(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_SUBSHARED(sbp)   \
+{
-        ((sbp)->sb_versionnum = \
+        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_SHAREDBIT))
+                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_SHAREDBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASDIRV2)
-int xfs_sb_version_hasdirv2(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASDIRV2(sbp)    xfs_sb_version_hasdirv2(sbp)
-#else
+static inline int xfs_sb_version_hasdirv2(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASDIRV2(sbp)    \
+{
-        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-         ((sbp)->sb_versionnum & XFS_SB_VERSION_DIRV2BIT))
+                ((sbp)->sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASLOGV2)
-int xfs_sb_version_haslogv2(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASLOGV2(sbp)   xfs_sb_version_haslogv2(sbp)
-#else
+static inline int xfs_sb_version_haslogv2(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASLOGV2(sbp)   \
+{
-        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-        ((sbp)->sb_versionnum & XFS_SB_VERSION_LOGV2BIT))
+                ((sbp)->sb_versionnum & XFS_SB_VERSION_LOGV2BIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASEXTFLGBIT)
-int xfs_sb_version_hasextflgbit(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASEXTFLGBIT(sbp)        xfs_sb_version_hasextflgbit(sbp)
-#else
+static inline int xfs_sb_version_hasextflgbit(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASEXTFLGBIT(sbp)        \
+{
-        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-         ((sbp)->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT))
+                ((sbp)->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDEXTFLGBIT)
-int xfs_sb_version_addextflgbit(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_ADDEXTFLGBIT(sbp)        xfs_sb_version_addextflgbit(sbp)
-#else
+static inline int xfs_sb_version_addextflgbit(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_ADDEXTFLGBIT(sbp)        \
+{
-        ((sbp)->sb_versionnum = \
+        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum | XFS_SB_VERSION_EXTFLGBIT))
+                ((sbp)->sb_versionnum | XFS_SB_VERSION_EXTFLGBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_SUBEXTFLGBIT)
-int xfs_sb_version_subextflgbit(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_SUBEXTFLGBIT(sbp)        xfs_sb_version_subextflgbit(sbp)
-#else
+static inline int xfs_sb_version_subextflgbit(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_SUBEXTFLGBIT(sbp)        \
+{
-        ((sbp)->sb_versionnum = \
+        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_EXTFLGBIT))
+                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_EXTFLGBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASSECTOR)
-int xfs_sb_version_hassector(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASSECTOR(sbp)   xfs_sb_version_hassector(sbp)
-#else
+static inline int xfs_sb_version_hassector(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASSECTOR(sbp)   \
+{
-        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-        ((sbp)->sb_versionnum & XFS_SB_VERSION_SECTORBIT))
+                ((sbp)->sb_versionnum & XFS_SB_VERSION_SECTORBIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASMOREBITSBIT)
-int xfs_sb_version_hasmorebits(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASMOREBITS(sbp) xfs_sb_version_hasmorebits(sbp)
-#else
+static inline int xfs_sb_version_hasmorebits(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASMOREBITS(sbp) \
+{
-        ((XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
-         ((sbp)->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT))
+                ((sbp)->sb_versionnum & XFS_SB_VERSION_MOREBITSBIT);
-#endif
+}
 /*
 * sb_features2 bit version macros.
@@ -512,65 +457,36 @@ int xfs_sb_version_hasmorebits(xfs_sb_t *sbp);
 *      ((XFS_SB_VERSION_HASMOREBITS(sbp) &&
 *       ((sbp)->sb_features2 & XFS_SB_VERSION2_FUNBIT)
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_HASATTR2)
-int xfs_sb_version_hasattr2(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_HASATTR2(sbp)    xfs_sb_version_hasattr2(sbp)
-#else
+static inline int xfs_sb_version_hasattr2(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_HASATTR2(sbp)    \
+{
-        ((XFS_SB_VERSION_HASMOREBITS(sbp)) &&   \
+        return (XFS_SB_VERSION_HASMOREBITS(sbp)) &&     \
-         ((sbp)->sb_features2 & XFS_SB_VERSION2_ATTR2BIT))
+                ((sbp)->sb_features2 & XFS_SB_VERSION2_ATTR2BIT);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_VERSION_ADDATTR2)
-void xfs_sb_version_addattr2(xfs_sb_t *sbp);
 #define XFS_SB_VERSION_ADDATTR2(sbp)    xfs_sb_version_addattr2(sbp)
-#else
+static inline void xfs_sb_version_addattr2(xfs_sb_t *sbp)
-#define XFS_SB_VERSION_ADDATTR2(sbp)    \
+{
        ((sbp)->sb_versionnum = \
                ((sbp)->sb_versionnum | XFS_SB_VERSION_MOREBITSBIT),    \
        ((sbp)->sb_features2 =  \
-                ((sbp)->sb_features2 | XFS_SB_VERSION2_ATTR2BIT)))
+                ((sbp)->sb_features2 | XFS_SB_VERSION2_ATTR2BIT)));
-#endif
+}
 /*
 * end of superblock version macros
 */
-#define XFS_SB_DADDR    ((xfs_daddr_t)0)        /* daddr in filesystem/ag */
+#define XFS_SB_DADDR            ((xfs_daddr_t)0) /* daddr in filesystem/ag */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_SB_BLOCK)
-xfs_agblock_t xfs_sb_block(struct xfs_mount *mp);
-#define XFS_SB_BLOCK(mp)        xfs_sb_block(mp)
-#else
 #define XFS_SB_BLOCK(mp)        XFS_HDR_BLOCK(mp, XFS_SB_DADDR)
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_HDR_BLOCK)
-xfs_agblock_t xfs_hdr_block(struct xfs_mount *mp, xfs_daddr_t d);
-#define XFS_HDR_BLOCK(mp,d)     xfs_hdr_block(mp,d)
-#else
-#define XFS_HDR_BLOCK(mp,d)     ((xfs_agblock_t)(XFS_BB_TO_FSBT(mp,d)))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_DADDR_TO_FSB)
-xfs_fsblock_t xfs_daddr_to_fsb(struct xfs_mount *mp, xfs_daddr_t d);
-#define XFS_DADDR_TO_FSB(mp,d)          xfs_daddr_to_fsb(mp,d)
-#else
-#define XFS_DADDR_TO_FSB(mp,d) \
-        XFS_AGB_TO_FSB(mp, XFS_DADDR_TO_AGNO(mp,d), XFS_DADDR_TO_AGBNO(mp,d))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_FSB_TO_DADDR)
-xfs_daddr_t xfs_fsb_to_daddr(struct xfs_mount *mp, xfs_fsblock_t fsbno);
-#define XFS_FSB_TO_DADDR(mp,fsbno)      xfs_fsb_to_daddr(mp,fsbno)
-#else
-#define XFS_FSB_TO_DADDR(mp,fsbno) \
-        XFS_AGB_TO_DADDR(mp, XFS_FSB_TO_AGNO(mp,fsbno), \
-                         XFS_FSB_TO_AGBNO(mp,fsbno))
-#endif
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_BUF_TO_SBP)
-xfs_sb_t *xfs_buf_to_sbp(struct xfs_buf *bp);
-#define XFS_BUF_TO_SBP(bp)      xfs_buf_to_sbp(bp)
-#else
 #define XFS_BUF_TO_SBP(bp)      ((xfs_sb_t *)XFS_BUF_PTR(bp))
-#endif
+#define XFS_HDR_BLOCK(mp,d)     ((xfs_agblock_t)XFS_BB_TO_FSBT(mp,d))
+#define XFS_DADDR_TO_FSB(mp,d)  XFS_AGB_TO_FSB(mp, \
+                        XFS_DADDR_TO_AGNO(mp,d), XFS_DADDR_TO_AGBNO(mp,d))
+#define XFS_FSB_TO_DADDR(mp,fsbno)      XFS_AGB_TO_DADDR(mp, \
+                        XFS_FSB_TO_AGNO(mp,fsbno), XFS_FSB_TO_AGBNO(mp,fsbno))
 /*
 * File system sector to basic block conversions.
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 5e33891b8049..d14adef65a26 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -29,12 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -43,21 +43,21 @@
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_error.h"
-#include "xfs_trans_priv.h"
+#include "xfs_da_btree.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_alloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
+#include "xfs_alloc.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_quota.h"
+#include "xfs_trans_priv.h"
 #include "xfs_trans_space.h"
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 0f333fba187c..6381669a34ac 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -234,68 +234,67 @@ typedef struct xfs_log_item_chunk {
 * lic_unused to the right value (0 matches all free).  The
 * lic_descs.lid_index values are set up as each desc is allocated.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_INIT)
-void xfs_lic_init(xfs_log_item_chunk_t *cp);
 #define XFS_LIC_INIT(cp)        xfs_lic_init(cp)
-#else
+static inline void xfs_lic_init(xfs_log_item_chunk_t *cp)
-#define XFS_LIC_INIT(cp)        ((cp)->lic_free = XFS_LIC_FREEMASK)
+{
-#endif
+        cp->lic_free = XFS_LIC_FREEMASK;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_INIT_SLOT)
+}
-void xfs_lic_init_slot(xfs_log_item_chunk_t *cp, int slot);
 #define XFS_LIC_INIT_SLOT(cp,slot)      xfs_lic_init_slot(cp, slot)
-#else
+static inline void xfs_lic_init_slot(xfs_log_item_chunk_t *cp, int slot)
-#define XFS_LIC_INIT_SLOT(cp,slot)      \
+{
-        ((cp)->lic_descs[slot].lid_index = (unsigned char)(slot))
+        cp->lic_descs[slot].lid_index = (unsigned char)(slot);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_VACANCY)
-int xfs_lic_vacancy(xfs_log_item_chunk_t *cp);
 #define XFS_LIC_VACANCY(cp)             xfs_lic_vacancy(cp)
-#else
+static inline int xfs_lic_vacancy(xfs_log_item_chunk_t *cp)
-#define XFS_LIC_VACANCY(cp)             (((cp)->lic_free) & XFS_LIC_FREEMASK)
+{
-#endif
+        return cp->lic_free & XFS_LIC_FREEMASK;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_ALL_FREE)
+}
-void xfs_lic_all_free(xfs_log_item_chunk_t *cp);
 #define XFS_LIC_ALL_FREE(cp)            xfs_lic_all_free(cp)
-#else
+static inline void xfs_lic_all_free(xfs_log_item_chunk_t *cp)
-#define XFS_LIC_ALL_FREE(cp)            ((cp)->lic_free = XFS_LIC_FREEMASK)
+{
-#endif
+        cp->lic_free = XFS_LIC_FREEMASK;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_ARE_ALL_FREE)
+}
-int xfs_lic_are_all_free(xfs_log_item_chunk_t *cp);
 #define XFS_LIC_ARE_ALL_FREE(cp)        xfs_lic_are_all_free(cp)
-#else
+static inline int xfs_lic_are_all_free(xfs_log_item_chunk_t *cp)
-#define XFS_LIC_ARE_ALL_FREE(cp)        (((cp)->lic_free & XFS_LIC_FREEMASK) ==\
+{
-                                        XFS_LIC_FREEMASK)
+        return ((cp->lic_free & XFS_LIC_FREEMASK) == XFS_LIC_FREEMASK);
-#endif
+}
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_ISFREE)
-int xfs_lic_isfree(xfs_log_item_chunk_t *cp, int slot);
 #define XFS_LIC_ISFREE(cp,slot) xfs_lic_isfree(cp,slot)
-#else
+static inline int xfs_lic_isfree(xfs_log_item_chunk_t *cp, int slot)
-#define XFS_LIC_ISFREE(cp,slot) ((cp)->lic_free & (1 << (slot)))
+{
-#endif
+        return (cp->lic_free & (1 << slot));
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_CLAIM)
+}
-void xfs_lic_claim(xfs_log_item_chunk_t *cp, int slot);
 #define XFS_LIC_CLAIM(cp,slot)          xfs_lic_claim(cp,slot)
-#else
+static inline void xfs_lic_claim(xfs_log_item_chunk_t *cp, int slot)
-#define XFS_LIC_CLAIM(cp,slot)          ((cp)->lic_free &= ~(1 << (slot)))
+{
-#endif
+        cp->lic_free &= ~(1 << slot);
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_RELSE)
+}
-void xfs_lic_relse(xfs_log_item_chunk_t *cp, int slot);
 #define XFS_LIC_RELSE(cp,slot)          xfs_lic_relse(cp,slot)
-#else
+static inline void xfs_lic_relse(xfs_log_item_chunk_t *cp, int slot)
-#define XFS_LIC_RELSE(cp,slot)          ((cp)->lic_free |= 1 << (slot))
+{
-#endif
+        cp->lic_free |= 1 << slot;
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_SLOT)
+}
-xfs_log_item_desc_t *xfs_lic_slot(xfs_log_item_chunk_t *cp, int slot);
 #define XFS_LIC_SLOT(cp,slot)           xfs_lic_slot(cp,slot)
-#else
+static inline xfs_log_item_desc_t *
-#define XFS_LIC_SLOT(cp,slot)           (&((cp)->lic_descs[slot]))
+xfs_lic_slot(xfs_log_item_chunk_t *cp, int slot)
-#endif
+{
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_DESC_TO_SLOT)
+        return &(cp->lic_descs[slot]);
-int xfs_lic_desc_to_slot(xfs_log_item_desc_t *dp);
+}
 #define XFS_LIC_DESC_TO_SLOT(dp)        xfs_lic_desc_to_slot(dp)
-#else
+static inline int xfs_lic_desc_to_slot(xfs_log_item_desc_t *dp)
-#define XFS_LIC_DESC_TO_SLOT(dp)        ((uint)((dp)->lid_index))
+{
-#endif
+        return (uint)dp->lid_index;
+}
 /*
 * Calculate the address of a chunk given a descriptor pointer:
 * dp - dp->lid_index give the address of the start of the lic_descs array.
@@ -303,15 +302,14 @@ int xfs_lic_desc_to_slot(xfs_log_item_desc_t *dp);
 * All of this yields the address of the chunk, which is
 * cast to a chunk pointer.
 */
-#if XFS_WANT_FUNCS || (XFS_WANT_SPACE && XFSSO_XFS_LIC_DESC_TO_CHUNK)
-xfs_log_item_chunk_t *xfs_lic_desc_to_chunk(xfs_log_item_desc_t *dp);
 #define XFS_LIC_DESC_TO_CHUNK(dp)       xfs_lic_desc_to_chunk(dp)
-#else
+static inline xfs_log_item_chunk_t *
-#define XFS_LIC_DESC_TO_CHUNK(dp)       ((xfs_log_item_chunk_t*) \
+xfs_lic_desc_to_chunk(xfs_log_item_desc_t *dp)
-                                        (((xfs_caddr_t)((dp) - (dp)->lid_index)) -\
+{
-                                        (xfs_caddr_t)(((xfs_log_item_chunk_t*) \
+        return (xfs_log_item_chunk_t*) \
-                                        0)->lic_descs)))
+                (((xfs_caddr_t)((dp) - (dp)->lid_index)) - \
-#endif
+                (xfs_caddr_t)(((xfs_log_item_chunk_t*)0)->lic_descs));
+}
 #ifdef __KERNEL__
 /*
@@ -328,7 +326,7 @@ typedef struct xfs_log_busy_slot {
 #define XFS_LBC_NUM_SLOTS       31
 typedef struct xfs_log_busy_chunk {
        struct xfs_log_busy_chunk       *lbc_next;
-        uint                            lbc_free;       /* bitmask of free slots */
+        uint                            lbc_free;       /* free slots bitmask */
        ushort                          lbc_unused;     /* first unused */
        xfs_log_busy_slot_t             lbc_busy[XFS_LBC_NUM_SLOTS];
 } xfs_log_busy_chunk_t;
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 2a71b4f91bfa..f248cb60ff7c 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -29,12 +29,11 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index e733293dd7f4..24630da76a29 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -29,19 +29,28 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
-#include "xfs_buf_item.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir.h"
+#include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
+#include "xfs_ialloc_btree.h"
+#include "xfs_dir_sf.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
+#include "xfs_buf_item.h"
 #include "xfs_trans_priv.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
diff --git a/fs/xfs/xfs_trans_extfree.c b/fs/xfs/xfs_trans_extfree.c
index 93259a15f983..1f6b17777f2d 100644
--- a/fs/xfs/xfs_trans_extfree.c
+++ b/fs/xfs/xfs_trans_extfree.c
@@ -29,12 +29,11 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_dir.h"
diff --git a/fs/xfs/xfs_trans_inode.c b/fs/xfs/xfs_trans_inode.c
index 7e7631ca4979..060b1a72eef1 100644
--- a/fs/xfs/xfs_trans_inode.c
+++ b/fs/xfs/xfs_trans_inode.c
@@ -29,12 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -42,18 +42,18 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_trans_priv.h"
-#include "xfs_alloc_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
+#include "xfs_trans_priv.h"
+#include "xfs_inode_item.h"
 #ifdef XFS_TRANS_DEBUG
 STATIC void
diff --git a/fs/xfs/xfs_trans_item.c b/fs/xfs/xfs_trans_item.c
index 1b8a756d80ed..8edfb151df10 100644
--- a/fs/xfs/xfs_trans_item.c
+++ b/fs/xfs/xfs_trans_item.c
@@ -29,12 +29,11 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 STATIC int      xfs_trans_unlock_chunk(xfs_log_item_chunk_t *,
diff --git a/fs/xfs/xfs_utils.c b/fs/xfs/xfs_utils.c
index 11351f08d438..c6459514fadb 100644
--- a/fs/xfs/xfs_utils.c
+++ b/fs/xfs/xfs_utils.c
@@ -29,25 +29,26 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
 #include "xfs_bmap.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
diff --git a/fs/xfs/xfs_vfsops.c b/fs/xfs/xfs_vfsops.c
index 200e0c50acf2..9ea201762a9c 100644
--- a/fs/xfs/xfs_vfsops.c
+++ b/fs/xfs/xfs_vfsops.c
@@ -1,6 +1,4 @@
 /*
- * XFS filesystem operations.
- *
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.  All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
@@ -31,44 +29,44 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
+#include "xfs_ag.h"
 #include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_alloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_alloc.h"
-#include "xfs_ialloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
-#include "xfs_ag.h"
+#include "xfs_inode_item.h"
+#include "xfs_btree.h"
+#include "xfs_alloc.h"
+#include "xfs_ialloc.h"
+#include "xfs_quota.h"
 #include "xfs_error.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_rw.h"
 #include "xfs_refcache.h"
 #include "xfs_buf_item.h"
-#include "xfs_extfree_item.h"
+#include "xfs_log_priv.h"
-#include "xfs_quota.h"
 #include "xfs_dir2_trace.h"
+#include "xfs_extfree_item.h"
 #include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_clnt.h"
-#include "xfs_log_priv.h"
 STATIC int xfs_sync(bhv_desc_t *, int, cred_t *);
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 8221b11a48c0..443ec6a0b2b8 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -29,12 +29,12 @@
 *
 * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
 */
 #include "xfs.h"
-#include "xfs_macros.h"
+#include "xfs_fs.h"
 #include "xfs_types.h"
-#include "xfs_inum.h"
+#include "xfs_bit.h"
 #include "xfs_log.h"
+#include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
@@ -42,33 +42,32 @@
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
-#include "xfs_alloc_btree.h"
+#include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_itable.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_alloc.h"
-#include "xfs_attr_sf.h"
 #include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
-#include "xfs_inode_item.h"
 #include "xfs_inode.h"
+#include "xfs_inode_item.h"
+#include "xfs_dir_leaf.h"
+#include "xfs_itable.h"
+#include "xfs_btree.h"
+#include "xfs_ialloc.h"
+#include "xfs_alloc.h"
 #include "xfs_bmap.h"
-#include "xfs_da_btree.h"
 #include "xfs_attr.h"
 #include "xfs_rw.h"
-#include "xfs_refcache.h"
 #include "xfs_error.h"
-#include "xfs_bit.h"
-#include "xfs_rtalloc.h"
 #include "xfs_quota.h"
 #include "xfs_utils.h"
+#include "xfs_rtalloc.h"
+#include "xfs_refcache.h"
 #include "xfs_trans_space.h"
-#include "xfs_dir_leaf.h"
-#include "xfs_mac.h"
 #include "xfs_log_priv.h"
+#include "xfs_mac.h"
 /*