5 files changed, 37 insertions, 86 deletions

diff --git a/fs/xfs/libxfs/xfs_da_format.c b/fs/xfs/libxfs/xfs_da_format.c
index 9d624a622946..f1e8d4dbb600 100644
--- a/fs/xfs/libxfs/xfs_da_format.c
+++ b/fs/xfs/libxfs/xfs_da_format.c
@@ -40,8 +40,7 @@ xfs_dir2_sf_entsize(
         int count = sizeof(struct xfs_dir2_sf_entry);   /* namelen + offset */
 
         count += len;                                   /* name */
-        count += hdr->i8count ? sizeof(xfs_dir2_ino8_t) :
-                                sizeof(xfs_dir2_ino4_t); /* ino # */
+        count += hdr->i8count ? XFS_INO64_SIZE : XFS_INO32_SIZE; /* ino # */
         return count;
 }
 
@@ -125,33 +124,33 @@ xfs_dir3_sfe_put_ftype(
 static xfs_ino_t
 xfs_dir2_sf_get_ino(
         struct xfs_dir2_sf_hdr  *hdr,
-        xfs_dir2_inou_t         *from)
+        __uint8_t               *from)
 {
         if (hdr->i8count)
-                return get_unaligned_be64(&from->i8.i) & 0x00ffffffffffffffULL;
+                return get_unaligned_be64(from) & 0x00ffffffffffffffULL;
         else
-                return get_unaligned_be32(&from->i4.i);
+                return get_unaligned_be32(from);
 }
 
 static void
 xfs_dir2_sf_put_ino(
         struct xfs_dir2_sf_hdr  *hdr,
-        xfs_dir2_inou_t         *to,
+        __uint8_t               *to,
         xfs_ino_t               ino)
 {
         ASSERT((ino & 0xff00000000000000ULL) == 0);
 
         if (hdr->i8count)
-                put_unaligned_be64(ino, &to->i8.i);
+                put_unaligned_be64(ino, to);
         else
-                put_unaligned_be32(ino, &to->i4.i);
+                put_unaligned_be32(ino, to);
 }
 
 static xfs_ino_t
 xfs_dir2_sf_get_parent_ino(
         struct xfs_dir2_sf_hdr  *hdr)
 {
-        return xfs_dir2_sf_get_ino(hdr, &hdr->parent);
+        return xfs_dir2_sf_get_ino(hdr, hdr->parent);
 }
 
 static void
@@ -159,7 +158,7 @@ xfs_dir2_sf_put_parent_ino(
         struct xfs_dir2_sf_hdr  *hdr,
         xfs_ino_t               ino)
 {
-        xfs_dir2_sf_put_ino(hdr, &hdr->parent, ino);
+        xfs_dir2_sf_put_ino(hdr, hdr->parent, ino);
 }
 
 /*
@@ -173,8 +172,7 @@ xfs_dir2_sfe_get_ino(
         struct xfs_dir2_sf_hdr  *hdr,
         struct xfs_dir2_sf_entry *sfep)
 {
-        return xfs_dir2_sf_get_ino(hdr,
-                                (xfs_dir2_inou_t *)&sfep->name[sfep->namelen]);
+        return xfs_dir2_sf_get_ino(hdr, &sfep->name[sfep->namelen]);
 }
 
 static void
@@ -183,8 +181,7 @@ xfs_dir2_sfe_put_ino(
         struct xfs_dir2_sf_entry *sfep,
         xfs_ino_t               ino)
 {
-        xfs_dir2_sf_put_ino(hdr,
-                            (xfs_dir2_inou_t *)&sfep->name[sfep->namelen], ino);
+        xfs_dir2_sf_put_ino(hdr, &sfep->name[sfep->namelen], ino);
 }
 
 static xfs_ino_t
@@ -192,8 +189,7 @@ xfs_dir3_sfe_get_ino(
         struct xfs_dir2_sf_hdr  *hdr,
         struct xfs_dir2_sf_entry *sfep)
 {
-        return xfs_dir2_sf_get_ino(hdr,
-                        (xfs_dir2_inou_t *)&sfep->name[sfep->namelen + 1]);
+        return xfs_dir2_sf_get_ino(hdr, &sfep->name[sfep->namelen + 1]);
 }
 
 static void
@@ -202,8 +198,7 @@ xfs_dir3_sfe_put_ino(
         struct xfs_dir2_sf_entry *sfep,
         xfs_ino_t               ino)
 {
-        xfs_dir2_sf_put_ino(hdr,
-                        (xfs_dir2_inou_t *)&sfep->name[sfep->namelen + 1], ino);
+        xfs_dir2_sf_put_ino(hdr, &sfep->name[sfep->namelen + 1], ino);
 }
 
 
diff --git a/fs/xfs/libxfs/xfs_da_format.h b/fs/xfs/libxfs/xfs_da_format.h
index 8d4d8bce41bf..685f23b67056 100644
--- a/fs/xfs/libxfs/xfs_da_format.h
+++ b/fs/xfs/libxfs/xfs_da_format.h
@@ -192,12 +192,6 @@ typedef	__uint16_t	xfs_dir2_data_off_t;
 typedef uint            xfs_dir2_data_aoff_t;   /* argument form */
 
 /*
- * Normalized offset (in a data block) of the entry, really xfs_dir2_data_off_t.
- * Only need 16 bits, this is the byte offset into the single block form.
- */
-typedef struct { __uint8_t i[2]; } __arch_pack xfs_dir2_sf_off_t;
-
-/*
  * Offset in data space of a data entry.
  */
 typedef __uint32_t      xfs_dir2_dataptr_t;
@@ -214,22 +208,10 @@ typedef	xfs_off_t	xfs_dir2_off_t;
  */
 typedef __uint32_t      xfs_dir2_db_t;
 
-/*
- * Inode number stored as 8 8-bit values.
- */
-typedef struct { __uint8_t i[8]; } xfs_dir2_ino8_t;
-
-/*
- * Inode number stored as 4 8-bit values.
- * Works a lot of the time, when all the inode numbers in a directory
- * fit in 32 bits.
- */
-typedef struct { __uint8_t i[4]; } xfs_dir2_ino4_t;
+#define XFS_INO32_SIZE  4
+#define XFS_INO64_SIZE  8
+#define XFS_INO64_DIFF  (XFS_INO64_SIZE - XFS_INO32_SIZE)
 
-typedef union {
-        xfs_dir2_ino8_t i8;
-        xfs_dir2_ino4_t i4;
-} xfs_dir2_inou_t;
 #define XFS_DIR2_MAX_SHORT_INUM ((xfs_ino_t)0xffffffffULL)
 
 /*
@@ -246,39 +228,38 @@ typedef union {
 typedef struct xfs_dir2_sf_hdr {
         __uint8_t               count;          /* count of entries */
         __uint8_t               i8count;        /* count of 8-byte inode #s */
-        xfs_dir2_inou_t         parent;         /* parent dir inode number */
-} __arch_pack xfs_dir2_sf_hdr_t;
+        __uint8_t               parent[8];      /* parent dir inode number */
+} __packed xfs_dir2_sf_hdr_t;
 
 typedef struct xfs_dir2_sf_entry {
         __u8                    namelen;        /* actual name length */
-        xfs_dir2_sf_off_t       offset;         /* saved offset */
+        __u8                    offset[2];      /* saved offset */
         __u8                    name[];         /* name, variable size */
         /*
          * A single byte containing the file type field follows the inode
          * number for version 3 directory entries.
          *
-         * A xfs_dir2_ino8_t or xfs_dir2_ino4_t follows here, at a
-         * variable offset after the name.
+         * A 64-bit or 32-bit inode number follows here, at a variable offset
+         * after the name.
          */
-} __arch_pack xfs_dir2_sf_entry_t;
+} xfs_dir2_sf_entry_t;
 
 static inline int xfs_dir2_sf_hdr_size(int i8count)
 {
         return sizeof(struct xfs_dir2_sf_hdr) -
-                (i8count == 0) *
-                (sizeof(xfs_dir2_ino8_t) - sizeof(xfs_dir2_ino4_t));
+                (i8count == 0) * XFS_INO64_DIFF;
 }
 
 static inline xfs_dir2_data_aoff_t
 xfs_dir2_sf_get_offset(xfs_dir2_sf_entry_t *sfep)
 {
-        return get_unaligned_be16(&sfep->offset.i);
+        return get_unaligned_be16(sfep->offset);
 }
 
 static inline void
 xfs_dir2_sf_put_offset(xfs_dir2_sf_entry_t *sfep, xfs_dir2_data_aoff_t off)
 {
-        put_unaligned_be16(off, &sfep->offset.i);
+        put_unaligned_be16(off, sfep->offset);
 }
 
 static inline struct xfs_dir2_sf_entry *
diff --git a/fs/xfs/libxfs/xfs_dir2_sf.c b/fs/xfs/libxfs/xfs_dir2_sf.c
index e5bb9cc3b243..c6809ff41197 100644
--- a/fs/xfs/libxfs/xfs_dir2_sf.c
+++ b/fs/xfs/libxfs/xfs_dir2_sf.c
@@ -126,13 +126,12 @@ xfs_dir2_block_sfsize(
                 /*
                  * Calculate the new size, see if we should give up yet.
                  */
-                size = xfs_dir2_sf_hdr_size(i8count) +          /* header */
-                       count +                                  /* namelen */
-                       count * (uint)sizeof(xfs_dir2_sf_off_t) + /* offset */
-                       namelen +                                /* name */
-                       (i8count ?                               /* inumber */
-                                (uint)sizeof(xfs_dir2_ino8_t) * count :
-                                (uint)sizeof(xfs_dir2_ino4_t) * count);
+                size = xfs_dir2_sf_hdr_size(i8count) +  /* header */
+                       count * 3 * sizeof(u8) +         /* namelen + offset */
+                       namelen +                        /* name */
+                       (i8count ?                       /* inumber */
+                                count * XFS_INO64_SIZE :
+                                count * XFS_INO32_SIZE);
                 if (size > XFS_IFORK_DSIZE(dp))
                         return size;            /* size value is a failure */
         }
@@ -319,10 +318,7 @@ xfs_dir2_sf_addname(
                 /*
                  * Yes, adjust the inode size.  old count + (parent + new)
                  */
-                incr_isize +=
-                        (sfp->count + 2) *
-                        ((uint)sizeof(xfs_dir2_ino8_t) -
-                         (uint)sizeof(xfs_dir2_ino4_t));
+                incr_isize += (sfp->count + 2) * XFS_INO64_DIFF;
                 objchange = 1;
         }
 
@@ -897,11 +893,7 @@ xfs_dir2_sf_replace(
                 int     error;                  /* error return value */
                 int     newsize;                /* new inode size */
 
-                newsize =
-                        dp->i_df.if_bytes +
-                        (sfp->count + 1) *
-                        ((uint)sizeof(xfs_dir2_ino8_t) -
-                         (uint)sizeof(xfs_dir2_ino4_t));
+                newsize = dp->i_df.if_bytes + (sfp->count + 1) * XFS_INO64_DIFF;
                 /*
                  * Won't fit as shortform, convert to block then do replace.
                  */
@@ -1022,10 +1014,7 @@ xfs_dir2_sf_toino4(
         /*
          * Compute the new inode size.
          */
-        newsize =
-                oldsize -
-                (oldsfp->count + 1) *
-                ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t));
+        newsize = oldsize - (oldsfp->count + 1) * XFS_INO64_DIFF;
         xfs_idata_realloc(dp, -oldsize, XFS_DATA_FORK);
         xfs_idata_realloc(dp, newsize, XFS_DATA_FORK);
         /*
@@ -1048,7 +1037,7 @@ xfs_dir2_sf_toino4(
              i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep),
                   oldsfep = dp->d_ops->sf_nextentry(oldsfp, oldsfep)) {
                 sfep->namelen = oldsfep->namelen;
-                sfep->offset = oldsfep->offset;
+                memcpy(sfep->offset, oldsfep->offset, sizeof(sfep->offset));
                 memcpy(sfep->name, oldsfep->name, sfep->namelen);
                 dp->d_ops->sf_put_ino(sfp, sfep,
                                       dp->d_ops->sf_get_ino(oldsfp, oldsfep));
@@ -1098,10 +1087,7 @@ xfs_dir2_sf_toino8(
         /*
          * Compute the new inode size (nb: entry count + 1 for parent)
          */
-        newsize =
-                oldsize +
-                (oldsfp->count + 1) *
-                ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t));
+        newsize = oldsize + (oldsfp->count + 1) * XFS_INO64_DIFF;
         xfs_idata_realloc(dp, -oldsize, XFS_DATA_FORK);
         xfs_idata_realloc(dp, newsize, XFS_DATA_FORK);
         /*
@@ -1124,7 +1110,7 @@ xfs_dir2_sf_toino8(
              i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep),
                   oldsfep = dp->d_ops->sf_nextentry(oldsfp, oldsfep)) {
                 sfep->namelen = oldsfep->namelen;
-                sfep->offset = oldsfep->offset;
+                memcpy(sfep->offset, oldsfep->offset, sizeof(sfep->offset));
                 memcpy(sfep->name, oldsfep->name, sfep->namelen);
                 dp->d_ops->sf_put_ino(sfp, sfep,
                                       dp->d_ops->sf_get_ino(oldsfp, oldsfep));
diff --git a/fs/xfs/xfs_linux.h b/fs/xfs/xfs_linux.h
index a8192dc797dc..b8d64d520e12 100644
--- a/fs/xfs/xfs_linux.h
+++ b/fs/xfs/xfs_linux.h
@@ -328,13 +328,6 @@ static inline __uint64_t howmany_64(__uint64_t x, __uint32_t y)
         return x;
 }
 
-/* ARM old ABI has some weird alignment/padding */
-#if defined(__arm__) && !defined(__ARM_EABI__)
-#define __arch_pack __attribute__((packed))
-#else
-#define __arch_pack
-#endif
-
 #define ASSERT_ALWAYS(expr)     \
         (unlikely(expr) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
 
diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
index 17ec0248f771..0cc8d8f74356 100644
--- a/fs/xfs/xfs_ondisk.h
+++ b/fs/xfs/xfs_ondisk.h
@@ -106,9 +106,6 @@ xfs_check_ondisk_structs(void)
         XFS_CHECK_OFFSET(xfs_dir2_data_unused_t, length,        2);
         XFS_CHECK_STRUCT_SIZE(xfs_dir2_free_hdr_t,              16);
         XFS_CHECK_STRUCT_SIZE(xfs_dir2_free_t,                  16);
-        XFS_CHECK_STRUCT_SIZE(xfs_dir2_ino4_t,                  4);
-        XFS_CHECK_STRUCT_SIZE(xfs_dir2_ino8_t,                  8);
-        XFS_CHECK_STRUCT_SIZE(xfs_dir2_inou_t,                  8);
         XFS_CHECK_STRUCT_SIZE(xfs_dir2_leaf_entry_t,            8);
         XFS_CHECK_STRUCT_SIZE(xfs_dir2_leaf_hdr_t,              16);
         XFS_CHECK_STRUCT_SIZE(xfs_dir2_leaf_t,                  16);
@@ -118,7 +115,6 @@ xfs_check_ondisk_structs(void)
         XFS_CHECK_OFFSET(xfs_dir2_sf_entry_t, offset,           1);
         XFS_CHECK_OFFSET(xfs_dir2_sf_entry_t, name,             3);
         XFS_CHECK_STRUCT_SIZE(xfs_dir2_sf_hdr_t,                10);
-        XFS_CHECK_STRUCT_SIZE(xfs_dir2_sf_off_t,                2);
 
         /* log structures */
         XFS_CHECK_STRUCT_SIZE(struct xfs_dq_logformat,          24);