Introduce constants for 'sync' and 'adopt' flags.

This is much better than having '0' and '1' and arguments in hard to
remember places.

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

diff --git a/block.c b/block.c
index 4fc767434889334edd93988a310c204ed08987d5..48d6a106e260c042e0b328dbf3bfb514b72c97ba 100644 (file)
--- a/block.c
+++ b/block.c
@@ -431,7 +431,7 @@ lafs_pin_dblock(struct datablock *b, int alloc_type)
        if (LAFSI(b->b.inode)->type == TypeInodeFile &&
            b->my_inode &&
            LAFSI(b->my_inode)->iblock) {
-               struct indexblock *ib = lafs_make_iblock(b->my_inode, 1, 0,
+               struct indexblock *ib = lafs_make_iblock(b->my_inode, ADOPT, SYNC,
                                                         MKREF(pindb));
                if (IS_ERR(ib))
                        blk = getref(&b->b, MKREF(pindb));

diff --git a/clean.c b/clean.c
index a1664be0bf5818bffa17b3958ca9acbea482c0bb..ad130314e92ec3d43b226e25de125bca8b5b8430 100644 (file)
--- a/clean.c
+++ b/clean.c
@@ -372,7 +372,7 @@ static int try_clean(struct fs *fs, struct toclean *tc)
                    LAFSI(ino)->filesys->i_ino != fsnum) {
                        if (ino)
                                iput(ino);
-                       ino = lafs_iget_fs(fs, fsnum, inum, 1);
+                       ino = lafs_iget_fs(fs, fsnum, inum, ASYNC);
                }
                if (IS_ERR(ino)) {
                        /* FIXME check that this is -EAGAIN

diff --git a/dir.c b/dir.c
index 8c61dd1ca73903d8bccd2542191acf19ef62fbfb..e492985c2000e77d15f410a1a026838470ace4a5 100644 (file)
--- a/dir.c
+++ b/dir.c
@@ -646,7 +646,7 @@ lafs_link(struct dentry *from, struct inode *dir, struct dentry *to)
                                 &doh);
        err = dir_log_prepare(&uh, fs, &to->d_name) ?: err;
 
-       inodb = lafs_inode_dblock(dir, 0, MKREF(link));
+       inodb = lafs_inode_dblock(dir, SYNC, MKREF(link));
        if (IS_ERR(inodb))
                err = PTR_ERR(inodb);
        if (err)
@@ -705,7 +705,7 @@ lafs_unlink(struct inode *dir, struct dentry *de)
        err = dir_delete_prepare(fs, dir, de->d_name.name, de->d_name.len,
                                 &doh);
        err = dir_log_prepare(&uh, fs, &de->d_name) ?: err;
-       inodb = lafs_inode_dblock(inode, 0, MKREF(inode_update));
+       inodb = lafs_inode_dblock(inode, SYNC, MKREF(inode_update));
        if (IS_ERR(inodb))
                err = PTR_ERR(inodb);
        if (last && !err)
@@ -787,7 +787,7 @@ lafs_rmdir(struct inode *dir, struct dentry *de)
        err = dir_delete_prepare(fs, dir, de->d_name.name, de->d_name.len,
                                 &doh);
        err = dir_log_prepare(&uh, fs, &de->d_name) ?: err;
-       inodb = lafs_inode_dblock(inode, 0, MKREF(inode_update));
+       inodb = lafs_inode_dblock(inode, SYNC, MKREF(inode_update));
        if (IS_ERR(inodb))
                err = PTR_ERR(inodb);
        if (!err)
@@ -1092,7 +1092,7 @@ lafs_rename(struct inode *old_dir, struct dentry *old_dentry,
                                 &old_doh);
        err = dir_log_prepare(&old_uh, fs, &old_dentry->d_name) ?: err;
        err = dir_log_prepare(&new_uh, fs, &new_dentry->d_name) ?: err;
-       olddb = lafs_inode_dblock(old_inode, 0, MKREF(inode_update));
+       olddb = lafs_inode_dblock(old_inode, SYNC, MKREF(inode_update));
        if (IS_ERR(olddb))
                err = PTR_ERR(olddb);
 
@@ -1102,7 +1102,7 @@ lafs_rename(struct inode *old_dir, struct dentry *old_dentry,
                                         new_dentry->d_name.name,
                                         new_dentry->d_name.len,
                                         &new_doh) ?: err;
-               newdb = lafs_inode_dblock(new_inode, 0, MKREF(inode_update));
+               newdb = lafs_inode_dblock(new_inode, SYNC, MKREF(inode_update));
                if (IS_ERR(newdb))
                        err = PTR_ERR(newdb);
                if (last && !err)
@@ -1496,7 +1496,7 @@ lafs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 
        if (err < 0)
                ERR_PTR(err);
-       ino = lafs_iget(dir->i_sb, inum, 0);
+       ino = lafs_iget(dir->i_sb, inum, SYNC);
 
        if (IS_ERR(ino))
                return ERR_PTR(PTR_ERR(ino));

diff --git a/file.c b/file.c
index dc5150b099b68a68ccdbc9809f325d8521395ac7..febab0547631e33dac47b4156a6d7e556a3ec3fd 100644 (file)
--- a/file.c
+++ b/file.c
@@ -39,7 +39,7 @@ lafs_readpage(struct file *file, struct page *page)
                        break;
                }
 
-               err = lafs_find_block(b, 0);
+               err = lafs_find_block(b, NOADOPT);
                if (err) {
                        putdref(b, MKREF(readpage));
                        break;
@@ -93,7 +93,7 @@ lafs_prepare_write(struct file *file, struct page *page,
                lafs_get_block(ino, i, page, GFP_KERNEL, MKREF(write));
 
        if (start != (first << bits)) {
-               err = lafs_find_block(fb, 0);
+               err = lafs_find_block(fb, NOADOPT);
                if (!err)
                        err = lafs_load_block(&fb->b);
                if (err)
@@ -104,7 +104,7 @@ lafs_prepare_write(struct file *file, struct page *page,
            end != ((last+1) << bits)) {
                struct datablock *lb = fb + last - first;
 
-               err = lafs_find_block(lb, 1);
+               err = lafs_find_block(lb, ADOPT);
                if (!err)
                        err = lafs_load_block(&lb->b);
                if (err)
@@ -239,7 +239,7 @@ lafs_writepage(struct page *page, struct writeback_control *wbc)
                 * the page to be clean.
                 * so write the inode.
                 */
-               struct datablock *b = lafs_inode_dblock(ino, 0,
+               struct datablock *b = lafs_inode_dblock(ino, SYNC,
                                                        MKREF(writepageflush));
                if (test_bit(B_Dirty, &b->b.flags)) {
                        lafs_iolock_written(&b->b);

diff --git a/index.c b/index.c
index 77e21bd9b766d64abf3d99760097357f603d6f49..ea8bd46390bd22986138862545a7dea78034b238 100644 (file)
--- a/index.c
+++ b/index.c
@@ -1505,12 +1505,12 @@ static int __lafs_find_next(struct inode *ino, loff_t *addrp)
        if (lai->depth == 0) {
                if (*addrp == 0)
                        return 1;
-               leaf = lafs_make_iblock(ino, 0, 0, MKREF(find_next));
+               leaf = lafs_make_iblock(ino, NOADOPT, SYNC, MKREF(find_next));
                if (IS_ERR(leaf))
                        return PTR_ERR(leaf);
                nextd = 0xFFFFFFFF;
        } else {
-               leaf = lafs_leaf_find(ino, *addrp, 0, &nexti, 0,
+               leaf = lafs_leaf_find(ino, *addrp, NOADOPT, &nexti, SYNC,
                                      MKREF(find_next));
                /* FIXME what if 'leaf' is an error?? */
                offset = 0;
@@ -1584,7 +1584,7 @@ int lafs_find_next(struct inode *ino, loff_t *bnump)
        /* Need to hold a reference to dblock while calling
         * __lafs_find_next
         */
-       struct datablock *db = lafs_inode_dblock(ino, 0, MKREF(find_nexti));
+       struct datablock *db = lafs_inode_dblock(ino, SYNC, MKREF(find_nexti));
 
        if (IS_ERR(db))
                return PTR_ERR(db);
@@ -1604,7 +1604,7 @@ int lafs_find_next(struct inode *ino, loff_t *bnump)
                if (!b)
                        return -ENOMEM;
 
-               rv = lafs_find_block(b, 0);
+               rv = lafs_find_block(b, NOADOPT);
                if (rv) {
                        putdref(b, MKREF(find_next));
                        return rv;
@@ -1798,13 +1798,13 @@ find_block(struct datablock *b, int adopt, int async)
 int __must_check
 lafs_find_block(struct datablock *b, int adopt)
 {
-       return find_block(b, adopt, 0);
+       return find_block(b, adopt, SYNC);
 }
 
 int __must_check
 lafs_find_block_async(struct datablock *b)
 {
-       return find_block(b, 1, 1);
+       return find_block(b, ADOPT, ASYNC);
 }
 
 /*

diff --git a/inode.c b/inode.c
index e1ce2f270c54d8b695172861132397eecf256dcb..a4ef3aa6b452240edc44d58273d6056e78ea5058 100644 (file)
--- a/inode.c
+++ b/inode.c
@@ -594,7 +594,7 @@ void lafs_inode_handle_orphan(struct datablock *b)
                return;
        }
 
-       ib = lafs_make_iblock(ino, 1, 0, MKREF(inode_handle_orphan));
+       ib = lafs_make_iblock(ino, ADOPT, SYNC, MKREF(inode_handle_orphan));
        if (IS_ERR(ib))
                return;
 
@@ -720,8 +720,8 @@ void lafs_inode_handle_orphan(struct datablock *b)
 
        putiref(ib, MKREF(inode_handle_orphan));
 
-       ib = lafs_leaf_find(ino, trunc_next, 1, &next_trunc,
-                           1, MKREF(inode_handle_orphan3));
+       ib = lafs_leaf_find(ino, trunc_next, ADOPT, &next_trunc,
+                           ASYNC, MKREF(inode_handle_orphan3));
 
        if (IS_ERR(ib))
                return;
@@ -886,7 +886,7 @@ int lafs_write_inode(struct inode *ino, int wait)
        if (wait == 0)
                return 0;
 
-       b = lafs_inode_dblock(ino, 0, MKREF(write_inode));
+       b = lafs_inode_dblock(ino, SYNC, MKREF(write_inode));
        if (IS_ERR(b)) /* FIXME should I mark something clean?? */
                return PTR_ERR(b);
 
@@ -1076,7 +1076,7 @@ static int
 choose_free_inum(struct fs *fs, struct inode *filesys, u32 *inump,
                 struct datablock **bp, int *restarted)
 {
-       struct inode *im = lafs_iget(filesys->i_sb, 1, 0);
+       struct inode *im = lafs_iget(filesys->i_sb, 1, SYNC);
        loff_t bnum;
        struct datablock *b;
        char *buf;
@@ -1148,7 +1148,7 @@ choose_free_inum(struct fs *fs, struct inode *filesys, u32 *inump,
        if (!b)
                goto abort;
        *bp = b;
-       err = lafs_find_block(b, 0);
+       err = lafs_find_block(b, NOADOPT);
        if (err)
                goto abort;
        if (b->b.physaddr == 0 && !test_bit(B_Valid, &b->b.flags)) {
@@ -1320,7 +1320,7 @@ lafs_new_inode(struct fs *fs, struct inode *dir, int type, int inum, int mode,
        lafs_iounlock_block(&b->b);
 
        inode_map_new_commit(&imni);
-       ino = lafs_iget(dir->i_sb, b->b.fileaddr, 0);
+       ino = lafs_iget(dir->i_sb, b->b.fileaddr, SYNC);
        if (IS_ERR(ino)) {
                lafs_cluster_update_abort(&ui);
                LAFS_BUG(1, &b->b);
@@ -1347,7 +1347,7 @@ lafs_new_inode(struct fs *fs, struct inode *dir, int type, int inum, int mode,
 
 static int inode_map_free(struct fs *fs, struct inode *filesys, u32 inum)
 {
-       struct inode *im = lafs_iget(filesys->i_sb, 1, 0);
+       struct inode *im = lafs_iget(filesys->i_sb, 1, SYNC);
        int bit;
        unsigned long *buf;
        struct datablock *b;
@@ -1394,7 +1394,7 @@ int lafs_setattr(struct dentry *dentry, struct iattr *attr)
        struct datablock *db;
 
        err = inode_change_ok(ino, attr);
-       db = lafs_inode_dblock(ino, 0, MKREF(setattr));
+       db = lafs_inode_dblock(ino, SYNC, MKREF(setattr));
        if (IS_ERR(db))
                err = PTR_ERR(db);
        if (err)
@@ -1430,7 +1430,7 @@ void lafs_truncate(struct inode *ino)
         * So just start the background truncate
         */
        struct fs *fs = fs_from_inode(ino);
-       struct datablock *db = lafs_inode_dblock(ino, 0, MKREF(trunc));
+       struct datablock *db = lafs_inode_dblock(ino, SYNC, MKREF(trunc));
 
        if (IS_ERR(db))
                return;

diff --git a/io.c b/io.c
index 356691a92dfafd94c279a62d6e397e528889f657..9810d5f44f177d1b50dec2b03b89be5c13d81f7e 100644 (file)
--- a/io.c
+++ b/io.c
@@ -465,7 +465,7 @@ lafs_read_block(struct datablock *b)
        if (test_bit(B_Valid, &b->b.flags))
                return 0;
 
-       rv = lafs_find_block(b, 0);
+       rv = lafs_find_block(b, NOADOPT);
        if (rv)
                return rv;
        rv = lafs_load_block(&b->b);

diff --git a/lafs.h b/lafs.h
index 5b6040ad837c751d6156e174f23c34197eeb1918..c4f96d1f7aad485ddb5190cce5e1a9190117997d 100644 (file)
--- a/lafs.h
+++ b/lafs.h
@@ -82,6 +82,12 @@ extern struct address_space_operations lafs_file_aops;
 
 extern struct address_space_operations lafs_index_operations;
 
+#define SYNC 0
+#define ASYNC 1
+
+#define NOADOPT 0
+#define ADOPT 1
+
 typedef u32 faddr_t;
 typedef u64 paddr_t;
 typedef u64 vaddr_t;

diff --git a/roll.c b/roll.c
index 5769cdd01d320fa9e634c5d3545ff68a55ea1471..3150a69d0c7ea14a389c525dd81b9df89fcdf35a 100644 (file)
--- a/roll.c
+++ b/roll.c
@@ -194,7 +194,7 @@ roll_mini(struct fs *fs, int fsnum, int inum, int trunc, int flg,
        if (flg)
                return 0; /* old stuff isn't interesting, or even possible */
 
-       inode = lafs_iget_fs(fs, fsnum, inum, 0);
+       inode = lafs_iget_fs(fs, fsnum, inum, SYNC);
        if (IS_ERR(inode))
                return PTR_ERR(inode);
 
@@ -205,7 +205,7 @@ roll_mini(struct fs *fs, int fsnum, int inum, int trunc, int flg,
 
                BUG_ON(fsnum); /* FIXME should be more careful */
                iput(inode);
-               inode = lafs_iget_fs(fs, inum, bnum, 0);
+               inode = lafs_iget_fs(fs, inum, bnum, SYNC);
                if (IS_ERR(inode)) {
                        err = PTR_ERR(inode);
                        if (err == -EIO && offset == 0) {
@@ -213,7 +213,7 @@ roll_mini(struct fs *fs, int fsnum, int inum, int trunc, int flg,
                        }
                        return PTR_ERR(inode);
                }
-               db = lafs_inode_dblock(inode, 0, MKREF(roll));
+               db = lafs_inode_dblock(inode, SYNC, MKREF(roll));
                buf = map_dblock(db);
                /* FIXME do I sync the inode back to the datablock first? */
                memcpy(buf+offset, data, len);
@@ -257,7 +257,7 @@ roll_block(struct fs *fs, int fsnum, int inum, int trunc, int flg,
               (unsigned long long)baddr);
 
        /* find/load the inode */
-       inode = lafs_iget_fs(fs, fsnum, inum, 0);
+       inode = lafs_iget_fs(fs, fsnum, inum, SYNC);
        if (IS_ERR(inode))
                return PTR_ERR(inode);
 
@@ -323,7 +323,7 @@ roll_block(struct fs *fs, int fsnum, int inum, int trunc, int flg,
                if (!blk)
                        break;
 
-               err = lafs_find_block(blk, 1);
+               err = lafs_find_block(blk, ADOPT);
                if (err)
                        break;
 
@@ -570,7 +570,7 @@ lafs_mount(struct fs *fs)
        unlock_new_inode(root);
        /* FIXME lots of error checking */
 
-       rootdir = lafs_iget(fs->prime_sb, 2, 0);
+       rootdir = lafs_iget(fs->prime_sb, 2, SYNC);
        err = PTR_ERR(rootdir);
        if (IS_ERR(rootdir))
                goto err2;
@@ -580,11 +580,11 @@ lafs_mount(struct fs *fs)
                goto err2;
        fs->prime_sb->s_root = de;
 
-       fs->orphans = lafs_iget(fs->prime_sb, 8, 0);
+       fs->orphans = lafs_iget(fs->prime_sb, 8, SYNC);
        for (d = 0; d < fs->devices ; d++) {
                fs->devs[d].segsum = lafs_iget(fs->prime_sb,
                                               fs->devs[d].usage_inum,
-                                              0);
+                                              SYNC);
        }
        lafs_checkpoint_lock(fs);
        err = roll_forward(fs);

diff --git a/snapshot.c b/snapshot.c
index f956f93df2513d52c2fe0af4826ff02b3658d345..413c1f8b2304410d538a6be3f9c3d40dde86364e 100644 (file)
--- a/snapshot.c
+++ b/snapshot.c
@@ -146,7 +146,7 @@ lafs_snap_get_sb(struct file_system_type *fstype,
                        goto fail;
                }
                unlock_new_inode(fs->ss[s].root);
-               rootdir = lafs_iget(sb, 2, 0);
+               rootdir = lafs_iget(sb, 2, SYNC);
                sb->s_root = d_alloc_root(rootdir);
                sb->s_op = fs->prime_sb->s_op;
                sb2 = sget(&lafs_fs_type, match_one, discard_one, fs->prime_sb);