xfs: make use of xfs_calc_buf_res() in xfs_trans.c

Refining the existing reservations with xfs_calc_buf_res() in xfs_trans.c Signed-off-by: Jie Liu <jeff.liu@oracle.com> CC: Dave Chinner <david@fromorbit.com> Reviewed-by: Mark Tinguely <tinguely@sgi.com> Signed-off-by: Ben Myers <bpm@sgi.com>
author: Jeff Liu <jeff.liu@oracle.com> 2013-02-01 15:39:29 -0500
committer: Ben Myers <bpm@sgi.com> 2013-02-01 15:39:29 -0500
commit: 5b292ae3a951a58e32119d73c7ac8f5bec7395a3 (patch)
tree: d9ccedba0156706911be0c364019c6d26e1977c8
parent: 4f3b57832ba39223c6f8823d07b9fb206e282ced (diff)
1 files changed, 112 insertions, 128 deletions
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 6c601ea77a9e..a81625c75a91 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -116,18 +116,15 @@ xfs_calc_write_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                MAX((mp->m_sb.sb_inodesize +
+                MAX((xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
-                     XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) +
+                     xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
-                     2 * mp->m_sb.sb_sectsize +
+                                      XFS_FSB_TO_B(mp, 1)) +
-                     mp->m_sb.sb_sectsize +
+                     xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
-                     XFS_ALLOCFREE_LOG_RES(mp, 2) +
+                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
-                     128 * (4 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) +
+                                      XFS_FSB_TO_B(mp, 1))),
-                            XFS_ALLOCFREE_LOG_COUNT(mp, 2))),
+                    (xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
-                    (2 * mp->m_sb.sb_sectsize +
+                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
-                     2 * mp->m_sb.sb_sectsize +
+                                      XFS_FSB_TO_B(mp, 1))));
-                     mp->m_sb.sb_sectsize +
-                     XFS_ALLOCFREE_LOG_RES(mp, 2) +
-                     128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))));
 }
 /*
@@ -148,18 +145,17 @@ xfs_calc_itruncate_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                MAX((mp->m_sb.sb_inodesize +
+                MAX((xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
-                     XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1) +
+                     xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1,
-                     128 * (2 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))),
+                                      XFS_FSB_TO_B(mp, 1))),
-                    (4 * mp->m_sb.sb_sectsize +
+                    (xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
-                     4 * mp->m_sb.sb_sectsize +
+                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 4),
-                     mp->m_sb.sb_sectsize +
+                                      XFS_FSB_TO_B(mp, 1)) +
-                     XFS_ALLOCFREE_LOG_RES(mp, 4) +
+                    xfs_calc_buf_res(5, 0) +
-                     128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4)) +
+                    xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
-                     128 * 5 +
+                                     XFS_FSB_TO_B(mp, 1)) +
-                     XFS_ALLOCFREE_LOG_RES(mp, 1) +
+                    xfs_calc_buf_res(2 + XFS_IALLOC_BLOCKS(mp) +
-                     128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +
+                                     mp->m_in_maxlevels, 0)));
-                            XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
 }
 /*
@@ -179,14 +175,12 @@ xfs_calc_rename_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                MAX((4 * mp->m_sb.sb_inodesize +
+                MAX((xfs_calc_buf_res(4, mp->m_sb.sb_inodesize) +
-                     2 * XFS_DIROP_LOG_RES(mp) +
+                     xfs_calc_buf_res(2 * XFS_DIROP_LOG_COUNT(mp),
-                     128 * (4 + 2 * XFS_DIROP_LOG_COUNT(mp))),
+                                      XFS_FSB_TO_B(mp, 1))),
-                    (3 * mp->m_sb.sb_sectsize +
+                    (xfs_calc_buf_res(7, mp->m_sb.sb_sectsize) +
-                     3 * mp->m_sb.sb_sectsize +
+                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 3),
-                     mp->m_sb.sb_sectsize +
+                                      XFS_FSB_TO_B(mp, 1))));
-                     XFS_ALLOCFREE_LOG_RES(mp, 3) +
-                     128 * (7 + XFS_ALLOCFREE_LOG_COUNT(mp, 3))));
 }
 /*
@@ -206,15 +200,12 @@ xfs_calc_link_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                MAX((mp->m_sb.sb_inodesize +
+                MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
-                     mp->m_sb.sb_inodesize +
+                     xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
-                     XFS_DIROP_LOG_RES(mp) +
+                                      XFS_FSB_TO_B(mp, 1))),
-                     128 * (2 + XFS_DIROP_LOG_COUNT(mp))),
+                    (xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
-                    (mp->m_sb.sb_sectsize +
+                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
-                     mp->m_sb.sb_sectsize +
+                                      XFS_FSB_TO_B(mp, 1))));
-                     mp->m_sb.sb_sectsize +
-                     XFS_ALLOCFREE_LOG_RES(mp, 1) +
-                     128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
 }
 /*
@@ -234,15 +225,12 @@ xfs_calc_remove_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                MAX((mp->m_sb.sb_inodesize +
+                MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
-                     mp->m_sb.sb_inodesize +
+                     xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
-                     XFS_DIROP_LOG_RES(mp) +
+                                      XFS_FSB_TO_B(mp, 1))),
-                     128 * (2 + XFS_DIROP_LOG_COUNT(mp))),
+                    (xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
-                    (2 * mp->m_sb.sb_sectsize +
+                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
-                     2 * mp->m_sb.sb_sectsize +
+                                      XFS_FSB_TO_B(mp, 1))));
-                     mp->m_sb.sb_sectsize +
-                     XFS_ALLOCFREE_LOG_RES(mp, 2) +
-                     128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))));
 }
 /*
@@ -264,18 +252,18 @@ xfs_calc_symlink_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                MAX((mp->m_sb.sb_inodesize +
+                MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
-                     mp->m_sb.sb_inodesize +
+                     xfs_calc_buf_res(1, XFS_FSB_TO_B(mp, 1)) +
-                     XFS_FSB_TO_B(mp, 1) +
+                     xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
-                     XFS_DIROP_LOG_RES(mp) +
+                                      XFS_FSB_TO_B(mp, 1)) +
-                     1024 +
+                     xfs_calc_buf_res(1, 1024)),
-                     128 * (4 + XFS_DIROP_LOG_COUNT(mp))),
+                    (xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
-                    (2 * mp->m_sb.sb_sectsize +
+                     xfs_calc_buf_res(XFS_IALLOC_BLOCKS(mp),
-                     XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) +
+                                      XFS_FSB_TO_B(mp, 1)) +
-                     XFS_FSB_TO_B(mp, mp->m_in_maxlevels) +
+                     xfs_calc_buf_res(mp->m_in_maxlevels,
-                     XFS_ALLOCFREE_LOG_RES(mp, 1) +
+                                      XFS_FSB_TO_B(mp, 1)) +
-                     128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +
+                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
-                            XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
+                                      XFS_FSB_TO_B(mp, 1))));
 }
 /*
@@ -298,18 +286,19 @@ xfs_calc_create_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                MAX((mp->m_sb.sb_inodesize +
+                MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
-                     mp->m_sb.sb_inodesize +
+                     xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
+                     (uint)XFS_FSB_TO_B(mp, 1) +
+                     xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
+                                      XFS_FSB_TO_B(mp, 1))),
+                    (xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
                     mp->m_sb.sb_sectsize +
-                     XFS_FSB_TO_B(mp, 1) +
+                     xfs_calc_buf_res(XFS_IALLOC_BLOCKS(mp),
-                     XFS_DIROP_LOG_RES(mp) +
+                                      XFS_FSB_TO_B(mp, 1)) +
-                     128 * (3 + XFS_DIROP_LOG_COUNT(mp))),
+                     xfs_calc_buf_res(mp->m_in_maxlevels,
-                    (3 * mp->m_sb.sb_sectsize +
+                                      XFS_FSB_TO_B(mp, 1)) +
-                     XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) +
+                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
-                     XFS_FSB_TO_B(mp, mp->m_in_maxlevels) +
+                                      XFS_FSB_TO_B(mp, 1))));
-                     XFS_ALLOCFREE_LOG_RES(mp, 1) +
-                     128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +
-                            XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
 }
 /*
@@ -337,16 +326,16 @@ xfs_calc_ifree_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                mp->m_sb.sb_inodesize +
+                xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
-                mp->m_sb.sb_sectsize +
+                xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
-                mp->m_sb.sb_sectsize +
+                xfs_calc_buf_res(1, XFS_FSB_TO_B(mp, 1)) +
-                XFS_FSB_TO_B(mp, 1) +
                MAX((__uint16_t)XFS_FSB_TO_B(mp, 1),
                    XFS_INODE_CLUSTER_SIZE(mp)) +
-                128 * 5 +
+                xfs_calc_buf_res(1, 0) +
-                XFS_ALLOCFREE_LOG_RES(mp, 1) +
+                xfs_calc_buf_res(2 + XFS_IALLOC_BLOCKS(mp) +
-                128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +
+                                 mp->m_in_maxlevels, 0) +
-                       XFS_ALLOCFREE_LOG_COUNT(mp, 1));
+                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
+                                 XFS_FSB_TO_B(mp, 1));
 }
 /*
@@ -374,9 +363,9 @@ STATIC uint
 xfs_calc_growdata_reservation(
        struct xfs_mount        *mp)
 {
-        return mp->m_sb.sb_sectsize * 3 +
+        return xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
-                XFS_ALLOCFREE_LOG_RES(mp, 1) +
+                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
-                128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1));
+                                 XFS_FSB_TO_B(mp, 1));
 }
 /*
@@ -393,12 +382,12 @@ STATIC uint
 xfs_calc_growrtalloc_reservation(
        struct xfs_mount        *mp)
 {
-        return 2 * mp->m_sb.sb_sectsize +
+        return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
-                XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) +
+                xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
-                mp->m_sb.sb_inodesize +
+                                 XFS_FSB_TO_B(mp, 1)) +
-                XFS_ALLOCFREE_LOG_RES(mp, 1) +
+                xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
-                128 * (3 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) +
+                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
-                       XFS_ALLOCFREE_LOG_COUNT(mp, 1));
+                                 XFS_FSB_TO_B(mp, 1));
 }
 /*
@@ -410,7 +399,7 @@ STATIC uint
 xfs_calc_growrtzero_reservation(
        struct xfs_mount        *mp)
 {
-        return mp->m_sb.sb_blocksize + 128;
+        return xfs_calc_buf_res(1, mp->m_sb.sb_blocksize);
 }
 /*
@@ -427,11 +416,10 @@ STATIC uint
 xfs_calc_growrtfree_reservation(
        struct xfs_mount        *mp)
 {
-        return mp->m_sb.sb_sectsize +
+        return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
-                2 * mp->m_sb.sb_inodesize +
+                xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
-                mp->m_sb.sb_blocksize +
+                xfs_calc_buf_res(1, mp->m_sb.sb_blocksize) +
-                mp->m_rsumsize +
+                xfs_calc_buf_res(1, mp->m_rsumsize);
-                128 * 5;
 }
 /*
@@ -442,7 +430,7 @@ STATIC uint
 xfs_calc_swrite_reservation(
        struct xfs_mount        *mp)
 {
-        return mp->m_sb.sb_inodesize + 128;
+        return xfs_calc_buf_res(1, mp->m_sb.sb_inodesize);
 }
 /*
@@ -452,7 +440,7 @@ xfs_calc_swrite_reservation(
 STATIC uint
 xfs_calc_writeid_reservation(xfs_mount_t *mp)
 {
-        return mp->m_sb.sb_inodesize + 128;
+        return xfs_calc_buf_res(1, mp->m_sb.sb_inodesize);
 }
 /*
@@ -468,13 +456,13 @@ xfs_calc_addafork_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                mp->m_sb.sb_inodesize +
+                xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
-                mp->m_sb.sb_sectsize * 2 +
+                xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
-                mp->m_dirblksize +
+                xfs_calc_buf_res(1, mp->m_dirblksize) +
-                XFS_FSB_TO_B(mp, XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1) +
+                xfs_calc_buf_res(XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1,
-                XFS_ALLOCFREE_LOG_RES(mp, 1) +
+                                 XFS_FSB_TO_B(mp, 1)) +
-                128 * (4 + XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1 +
+                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
-                       XFS_ALLOCFREE_LOG_COUNT(mp, 1));
+                                 XFS_FSB_TO_B(mp, 1));
 }
 /*
@@ -492,14 +480,12 @@ STATIC uint
 xfs_calc_attrinval_reservation(
        struct xfs_mount        *mp)
 {
-        return MAX((mp->m_sb.sb_inodesize +
+        return MAX((xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
-                    XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +
+                    xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK),
-                    128 * (1 + XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK))),
+                                     XFS_FSB_TO_B(mp, 1))),
-                   (4 * mp->m_sb.sb_sectsize +
+                   (xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
-                    4 * mp->m_sb.sb_sectsize +
+                    xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 4),
-                    mp->m_sb.sb_sectsize +
+                                     XFS_FSB_TO_B(mp, 1))));
-                    XFS_ALLOCFREE_LOG_RES(mp, 4) +
-                    128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4))));
 }
 /*
@@ -517,10 +503,9 @@ xfs_calc_attrset_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                mp->m_sb.sb_inodesize +
+                xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
-                mp->m_sb.sb_sectsize +
+                xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
-                XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) +
+                xfs_calc_buf_res(XFS_DA_NODE_MAXDEPTH, XFS_FSB_TO_B(mp, 1));
-                128 * (2 + XFS_DA_NODE_MAXDEPTH);
 }
 /*
@@ -539,16 +524,15 @@ xfs_calc_attrrm_reservation(
        struct xfs_mount        *mp)
 {
        return XFS_DQUOT_LOGRES(mp) +
-                MAX((mp->m_sb.sb_inodesize +
+                MAX((xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
-                     XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) +
+                     xfs_calc_buf_res(XFS_DA_NODE_MAXDEPTH,
-                     XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +
+                                      XFS_FSB_TO_B(mp, 1)) +
-                     128 * (1 + XFS_DA_NODE_MAXDEPTH +
+                     (uint)XFS_FSB_TO_B(mp,
-                            XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))),
+                                        XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +
-                    (2 * mp->m_sb.sb_sectsize +
+                     xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK), 0)),
-                     2 * mp->m_sb.sb_sectsize +
+                    (xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
-                     mp->m_sb.sb_sectsize +
+                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
-                     XFS_ALLOCFREE_LOG_RES(mp, 2) +
+                                      XFS_FSB_TO_B(mp, 1))));
-                     128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))));
 }
 /*
@@ -558,7 +542,7 @@ STATIC uint
 xfs_calc_clear_agi_bucket_reservation(
        struct xfs_mount        *mp)
 {
-        return mp->m_sb.sb_sectsize + 128;
+        return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
 }
 /*
author	Jeff Liu <jeff.liu@oracle.com>	2013-02-01 15:39:29 -0500
committer	Ben Myers <bpm@sgi.com>	2013-02-01 15:39:29 -0500
commit	5b292ae3a951a58e32119d73c7ac8f5bec7395a3 (patch)
tree	d9ccedba0156706911be0c364019c6d26e1977c8
parent	4f3b57832ba39223c6f8823d07b9fb206e282ced (diff)

diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c index 6c601ea77a9e..a81625c75a91 100644 --- a/fs/xfs/xfs_trans.c +++ b/fs/xfs/xfs_trans.c
@@ -116,18 +116,15 @@ xfs_calc_write_reservation(
116	struct xfs_mount *mp)	116	struct xfs_mount *mp)
117	{	117	{
118	return XFS_DQUOT_LOGRES(mp) +	118	return XFS_DQUOT_LOGRES(mp) +
119	MAX((mp->m_sb.sb_inodesize +	119	MAX((xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
120	XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) +	120	xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
121	2 * mp->m_sb.sb_sectsize +	121	XFS_FSB_TO_B(mp, 1)) +
122	mp->m_sb.sb_sectsize +	122	xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
123	XFS_ALLOCFREE_LOG_RES(mp, 2) +	123	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
124	128 * (4 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) +	124	XFS_FSB_TO_B(mp, 1))),
125	XFS_ALLOCFREE_LOG_COUNT(mp, 2))),	125	(xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
126	(2 * mp->m_sb.sb_sectsize +	126	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
127	2 * mp->m_sb.sb_sectsize +	127	XFS_FSB_TO_B(mp, 1))));
128	mp->m_sb.sb_sectsize +
129	XFS_ALLOCFREE_LOG_RES(mp, 2) +
130	128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))));
131	}	128	}
132		129
133	/*	130	/*
@@ -148,18 +145,17 @@ xfs_calc_itruncate_reservation(
148	struct xfs_mount *mp)	145	struct xfs_mount *mp)
149	{	146	{
150	return XFS_DQUOT_LOGRES(mp) +	147	return XFS_DQUOT_LOGRES(mp) +
151	MAX((mp->m_sb.sb_inodesize +	148	MAX((xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
152	XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1) +	149	xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1,
153	128 * (2 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))),	150	XFS_FSB_TO_B(mp, 1))),
154	(4 * mp->m_sb.sb_sectsize +	151	(xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
155	4 * mp->m_sb.sb_sectsize +	152	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 4),
156	mp->m_sb.sb_sectsize +	153	XFS_FSB_TO_B(mp, 1)) +
157	XFS_ALLOCFREE_LOG_RES(mp, 4) +	154	xfs_calc_buf_res(5, 0) +
158	128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4)) +	155	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
159	128 * 5 +	156	XFS_FSB_TO_B(mp, 1)) +
160	XFS_ALLOCFREE_LOG_RES(mp, 1) +	157	xfs_calc_buf_res(2 + XFS_IALLOC_BLOCKS(mp) +
161	128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +	158	mp->m_in_maxlevels, 0)));
162	XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
163	}	159	}
164		160
165	/*	161	/*
@@ -179,14 +175,12 @@ xfs_calc_rename_reservation(
179	struct xfs_mount *mp)	175	struct xfs_mount *mp)
180	{	176	{
181	return XFS_DQUOT_LOGRES(mp) +	177	return XFS_DQUOT_LOGRES(mp) +
182	MAX((4 * mp->m_sb.sb_inodesize +	178	MAX((xfs_calc_buf_res(4, mp->m_sb.sb_inodesize) +
183	2 * XFS_DIROP_LOG_RES(mp) +	179	xfs_calc_buf_res(2 * XFS_DIROP_LOG_COUNT(mp),
184	128 * (4 + 2 * XFS_DIROP_LOG_COUNT(mp))),	180	XFS_FSB_TO_B(mp, 1))),
185	(3 * mp->m_sb.sb_sectsize +	181	(xfs_calc_buf_res(7, mp->m_sb.sb_sectsize) +
186	3 * mp->m_sb.sb_sectsize +	182	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 3),
187	mp->m_sb.sb_sectsize +	183	XFS_FSB_TO_B(mp, 1))));
188	XFS_ALLOCFREE_LOG_RES(mp, 3) +
189	128 * (7 + XFS_ALLOCFREE_LOG_COUNT(mp, 3))));
190	}	184	}
191		185
192	/*	186	/*
@@ -206,15 +200,12 @@ xfs_calc_link_reservation(
206	struct xfs_mount *mp)	200	struct xfs_mount *mp)
207	{	201	{
208	return XFS_DQUOT_LOGRES(mp) +	202	return XFS_DQUOT_LOGRES(mp) +
209	MAX((mp->m_sb.sb_inodesize +	203	MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
210	mp->m_sb.sb_inodesize +	204	xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
211	XFS_DIROP_LOG_RES(mp) +	205	XFS_FSB_TO_B(mp, 1))),
212	128 * (2 + XFS_DIROP_LOG_COUNT(mp))),	206	(xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
213	(mp->m_sb.sb_sectsize +	207	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
214	mp->m_sb.sb_sectsize +	208	XFS_FSB_TO_B(mp, 1))));
215	mp->m_sb.sb_sectsize +
216	XFS_ALLOCFREE_LOG_RES(mp, 1) +
217	128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
218	}	209	}
219		210
220	/*	211	/*
@@ -234,15 +225,12 @@ xfs_calc_remove_reservation(
234	struct xfs_mount *mp)	225	struct xfs_mount *mp)
235	{	226	{
236	return XFS_DQUOT_LOGRES(mp) +	227	return XFS_DQUOT_LOGRES(mp) +
237	MAX((mp->m_sb.sb_inodesize +	228	MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
238	mp->m_sb.sb_inodesize +	229	xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
239	XFS_DIROP_LOG_RES(mp) +	230	XFS_FSB_TO_B(mp, 1))),
240	128 * (2 + XFS_DIROP_LOG_COUNT(mp))),	231	(xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
241	(2 * mp->m_sb.sb_sectsize +	232	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
242	2 * mp->m_sb.sb_sectsize +	233	XFS_FSB_TO_B(mp, 1))));
243	mp->m_sb.sb_sectsize +
244	XFS_ALLOCFREE_LOG_RES(mp, 2) +
245	128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))));
246	}	234	}
247		235
248	/*	236	/*
@@ -264,18 +252,18 @@ xfs_calc_symlink_reservation(
264	struct xfs_mount *mp)	252	struct xfs_mount *mp)
265	{	253	{
266	return XFS_DQUOT_LOGRES(mp) +	254	return XFS_DQUOT_LOGRES(mp) +
267	MAX((mp->m_sb.sb_inodesize +	255	MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
268	mp->m_sb.sb_inodesize +	256	xfs_calc_buf_res(1, XFS_FSB_TO_B(mp, 1)) +
269	XFS_FSB_TO_B(mp, 1) +	257	xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
270	XFS_DIROP_LOG_RES(mp) +	258	XFS_FSB_TO_B(mp, 1)) +
271	1024 +	259	xfs_calc_buf_res(1, 1024)),
272	128 * (4 + XFS_DIROP_LOG_COUNT(mp))),	260	(xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
273	(2 * mp->m_sb.sb_sectsize +	261	xfs_calc_buf_res(XFS_IALLOC_BLOCKS(mp),
274	XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) +	262	XFS_FSB_TO_B(mp, 1)) +
275	XFS_FSB_TO_B(mp, mp->m_in_maxlevels) +	263	xfs_calc_buf_res(mp->m_in_maxlevels,
276	XFS_ALLOCFREE_LOG_RES(mp, 1) +	264	XFS_FSB_TO_B(mp, 1)) +
277	128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +	265	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
278	XFS_ALLOCFREE_LOG_COUNT(mp, 1))));	266	XFS_FSB_TO_B(mp, 1))));
279	}	267	}
280		268
281	/*	269	/*
@@ -298,18 +286,19 @@ xfs_calc_create_reservation(
298	struct xfs_mount *mp)	286	struct xfs_mount *mp)
299	{	287	{
300	return XFS_DQUOT_LOGRES(mp) +	288	return XFS_DQUOT_LOGRES(mp) +
301	MAX((mp->m_sb.sb_inodesize +	289	MAX((xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
302	mp->m_sb.sb_inodesize +	290	xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
		291	(uint)XFS_FSB_TO_B(mp, 1) +
		292	xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
		293	XFS_FSB_TO_B(mp, 1))),
		294	(xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
303	mp->m_sb.sb_sectsize +	295	mp->m_sb.sb_sectsize +
304	XFS_FSB_TO_B(mp, 1) +	296	xfs_calc_buf_res(XFS_IALLOC_BLOCKS(mp),
305	XFS_DIROP_LOG_RES(mp) +	297	XFS_FSB_TO_B(mp, 1)) +
306	128 * (3 + XFS_DIROP_LOG_COUNT(mp))),	298	xfs_calc_buf_res(mp->m_in_maxlevels,
307	(3 * mp->m_sb.sb_sectsize +	299	XFS_FSB_TO_B(mp, 1)) +
308	XFS_FSB_TO_B(mp, XFS_IALLOC_BLOCKS(mp)) +	300	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
309	XFS_FSB_TO_B(mp, mp->m_in_maxlevels) +	301	XFS_FSB_TO_B(mp, 1))));
310	XFS_ALLOCFREE_LOG_RES(mp, 1) +
311	128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +
312	XFS_ALLOCFREE_LOG_COUNT(mp, 1))));
313	}	302	}
314		303
315	/*	304	/*
@@ -337,16 +326,16 @@ xfs_calc_ifree_reservation(
337	struct xfs_mount *mp)	326	struct xfs_mount *mp)
338	{	327	{
339	return XFS_DQUOT_LOGRES(mp) +	328	return XFS_DQUOT_LOGRES(mp) +
340	mp->m_sb.sb_inodesize +	329	xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
341	mp->m_sb.sb_sectsize +	330	xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
342	mp->m_sb.sb_sectsize +	331	xfs_calc_buf_res(1, XFS_FSB_TO_B(mp, 1)) +
343	XFS_FSB_TO_B(mp, 1) +
344	MAX((__uint16_t)XFS_FSB_TO_B(mp, 1),	332	MAX((__uint16_t)XFS_FSB_TO_B(mp, 1),
345	XFS_INODE_CLUSTER_SIZE(mp)) +	333	XFS_INODE_CLUSTER_SIZE(mp)) +
346	128 * 5 +	334	xfs_calc_buf_res(1, 0) +
347	XFS_ALLOCFREE_LOG_RES(mp, 1) +	335	xfs_calc_buf_res(2 + XFS_IALLOC_BLOCKS(mp) +
348	128 * (2 + XFS_IALLOC_BLOCKS(mp) + mp->m_in_maxlevels +	336	mp->m_in_maxlevels, 0) +
349	XFS_ALLOCFREE_LOG_COUNT(mp, 1));	337	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
		338	XFS_FSB_TO_B(mp, 1));
350	}	339	}
351		340
352	/*	341	/*
@@ -374,9 +363,9 @@ STATIC uint
374	xfs_calc_growdata_reservation(	363	xfs_calc_growdata_reservation(
375	struct xfs_mount *mp)	364	struct xfs_mount *mp)
376	{	365	{
377	return mp->m_sb.sb_sectsize * 3 +	366	return xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
378	XFS_ALLOCFREE_LOG_RES(mp, 1) +	367	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
379	128 * (3 + XFS_ALLOCFREE_LOG_COUNT(mp, 1));	368	XFS_FSB_TO_B(mp, 1));
380	}	369	}
381		370
382	/*	371	/*
@@ -393,12 +382,12 @@ STATIC uint
393	xfs_calc_growrtalloc_reservation(	382	xfs_calc_growrtalloc_reservation(
394	struct xfs_mount *mp)	383	struct xfs_mount *mp)
395	{	384	{
396	return 2 * mp->m_sb.sb_sectsize +	385	return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
397	XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK)) +	386	xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
398	mp->m_sb.sb_inodesize +	387	XFS_FSB_TO_B(mp, 1)) +
399	XFS_ALLOCFREE_LOG_RES(mp, 1) +	388	xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
400	128 * (3 + XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) +	389	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
401	XFS_ALLOCFREE_LOG_COUNT(mp, 1));	390	XFS_FSB_TO_B(mp, 1));
402	}	391	}
403		392
404	/*	393	/*
@@ -410,7 +399,7 @@ STATIC uint
410	xfs_calc_growrtzero_reservation(	399	xfs_calc_growrtzero_reservation(
411	struct xfs_mount *mp)	400	struct xfs_mount *mp)
412	{	401	{
413	return mp->m_sb.sb_blocksize + 128;	402	return xfs_calc_buf_res(1, mp->m_sb.sb_blocksize);
414	}	403	}
415		404
416	/*	405	/*
@@ -427,11 +416,10 @@ STATIC uint
427	xfs_calc_growrtfree_reservation(	416	xfs_calc_growrtfree_reservation(
428	struct xfs_mount *mp)	417	struct xfs_mount *mp)
429	{	418	{
430	return mp->m_sb.sb_sectsize +	419	return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
431	2 * mp->m_sb.sb_inodesize +	420	xfs_calc_buf_res(2, mp->m_sb.sb_inodesize) +
432	mp->m_sb.sb_blocksize +	421	xfs_calc_buf_res(1, mp->m_sb.sb_blocksize) +
433	mp->m_rsumsize +	422	xfs_calc_buf_res(1, mp->m_rsumsize);
434	128 * 5;
435	}	423	}
436		424
437	/*	425	/*
@@ -442,7 +430,7 @@ STATIC uint
442	xfs_calc_swrite_reservation(	430	xfs_calc_swrite_reservation(
443	struct xfs_mount *mp)	431	struct xfs_mount *mp)
444	{	432	{
445	return mp->m_sb.sb_inodesize + 128;	433	return xfs_calc_buf_res(1, mp->m_sb.sb_inodesize);
446	}	434	}
447		435
448	/*	436	/*
@@ -452,7 +440,7 @@ xfs_calc_swrite_reservation(
452	STATIC uint	440	STATIC uint
453	xfs_calc_writeid_reservation(xfs_mount_t *mp)	441	xfs_calc_writeid_reservation(xfs_mount_t *mp)
454	{	442	{
455	return mp->m_sb.sb_inodesize + 128;	443	return xfs_calc_buf_res(1, mp->m_sb.sb_inodesize);
456	}	444	}
457		445
458	/*	446	/*
@@ -468,13 +456,13 @@ xfs_calc_addafork_reservation(
468	struct xfs_mount *mp)	456	struct xfs_mount *mp)
469	{	457	{
470	return XFS_DQUOT_LOGRES(mp) +	458	return XFS_DQUOT_LOGRES(mp) +
471	mp->m_sb.sb_inodesize +	459	xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
472	mp->m_sb.sb_sectsize * 2 +	460	xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
473	mp->m_dirblksize +	461	xfs_calc_buf_res(1, mp->m_dirblksize) +
474	XFS_FSB_TO_B(mp, XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1) +	462	xfs_calc_buf_res(XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1,
475	XFS_ALLOCFREE_LOG_RES(mp, 1) +	463	XFS_FSB_TO_B(mp, 1)) +
476	128 * (4 + XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1 +	464	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
477	XFS_ALLOCFREE_LOG_COUNT(mp, 1));	465	XFS_FSB_TO_B(mp, 1));
478	}	466	}
479		467
480	/*	468	/*
@@ -492,14 +480,12 @@ STATIC uint
492	xfs_calc_attrinval_reservation(	480	xfs_calc_attrinval_reservation(
493	struct xfs_mount *mp)	481	struct xfs_mount *mp)
494	{	482	{
495	return MAX((mp->m_sb.sb_inodesize +	483	return MAX((xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
496	XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +	484	xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK),
497	128 * (1 + XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK))),	485	XFS_FSB_TO_B(mp, 1))),
498	(4 * mp->m_sb.sb_sectsize +	486	(xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
499	4 * mp->m_sb.sb_sectsize +	487	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 4),
500	mp->m_sb.sb_sectsize +	488	XFS_FSB_TO_B(mp, 1))));
501	XFS_ALLOCFREE_LOG_RES(mp, 4) +
502	128 * (9 + XFS_ALLOCFREE_LOG_COUNT(mp, 4))));
503	}	489	}
504		490
505	/*	491	/*
@@ -517,10 +503,9 @@ xfs_calc_attrset_reservation(
517	struct xfs_mount *mp)	503	struct xfs_mount *mp)
518	{	504	{
519	return XFS_DQUOT_LOGRES(mp) +	505	return XFS_DQUOT_LOGRES(mp) +
520	mp->m_sb.sb_inodesize +	506	xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
521	mp->m_sb.sb_sectsize +	507	xfs_calc_buf_res(1, mp->m_sb.sb_sectsize) +
522	XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) +	508	xfs_calc_buf_res(XFS_DA_NODE_MAXDEPTH, XFS_FSB_TO_B(mp, 1));
523	128 * (2 + XFS_DA_NODE_MAXDEPTH);
524	}	509	}
525		510
526	/*	511	/*
@@ -539,16 +524,15 @@ xfs_calc_attrrm_reservation(
539	struct xfs_mount *mp)	524	struct xfs_mount *mp)
540	{	525	{
541	return XFS_DQUOT_LOGRES(mp) +	526	return XFS_DQUOT_LOGRES(mp) +
542	MAX((mp->m_sb.sb_inodesize +	527	MAX((xfs_calc_buf_res(1, mp->m_sb.sb_inodesize) +
543	XFS_FSB_TO_B(mp, XFS_DA_NODE_MAXDEPTH) +	528	xfs_calc_buf_res(XFS_DA_NODE_MAXDEPTH,
544	XFS_FSB_TO_B(mp, XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +	529	XFS_FSB_TO_B(mp, 1)) +
545	128 * (1 + XFS_DA_NODE_MAXDEPTH +	530	(uint)XFS_FSB_TO_B(mp,
546	XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK))),	531	XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +
547	(2 * mp->m_sb.sb_sectsize +	532	xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK), 0)),
548	2 * mp->m_sb.sb_sectsize +	533	(xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
549	mp->m_sb.sb_sectsize +	534	xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
550	XFS_ALLOCFREE_LOG_RES(mp, 2) +	535	XFS_FSB_TO_B(mp, 1))));
551	128 * (5 + XFS_ALLOCFREE_LOG_COUNT(mp, 2))));
552	}	536	}
553		537
554	/*	538	/*
@@ -558,7 +542,7 @@ STATIC uint
558	xfs_calc_clear_agi_bucket_reservation(	542	xfs_calc_clear_agi_bucket_reservation(
559	struct xfs_mount *mp)	543	struct xfs_mount *mp)
560	{	544	{
561	return mp->m_sb.sb_sectsize + 128;	545	return xfs_calc_buf_res(1, mp->m_sb.sb_sectsize);
562	}	546	}
563		547
564	/*	548	/*