Merge branch 'for-linus' into for-4.12/block

[karo-tx-linux.git] / fs / f2fs / extent_cache.c

diff --git a/fs/f2fs/extent_cache.c b/fs/f2fs/extent_cache.c
index 4db44da7ef69d1d4bb7be862d8266508c58a4793..c6934f014e0f1d9a458a6489422612a6484fe198 100644 (file)
--- a/fs/f2fs/extent_cache.c
+++ b/fs/f2fs/extent_cache.c
@@ -77,7 +77,7 @@ static struct extent_tree *__grab_extent_tree(struct inode *inode)
        struct extent_tree *et;
        nid_t ino = inode->i_ino;
 
-       down_write(&sbi->extent_tree_lock);
+       mutex_lock(&sbi->extent_tree_lock);
        et = radix_tree_lookup(&sbi->extent_tree_root, ino);
        if (!et) {
                et = f2fs_kmem_cache_alloc(extent_tree_slab, GFP_NOFS);
@@ -94,7 +94,7 @@ static struct extent_tree *__grab_extent_tree(struct inode *inode)
                atomic_dec(&sbi->total_zombie_tree);
                list_del_init(&et->list);
        }
-       up_write(&sbi->extent_tree_lock);
+       mutex_unlock(&sbi->extent_tree_lock);
 
        /* never died until evict_inode */
        F2FS_I(inode)->extent_tree = et;
@@ -311,28 +311,24 @@ static struct extent_node *__lookup_extent_tree_ret(struct extent_tree *et,
        tmp_node = parent;
        if (parent && fofs > en->ei.fofs)
                tmp_node = rb_next(parent);
-       *next_ex = tmp_node ?
-               rb_entry(tmp_node, struct extent_node, rb_node) : NULL;
+       *next_ex = rb_entry_safe(tmp_node, struct extent_node, rb_node);
 
        tmp_node = parent;
        if (parent && fofs < en->ei.fofs)
                tmp_node = rb_prev(parent);
-       *prev_ex = tmp_node ?
-               rb_entry(tmp_node, struct extent_node, rb_node) : NULL;
+       *prev_ex = rb_entry_safe(tmp_node, struct extent_node, rb_node);
        return NULL;
 
 lookup_neighbors:
        if (fofs == en->ei.fofs) {
                /* lookup prev node for merging backward later */
                tmp_node = rb_prev(&en->rb_node);
-               *prev_ex = tmp_node ?
-                       rb_entry(tmp_node, struct extent_node, rb_node) : NULL;
+               *prev_ex = rb_entry_safe(tmp_node, struct extent_node, rb_node);
        }
        if (fofs == en->ei.fofs + en->ei.len - 1) {
                /* lookup next node for merging frontward later */
                tmp_node = rb_next(&en->rb_node);
-               *next_ex = tmp_node ?
-                       rb_entry(tmp_node, struct extent_node, rb_node) : NULL;
+               *next_ex = rb_entry_safe(tmp_node, struct extent_node, rb_node);
        }
        return en;
 }
@@ -352,11 +348,12 @@ static struct extent_node *__try_merge_extent_node(struct inode *inode,
        }
 
        if (next_ex && __is_front_mergeable(ei, &next_ex->ei)) {
-               if (en)
-                       __release_extent_node(sbi, et, prev_ex);
                next_ex->ei.fofs = ei->fofs;
                next_ex->ei.blk = ei->blk;
                next_ex->ei.len += ei->len;
+               if (en)
+                       __release_extent_node(sbi, et, prev_ex);
+
                en = next_ex;
        }
 
@@ -416,7 +413,7 @@ do_insert:
        return en;
 }
 
-static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
+static void f2fs_update_extent_tree_range(struct inode *inode,
                                pgoff_t fofs, block_t blkaddr, unsigned int len)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
@@ -429,7 +426,7 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
        unsigned int pos = (unsigned int)fofs;
 
        if (!et)
-               return false;
+               return;
 
        trace_f2fs_update_extent_tree_range(inode, fofs, blkaddr, len);
 
@@ -437,7 +434,7 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
 
        if (is_inode_flag_set(inode, FI_NO_EXTENT)) {
                write_unlock(&et->lock);
-               return false;
+               return;
        }
 
        prev = et->largest;
@@ -492,9 +489,8 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
                if (!next_en) {
                        struct rb_node *node = rb_next(&en->rb_node);
 
-                       next_en = node ?
-                               rb_entry(node, struct extent_node, rb_node)
-                               : NULL;
+                       next_en = rb_entry_safe(node, struct extent_node,
+                                               rb_node);
                }
 
                if (parts)
@@ -535,8 +531,6 @@ static unsigned int f2fs_update_extent_tree_range(struct inode *inode,
                __free_extent_tree(sbi, et);
 
        write_unlock(&et->lock);
-
-       return !__is_extent_same(&prev, &et->largest);
 }
 
 unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
@@ -552,7 +546,7 @@ unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
        if (!atomic_read(&sbi->total_zombie_tree))
                goto free_node;
 
-       if (!down_write_trylock(&sbi->extent_tree_lock))
+       if (!mutex_trylock(&sbi->extent_tree_lock))
                goto out;
 
        /* 1. remove unreferenced extent tree */
@@ -574,11 +568,11 @@ unsigned int f2fs_shrink_extent_tree(struct f2fs_sb_info *sbi, int nr_shrink)
                        goto unlock_out;
                cond_resched();
        }
-       up_write(&sbi->extent_tree_lock);
+       mutex_unlock(&sbi->extent_tree_lock);
 
 free_node:
        /* 2. remove LRU extent entries */
-       if (!down_write_trylock(&sbi->extent_tree_lock))
+       if (!mutex_trylock(&sbi->extent_tree_lock))
                goto out;
 
        remained = nr_shrink - (node_cnt + tree_cnt);
@@ -608,7 +602,7 @@ free_node:
        spin_unlock(&sbi->extent_lock);
 
 unlock_out:
-       up_write(&sbi->extent_tree_lock);
+       mutex_unlock(&sbi->extent_tree_lock);
 out:
        trace_f2fs_shrink_extent_tree(sbi, node_cnt, tree_cnt);
 
@@ -655,10 +649,10 @@ void f2fs_destroy_extent_tree(struct inode *inode)
 
        if (inode->i_nlink && !is_bad_inode(inode) &&
                                        atomic_read(&et->node_cnt)) {
-               down_write(&sbi->extent_tree_lock);
+               mutex_lock(&sbi->extent_tree_lock);
                list_add_tail(&et->list, &sbi->zombie_list);
                atomic_inc(&sbi->total_zombie_tree);
-               up_write(&sbi->extent_tree_lock);
+               mutex_unlock(&sbi->extent_tree_lock);
                return;
        }
 
@@ -666,12 +660,12 @@ void f2fs_destroy_extent_tree(struct inode *inode)
        node_cnt = f2fs_destroy_extent_node(inode);
 
        /* delete extent tree entry in radix tree */
-       down_write(&sbi->extent_tree_lock);
+       mutex_lock(&sbi->extent_tree_lock);
        f2fs_bug_on(sbi, atomic_read(&et->node_cnt));
        radix_tree_delete(&sbi->extent_tree_root, inode->i_ino);
        kmem_cache_free(extent_tree_slab, et);
        atomic_dec(&sbi->total_ext_tree);
-       up_write(&sbi->extent_tree_lock);
+       mutex_unlock(&sbi->extent_tree_lock);
 
        F2FS_I(inode)->extent_tree = NULL;
 
@@ -718,7 +712,7 @@ void f2fs_update_extent_cache_range(struct dnode_of_data *dn,
 void init_extent_cache_info(struct f2fs_sb_info *sbi)
 {
        INIT_RADIX_TREE(&sbi->extent_tree_root, GFP_NOIO);
-       init_rwsem(&sbi->extent_tree_lock);
+       mutex_init(&sbi->extent_tree_lock);
        INIT_LIST_HEAD(&sbi->extent_list);
        spin_lock_init(&sbi->extent_lock);
        atomic_set(&sbi->total_ext_tree, 0);