Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs

Pull btrfs fixes and features from Chris Mason:
 "We've merged in the error handling patches from SuSE.  These are
  already shipping in the sles kernel, and they give btrfs the ability
  to abort transactions and go readonly on errors.  It involves a lot of
  churn as they clarify BUG_ONs, and remove the ones we now properly
  deal with.

  Josef reworked the way our metadata interacts with the page cache.
  page->private now points to the btrfs extent_buffer object, which
  makes everything faster.  He changed it so we write an whole extent
  buffer at a time instead of allowing individual pages to go down,,
  which will be important for the raid5/6 code (for the 3.5 merge
  window ;)

  Josef also made us more aggressive about dropping pages for metadata
  blocks that were freed due to COW.  Overall, our metadata caching is
  much faster now.

  We've integrated my patch for metadata bigger than the page size.
  This allows metadata blocks up to 64KB in size.  In practice 16K and
  32K seem to work best.  For workloads with lots of metadata, this cuts
  down the size of the extent allocation tree dramatically and fragments
  much less.

  Scrub was updated to support the larger block sizes, which ended up
  being a fairly large change (thanks Stefan Behrens).

  We also have an assortment of fixes and updates, especially to the
  balancing code (Ilya Dryomov), the back ref walker (Jan Schmidt) and
  the defragging code (Liu Bo)."

Fixed up trivial conflicts in fs/btrfs/scrub.c that were just due to
removal of the second argument to k[un]map_atomic() in commit
7ac687d9e047.

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (75 commits)
  Btrfs: update the checks for mixed block groups with big metadata blocks
  Btrfs: update to the right index of defragment
  Btrfs: do not bother to defrag an extent if it is a big real extent
  Btrfs: add a check to decide if we should defrag the range
  Btrfs: fix recursive defragment with autodefrag option
  Btrfs: fix the mismatch of page->mapping
  Btrfs: fix race between direct io and autodefrag
  Btrfs: fix deadlock during allocating chunks
  Btrfs: show useful info in space reservation tracepoint
  Btrfs: don't use crc items bigger than 4KB
  Btrfs: flush out and clean up any block device pages during mount
  btrfs: disallow unequal data/metadata blocksize for mixed block groups
  Btrfs: enhance superblock sanity checks
  Btrfs: change scrub to support big blocks
  Btrfs: minor cleanup in scrub
  Btrfs: introduce common define for max number of mirrors
  Btrfs: fix infinite loop in btrfs_shrink_device()
  Btrfs: fix memory leak in resolver code
  Btrfs: allow dup for data chunks in mixed mode
  Btrfs: validate target profiles only if we are going to use them
  ...

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)