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

Pull btrfs update from Chris Mason:
 "These are mostly fixes.  The biggest exceptions are Josef's skinny
  extents and Jan Schmidt's code to rebuild our quota indexes if they
  get out of sync (or you enable quotas on an existing filesystem).

  The skinny extents are off by default because they are a new variation
  on the extent allocation tree format.  btrfstune -x enables them, and
  the new format makes the extent allocation tree about 30% smaller.

  I rebased this a few days ago to rework Dave Sterba's crc checks on
  the super block, but almost all of these go back to rc6, since I
  though 3.9 was due any minute.

  The biggest missing fix is the tracepoint bug that was hit late in
  3.9.  I ran into problems with that in overnight testing and I'm still
  tracking it down.  I'll definitely have that fixed for rc2."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (101 commits)
  Btrfs: allow superblock mismatch from older mkfs
  btrfs: enhance superblock checks
  btrfs: fix misleading variable name for flags
  btrfs: use unsigned long type for extent state bits
  Btrfs: improve the loop of scrub_stripe
  btrfs: read entire device info under lock
  btrfs: remove unused gfp mask parameter from release_extent_buffer callchain
  btrfs: handle errors returned from get_tree_block_key
  btrfs: make static code static & remove dead code
  Btrfs: deal with errors in write_dev_supers
  Btrfs: remove almost all of the BUG()'s from tree-log.c
  Btrfs: deal with free space cache errors while replaying log
  Btrfs: automatic rescan after "quota enable" command
  Btrfs: rescan for qgroups
  Btrfs: split btrfs_qgroup_account_ref into four functions
  Btrfs: allocate new chunks if the space is not enough for global rsv
  Btrfs: separate sequence numbers for delayed ref tracking and tree mod log
  btrfs: move leak debug code to functions
  Btrfs: return free space in cow error path
  Btrfs: set UUID in root_item for created trees
  ...

1 files changed, 19 insertions, 18 deletions

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index bc4d54c465a0..4205ba752d40 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -193,8 +193,8 @@ int btrfs_add_inode_defrag(struct btrfs_trans_handle *trans,
  * the same inode in the tree, we will merge them together (by
  * __btrfs_add_inode_defrag()) and free the one that we want to requeue.
  */
-void btrfs_requeue_inode_defrag(struct inode *inode,
-                                struct inode_defrag *defrag)
+static void btrfs_requeue_inode_defrag(struct inode *inode,
+                                       struct inode_defrag *defrag)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret;
@@ -474,7 +474,7 @@ static noinline int btrfs_copy_from_user(loff_t pos, int num_pages,
 /*
  * unlocks pages after btrfs_file_write is done with them
  */
-void btrfs_drop_pages(struct page **pages, size_t num_pages)
+static void btrfs_drop_pages(struct page **pages, size_t num_pages)
 {
         size_t i;
         for (i = 0; i < num_pages; i++) {
@@ -498,9 +498,9 @@ void btrfs_drop_pages(struct page **pages, size_t num_pages)
  * doing real data extents, marking pages dirty and delalloc as required.
  */
 int btrfs_dirty_pages(struct btrfs_root *root, struct inode *inode,
-                      struct page **pages, size_t num_pages,
-                      loff_t pos, size_t write_bytes,
-                      struct extent_state **cached)
+                             struct page **pages, size_t num_pages,
+                             loff_t pos, size_t write_bytes,
+                             struct extent_state **cached)
 {
         int err = 0;
         int i;
@@ -553,6 +553,7 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
         int testend = 1;
         unsigned long flags;
         int compressed = 0;
+        bool modified;
 
         WARN_ON(end < start);
         if (end == (u64)-1) {
@@ -562,6 +563,7 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
         while (1) {
                 int no_splits = 0;
 
+                modified = false;
                 if (!split)
                         split = alloc_extent_map();
                 if (!split2)
@@ -593,6 +595,7 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                 compressed = test_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
                 clear_bit(EXTENT_FLAG_PINNED, &em->flags);
                 clear_bit(EXTENT_FLAG_LOGGING, &flags);
+                modified = !list_empty(&em->list);
                 remove_extent_mapping(em_tree, em);
                 if (no_splits)
                         goto next;
@@ -608,15 +611,15 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                                 split->block_len = em->block_len;
                         else
                                 split->block_len = split->len;
+                        split->ram_bytes = em->ram_bytes;
                         split->orig_block_len = max(split->block_len,
                                                     em->orig_block_len);
                         split->generation = gen;
                         split->bdev = em->bdev;
                         split->flags = flags;
                         split->compress_type = em->compress_type;
-                        ret = add_extent_mapping(em_tree, split);
+                        ret = add_extent_mapping(em_tree, split, modified);
                         BUG_ON(ret); /* Logic error */
-                        list_move(&split->list, &em_tree->modified_extents);
                         free_extent_map(split);
                         split = split2;
                         split2 = NULL;
@@ -633,6 +636,7 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                         split->generation = gen;
                         split->orig_block_len = max(em->block_len,
                                                     em->orig_block_len);
+                        split->ram_bytes = em->ram_bytes;
 
                         if (compressed) {
                                 split->block_len = em->block_len;
@@ -644,9 +648,8 @@ void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                                 split->orig_start = em->orig_start;
                         }
 
-                        ret = add_extent_mapping(em_tree, split);
+                        ret = add_extent_mapping(em_tree, split, modified);
                         BUG_ON(ret); /* Logic error */
-                        list_move(&split->list, &em_tree->modified_extents);
                         free_extent_map(split);
                         split = NULL;
                 }
@@ -822,7 +825,7 @@ next_slot:
 
                         memcpy(&new_key, &key, sizeof(new_key));
                         new_key.offset = end;
-                        btrfs_set_item_key_safe(trans, root, path, &new_key);
+                        btrfs_set_item_key_safe(root, path, &new_key);
 
                         extent_offset += end - key.offset;
                         btrfs_set_file_extent_offset(leaf, fi, extent_offset);
@@ -1038,7 +1041,7 @@ again:
                                      ino, bytenr, orig_offset,
                                      &other_start, &other_end)) {
                         new_key.offset = end;
-                        btrfs_set_item_key_safe(trans, root, path, &new_key);
+                        btrfs_set_item_key_safe(root, path, &new_key);
                         fi = btrfs_item_ptr(leaf, path->slots[0],
                                             struct btrfs_file_extent_item);
                         btrfs_set_file_extent_generation(leaf, fi,
@@ -1072,7 +1075,7 @@ again:
                                                          trans->transid);
                         path->slots[0]++;
                         new_key.offset = start;
-                        btrfs_set_item_key_safe(trans, root, path, &new_key);
+                        btrfs_set_item_key_safe(root, path, &new_key);
 
                         fi = btrfs_item_ptr(leaf, path->slots[0],
                                             struct btrfs_file_extent_item);
@@ -1883,7 +1886,7 @@ static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
 
                 path->slots[0]++;
                 key.offset = offset;
-                btrfs_set_item_key_safe(trans, root, path, &key);
+                btrfs_set_item_key_safe(root, path, &key);
                 fi = btrfs_item_ptr(leaf, path->slots[0],
                                     struct btrfs_file_extent_item);
                 num_bytes = btrfs_file_extent_num_bytes(leaf, fi) + end -
@@ -1913,6 +1916,7 @@ out:
         } else {
                 hole_em->start = offset;
                 hole_em->len = end - offset;
+                hole_em->ram_bytes = hole_em->len;
                 hole_em->orig_start = offset;
 
                 hole_em->block_start = EXTENT_MAP_HOLE;
@@ -1925,10 +1929,7 @@ out:
                 do {
                         btrfs_drop_extent_cache(inode, offset, end - 1, 0);
                         write_lock(&em_tree->lock);
-                        ret = add_extent_mapping(em_tree, hole_em);
-                        if (!ret)
-                                list_move(&hole_em->list,
-                                          &em_tree->modified_extents);
+                        ret = add_extent_mapping(em_tree, hole_em, 1);
                         write_unlock(&em_tree->lock);
                 } while (ret == -EEXIST);
                 free_extent_map(hole_em);