introduce lafs_iolock_block_async

In several places we want this an open code it.
Just write the real code.

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

diff --git a/index.c b/index.c
index 0bc1de8ed9274920875131fbf76111e4b5f597e7..d717670c22cb9ab283a0d6336558c2147088b76e 100644 (file)
--- a/index.c
+++ b/index.c
@@ -1371,13 +1371,11 @@ lafs_leaf_find(struct inode *inode, u32 addr, int adopt, u32 *next,
                return ib;
        offset = li->metadata_size;
 
+       err = -EAGAIN;
        if (!async)
                lafs_iolock_block(&ib->b);
-       else if (test_and_set_bit(B_IOLock, &ib->b.flags)) {
-               err = -EAGAIN;
-               goto err;
-       } else
-               set_iolock_info(&ib->b);
+       else if (!lafs_iolock_block_async(&ib->b))
+                goto err;
                
        while (ib->depth > 1) {
                /* internal index block */
@@ -1450,21 +1448,17 @@ lafs_leaf_find(struct inode *inode, u32 addr, int adopt, u32 *next,
                                err = lafs_wait_block(&ib2->b);
                        if (err)
                                goto err_ib2;
+                       err = -EAGAIN;
                        if (!async)
                                lafs_iolock_block(&ib->b);
-                       else if (test_and_set_bit(B_IOLock, &ib->b.flags)) {
-                               err = -EAGAIN;
+                       else if (!lafs_iolock_block_async(&ib->b))
                                goto err_ib2;
-                       } else
-                               set_iolock_info(&ib->b);
                }
+               err = -EAGAIN;
                if (!async)
                        lafs_iolock_block(&ib2->b);
-               else if (test_and_set_bit(B_IOLock, &ib2->b.flags)) {
-                       err = -EAGAIN;
+               else if (!lafs_iolock_block_async(&ib2->b))
                        goto err_ib2;
-               } else
-                       set_iolock_info(&ib2->b);
 
                /* This block might have been split, in which case
                 * we need to consider adjacent siblings.
@@ -1491,12 +1485,11 @@ lafs_leaf_find(struct inode *inode, u32 addr, int adopt, u32 *next,
                        spin_unlock(&inode->i_data.private_lock);
                        if (!async)
                                lafs_iolock_block(nxt);
-                       else if (test_and_set_bit(B_IOLock, &nxt->flags)) {
-                               err = -EAGAIN;
+                       else if (!lafs_iolock_block_async(nxt)) {
                                putref(nxt, REF);
+                               err = -EAGAIN;
                                goto err_ib2;
-                       } else
-                               set_iolock_info(nxt);
+                       }
 
                        lafs_iounlock_block(&ib2->b);
                        putiref(ib2, REF);

diff --git a/inode.c b/inode.c
index 0aa557de5b82d58adae03bc3eb0a90e9e6b0fa72..a78991e7a0ebdc797acca259554e3dabeb0940e3 100644 (file)
--- a/inode.c
+++ b/inode.c
@@ -678,11 +678,10 @@ void lafs_inode_handle_orphan(struct datablock *b)
                 */
                        
                /* lafs_iolock_written(&ib2->b); - without blocking */
-               if (test_and_set_bit(B_IOLock, &ib2->b.flags)) {
+               if (!lafs_iolock_block_async(&ib2->b)) {
                        putiref(ib2, MKREF(inode_handle_orphan2));
                        goto out2;
                }
-               set_iolock_info(&ib2->b);
                if (test_bit(B_Writeback, &ib2->b.flags)) {
                        lafs_iounlock_block(&ib2->b);
                        putiref(ib2, MKREF(inode_handle_orphan2));
@@ -709,8 +708,7 @@ void lafs_inode_handle_orphan(struct datablock *b)
                }
                putiref(ib2, MKREF(inode_handle_orphan2));
                if (ib->uninc) {
-                       if (!test_and_set_bit(B_IOLock, &ib->b.flags)) {
-                               set_iolock_info(&ib->b);
+                       if (lafs_iolock_block_async(&ib->b)) {
                                if (!test_bit(B_Writeback, &ib->b.flags))
                                        while (ib->uninc)
                                                lafs_incorporate(fs, ib);

diff --git a/lafs.h b/lafs.h
index ce7c0ba11347d55683fd60da10c73d3f4798a1cb..6457c7b3d356bf7540b9421280fd3febb3f53548 100644 (file)
--- a/lafs.h
+++ b/lafs.h
@@ -114,11 +114,15 @@ int lafs_index_empty(struct indexblock *ib);
 #define set_iolock_info(b) (0)
 #endif
 #define lafs_iolock_block(b) do { _lafs_iolock_block(b); set_iolock_info(b); } while(0)
+#define lafs_iolock_block_async(b) ( _lafs_iolock_block_async(b) ? ( set_iolock_info(b), 1) : 0)
 #define lafs_iolock_written(b) do { _lafs_iolock_written(b); set_iolock_info(b); } while(0)
 
 void lafs_io_wake(struct block *b);
 void _lafs_iolock_block(struct block *b);
 void _lafs_iolock_written(struct block *b);
+static inline int _lafs_iolock_block_async(struct block *b) {
+       return !test_and_set_bit(B_IOLock, &b->flags);
+}
 void lafs_iounlock_block(struct block *b);
 void lafs_iocheck_block(struct datablock *db, int unlock);
 void lafs_iocheck_writeback(struct datablock *db, int unlock);