12 files changed, 85 insertions, 38 deletions

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index c38734a07a65..0d195b507660 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -3341,10 +3341,22 @@ ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size);
 /* super.c */
 int btrfs_parse_options(struct btrfs_root *root, char *options);
 int btrfs_sync_fs(struct super_block *sb, int wait);
+
+#ifdef CONFIG_PRINTK
+__printf(2, 3)
 void btrfs_printk(struct btrfs_fs_info *fs_info, const char *fmt, ...);
+#else
+static inline __printf(2, 3)
+void btrfs_printk(struct btrfs_fs_info *fs_info, const char *fmt, ...)
+{
+}
+#endif
+
+__printf(5, 6)
 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
                      unsigned int line, int errno, const char *fmt, ...);
 
+
 void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
                                struct btrfs_root *root, const char *function,
                                unsigned int line, int errno);
@@ -3385,6 +3397,7 @@ do {								\
                           (errno), fmt, ##args);                \
 } while (0)
 
+__printf(5, 6)
 void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
                    unsigned int line, int errno, const char *fmt, ...);
 
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 29c69e60d3b0..22e98e04c2ea 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1116,7 +1116,7 @@ void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
                                 spin_unlock(&root->fs_info->delalloc_lock);
                                 btrfs_panic(root->fs_info, -EOVERFLOW,
                                           "Can't clear %lu bytes from "
-                                          " dirty_mdatadata_bytes (%lu)",
+                                          " dirty_mdatadata_bytes (%llu)",
                                           buf->len,
                                           root->fs_info->dirty_metadata_bytes);
                         }
@@ -1616,8 +1616,6 @@ static int cleaner_kthread(void *arg)
         struct btrfs_root *root = arg;
 
         do {
-                vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
-
                 if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
                     mutex_trylock(&root->fs_info->cleaner_mutex)) {
                         btrfs_run_delayed_iputs(root);
@@ -1649,7 +1647,6 @@ static int transaction_kthread(void *arg)
         do {
                 cannot_commit = false;
                 delay = HZ * 30;
-                vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
                 mutex_lock(&root->fs_info->transaction_kthread_mutex);
 
                 spin_lock(&root->fs_info->trans_lock);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 49085f2336d2..4c878476bb91 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -929,7 +929,8 @@ int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits,
 
 
 /**
- * convert_extent - convert all bits in a given range from one bit to another
+ * convert_extent_bit - convert all bits in a given range from one bit to
+ *                      another
  * @tree:       the io tree to search
  * @start:      the start offset in bytes
  * @end:        the end offset in bytes (inclusive)
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 9aa01ec2138d..5caf285c6e4d 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1379,7 +1379,7 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
         ssize_t err = 0;
         size_t count, ocount;
 
-        vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
+        sb_start_write(inode->i_sb);
 
         mutex_lock(&inode->i_mutex);
 
@@ -1469,6 +1469,7 @@ static ssize_t btrfs_file_aio_write(struct kiocb *iocb,
                         num_written = err;
         }
 out:
+        sb_end_write(inode->i_sb);
         current->backing_dev_info = NULL;
         return num_written ? num_written : err;
 }
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 6ba80b902877..ec154f954646 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -324,7 +324,8 @@ static noinline int add_async_extent(struct async_cow *cow,
  * If this code finds it can't get good compression, it puts an
  * entry onto the work queue to write the uncompressed bytes.  This
  * makes sure that both compressed inodes and uncompressed inodes
- * are written in the same order that pdflush sent them down.
+ * are written in the same order that the flusher thread sent them
+ * down.
  */
 static noinline int compress_file_range(struct inode *inode,
                                         struct page *locked_page,
@@ -4249,7 +4250,7 @@ static void btrfs_dentry_release(struct dentry *dentry)
 }
 
 static struct dentry *btrfs_lookup(struct inode *dir, struct dentry *dentry,
-                                   struct nameidata *nd)
+                                   unsigned int flags)
 {
         struct dentry *ret;
 
@@ -4903,7 +4904,7 @@ out_unlock:
 }
 
 static int btrfs_create(struct inode *dir, struct dentry *dentry,
-                        umode_t mode, struct nameidata *nd)
+                        umode_t mode, bool excl)
 {
         struct btrfs_trans_handle *trans;
         struct btrfs_root *root = BTRFS_I(dir)->root;
@@ -6631,6 +6632,7 @@ int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
         u64 page_start;
         u64 page_end;
 
+        sb_start_pagefault(inode->i_sb);
         ret  = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
         if (!ret) {
                 ret = file_update_time(vma->vm_file);
@@ -6720,12 +6722,15 @@ again:
         unlock_extent_cached(io_tree, page_start, page_end, &cached_state, GFP_NOFS);
 
 out_unlock:
-        if (!ret)
+        if (!ret) {
+                sb_end_pagefault(inode->i_sb);
                 return VM_FAULT_LOCKED;
+        }
         unlock_page(page);
 out:
         btrfs_delalloc_release_space(inode, PAGE_CACHE_SIZE);
 out_noreserve:
+        sb_end_pagefault(inode->i_sb);
         return ret;
 }
 
@@ -6997,7 +7002,7 @@ void btrfs_destroy_inode(struct inode *inode)
         struct btrfs_ordered_extent *ordered;
         struct btrfs_root *root = BTRFS_I(inode)->root;
 
-        WARN_ON(!list_empty(&inode->i_dentry));
+        WARN_ON(!hlist_empty(&inode->i_dentry));
         WARN_ON(inode->i_data.nrpages);
         WARN_ON(BTRFS_I(inode)->outstanding_extents);
         WARN_ON(BTRFS_I(inode)->reserved_extents);
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index a1fbca0a1003..9df50fa8a078 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -195,6 +195,10 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
         if (!inode_owner_or_capable(inode))
                 return -EACCES;
 
+        ret = mnt_want_write_file(file);
+        if (ret)
+                return ret;
+
         mutex_lock(&inode->i_mutex);
 
         ip_oldflags = ip->flags;
@@ -209,10 +213,6 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
                 }
         }
 
-        ret = mnt_want_write_file(file);
-        if (ret)
-                goto out_unlock;
-
         if (flags & FS_SYNC_FL)
                 ip->flags |= BTRFS_INODE_SYNC;
         else
@@ -275,9 +275,9 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
                 inode->i_flags = i_oldflags;
         }
 
-        mnt_drop_write_file(file);
  out_unlock:
         mutex_unlock(&inode->i_mutex);
+        mnt_drop_write_file(file);
         return ret;
 }
 
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 643335a4fe3c..051c7fe551dd 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -596,7 +596,7 @@ void btrfs_start_ordered_extent(struct inode *inode,
         /*
          * pages in the range can be dirty, clean or writeback.  We
          * start IO on any dirty ones so the wait doesn't stall waiting
-         * for pdflush to find them
+         * for the flusher thread to find them
          */
         if (!test_bit(BTRFS_ORDERED_DIRECT, &entry->flags))
                 filemap_fdatawrite_range(inode->i_mapping, start, end);
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index c5dbd9149679..4da08652004d 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1241,7 +1241,7 @@ static int __must_check __add_reloc_root(struct btrfs_root *root)
         if (rb_node) {
                 btrfs_panic(root->fs_info, -EEXIST, "Duplicate root found "
                             "for start=%llu while inserting into relocation "
-                            "tree\n");
+                            "tree\n", node->bytenr);
                 kfree(node);
                 return -EEXIST;
         }
diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index bf232c88a0bf..fb5ffe95f869 100644
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -25,6 +25,7 @@
 #include <linux/posix_acl_xattr.h>
 #include <linux/radix-tree.h>
 #include <linux/crc32c.h>
+#include <linux/vmalloc.h>
 
 #include "send.h"
 #include "backref.h"
@@ -1993,7 +1994,7 @@ static int open_cur_inode_file(struct send_ctx *sctx)
 {
         int ret = 0;
         struct btrfs_key key;
-        struct vfsmount *mnt;
+        struct path path;
         struct inode *inode;
         struct dentry *dentry;
         struct file *filp;
@@ -2020,10 +2021,11 @@ static int open_cur_inode_file(struct send_ctx *sctx)
                 goto out;
         }
 
-        mnt = mntget(sctx->mnt);
-        filp = dentry_open(dentry, mnt, O_RDONLY | O_LARGEFILE, current_cred());
+        path.mnt = sctx->mnt;
+        path.dentry = dentry;
+        filp = dentry_open(&path, O_RDONLY | O_LARGEFILE, current_cred());
+        dput(dentry);
         dentry = NULL;
-        mnt = NULL;
         if (IS_ERR(filp)) {
                 ret = PTR_ERR(filp);
                 goto out;
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 073c2368f459..83d6f9f9c220 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -100,10 +100,6 @@ static void __save_error_info(struct btrfs_fs_info *fs_info)
         fs_info->fs_state = BTRFS_SUPER_FLAG_ERROR;
 }
 
-/* NOTE:
- *      We move write_super stuff at umount in order to avoid deadlock
- *      for umount hold all lock.
- */
 static void save_error_info(struct btrfs_fs_info *fs_info)
 {
         __save_error_info(fs_info);
@@ -125,6 +121,7 @@ static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
         }
 }
 
+#ifdef CONFIG_PRINTK
 /*
  * __btrfs_std_error decodes expected errors from the caller and
  * invokes the approciate error response.
@@ -167,7 +164,7 @@ void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
         va_end(args);
 }
 
-const char *logtypes[] = {
+static const char * const logtypes[] = {
         "emergency",
         "alert",
         "critical",
@@ -185,21 +182,49 @@ void btrfs_printk(struct btrfs_fs_info *fs_info, const char *fmt, ...)
         struct va_format vaf;
         va_list args;
         const char *type = logtypes[4];
+        int kern_level;
 
         va_start(args, fmt);
 
-        if (fmt[0] == '<' && isdigit(fmt[1]) && fmt[2] == '>') {
-                memcpy(lvl, fmt, 3);
-                lvl[3] = '\0';
-                fmt += 3;
-                type = logtypes[fmt[1] - '0'];
+        kern_level = printk_get_level(fmt);
+        if (kern_level) {
+                size_t size = printk_skip_level(fmt) - fmt;
+                memcpy(lvl, fmt,  size);
+                lvl[size] = '\0';
+                fmt += size;
+                type = logtypes[kern_level - '0'];
         } else
                 *lvl = '\0';
 
         vaf.fmt = fmt;
         vaf.va = &args;
+
         printk("%sBTRFS %s (device %s): %pV", lvl, type, sb->s_id, &vaf);
+
+        va_end(args);
+}
+
+#else
+
+void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
+                       unsigned int line, int errno, const char *fmt, ...)
+{
+        struct super_block *sb = fs_info->sb;
+
+        /*
+         * Special case: if the error is EROFS, and we're already
+         * under MS_RDONLY, then it is safe here.
+         */
+        if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
+                return;
+
+        /* Don't go through full error handling during mount */
+        if (sb->s_flags & MS_BORN) {
+                save_error_info(fs_info);
+                btrfs_handle_error(fs_info);
+        }
 }
+#endif
 
 /*
  * We only mark the transaction aborted and then set the file system read-only.
@@ -1081,7 +1106,8 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
         }
 
         bdev = fs_devices->latest_bdev;
-        s = sget(fs_type, btrfs_test_super, btrfs_set_super, fs_info);
+        s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
+                 fs_info);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto error_close_devices;
@@ -1095,7 +1121,6 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
         } else {
                 char b[BDEVNAME_SIZE];
 
-                s->s_flags = flags | MS_NOSEC;
                 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
                 btrfs_sb(s)->bdev_holder = fs_type;
                 error = btrfs_fill_super(s, fs_devices, data,
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 3ee8d58e97ad..27c26004e050 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -335,6 +335,8 @@ again:
         if (!h)
                 return ERR_PTR(-ENOMEM);
 
+        sb_start_intwrite(root->fs_info->sb);
+
         if (may_wait_transaction(root, type))
                 wait_current_trans(root);
 
@@ -345,6 +347,7 @@ again:
         } while (ret == -EBUSY);
 
         if (ret < 0) {
+                sb_end_intwrite(root->fs_info->sb);
                 kmem_cache_free(btrfs_trans_handle_cachep, h);
                 return ERR_PTR(ret);
         }
@@ -548,6 +551,8 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
         btrfs_trans_release_metadata(trans, root);
         trans->block_rsv = NULL;
 
+        sb_end_intwrite(root->fs_info->sb);
+
         if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
             should_end_transaction(trans, root)) {
                 trans->transaction->blocked = 1;
@@ -1579,6 +1584,8 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
         put_transaction(cur_trans);
         put_transaction(cur_trans);
 
+        sb_end_intwrite(root->fs_info->sb);
+
         trace_btrfs_transaction_commit(root);
 
         btrfs_scrub_continue(root);
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 3f4e70e171ed..88b969aeeb71 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -1745,10 +1745,6 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path)
 
         device->fs_devices = root->fs_info->fs_devices;
 
-        /*
-         * we don't want write_supers to jump in here with our device
-         * half setup
-         */
         mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
         list_add_rcu(&device->dev_list, &root->fs_info->fs_devices->devices);
         list_add(&device->dev_alloc_list,