1 files changed, 145 insertions, 49 deletions

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index d8b54715c2de..18cc23d164a8 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -425,22 +425,37 @@ static noinline int create_subvol(struct btrfs_root *root,
 
         key.offset = (u64)-1;
         new_root = btrfs_read_fs_root_no_name(root->fs_info, &key);
-        BUG_ON(IS_ERR(new_root));
+        if (IS_ERR(new_root)) {
+                btrfs_abort_transaction(trans, root, PTR_ERR(new_root));
+                ret = PTR_ERR(new_root);
+                goto fail;
+        }
 
         btrfs_record_root_in_trans(trans, new_root);
 
         ret = btrfs_create_subvol_root(trans, new_root, new_dirid);
+        if (ret) {
+                /* We potentially lose an unused inode item here */
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
+
         /*
          * insert the directory item
          */
         ret = btrfs_set_inode_index(dir, &index);
-        BUG_ON(ret);
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
+                goto fail;
+        }
 
         ret = btrfs_insert_dir_item(trans, root,
                                     name, namelen, dir, &key,
                                     BTRFS_FT_DIR, index);
-        if (ret)
+        if (ret) {
+                btrfs_abort_transaction(trans, root, ret);
                 goto fail;
+        }
 
         btrfs_i_size_write(dir, dir->i_size + namelen * 2);
         ret = btrfs_update_inode(trans, root, dir);
@@ -769,6 +784,31 @@ none:
         return -ENOENT;
 }
 
+/*
+ * Validaty check of prev em and next em:
+ * 1) no prev/next em
+ * 2) prev/next em is an hole/inline extent
+ */
+static int check_adjacent_extents(struct inode *inode, struct extent_map *em)
+{
+        struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+        struct extent_map *prev = NULL, *next = NULL;
+        int ret = 0;
+
+        read_lock(&em_tree->lock);
+        prev = lookup_extent_mapping(em_tree, em->start - 1, (u64)-1);
+        next = lookup_extent_mapping(em_tree, em->start + em->len, (u64)-1);
+        read_unlock(&em_tree->lock);
+
+        if ((!prev || prev->block_start >= EXTENT_MAP_LAST_BYTE) &&
+            (!next || next->block_start >= EXTENT_MAP_LAST_BYTE))
+                ret = 1;
+        free_extent_map(prev);
+        free_extent_map(next);
+
+        return ret;
+}
+
 static int should_defrag_range(struct inode *inode, u64 start, u64 len,
                                int thresh, u64 *last_len, u64 *skip,
                                u64 *defrag_end)
@@ -797,17 +837,25 @@ static int should_defrag_range(struct inode *inode, u64 start, u64 len,
 
         if (!em) {
                 /* get the big lock and read metadata off disk */
-                lock_extent(io_tree, start, start + len - 1, GFP_NOFS);
+                lock_extent(io_tree, start, start + len - 1);
                 em = btrfs_get_extent(inode, NULL, 0, start, len, 0);
-                unlock_extent(io_tree, start, start + len - 1, GFP_NOFS);
+                unlock_extent(io_tree, start, start + len - 1);
 
                 if (IS_ERR(em))
                         return 0;
         }
 
         /* this will cover holes, and inline extents */
-        if (em->block_start >= EXTENT_MAP_LAST_BYTE)
+        if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
                 ret = 0;
+                goto out;
+        }
+
+        /* If we have nothing to merge with us, just skip. */
+        if (check_adjacent_extents(inode, em)) {
+                ret = 0;
+                goto out;
+        }
 
         /*
          * we hit a real extent, if it is big don't bother defragging it again
@@ -815,6 +863,7 @@ static int should_defrag_range(struct inode *inode, u64 start, u64 len,
         if ((*last_len == 0 || *last_len >= thresh) && em->len >= thresh)
                 ret = 0;
 
+out:
         /*
          * last_len ends up being a counter of how many bytes we've defragged.
          * every time we choose not to defrag an extent, we reset *last_len
@@ -856,6 +905,7 @@ static int cluster_pages_for_defrag(struct inode *inode,
         u64 isize = i_size_read(inode);
         u64 page_start;
         u64 page_end;
+        u64 page_cnt;
         int ret;
         int i;
         int i_done;
@@ -864,19 +914,21 @@ static int cluster_pages_for_defrag(struct inode *inode,
         struct extent_io_tree *tree;
         gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping);
 
-        if (isize == 0)
-                return 0;
         file_end = (isize - 1) >> PAGE_CACHE_SHIFT;
+        if (!isize || start_index > file_end)
+                return 0;
+
+        page_cnt = min_t(u64, (u64)num_pages, (u64)file_end - start_index + 1);
 
         ret = btrfs_delalloc_reserve_space(inode,
-                                           num_pages << PAGE_CACHE_SHIFT);
+                                           page_cnt << PAGE_CACHE_SHIFT);
         if (ret)
                 return ret;
         i_done = 0;
         tree = &BTRFS_I(inode)->io_tree;
 
         /* step one, lock all the pages */
-        for (i = 0; i < num_pages; i++) {
+        for (i = 0; i < page_cnt; i++) {
                 struct page *page;
 again:
                 page = find_or_create_page(inode->i_mapping,
@@ -887,10 +939,10 @@ again:
                 page_start = page_offset(page);
                 page_end = page_start + PAGE_CACHE_SIZE - 1;
                 while (1) {
-                        lock_extent(tree, page_start, page_end, GFP_NOFS);
+                        lock_extent(tree, page_start, page_end);
                         ordered = btrfs_lookup_ordered_extent(inode,
                                                               page_start);
-                        unlock_extent(tree, page_start, page_end, GFP_NOFS);
+                        unlock_extent(tree, page_start, page_end);
                         if (!ordered)
                                 break;
 
@@ -898,6 +950,15 @@ again:
                         btrfs_start_ordered_extent(inode, ordered, 1);
                         btrfs_put_ordered_extent(ordered);
                         lock_page(page);
+                        /*
+                         * we unlocked the page above, so we need check if
+                         * it was released or not.
+                         */
+                        if (page->mapping != inode->i_mapping) {
+                                unlock_page(page);
+                                page_cache_release(page);
+                                goto again;
+                        }
                 }
 
                 if (!PageUptodate(page)) {
@@ -911,15 +972,6 @@ again:
                         }
                 }
 
-                isize = i_size_read(inode);
-                file_end = (isize - 1) >> PAGE_CACHE_SHIFT;
-                if (!isize || page->index > file_end) {
-                        /* whoops, we blew past eof, skip this page */
-                        unlock_page(page);
-                        page_cache_release(page);
-                        break;
-                }
-
                 if (page->mapping != inode->i_mapping) {
                         unlock_page(page);
                         page_cache_release(page);
@@ -946,19 +998,18 @@ again:
         page_end = page_offset(pages[i_done - 1]) + PAGE_CACHE_SIZE;
 
         lock_extent_bits(&BTRFS_I(inode)->io_tree,
-                         page_start, page_end - 1, 0, &cached_state,
-                         GFP_NOFS);
+                         page_start, page_end - 1, 0, &cached_state);
         clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start,
                           page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
                           EXTENT_DO_ACCOUNTING, 0, 0, &cached_state,
                           GFP_NOFS);
 
-        if (i_done != num_pages) {
+        if (i_done != page_cnt) {
                 spin_lock(&BTRFS_I(inode)->lock);
                 BTRFS_I(inode)->outstanding_extents++;
                 spin_unlock(&BTRFS_I(inode)->lock);
                 btrfs_delalloc_release_space(inode,
-                                     (num_pages - i_done) << PAGE_CACHE_SHIFT);
+                                     (page_cnt - i_done) << PAGE_CACHE_SHIFT);
         }
 
 
@@ -983,7 +1034,7 @@ out:
                 unlock_page(pages[i]);
                 page_cache_release(pages[i]);
         }
-        btrfs_delalloc_release_space(inode, num_pages << PAGE_CACHE_SHIFT);
+        btrfs_delalloc_release_space(inode, page_cnt << PAGE_CACHE_SHIFT);
         return ret;
 
 }
@@ -1089,12 +1140,9 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
                 if (!(inode->i_sb->s_flags & MS_ACTIVE))
                         break;
 
-                if (!newer_than &&
-                    !should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
-                                        PAGE_CACHE_SIZE,
-                                        extent_thresh,
-                                        &last_len, &skip,
-                                        &defrag_end)) {
+                if (!should_defrag_range(inode, (u64)i << PAGE_CACHE_SHIFT,
+                                         PAGE_CACHE_SIZE, extent_thresh,
+                                         &last_len, &skip, &defrag_end)) {
                         unsigned long next;
                         /*
                          * the should_defrag function tells us how much to skip
@@ -1123,17 +1171,24 @@ int btrfs_defrag_file(struct inode *inode, struct file *file,
                         ra_index += max_cluster;
                 }
 
+                mutex_lock(&inode->i_mutex);
                 ret = cluster_pages_for_defrag(inode, pages, i, cluster);
-                if (ret < 0)
+                if (ret < 0) {
+                        mutex_unlock(&inode->i_mutex);
                         goto out_ra;
+                }
 
                 defrag_count += ret;
                 balance_dirty_pages_ratelimited_nr(inode->i_mapping, ret);
+                mutex_unlock(&inode->i_mutex);
 
                 if (newer_than) {
                         if (newer_off == (u64)-1)
                                 break;
 
+                        if (ret > 0)
+                                i += ret;
+
                         newer_off = max(newer_off + 1,
                                         (u64)i << PAGE_CACHE_SHIFT);
 
@@ -1966,7 +2021,11 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
                                 dest->root_key.objectid,
                                 dentry->d_name.name,
                                 dentry->d_name.len);
-        BUG_ON(ret);
+        if (ret) {
+                err = ret;
+                btrfs_abort_transaction(trans, root, ret);
+                goto out_end_trans;
+        }
 
         btrfs_record_root_in_trans(trans, dest);
 
@@ -1979,11 +2038,16 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
                 ret = btrfs_insert_orphan_item(trans,
                                         root->fs_info->tree_root,
                                         dest->root_key.objectid);
-                BUG_ON(ret);
+                if (ret) {
+                        btrfs_abort_transaction(trans, root, ret);
+                        err = ret;
+                        goto out_end_trans;
+                }
         }
-
+out_end_trans:
         ret = btrfs_end_transaction(trans, root);
-        BUG_ON(ret);
+        if (ret && !err)
+                err = ret;
         inode->i_flags |= S_DEAD;
 out_up_write:
         up_write(&root->fs_info->subvol_sem);
@@ -2326,13 +2390,13 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
            another, and lock file content */
         while (1) {
                 struct btrfs_ordered_extent *ordered;
-                lock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS);
+                lock_extent(&BTRFS_I(src)->io_tree, off, off+len);
                 ordered = btrfs_lookup_first_ordered_extent(src, off+len);
                 if (!ordered &&
                     !test_range_bit(&BTRFS_I(src)->io_tree, off, off+len,
                                    EXTENT_DELALLOC, 0, NULL))
                         break;
-                unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS);
+                unlock_extent(&BTRFS_I(src)->io_tree, off, off+len);
                 if (ordered)
                         btrfs_put_ordered_extent(ordered);
                 btrfs_wait_ordered_range(src, off, len);
@@ -2447,11 +2511,21 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                                          new_key.offset,
                                                          new_key.offset + datal,
                                                          &hint_byte, 1);
-                                BUG_ON(ret);
+                                if (ret) {
+                                        btrfs_abort_transaction(trans, root,
+                                                                ret);
+                                        btrfs_end_transaction(trans, root);
+                                        goto out;
+                                }
 
                                 ret = btrfs_insert_empty_item(trans, root, path,
                                                               &new_key, size);
-                                BUG_ON(ret);
+                                if (ret) {
+                                        btrfs_abort_transaction(trans, root,
+                                                                ret);
+                                        btrfs_end_transaction(trans, root);
+                                        goto out;
+                                }
 
                                 leaf = path->nodes[0];
                                 slot = path->slots[0];
@@ -2478,7 +2552,15 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                                         btrfs_ino(inode),
                                                         new_key.offset - datao,
                                                         0);
-                                        BUG_ON(ret);
+                                        if (ret) {
+                                                btrfs_abort_transaction(trans,
+                                                                        root,
+                                                                        ret);
+                                                btrfs_end_transaction(trans,
+                                                                      root);
+                                                goto out;
+
+                                        }
                                 }
                         } else if (type == BTRFS_FILE_EXTENT_INLINE) {
                                 u64 skip = 0;
@@ -2503,11 +2585,21 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                                          new_key.offset,
                                                          new_key.offset + datal,
                                                          &hint_byte, 1);
-                                BUG_ON(ret);
+                                if (ret) {
+                                        btrfs_abort_transaction(trans, root,
+                                                                ret);
+                                        btrfs_end_transaction(trans, root);
+                                        goto out;
+                                }
 
                                 ret = btrfs_insert_empty_item(trans, root, path,
                                                               &new_key, size);
-                                BUG_ON(ret);
+                                if (ret) {
+                                        btrfs_abort_transaction(trans, root,
+                                                                ret);
+                                        btrfs_end_transaction(trans, root);
+                                        goto out;
+                                }
 
                                 if (skip) {
                                         u32 start =
@@ -2541,8 +2633,12 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                 btrfs_i_size_write(inode, endoff);
 
                         ret = btrfs_update_inode(trans, root, inode);
-                        BUG_ON(ret);
-                        btrfs_end_transaction(trans, root);
+                        if (ret) {
+                                btrfs_abort_transaction(trans, root, ret);
+                                btrfs_end_transaction(trans, root);
+                                goto out;
+                        }
+                        ret = btrfs_end_transaction(trans, root);
                 }
 next:
                 btrfs_release_path(path);
@@ -2551,7 +2647,7 @@ next:
         ret = 0;
 out:
         btrfs_release_path(path);
-        unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS);
+        unlock_extent(&BTRFS_I(src)->io_tree, off, off+len);
 out_unlock:
         mutex_unlock(&src->i_mutex);
         mutex_unlock(&inode->i_mutex);
@@ -3066,8 +3162,8 @@ static long btrfs_ioctl_logical_to_ino(struct btrfs_root *root,
                 goto out;
 
         extent_item_pos = loi->logical - key.objectid;
-        ret = iterate_extent_inodes(root->fs_info, path, key.objectid,
-                                        extent_item_pos, build_ino_list,
+        ret = iterate_extent_inodes(root->fs_info, key.objectid,
+                                        extent_item_pos, 0, build_ino_list,
                                         inodes);
 
         if (ret < 0)