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

Pull btrfs fixes from Chris Mason:
 "Almost all of these are bug fixes.  Dave Sterba's documentation update
  is the big exception because he removed our promises to set any
  machine running Btrfs on fire"

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs:
  Documentation: filesystems: update btrfs tools section
  Documentation: filesystems: add new btrfs mount options
  btrfs: update kconfig help text
  btrfs: fix bio_size_ok() for max_sectors > 0xffff
  btrfs: Use trace condition for get_extent tracepoint
  btrfs: fix typo in the log message
  Btrfs: fix list delete warning when removing ordered root from the list
  Btrfs: print bytenr instead of page pointer in check-int
  Btrfs: remove dead codes from ctree.h
  Btrfs: don't wait for ordered data outside desired range
  Btrfs: fix lockdep error in async commit
  Btrfs: avoid heavy operations in btrfs_commit_super
  Btrfs: fix __btrfs_start_workers retval
  Btrfs: disable online raid-repair on ro mounts
  Btrfs: do not inc uncorrectable_errors counter on ro scrubs
  Btrfs: only drop modified extents if we logged the whole inode
  Btrfs: make sure to copy everything if we rename
  Btrfs: don't BUG_ON() if we get an error walking backrefs

13 files changed, 53 insertions, 54 deletions

diff --git a/fs/btrfs/Kconfig b/fs/btrfs/Kconfig
index f9d5094e1029..aa976eced2d2 100644
--- a/fs/btrfs/Kconfig
+++ b/fs/btrfs/Kconfig
@@ -9,12 +9,17 @@ config BTRFS_FS
         select XOR_BLOCKS
 
         help
-          Btrfs is a new filesystem with extents, writable snapshotting,
-          support for multiple devices and many more features.
+          Btrfs is a general purpose copy-on-write filesystem with extents,
+          writable snapshotting, support for multiple devices and many more
+          features focused on fault tolerance, repair and easy administration.
 
-          Btrfs is highly experimental, and THE DISK FORMAT IS NOT YET
-          FINALIZED.  You should say N here unless you are interested in
-          testing Btrfs with non-critical data.
+          The filesystem disk format is no longer unstable, and it's not
+          expected to change unless there are strong reasons to do so. If there
+          is a format change, file systems with a unchanged format will
+          continue to be mountable and usable by newer kernels.
+
+          For more information, please see the web pages at
+          http://btrfs.wiki.kernel.org.
 
           To compile this file system support as a module, choose M here. The
           module will be called btrfs.
diff --git a/fs/btrfs/async-thread.c b/fs/btrfs/async-thread.c
index 8aec751fa464..c1e0b0caf9cc 100644
--- a/fs/btrfs/async-thread.c
+++ b/fs/btrfs/async-thread.c
@@ -495,6 +495,7 @@ static int __btrfs_start_workers(struct btrfs_workers *workers)
         spin_lock_irq(&workers->lock);
         if (workers->stopping) {
                 spin_unlock_irq(&workers->lock);
+                ret = -EINVAL;
                 goto fail_kthread;
         }
         list_add_tail(&worker->worker_list, &workers->idle_list);
diff --git a/fs/btrfs/check-integrity.c b/fs/btrfs/check-integrity.c
index e0aab4456974..b50764bef141 100644
--- a/fs/btrfs/check-integrity.c
+++ b/fs/btrfs/check-integrity.c
@@ -77,6 +77,15 @@
  * the integrity of (super)-block write requests, do not
  * enable the config option BTRFS_FS_CHECK_INTEGRITY to
  * include and compile the integrity check tool.
+ *
+ * Expect millions of lines of information in the kernel log with an
+ * enabled check_int_print_mask. Therefore set LOG_BUF_SHIFT in the
+ * kernel config to at least 26 (which is 64MB). Usually the value is
+ * limited to 21 (which is 2MB) in init/Kconfig. The file needs to be
+ * changed like this before LOG_BUF_SHIFT can be set to a high value:
+ * config LOG_BUF_SHIFT
+ *       int "Kernel log buffer size (16 => 64KB, 17 => 128KB)"
+ *       range 12 30
  */
 
 #include <linux/sched.h>
@@ -124,6 +133,7 @@
 #define BTRFSIC_PRINT_MASK_INITIAL_DATABASE                     0x00000400
 #define BTRFSIC_PRINT_MASK_NUM_COPIES                           0x00000800
 #define BTRFSIC_PRINT_MASK_TREE_WITH_ALL_MIRRORS                0x00001000
+#define BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH_VERBOSE                0x00002000
 
 struct btrfsic_dev_state;
 struct btrfsic_state;
@@ -3015,6 +3025,7 @@ void btrfsic_submit_bio(int rw, struct bio *bio)
             (rw & WRITE) && NULL != bio->bi_io_vec) {
                 unsigned int i;
                 u64 dev_bytenr;
+                u64 cur_bytenr;
                 int bio_is_patched;
                 char **mapped_datav;
 
@@ -3033,6 +3044,7 @@ void btrfsic_submit_bio(int rw, struct bio *bio)
                                        GFP_NOFS);
                 if (!mapped_datav)
                         goto leave;
+                cur_bytenr = dev_bytenr;
                 for (i = 0; i < bio->bi_vcnt; i++) {
                         BUG_ON(bio->bi_io_vec[i].bv_len != PAGE_CACHE_SIZE);
                         mapped_datav[i] = kmap(bio->bi_io_vec[i].bv_page);
@@ -3044,16 +3056,13 @@ void btrfsic_submit_bio(int rw, struct bio *bio)
                                 kfree(mapped_datav);
                                 goto leave;
                         }
-                        if ((BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
-                             BTRFSIC_PRINT_MASK_VERBOSE) ==
-                            (dev_state->state->print_mask &
-                             (BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH |
-                              BTRFSIC_PRINT_MASK_VERBOSE)))
+                        if (dev_state->state->print_mask &
+                            BTRFSIC_PRINT_MASK_SUBMIT_BIO_BH_VERBOSE)
                                 printk(KERN_INFO
-                                       "#%u: page=%p, len=%u, offset=%u\n",
-                                       i, bio->bi_io_vec[i].bv_page,
-                                       bio->bi_io_vec[i].bv_len,
+                                       "#%u: bytenr=%llu, len=%u, offset=%u\n",
+                                       i, cur_bytenr, bio->bi_io_vec[i].bv_len,
                                        bio->bi_io_vec[i].bv_offset);
+                        cur_bytenr += bio->bi_io_vec[i].bv_len;
                 }
                 btrfsic_process_written_block(dev_state, dev_bytenr,
                                               mapped_datav, bio->bi_vcnt,
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index f9aeb2759a64..54ab86127f7a 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -3613,9 +3613,6 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
                            struct btrfs_ordered_sum *sums);
 int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
                        struct bio *bio, u64 file_start, int contig);
-int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
-                        struct btrfs_root *root, struct btrfs_path *path,
-                        u64 isize);
 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
                              struct list_head *list, int search_commit);
 /* inode.c */
@@ -3744,9 +3741,6 @@ void btrfs_cleanup_defrag_inodes(struct btrfs_fs_info *fs_info);
 int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync);
 void btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end,
                              int skip_pinned);
-int btrfs_replace_extent_cache(struct inode *inode, struct extent_map *replace,
-                               u64 start, u64 end, int skip_pinned,
-                               int modified);
 extern const struct file_operations btrfs_file_operations;
 int __btrfs_drop_extents(struct btrfs_trans_handle *trans,
                          struct btrfs_root *root, struct inode *inode,
diff --git a/fs/btrfs/dev-replace.c b/fs/btrfs/dev-replace.c
index 342f9fd411e3..2cfc3dfff64f 100644
--- a/fs/btrfs/dev-replace.c
+++ b/fs/btrfs/dev-replace.c
@@ -366,7 +366,7 @@ int btrfs_dev_replace_start(struct btrfs_root *root,
         dev_replace->tgtdev = tgt_device;
 
         printk_in_rcu(KERN_INFO
-                      "btrfs: dev_replace from %s (devid %llu) to %s) started\n",
+                      "btrfs: dev_replace from %s (devid %llu) to %s started\n",
                       src_device->missing ? "<missing disk>" :
                         rcu_str_deref(src_device->name),
                       src_device->devid,
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 4c4ed0bb3da1..8072cfa8a3b1 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -3517,7 +3517,6 @@ int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
 int btrfs_commit_super(struct btrfs_root *root)
 {
         struct btrfs_trans_handle *trans;
-        int ret;
 
         mutex_lock(&root->fs_info->cleaner_mutex);
         btrfs_run_delayed_iputs(root);
@@ -3531,25 +3530,7 @@ int btrfs_commit_super(struct btrfs_root *root)
         trans = btrfs_join_transaction(root);
         if (IS_ERR(trans))
                 return PTR_ERR(trans);
-        ret = btrfs_commit_transaction(trans, root);
-        if (ret)
-                return ret;
-        /* run commit again to drop the original snapshot */
-        trans = btrfs_join_transaction(root);
-        if (IS_ERR(trans))
-                return PTR_ERR(trans);
-        ret = btrfs_commit_transaction(trans, root);
-        if (ret)
-                return ret;
-        ret = btrfs_write_and_wait_transaction(NULL, root);
-        if (ret) {
-                btrfs_error(root->fs_info, ret,
-                            "Failed to sync btree inode to disk.");
-                return ret;
-        }
-
-        ret = write_ctree_super(NULL, root, 0);
-        return ret;
+        return btrfs_commit_transaction(trans, root);
 }
 
 int close_ctree(struct btrfs_root *root)
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 856bc2b2192c..8e457fca0a0b 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -1980,6 +1980,7 @@ int repair_io_failure(struct btrfs_fs_info *fs_info, u64 start,
         struct btrfs_mapping_tree *map_tree = &fs_info->mapping_tree;
         int ret;
 
+        ASSERT(!(fs_info->sb->s_flags & MS_RDONLY));
         BUG_ON(!mirror_num);
 
         /* we can't repair anything in raid56 yet */
@@ -2036,6 +2037,9 @@ int repair_eb_io_failure(struct btrfs_root *root, struct extent_buffer *eb,
         unsigned long i, num_pages = num_extent_pages(eb->start, eb->len);
         int ret = 0;
 
+        if (root->fs_info->sb->s_flags & MS_RDONLY)
+                return -EROFS;
+
         for (i = 0; i < num_pages; i++) {
                 struct page *p = extent_buffer_page(eb, i);
                 ret = repair_io_failure(root->fs_info, start, PAGE_CACHE_SIZE,
@@ -2057,12 +2061,12 @@ static int clean_io_failure(u64 start, struct page *page)
         u64 private;
         u64 private_failure;
         struct io_failure_record *failrec;
-        struct btrfs_fs_info *fs_info;
+        struct inode *inode = page->mapping->host;
+        struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
         struct extent_state *state;
         int num_copies;
         int did_repair = 0;
         int ret;
-        struct inode *inode = page->mapping->host;
 
         private = 0;
         ret = count_range_bits(&BTRFS_I(inode)->io_failure_tree, &private,
@@ -2085,6 +2089,8 @@ static int clean_io_failure(u64 start, struct page *page)
                 did_repair = 1;
                 goto out;
         }
+        if (fs_info->sb->s_flags & MS_RDONLY)
+                goto out;
 
         spin_lock(&BTRFS_I(inode)->io_tree.lock);
         state = find_first_extent_bit_state(&BTRFS_I(inode)->io_tree,
@@ -2094,7 +2100,6 @@ static int clean_io_failure(u64 start, struct page *page)
 
         if (state && state->start <= failrec->start &&
             state->end >= failrec->start + failrec->len - 1) {
-                fs_info = BTRFS_I(inode)->root->fs_info;
                 num_copies = btrfs_num_copies(fs_info, failrec->logical,
                                               failrec->len);
                 if (num_copies > 1)  {
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index da8d2f696ac5..f1a77449d032 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -2129,7 +2129,8 @@ static noinline bool record_extent_backrefs(struct btrfs_path *path,
                                                   old->extent_offset, fs_info,
                                                   path, record_one_backref,
                                                   old);
-                BUG_ON(ret < 0 && ret != -ENOENT);
+                if (ret < 0 && ret != -ENOENT)
+                        return false;
 
                 /* no backref to be processed for this extent */
                 if (!old->count) {
@@ -6186,8 +6187,7 @@ insert:
         write_unlock(&em_tree->lock);
 out:
 
-        if (em)
-                trace_btrfs_get_extent(root, em);
+        trace_btrfs_get_extent(root, em);
 
         if (path)
                 btrfs_free_path(path);
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 25a8f3812f14..69582d5b69d1 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -638,6 +638,7 @@ void btrfs_wait_ordered_roots(struct btrfs_fs_info *fs_info, int nr)
                         WARN_ON(nr < 0);
                 }
         }
+        list_splice_tail(&splice, &fs_info->ordered_roots);
         spin_unlock(&fs_info->ordered_root_lock);
 }
 
@@ -803,7 +804,7 @@ int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
                         btrfs_put_ordered_extent(ordered);
                         break;
                 }
-                if (ordered->file_offset + ordered->len < start) {
+                if (ordered->file_offset + ordered->len <= start) {
                         btrfs_put_ordered_extent(ordered);
                         break;
                 }
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 2544805544f0..561e2f16ba3e 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -938,8 +938,10 @@ static int scrub_handle_errored_block(struct scrub_block *sblock_to_check)
                                 BTRFS_DEV_STAT_CORRUPTION_ERRS);
         }
 
-        if (sctx->readonly && !sctx->is_dev_replace)
-                goto did_not_correct_error;
+        if (sctx->readonly) {
+                ASSERT(!sctx->is_dev_replace);
+                goto out;
+        }
 
         if (!is_metadata && !have_csum) {
                 struct scrub_fixup_nodatasum *fixup_nodatasum;
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 57c16b46afbd..c6a872a8a468 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -1480,7 +1480,7 @@ static void do_async_commit(struct work_struct *work)
          * We've got freeze protection passed with the transaction.
          * Tell lockdep about it.
          */
-        if (ac->newtrans->type < TRANS_JOIN_NOLOCK)
+        if (ac->newtrans->type & __TRANS_FREEZABLE)
                 rwsem_acquire_read(
                      &ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
                      0, 1, _THIS_IP_);
@@ -1521,7 +1521,7 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
          * Tell lockdep we've released the freeze rwsem, since the
          * async commit thread will be the one to unlock it.
          */
-        if (trans->type < TRANS_JOIN_NOLOCK)
+        if (ac->newtrans->type & __TRANS_FREEZABLE)
                 rwsem_release(
                         &root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
                         1, _THIS_IP_);
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 744553c83fe2..9f7fc51ca334 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -3697,7 +3697,8 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
                         ret = btrfs_truncate_inode_items(trans, log,
                                                          inode, 0, 0);
                 } else if (test_and_clear_bit(BTRFS_INODE_COPY_EVERYTHING,
-                                              &BTRFS_I(inode)->runtime_flags)) {
+                                              &BTRFS_I(inode)->runtime_flags) ||
+                           inode_only == LOG_INODE_EXISTS) {
                         if (inode_only == LOG_INODE_ALL)
                                 fast_search = true;
                         max_key.type = BTRFS_XATTR_ITEM_KEY;
@@ -3801,7 +3802,7 @@ log_extents:
                         err = ret;
                         goto out_unlock;
                 }
-        } else {
+        } else if (inode_only == LOG_INODE_ALL) {
                 struct extent_map_tree *tree = &BTRFS_I(inode)->extent_tree;
                 struct extent_map *em, *n;
 
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 0db637097862..92303f42baaa 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -5394,7 +5394,7 @@ static int bio_size_ok(struct block_device *bdev, struct bio *bio,
 {
         struct bio_vec *prev;
         struct request_queue *q = bdev_get_queue(bdev);
-        unsigned short max_sectors = queue_max_sectors(q);
+        unsigned int max_sectors = queue_max_sectors(q);
         struct bvec_merge_data bvm = {
                 .bi_bdev = bdev,
                 .bi_sector = sector,