Assorted changes to scheduling

and a few 'trace' changes.
This seems to make checkpoint and flush both work properly.

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

diff --git a/lib/internal.h b/lib/internal.h
index ae238fa7ba839c6c611df8bcd7e17f487bd91fc6..97d2cdf4ddc8406680954efe5012fd63fdd3546a 100644 (file)
--- a/lib/internal.h
+++ b/lib/internal.h
@@ -20,7 +20,7 @@ de_sched(struct lafs_blk *b)
 
        if (b->parent) {
                struct lafs_iblk *p = b->parent;
-               trace(2,"ds %d/%lld %d\n", p->b.ino->inum, (long long)p->b.fileaddr,
+               trace(2,"desched %d/%lld %d/%lld %d\n", b->ino->inum, (long long)b->fileaddr, p->b.ino->inum, (long long)p->b.fileaddr,
                      p->sched_cnt);
                p->sched_cnt--;
                if (p->sched_cnt == 0)

diff --git a/lib/lafs_allocated_block.c b/lib/lafs_allocated_block.c
index 2d358bea33271b5ac51fa3c59501e47cf00482b7..3ab2c42ca94111c188622587f3ef544d5f81b077 100644 (file)
--- a/lib/lafs_allocated_block.c
+++ b/lib/lafs_allocated_block.c
@@ -39,6 +39,7 @@ void lafs_allocated_block(struct lafs_blk *b, loff_t addr)
                b->flags |= B_Uninc;
                b->chain = p->uninc;
                p->uninc = b;
+               lafs_sched_blk(&p->b);
        }
 }
 

diff --git a/lib/lafs_checkpoint.c b/lib/lafs_checkpoint.c
index 8633b2f032b1237797036d33df435d28eb3f40c6..0e1a64a7bb23df213c546e2ea88049d491b0bfc0 100644 (file)
--- a/lib/lafs_checkpoint.c
+++ b/lib/lafs_checkpoint.c
@@ -20,14 +20,17 @@ int lafs_checkpoint(struct lafs *fs)
                        b = list_first_entry(&fs->leafs,
                                             struct lafs_blk,
                                             leafs);
-                       trace(1, "checkpoint %p %d/%lld %s %p\n", b, b->ino->inum,
+                       trace(1, "checkpoint %p %d/%lld %s-%d %p\n", b, b->ino->inum,
                              (long long)b->fileaddr,
-                             (b->flags & B_Index) ? "index":"data", b->parent);
+                             (b->flags & B_Index) ? "index":"data",
+                             (b->flags & B_Index) ? iblk(b)->sched_cnt:0,
+                             b->parent);
                        list_del_init(&b->leafs);
                        if (!(b->flags & B_Index)) {
                                struct lafs_dblk *db = dblk(b);
                                if (b->ino->type == TypeSegmentMap) {
-                                       /* Allow parents to be processed, but freeze this */
+                                       /* Allow parents to be processed,
+                                        * but freeze this */
                                        de_sched(b); b->flags |= B_Sched;
                                        list_add(&b->leafs, &fs->account_leafs);
                                        continue;
@@ -35,26 +38,33 @@ int lafs_checkpoint(struct lafs *fs)
                                if (b->ino->type == TypeInodeFile &&
                                    db->my_inode &&
                                    db->my_inode->iblock &&
-                                   db->my_inode->iblock->sched_cnt) {
-                                       de_sched(b);
+                                   db->my_inode->iblock->sched_cnt)
+                                       /* Wait for InoIdx block to be ready */
                                        continue;
-                               }
                        }
 
                        if (b->flags & B_Index) {
                                struct lafs_iblk *ib = iblk(b);
-                               if (ib->sched_cnt) {
-                                       de_sched(b);
+                               if (ib->sched_cnt)
+                                       /* Not ready yet, leave it off the list */
                                        continue;
-                               }
+
                                if (ib->uninc) {
-                                       de_sched(b);
                                        lafs_incorporate(ib);
-                                       if (!(ib->b.flags & B_Sched))
+                                       if (list_empty(&ib->b.leafs))
                                                abort();
                                        /* We'll pick it up next time 'round */
                                        continue;
                                }
+                               if (b->flags & B_InoIdx) {
+                                       /* InoIdx block is ready, so process
+                                        * the data block.
+                                        */
+                                       de_sched(b);
+                                       b->flags &= ~B_Dirty;
+                                       b = &b->ino->dblock->b;
+                                       b->flags |= B_Dirty;
+                               }
                        }
                        if (b->flags & B_Dirty) {
                                trace(2, "...alloc\n");

diff --git a/lib/lafs_cluster_allocate.c b/lib/lafs_cluster_allocate.c
index 3e5e627449ca1a1c63ce58843f0ae42b271322fd..1b3251ecb461e1e0a7b5482e9d5d7c3e5c7a59cf 100644 (file)
--- a/lib/lafs_cluster_allocate.c
+++ b/lib/lafs_cluster_allocate.c
@@ -44,5 +44,5 @@ void lafs_cluster_allocate(struct lafs_blk *b, int cnum)
                        abort();
        }
        wc->remaining--;
-       list_add_tail(&b->leafs, &wc->blocks);
+       list_move_tail(&b->leafs, &wc->blocks);
 }

diff --git a/lib/lafs_inode_fillblock.c b/lib/lafs_inode_fillblock.c
index ec1aabc1d4d9b031fea00a3dabbd635f2d342625..9887aa493823524621bbfa771d92bad5e340064b 100644 (file)
--- a/lib/lafs_inode_fillblock.c
+++ b/lib/lafs_inode_fillblock.c
@@ -22,7 +22,7 @@ void lafs_inode_fillblock(struct lafs_ino *ino, char *buf)
        lino->filetype = ino->type;
        lino->flags = ino->flags;
 
-       trace(1, "FILL inode %d\n", ino->type);
+       trace(1, "FILL inode (type=%d)\n", ino->type);
        switch(ino->type) {
        case TypeInodeFile:
        {

diff --git a/lib/lafs_sched_blk.c b/lib/lafs_sched_blk.c
index 2a740f3dc3069219750cce35ed41cb3839ec5bd3..8f1f79ac9cc266faf78701df3f5f6926b4b8de65 100644 (file)
--- a/lib/lafs_sched_blk.c
+++ b/lib/lafs_sched_blk.c
@@ -14,8 +14,11 @@ int lafs_sched_blk(struct lafs_blk *blk)
        struct lafs *fs = blk->ino->fs;
 
        blk->flags |= B_Dirty;
-       if (blk->flags & B_Sched)
+       if (blk->flags & B_Sched) {
+               if (list_empty(&blk->leafs))
+                       list_add_tail(&blk->leafs, &fs->leafs);
                return 0;
+       }
 
        if (!(blk->flags & B_Index)) {
                struct lafs_dblk *dblk = container_of(blk, struct lafs_dblk, b);
@@ -23,9 +26,13 @@ int lafs_sched_blk(struct lafs_blk *blk)
                        return -1;
        }
        blk->flags |= B_Sched;
-       if (blk->parent)
+       if (blk->parent) {
                blk->parent->sched_cnt++;
-       trace(1, "schedule %p\n", blk);
+               trace(1, "schedule %d/%d %d/%d %d\n", blk->ino->inum, (int)blk->fileaddr,
+                     blk->parent->b.ino->inum, (int)blk->parent->b.fileaddr,
+                     blk->parent->sched_cnt);
+       } else
+               trace(1, "schedule %d/%d\n", blk->ino->inum, (int)blk->fileaddr);
        list_move_tail(&blk->leafs, &fs->leafs);
        return 0;
 }