Roll-forward: change handling of 'desc' type.

Move handling of DescHole/DescIndex and flg out of
roll_mini/roll_block and into roll_one where they are easier to
handle.

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

diff --git a/roll.c b/roll.c
index ca80cf73c82c636d0b6af548e634ab0d1020ca9d..ca81735888e62a756f01ee62990309dd85ac0845 100644 (file)
--- a/roll.c
+++ b/roll.c
@@ -231,7 +231,7 @@ roll_locate(struct fs *fs, u64 start,
 }
 
 static int __must_check
-roll_mini(struct fs *fs, int fsnum, int inum, int trunc, int flg,
+roll_mini(struct fs *fs, int fsnum, int inum, int trunc,
          u32 bnum, int offset, int len, char *data)
 {
        struct inode *inode;
@@ -240,8 +240,8 @@ roll_mini(struct fs *fs, int fsnum, int inum, int trunc, int flg,
        int err = 0;
        void *buf;
 
-       dprintk("Roll Mini  %d/%d/%d/%lu/%d,%d\n",
-               fsnum, inum, flg, (unsigned long) bnum,
+       dprintk("Roll Mini  %d/%d/%lu/%d,%d\n",
+               fsnum, inum, (unsigned long) bnum,
                offset, len);
 
        /* The handling of miniblock updates is quite different for
@@ -256,9 +256,6 @@ roll_mini(struct fs *fs, int fsnum, int inum, int trunc, int flg,
         * directory: add/remove entries.
         */
 
-       if (flg)
-               return 0; /* old stuff isn't interesting, or even possible */
-
        inode = lafs_iget_fs(fs, fsnum, inum, SYNC);
        if (IS_ERR(inode))
                return PTR_ERR(inode);
@@ -323,7 +320,7 @@ roll_mini(struct fs *fs, int fsnum, int inum, int trunc, int flg,
 }
 
 static int __must_check
-roll_block(struct fs *fs, int fsnum, int inum, int trunc, int flg,
+roll_block(struct fs *fs, int fsnum, int inum, int trunc,
           u32 bnum, u64 baddr, int bytes, struct page *p)
 {
        struct inode *inode;
@@ -331,15 +328,8 @@ roll_block(struct fs *fs, int fsnum, int inum, int trunc, int flg,
        struct lafs_inode *li;
        int err = 0;
 
-       if (flg)
-               return 0; /* "old" blocks aren't interesting */
-       if (bytes == DescIndex)
-               return 0; /* index blocks aren't interesting either */
-       if (bytes == DescHole)
-               return 0; /* FIXME should I punch a hole here? */
-
-       dprintk("Roll Block %d/%d/%d/%lu/%llu\n",
-               fsnum, inum, flg, (unsigned long) bnum,
+       dprintk("Roll Block %d/%d/%lu/%llu\n",
+               fsnum, inum, (unsigned long) bnum,
                (unsigned long long)baddr);
 
        /* find/load the inode */
@@ -377,11 +367,12 @@ roll_block(struct fs *fs, int fsnum, int inum, int trunc, int flg,
                mdsize = le16_to_cpu(lai->metadata_size);
                if (lai->filetype >= TypeBase &&
                    lai->filetype != TypeDir  &&
+                   bytes == fs->blocksize &&
                    lai->depth == 0 &&
                    mdsize > 1 && mdsize < fs->blocksize) {
                        u64 sz = le64_to_cpu(lai->metadata[0].file.size);
                        if (sz <= fs->blocksize - mdsize)
-                               err = roll_mini(fs, inum, bnum, -1, flg, 0, 0,
+                               err = roll_mini(fs, inum, bnum, -1, 0, 0,
                                                (int)sz,
                                                page_address(p) + mdsize);
                }
@@ -508,6 +499,7 @@ roll_one(struct fs *fs, u64 *addrp, struct page *p, struct page *pg,
                            le16_to_cpu(desc->block_bytes) == DescIndex) {
                                u32 bnum = le32_to_cpu(desc->block_num);
                                int cnt = le16_to_cpu(desc->block_cnt);
+                               int bytes = le16_to_cpu(desc->block_bytes);
 
                                if (le16_to_cpu(desc->block_bytes) == DescIndex
                                    && cnt != 1)
@@ -516,13 +508,16 @@ roll_one(struct fs *fs, u64 *addrp, struct page *p, struct page *pg,
                                                      * response */
                                /* FIXME range check count */
                                while (!err && cnt--) {
-                                       err = roll_block(fs, fsnum, inum, trunc,
-                                                        flg, bnum, baddr,
-                                                        cnt == 0
-                                                        ? le16_to_cpu(desc->block_bytes)
-                                                        : blocksize,
-                                                        pg);
-                                       bnum++; baddr++;
+                                       if (!flg && bytes != DescIndex)
+                                               err = roll_block(fs, fsnum, inum, trunc,
+                                                                bnum, baddr,
+                                                                cnt == 0 || bytes == DescHole
+                                                                ? bytes
+                                                                : blocksize,
+                                                                pg);
+                                       bnum++;
+                                       if (bytes != DescHole)
+                                               baddr++;
                                }
                                /* FIXME allow for striping */
                                desc++;
@@ -532,8 +527,9 @@ roll_one(struct fs *fs, u64 *addrp, struct page *p, struct page *pg,
                                int offset = le16_to_cpu(mb->block_offset);
                                int len = le16_to_cpu(mb->length)
                                        - DescMiniOffset;
-                               err = roll_mini(fs, fsnum, inum, trunc, flg,
-                                               bnum, offset, len, (char *)(mb+1));
+                               if (!flg)
+                                       err = roll_mini(fs, fsnum, inum, trunc,
+                                                       bnum, offset, len, (char *)(mb+1));
 
                                mb++;
                                mb = (struct miniblock *)(((char*)mb)