Use segsum rather than separate dblock for youth in lafs_free_get

As segsum now always have a youthblk for ss==0, we don't need to
separately find a data block.

Signed-off-by: NeilBrown <neilb@suse.de>

diff --git a/segments.c b/segments.c
index 66d47eb9d26e1c8a21c6940148555941e364fa75..847c144c852f4f3b3d0c47f06b5c90279896817f 100644 (file)
--- a/segments.c
+++ b/segments.c
@@ -1062,10 +1062,9 @@ void lafs_free_get(struct fs *fs, unsigned int *dev, u32 *seg,
         * The youth value must have been zero, and we set it to the
         * current youth number.
         */
-       struct datablock *db = NULL;
        u16 *youthp;
        struct segstat *ss;
-       struct segsum *ssum;
+       struct segsum *ssum = NULL;
        int ssnum;
 
        BUG_ON(nonlogged); // FIXME should handle this case, not ignore it
@@ -1091,24 +1090,22 @@ again:
         * updates to the Youth block.
         */
        if (!test_bit(FinalCheckpoint, &fs->fsstate) &&
-           !(db &&
-             db->b.inode == fs->devs[*dev].segsum &&
-             db->b.fileaddr == ((*seg) >> (fs->blocksize_bits
-                                           - 1)))) {
+           !(ssum &&
+             ssum->devnum == ss->dev &&
+             ssum->segnum == ss->segment)) {
                spin_unlock(&fs->lock);
-               if (db)
-                       putdref(db, MKREF(youth));
-
-               db = lafs_get_block(fs->devs[*dev].segsum,
-                                   (*seg) >> (fs->blocksize_bits
-                                              - 1),
-                                   NULL, GFP_KERNEL,
-                                   MKREF(youth));
+               if (ssum)
+                       ss_put(ssum, fs);
+
+               ssum = segsum_find(fs, ss->segment, ss->dev, 0);
                /* As we hold a ref on youth block for anything in the
                 * table, and that block was loaded at the time, it must
                 * still be valid.
                 */
-               BUG_ON(!test_bit(B_Valid, &db->b.flags));
+               BUG_ON(!ssum || !ssum->youthblk);
+               BUG_ON(!test_bit(B_Valid, &ssum->youthblk->b.flags));
+               set_bit(B_PinPending, &ssum->youthblk->b.flags);
+               lafs_pin_dblock(ssum->youthblk, AccountSpace);
                goto again;
        }
        /* HACK youth_next should always be at least 0x8000 so that
@@ -1119,12 +1116,12 @@ again:
        if (fs->youth_next < 0x8000)
                fs->youth_next = 0x8000;
 
-       if (db && test_bit(FinalCheckpoint, &fs->fsstate)) {
-               putdref(db, MKREF(youth));
-               db = NULL;
+       if (ssum && test_bit(FinalCheckpoint, &fs->fsstate)) {
+               ss_put(ssum, fs);
+               ssum = NULL;
        }
 
-       if (db) {
+       if (ssum) {
                u16 y = fs->youth_next;
                if (fs->scan.do_decay &&
                    (fs->scan.free_dev < ss->dev
@@ -1134,11 +1131,12 @@ again:
                            ))
                        /* Haven't decayed this block yet - revert decay */
                        y = decay_undo(y);
-               youthp = map_dblock(db);
+               youthp = map_dblock(ssum->youthblk);
                youthp[(*seg) & ((1 << (fs->blocksize_bits
                                        - 1)) - 1)]
                        = cpu_to_le16(y);
-               unmap_dblock(db, youthp);
+               unmap_dblock(ssum->youthblk, youthp);
+               lafs_dirty_dblock(ssum->youthblk);
        }
        fs->youth_next++;
 
@@ -1161,20 +1159,15 @@ again:
                        /* ?? what do I need to release etc */
                        /* Maybe this cannot fail because we own references
                         * to the two blocks !! */
-                       LAFS_BUG(1, db ? &db->b : NULL);
+                       LAFS_BUG(1, NULL);
                lafs_checkpoint_lock(fs);
                set_bit(B_PinPending, &ssum->ssblk->b.flags);
                (void)lafs_pin_dblock(ssum->ssblk, AccountSpace);
-               if (ssnum == 0) {
-                       set_bit(B_PinPending, &ssum->youthblk->b.flags);
-                       (void)lafs_pin_dblock(ssum->youthblk, AccountSpace);
-               }
                lafs_checkpoint_unlock(fs);
        }
-       if (db) {
-               lafs_dirty_dblock(db);
-               putdref(db, MKREF(youth));
-       }
+       if (ssum)
+               ss_put(ssum, fs);
+
        dprintk("NEXT segment found %d/%d youth %d\n",
                *dev, *seg, fs->youth_next - 1);
        /* Note that we return an implicit reference to the ssum */