xfs
[Top] [All Lists]

[PATCH 13/27] xfs: factor out xfs_dir2_leaf_find_entry

To: xfs@xxxxxxxxxxx
Subject: [PATCH 13/27] xfs: factor out xfs_dir2_leaf_find_entry
From: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date: Wed, 29 Jun 2011 10:01:22 -0400
References: <20110629140109.003209430@xxxxxxxxxxxxxxxxxxxxxx>
User-agent: quilt/0.48-1
Add a new xfs_dir2_leaf_find_entry helper to factor out some duplicate code
from xfs_dir2_leaf_addname xfs_dir2_leafn_add.  Found by Eric Sandeen using
an automated code duplication checked.

Signed-off-by: Christoph Hellwig <hch@xxxxxx>

Index: xfs/fs/xfs/xfs_dir2_leaf.c
===================================================================
--- xfs.orig/fs/xfs/xfs_dir2_leaf.c     2011-06-22 21:56:26.102462981 +0200
+++ xfs/fs/xfs/xfs_dir2_leaf.c  2011-06-23 12:41:51.716439911 +0200
@@ -152,6 +152,118 @@ xfs_dir2_block_to_leaf(
        return 0;
 }
 
+xfs_dir2_leaf_entry_t *
+xfs_dir2_leaf_find_entry(
+       xfs_dir2_leaf_t         *leaf,          /* leaf structure */
+       int                     index,          /* leaf table position */
+       int                     compact,        /* need to compact leaves */
+       int                     lowstale,       /* index of prev stale leaf */
+       int                     highstale,      /* index of next stale leaf */
+       int                     *lfloglow,      /* low leaf logging index */
+       int                     *lfloghigh)     /* high leaf logging index */
+{
+       xfs_dir2_leaf_entry_t   *lep;           /* leaf entry table pointer */
+
+       if (!leaf->hdr.stale) {
+               /*
+                * Now we need to make room to insert the leaf entry.
+                *
+                * If there are no stale entries, just insert a hole at index.
+                */
+               lep = &leaf->ents[index];
+               if (index < be16_to_cpu(leaf->hdr.count))
+                       memmove(lep + 1, lep,
+                               (be16_to_cpu(leaf->hdr.count) - index) *
+                                sizeof(*lep));
+
+               /*
+                * Record low and high logging indices for the leaf.
+                */
+               *lfloglow = index;
+               *lfloghigh = be16_to_cpu(leaf->hdr.count);
+               be16_add_cpu(&leaf->hdr.count, 1);
+       } else {
+               /*
+                * There are stale entries.
+                *
+                * We will use one of them for the new entry.  It's probably
+                * not at the right location, so we'll have to shift some up
+                * or down first.
+                *
+                * If we didn't compact before, we need to find the nearest
+                * stale entries before and after our insertion point.
+                */
+               if (compact == 0) {
+                       /*
+                        * Find the first stale entry before the insertion
+                        * point, if any.
+                        */
+                       for (lowstale = index - 1;
+                            lowstale >= 0 &&
+                               be32_to_cpu(leaf->ents[lowstale].address) !=
+                               XFS_DIR2_NULL_DATAPTR;
+                            lowstale--)
+                               continue;
+                       /*
+                        * Find the next stale entry at or after the insertion
+                        * point, if any.   Stop if we go so far that the
+                        * lowstale entry would be better.
+                        */
+                       for (highstale = index;
+                            highstale < be16_to_cpu(leaf->hdr.count) &&
+                               be32_to_cpu(leaf->ents[highstale].address) !=
+                               XFS_DIR2_NULL_DATAPTR &&
+                               (lowstale < 0 ||
+                                index - lowstale - 1 >= highstale - index);
+                            highstale++)
+                               continue;
+               }
+               /*
+                * If the low one is better, use it.
+                */
+               if (lowstale >= 0 &&
+                   (highstale == be16_to_cpu(leaf->hdr.count) ||
+                    index - lowstale - 1 < highstale - index)) {
+                       ASSERT(index - lowstale - 1 >= 0);
+                       ASSERT(be32_to_cpu(leaf->ents[lowstale].address) ==
+                              XFS_DIR2_NULL_DATAPTR);
+                       /*
+                        * Copy entries up to cover the stale entry
+                        * and make room for the new entry.
+                        */
+                       if (index - lowstale - 1 > 0)
+                               memmove(&leaf->ents[lowstale],
+                                       &leaf->ents[lowstale + 1],
+                                       (index - lowstale - 1) * sizeof(*lep));
+                       lep = &leaf->ents[index - 1];
+                       *lfloglow = MIN(lowstale, *lfloglow);
+                       *lfloghigh = MAX(index - 1, *lfloghigh);
+
+               /*
+                * The high one is better, so use that one.
+                */
+               } else {
+                       ASSERT(highstale - index >= 0);
+                       ASSERT(be32_to_cpu(leaf->ents[highstale].address) ==
+                              XFS_DIR2_NULL_DATAPTR);
+                       /*
+                        * Copy entries down to cover the stale entry
+                        * and make room for the new entry.
+                        */
+                       if (highstale - index > 0)
+                               memmove(&leaf->ents[index + 1],
+                                       &leaf->ents[index],
+                                       (highstale - index) * sizeof(*lep));
+                       lep = &leaf->ents[index];
+                       *lfloglow = MIN(index, *lfloglow);
+                       *lfloghigh = MAX(highstale, *lfloghigh);
+               }
+               be16_add_cpu(&leaf->hdr.stale, -1);
+       }
+
+       return lep;
+}
+
 /*
  * Add an entry to a leaf form directory.
  */
@@ -430,102 +542,11 @@ xfs_dir2_leaf_addname(
                if (!grown)
                        xfs_dir2_leaf_log_bests(tp, lbp, use_block, use_block);
        }
-       /*
-        * Now we need to make room to insert the leaf entry.
-        * If there are no stale entries, we just insert a hole at index.
-        */
-       if (!leaf->hdr.stale) {
-               /*
-                * lep is still good as the index leaf entry.
-                */
-               if (index < be16_to_cpu(leaf->hdr.count))
-                       memmove(lep + 1, lep,
-                               (be16_to_cpu(leaf->hdr.count) - index) * 
sizeof(*lep));
-               /*
-                * Record low and high logging indices for the leaf.
-                */
-               lfloglow = index;
-               lfloghigh = be16_to_cpu(leaf->hdr.count);
-               be16_add_cpu(&leaf->hdr.count, 1);
-       }
-       /*
-        * There are stale entries.
-        * We will use one of them for the new entry.
-        * It's probably not at the right location, so we'll have to
-        * shift some up or down first.
-        */
-       else {
-               /*
-                * If we didn't compact before, we need to find the nearest
-                * stale entries before and after our insertion point.
-                */
-               if (compact == 0) {
-                       /*
-                        * Find the first stale entry before the insertion
-                        * point, if any.
-                        */
-                       for (lowstale = index - 1;
-                            lowstale >= 0 &&
-                               be32_to_cpu(leaf->ents[lowstale].address) !=
-                               XFS_DIR2_NULL_DATAPTR;
-                            lowstale--)
-                               continue;
-                       /*
-                        * Find the next stale entry at or after the insertion
-                        * point, if any.   Stop if we go so far that the
-                        * lowstale entry would be better.
-                        */
-                       for (highstale = index;
-                            highstale < be16_to_cpu(leaf->hdr.count) &&
-                               be32_to_cpu(leaf->ents[highstale].address) !=
-                               XFS_DIR2_NULL_DATAPTR &&
-                               (lowstale < 0 ||
-                                index - lowstale - 1 >= highstale - index);
-                            highstale++)
-                               continue;
-               }
-               /*
-                * If the low one is better, use it.
-                */
-               if (lowstale >= 0 &&
-                   (highstale == be16_to_cpu(leaf->hdr.count) ||
-                    index - lowstale - 1 < highstale - index)) {
-                       ASSERT(index - lowstale - 1 >= 0);
-                       ASSERT(be32_to_cpu(leaf->ents[lowstale].address) ==
-                              XFS_DIR2_NULL_DATAPTR);
-                       /*
-                        * Copy entries up to cover the stale entry
-                        * and make room for the new entry.
-                        */
-                       if (index - lowstale - 1 > 0)
-                               memmove(&leaf->ents[lowstale],
-                                       &leaf->ents[lowstale + 1],
-                                       (index - lowstale - 1) * sizeof(*lep));
-                       lep = &leaf->ents[index - 1];
-                       lfloglow = MIN(lowstale, lfloglow);
-                       lfloghigh = MAX(index - 1, lfloghigh);
-               }
-               /*
-                * The high one is better, so use that one.
-                */
-               else {
-                       ASSERT(highstale - index >= 0);
-                       ASSERT(be32_to_cpu(leaf->ents[highstale].address) ==
-                              XFS_DIR2_NULL_DATAPTR);
-                       /*
-                        * Copy entries down to cover the stale entry
-                        * and make room for the new entry.
-                        */
-                       if (highstale - index > 0)
-                               memmove(&leaf->ents[index + 1],
-                                       &leaf->ents[index],
-                                       (highstale - index) * sizeof(*lep));
-                       lep = &leaf->ents[index];
-                       lfloglow = MIN(index, lfloglow);
-                       lfloghigh = MAX(highstale, lfloghigh);
-               }
-               be16_add_cpu(&leaf->hdr.stale, -1);
-       }
+
+
+       lep = xfs_dir2_leaf_find_entry(leaf, index, compact, lowstale,
+                                      highstale, &lfloglow, &lfloghigh);
+
        /*
         * Fill in the new leaf entry.
         */
Index: xfs/fs/xfs/xfs_dir2_leaf.h
===================================================================
--- xfs.orig/fs/xfs/xfs_dir2_leaf.h     2011-06-22 21:56:26.119129649 +0200
+++ xfs/fs/xfs/xfs_dir2_leaf.h  2011-06-23 12:40:42.889776728 +0200
@@ -248,6 +248,9 @@ extern int xfs_dir2_leaf_search_hash(str
                                     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 xfs_dir2_leaf_entry_t *xfs_dir2_leaf_find_entry(xfs_dir2_leaf_t *, int,
+                                                      int, int, int,
+                                                      int *, int *);
 extern int xfs_dir2_node_to_leaf(struct xfs_da_state *state);
 
 #endif /* __XFS_DIR2_LEAF_H__ */
Index: xfs/fs/xfs/xfs_dir2_node.c
===================================================================
--- xfs.orig/fs/xfs/xfs_dir2_node.c     2011-06-22 21:56:26.089129649 +0200
+++ xfs/fs/xfs/xfs_dir2_node.c  2011-06-23 12:40:42.919776727 +0200
@@ -244,89 +244,14 @@ xfs_dir2_leafn_add(
                lfloglow = be16_to_cpu(leaf->hdr.count);
                lfloghigh = -1;
        }
-       /*
-        * No stale entries, just insert a space for the new entry.
-        */
-       if (!leaf->hdr.stale) {
-               lep = &leaf->ents[index];
-               if (index < be16_to_cpu(leaf->hdr.count))
-                       memmove(lep + 1, lep,
-                               (be16_to_cpu(leaf->hdr.count) - index) * 
sizeof(*lep));
-               lfloglow = index;
-               lfloghigh = be16_to_cpu(leaf->hdr.count);
-               be16_add_cpu(&leaf->hdr.count, 1);
-       }
-       /*
-        * There are stale entries.  We'll use one for the new entry.
-        */
-       else {
-               /*
-                * If we didn't do a compact then we need to figure out
-                * which stale entry will be used.
-                */
-               if (compact == 0) {
-                       /*
-                        * Find first stale entry before our insertion point.
-                        */
-                       for (lowstale = index - 1;
-                            lowstale >= 0 &&
-                               be32_to_cpu(leaf->ents[lowstale].address) !=
-                               XFS_DIR2_NULL_DATAPTR;
-                            lowstale--)
-                               continue;
-                       /*
-                        * Find next stale entry after insertion point.
-                        * Stop looking if the answer would be worse than
-                        * lowstale already found.
-                        */
-                       for (highstale = index;
-                            highstale < be16_to_cpu(leaf->hdr.count) &&
-                               be32_to_cpu(leaf->ents[highstale].address) !=
-                               XFS_DIR2_NULL_DATAPTR &&
-                               (lowstale < 0 ||
-                                index - lowstale - 1 >= highstale - index);
-                            highstale++)
-                               continue;
-               }
-               /*
-                * Using the low stale entry.
-                * Shift entries up toward the stale slot.
-                */
-               if (lowstale >= 0 &&
-                   (highstale == be16_to_cpu(leaf->hdr.count) ||
-                    index - lowstale - 1 < highstale - index)) {
-                       ASSERT(be32_to_cpu(leaf->ents[lowstale].address) ==
-                              XFS_DIR2_NULL_DATAPTR);
-                       ASSERT(index - lowstale - 1 >= 0);
-                       if (index - lowstale - 1 > 0)
-                               memmove(&leaf->ents[lowstale],
-                                       &leaf->ents[lowstale + 1],
-                                       (index - lowstale - 1) * sizeof(*lep));
-                       lep = &leaf->ents[index - 1];
-                       lfloglow = MIN(lowstale, lfloglow);
-                       lfloghigh = MAX(index - 1, lfloghigh);
-               }
-               /*
-                * Using the high stale entry.
-                * Shift entries down toward the stale slot.
-                */
-               else {
-                       ASSERT(be32_to_cpu(leaf->ents[highstale].address) ==
-                              XFS_DIR2_NULL_DATAPTR);
-                       ASSERT(highstale - index >= 0);
-                       if (highstale - index > 0)
-                               memmove(&leaf->ents[index + 1],
-                                       &leaf->ents[index],
-                                       (highstale - index) * sizeof(*lep));
-                       lep = &leaf->ents[index];
-                       lfloglow = MIN(index, lfloglow);
-                       lfloghigh = MAX(highstale, lfloghigh);
-               }
-               be16_add_cpu(&leaf->hdr.stale, -1);
-       }
+
+
        /*
         * Insert the new entry, log everything.
         */
+       lep = xfs_dir2_leaf_find_entry(leaf, index, compact, lowstale,
+                                      highstale, &lfloglow, &lfloghigh);
+
        lep->hashval = cpu_to_be32(args->hashval);
        lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(mp,
                                args->blkno, args->index));

<Prev in Thread] Current Thread [Next in Thread>