xfs: vectorise directory data operations part 2

Convert the rest of the directory data block encode/decode
operations to vector format.

This further reduces the size of the built binary:

   text    data     bss     dec     hex filename
 794490   96802    1096  892388   d9de4 fs/xfs/xfs.o.orig
 792986   96802    1096  890884   d9804 fs/xfs/xfs.o.p1
 792350   96802    1096  890248   d9588 fs/xfs/xfs.o.p2
 789293   96802    1096  887191   d8997 fs/xfs/xfs.o.p3
 789005   96802    1096  886903   d8997 fs/xfs/xfs.o.p4

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Ben Myers <bpm@sgi.com>

1 files changed, 57 insertions, 49 deletions

diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c
index 00006b3db054..13fa0d6b4ff7 100644
--- a/fs/xfs/xfs_dir2_data.c
+++ b/fs/xfs/xfs_dir2_data.c
@@ -66,8 +66,6 @@ __xfs_dir3_data_check(
 
         mp = bp->b_target->bt_mount;
         hdr = bp->b_addr;
-        bf = xfs_dir3_data_bestfree_p(hdr);
-        p = (char *)xfs_dir3_data_entry_p(hdr);
 
         /*
          * We can be passed a null dp here from a verifier, so manually
@@ -97,6 +95,8 @@ __xfs_dir3_data_check(
                 XFS_ERROR_REPORT("Bad Magic", XFS_ERRLEVEL_LOW, mp);
                 return EFSCORRUPTED;
         }
+        bf = ops->data_bestfree_p(hdr);
+        p = (char *)ops->data_entry_p(hdr);
 
         count = lastfree = freeseen = 0;
         /*
@@ -134,7 +134,7 @@ __xfs_dir3_data_check(
                         XFS_WANT_CORRUPTED_RETURN(
                                 be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)) ==
                                                (char *)dup - (char *)hdr);
-                        dfp = xfs_dir2_data_freefind(hdr, dup);
+                        dfp = xfs_dir2_data_freefind(hdr, bf, dup);
                         if (dfp) {
                                 i = (int)(dfp - bf);
                                 XFS_WANT_CORRUPTED_RETURN(
@@ -340,19 +340,18 @@ xfs_dir3_data_readahead(
  */
 xfs_dir2_data_free_t *
 xfs_dir2_data_freefind(
-        xfs_dir2_data_hdr_t     *hdr,           /* data block */
-        xfs_dir2_data_unused_t  *dup)           /* data unused entry */
+        struct xfs_dir2_data_hdr *hdr,          /* data block header */
+        struct xfs_dir2_data_free *bf,          /* bestfree table pointer */
+        struct xfs_dir2_data_unused *dup)       /* unused space */
 {
         xfs_dir2_data_free_t    *dfp;           /* bestfree entry */
         xfs_dir2_data_aoff_t    off;            /* offset value needed */
-        struct xfs_dir2_data_free *bf;
 #ifdef DEBUG
         int                     matched;        /* matched the value */
         int                     seenzero;       /* saw a 0 bestfree entry */
 #endif
 
         off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr);
-        bf = xfs_dir3_data_bestfree_p(hdr);
 
 #ifdef DEBUG
         /*
@@ -412,11 +411,11 @@ xfs_dir2_data_freefind(
  */
 xfs_dir2_data_free_t *                          /* entry inserted */
 xfs_dir2_data_freeinsert(
-        xfs_dir2_data_hdr_t     *hdr,           /* data block pointer */
-        xfs_dir2_data_unused_t  *dup,           /* unused space */
+        struct xfs_dir2_data_hdr *hdr,          /* data block pointer */
+        struct xfs_dir2_data_free *dfp,         /* bestfree table pointer */
+        struct xfs_dir2_data_unused *dup,       /* unused space */
         int                     *loghead)       /* log the data header (out) */
 {
-        xfs_dir2_data_free_t    *dfp;           /* bestfree table pointer */
         xfs_dir2_data_free_t    new;            /* new bestfree entry */
 
         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
@@ -424,7 +423,6 @@ xfs_dir2_data_freeinsert(
                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 
-        dfp = xfs_dir3_data_bestfree_p(hdr);
         new.length = dup->length;
         new.offset = cpu_to_be16((char *)dup - (char *)hdr);
 
@@ -457,11 +455,11 @@ xfs_dir2_data_freeinsert(
  */
 STATIC void
 xfs_dir2_data_freeremove(
-        xfs_dir2_data_hdr_t     *hdr,           /* data block header */
-        xfs_dir2_data_free_t    *dfp,           /* bestfree entry pointer */
+        struct xfs_dir2_data_hdr *hdr,          /* data block header */
+        struct xfs_dir2_data_free *bf,          /* bestfree table pointer */
+        struct xfs_dir2_data_free *dfp,         /* bestfree entry pointer */
         int                     *loghead)       /* out: log data header */
 {
-        struct xfs_dir2_data_free *bf;
 
         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
@@ -471,7 +469,6 @@ xfs_dir2_data_freeremove(
         /*
          * It's the first entry, slide the next 2 up.
          */
-        bf = xfs_dir3_data_bestfree_p(hdr);
         if (dfp == &bf[0]) {
                 bf[0] = bf[1];
                 bf[1] = bf[2];
@@ -518,13 +515,13 @@ xfs_dir2_data_freescan(
         /*
          * Start by clearing the table.
          */
-        bf = xfs_dir3_data_bestfree_p(hdr);
+        bf = dp->d_ops->data_bestfree_p(hdr);
         memset(bf, 0, sizeof(*bf) * XFS_DIR2_DATA_FD_COUNT);
         *loghead = 1;
         /*
          * Set up pointers.
          */
-        p = (char *)xfs_dir3_data_entry_p(hdr);
+        p = (char *)dp->d_ops->data_entry_p(hdr);
         if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
             hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
                 btp = xfs_dir2_block_tail_p(dp->i_mount, hdr);
@@ -542,7 +539,7 @@ xfs_dir2_data_freescan(
                 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
                         ASSERT((char *)dup - (char *)hdr ==
                                be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
-                        xfs_dir2_data_freeinsert(hdr, dup, loghead);
+                        xfs_dir2_data_freeinsert(hdr, bf, dup, loghead);
                         p += be16_to_cpu(dup->length);
                 }
                 /*
@@ -607,8 +604,8 @@ xfs_dir3_data_init(
         } else
                 hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
 
-        bf = xfs_dir3_data_bestfree_p(hdr);
-        bf[0].offset = cpu_to_be16(xfs_dir3_data_entry_offset(hdr));
+        bf = dp->d_ops->data_bestfree_p(hdr);
+        bf[0].offset = cpu_to_be16(dp->d_ops->data_entry_offset());
         for (i = 1; i < XFS_DIR2_DATA_FD_COUNT; i++) {
                 bf[i].length = 0;
                 bf[i].offset = 0;
@@ -617,17 +614,17 @@ xfs_dir3_data_init(
         /*
          * Set up an unused entry for the block's body.
          */
-        dup = xfs_dir3_data_unused_p(hdr);
+        dup = dp->d_ops->data_unused_p(hdr);
         dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
 
-        t = mp->m_dirblksize - (uint)xfs_dir3_data_entry_offset(hdr);
+        t = mp->m_dirblksize - (uint)dp->d_ops->data_entry_offset();
         bf[0].length = cpu_to_be16(t);
         dup->length = cpu_to_be16(t);
         *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16((char *)dup - (char *)hdr);
         /*
          * Log it and return it.
          */
-        xfs_dir2_data_log_header(tp, bp);
+        xfs_dir2_data_log_header(tp, dp, bp);
         xfs_dir2_data_log_unused(tp, bp, dup);
         *bpp = bp;
         return 0;
@@ -661,16 +658,19 @@ xfs_dir2_data_log_entry(
 void
 xfs_dir2_data_log_header(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp)
 {
-        xfs_dir2_data_hdr_t     *hdr = bp->b_addr;
+#ifdef DEBUG
+        struct xfs_dir2_data_hdr *hdr = bp->b_addr;
 
         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
+#endif
 
-        xfs_trans_log_buf(tp, bp, 0, xfs_dir3_data_entry_offset(hdr) - 1);
+        xfs_trans_log_buf(tp, bp, 0, dp->d_ops->data_entry_offset() - 1);
 }
 
 /*
@@ -711,6 +711,7 @@ xfs_dir2_data_log_unused(
 void
 xfs_dir2_data_make_free(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp,
         xfs_dir2_data_aoff_t    offset,         /* starting byte offset */
         xfs_dir2_data_aoff_t    len,            /* length in bytes */
@@ -748,7 +749,7 @@ xfs_dir2_data_make_free(
          * If this isn't the start of the block, then back up to
          * the previous entry and see if it's free.
          */
-        if (offset > xfs_dir3_data_entry_offset(hdr)) {
+        if (offset > dp->d_ops->data_entry_offset()) {
                 __be16                  *tagp;  /* tag just before us */
 
                 tagp = (__be16 *)((char *)hdr + offset) - 1;
@@ -774,15 +775,15 @@ xfs_dir2_data_make_free(
          * Previous and following entries are both free,
          * merge everything into a single free entry.
          */
-        bf = xfs_dir3_data_bestfree_p(hdr);
+        bf = dp->d_ops->data_bestfree_p(hdr);
         if (prevdup && postdup) {
                 xfs_dir2_data_free_t    *dfp2;  /* another bestfree pointer */
 
                 /*
                  * See if prevdup and/or postdup are in bestfree table.
                  */
-                dfp = xfs_dir2_data_freefind(hdr, prevdup);
-                dfp2 = xfs_dir2_data_freefind(hdr, postdup);
+                dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
+                dfp2 = xfs_dir2_data_freefind(hdr, bf, postdup);
                 /*
                  * We need a rescan unless there are exactly 2 free entries
                  * namely our two.  Then we know what's happening, otherwise
@@ -810,12 +811,13 @@ xfs_dir2_data_make_free(
                                 ASSERT(dfp2 == dfp);
                                 dfp2 = &bf[1];
                         }
-                        xfs_dir2_data_freeremove(hdr, dfp2, needlogp);
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp2, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
                         /*
                          * Now insert the new entry.
                          */
-                        dfp = xfs_dir2_data_freeinsert(hdr, prevdup, needlogp);
+                        dfp = xfs_dir2_data_freeinsert(hdr, bf, prevdup,
+                                                       needlogp);
                         ASSERT(dfp == &bf[0]);
                         ASSERT(dfp->length == prevdup->length);
                         ASSERT(!dfp[1].length);
@@ -826,7 +828,7 @@ xfs_dir2_data_make_free(
          * The entry before us is free, merge with it.
          */
         else if (prevdup) {
-                dfp = xfs_dir2_data_freefind(hdr, prevdup);
+                dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
                 be16_add_cpu(&prevdup->length, len);
                 *xfs_dir2_data_unused_tag_p(prevdup) =
                         cpu_to_be16((char *)prevdup - (char *)hdr);
@@ -837,8 +839,8 @@ xfs_dir2_data_make_free(
                  * the old one and add the new one.
                  */
                 if (dfp) {
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                        xfs_dir2_data_freeinsert(hdr, prevdup, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
+                        xfs_dir2_data_freeinsert(hdr, bf, prevdup, needlogp);
                 }
                 /*
                  * Otherwise we need a scan if the new entry is big enough.
@@ -852,7 +854,7 @@ xfs_dir2_data_make_free(
          * The following entry is free, merge with it.
          */
         else if (postdup) {
-                dfp = xfs_dir2_data_freefind(hdr, postdup);
+                dfp = xfs_dir2_data_freefind(hdr, bf, postdup);
                 newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
                 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
                 newdup->length = cpu_to_be16(len + be16_to_cpu(postdup->length));
@@ -865,8 +867,8 @@ xfs_dir2_data_make_free(
                  * the old one and add the new one.
                  */
                 if (dfp) {
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                        xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
+                        xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
                 }
                 /*
                  * Otherwise we need a scan if the new entry is big enough.
@@ -886,7 +888,7 @@ xfs_dir2_data_make_free(
                 *xfs_dir2_data_unused_tag_p(newdup) =
                         cpu_to_be16((char *)newdup - (char *)hdr);
                 xfs_dir2_data_log_unused(tp, bp, newdup);
-                xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
+                xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
         }
         *needscanp = needscan;
 }
@@ -897,6 +899,7 @@ xfs_dir2_data_make_free(
 void
 xfs_dir2_data_use_free(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp,
         xfs_dir2_data_unused_t  *dup,           /* unused entry */
         xfs_dir2_data_aoff_t    offset,         /* starting offset to use */
@@ -926,9 +929,9 @@ xfs_dir2_data_use_free(
         /*
          * Look up the entry in the bestfree table.
          */
-        dfp = xfs_dir2_data_freefind(hdr, dup);
         oldlen = be16_to_cpu(dup->length);
-        bf = xfs_dir3_data_bestfree_p(hdr);
+        bf = dp->d_ops->data_bestfree_p(hdr);
+        dfp = xfs_dir2_data_freefind(hdr, bf, dup);
         ASSERT(dfp || oldlen <= be16_to_cpu(bf[2].length));
         /*
          * Check for alignment with front and back of the entry.
@@ -945,7 +948,8 @@ xfs_dir2_data_use_free(
                 if (dfp) {
                         needscan = (bf[2].offset != 0);
                         if (!needscan)
-                                xfs_dir2_data_freeremove(hdr, dfp, needlogp);
+                                xfs_dir2_data_freeremove(hdr, bf, dfp,
+                                                         needlogp);
                 }
         }
         /*
@@ -963,8 +967,9 @@ xfs_dir2_data_use_free(
                  * If it was in the table, remove it and add the new one.
                  */
                 if (dfp) {
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                        dfp = xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
+                        dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
+                                                       needlogp);
                         ASSERT(dfp != NULL);
                         ASSERT(dfp->length == newdup->length);
                         ASSERT(be16_to_cpu(dfp->offset) == (char *)newdup - (char *)hdr);
@@ -990,8 +995,9 @@ xfs_dir2_data_use_free(
                  * If it was in the table, remove it and add the new one.
                  */
                 if (dfp) {
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                        dfp = xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
+                        dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
+                                                       needlogp);
                         ASSERT(dfp != NULL);
                         ASSERT(dfp->length == newdup->length);
                         ASSERT(be16_to_cpu(dfp->offset) == (char *)newdup - (char *)hdr);
@@ -1030,9 +1036,11 @@ xfs_dir2_data_use_free(
                 if (dfp) {
                         needscan = (bf[2].length != 0);
                         if (!needscan) {
-                                xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                                xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
-                                xfs_dir2_data_freeinsert(hdr, newdup2,
+                                xfs_dir2_data_freeremove(hdr, bf, dfp,
+                                                         needlogp);
+                                xfs_dir2_data_freeinsert(hdr, bf, newdup,
+                                                         needlogp);
+                                xfs_dir2_data_freeinsert(hdr, bf, newdup2,
                                                          needlogp);
                         }
                 }