[XFS] superblock endianess annotations

Creates a new xfs_dsb_t that is __be annotated and keeps xfs_sb_t for the
incore one. xfs_xlatesb is renamed to xfs_sb_to_disk and only handles the
incore -> disk conversion. A new helper xfs_sb_from_disk handles the other
direction and doesn't need the slightly hacky table-driven approach
because we only ever read the full sb from disk.

The handling of shared r/o filesystems has been buggy on little endian
system and fixing this required shuffling around of some code in that
area.

SGI-PV: 968563
SGI-Modid: xfs-linux-melb:xfs-kern:29477a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: David Chinner <dgc@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>

1 files changed, 33 insertions, 39 deletions

diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 356d6627f581..668996aae36d 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -548,7 +548,7 @@ STATIC void
 xfs_trans_apply_sb_deltas(
         xfs_trans_t     *tp)
 {
-        xfs_sb_t        *sbp;
+        xfs_dsb_t       *sbp;
         xfs_buf_t       *bp;
         int             whole = 0;
 
@@ -566,57 +566,51 @@ xfs_trans_apply_sb_deltas(
          * Only update the superblock counters if we are logging them
          */
         if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
-                if (tp->t_icount_delta != 0) {
-                        INT_MOD(sbp->sb_icount, ARCH_CONVERT, tp->t_icount_delta);
-                }
-                if (tp->t_ifree_delta != 0) {
-                        INT_MOD(sbp->sb_ifree, ARCH_CONVERT, tp->t_ifree_delta);
-                }
-
-                if (tp->t_fdblocks_delta != 0) {
-                        INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_fdblocks_delta);
-                }
-                if (tp->t_res_fdblocks_delta != 0) {
-                        INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_res_fdblocks_delta);
-                }
+                if (tp->t_icount_delta)
+                        be64_add(&sbp->sb_icount, tp->t_icount_delta);
+                if (tp->t_ifree_delta)
+                        be64_add(&sbp->sb_ifree, tp->t_ifree_delta);
+                if (tp->t_fdblocks_delta)
+                        be64_add(&sbp->sb_fdblocks, tp->t_fdblocks_delta);
+                if (tp->t_res_fdblocks_delta)
+                        be64_add(&sbp->sb_fdblocks, tp->t_res_fdblocks_delta);
         }
 
-        if (tp->t_frextents_delta != 0) {
-                INT_MOD(sbp->sb_frextents, ARCH_CONVERT, tp->t_frextents_delta);
-        }
-        if (tp->t_res_frextents_delta != 0) {
-                INT_MOD(sbp->sb_frextents, ARCH_CONVERT, tp->t_res_frextents_delta);
-        }
-        if (tp->t_dblocks_delta != 0) {
-                INT_MOD(sbp->sb_dblocks, ARCH_CONVERT, tp->t_dblocks_delta);
+        if (tp->t_frextents_delta)
+                be64_add(&sbp->sb_frextents, tp->t_frextents_delta);
+        if (tp->t_res_frextents_delta)
+                be64_add(&sbp->sb_frextents, tp->t_res_frextents_delta);
+
+        if (tp->t_dblocks_delta) {
+                be64_add(&sbp->sb_dblocks, tp->t_dblocks_delta);
                 whole = 1;
         }
-        if (tp->t_agcount_delta != 0) {
-                INT_MOD(sbp->sb_agcount, ARCH_CONVERT, tp->t_agcount_delta);
+        if (tp->t_agcount_delta) {
+                be32_add(&sbp->sb_agcount, tp->t_agcount_delta);
                 whole = 1;
         }
-        if (tp->t_imaxpct_delta != 0) {
-                INT_MOD(sbp->sb_imax_pct, ARCH_CONVERT, tp->t_imaxpct_delta);
+        if (tp->t_imaxpct_delta) {
+                sbp->sb_imax_pct += tp->t_imaxpct_delta;
                 whole = 1;
         }
-        if (tp->t_rextsize_delta != 0) {
-                INT_MOD(sbp->sb_rextsize, ARCH_CONVERT, tp->t_rextsize_delta);
+        if (tp->t_rextsize_delta) {
+                be32_add(&sbp->sb_rextsize, tp->t_rextsize_delta);
                 whole = 1;
         }
-        if (tp->t_rbmblocks_delta != 0) {
-                INT_MOD(sbp->sb_rbmblocks, ARCH_CONVERT, tp->t_rbmblocks_delta);
+        if (tp->t_rbmblocks_delta) {
+                be32_add(&sbp->sb_rbmblocks, tp->t_rbmblocks_delta);
                 whole = 1;
         }
-        if (tp->t_rblocks_delta != 0) {
-                INT_MOD(sbp->sb_rblocks, ARCH_CONVERT, tp->t_rblocks_delta);
+        if (tp->t_rblocks_delta) {
+                be64_add(&sbp->sb_rblocks, tp->t_rblocks_delta);
                 whole = 1;
         }
-        if (tp->t_rextents_delta != 0) {
-                INT_MOD(sbp->sb_rextents, ARCH_CONVERT, tp->t_rextents_delta);
+        if (tp->t_rextents_delta) {
+                be64_add(&sbp->sb_rextents, tp->t_rextents_delta);
                 whole = 1;
         }
-        if (tp->t_rextslog_delta != 0) {
-                INT_MOD(sbp->sb_rextslog, ARCH_CONVERT, tp->t_rextslog_delta);
+        if (tp->t_rextslog_delta) {
+                sbp->sb_rextslog += tp->t_rextslog_delta;
                 whole = 1;
         }
 
@@ -624,14 +618,14 @@ xfs_trans_apply_sb_deltas(
                 /*
                  * Log the whole thing, the fields are noncontiguous.
                  */
-                xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_sb_t) - 1);
+                xfs_trans_log_buf(tp, bp, 0, sizeof(xfs_dsb_t) - 1);
         else
                 /*
                  * Since all the modifiable fields are contiguous, we
                  * can get away with this.
                  */
-                xfs_trans_log_buf(tp, bp, offsetof(xfs_sb_t, sb_icount),
-                                  offsetof(xfs_sb_t, sb_frextents) +
+                xfs_trans_log_buf(tp, bp, offsetof(xfs_dsb_t, sb_icount),
+                                  offsetof(xfs_dsb_t, sb_frextents) +
                                   sizeof(sbp->sb_frextents) - 1);
 
         XFS_MTOVFS(tp->t_mountp)->vfs_super->s_dirt = 1;