Merge 4.7-rc6 into usb-next

We want the USB fixes in here as well.

Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

13 files changed, 91 insertions, 49 deletions

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 6276add8538a..a85cf7d23309 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -1786,10 +1786,12 @@ static noinline int generic_bin_search(struct extent_buffer *eb,
                         if (!err) {
                                 tmp = (struct btrfs_disk_key *)(kaddr + offset -
                                                         map_start);
-                        } else {
+                        } else if (err == 1) {
                                 read_extent_buffer(eb, &unaligned,
                                                    offset, sizeof(unaligned));
                                 tmp = &unaligned;
+                        } else {
+                                return err;
                         }
 
                 } else {
@@ -2830,6 +2832,8 @@ cow_done:
                 }
 
                 ret = key_search(b, key, level, &prev_cmp, &slot);
+                if (ret < 0)
+                        goto done;
 
                 if (level != 0) {
                         int dec = 0;
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 101c3cfd3f7c..4274a7bfdaed 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2518,7 +2518,7 @@ void btrfs_put_block_group(struct btrfs_block_group_cache *cache);
 int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
                            struct btrfs_root *root, unsigned long count);
 int btrfs_async_run_delayed_refs(struct btrfs_root *root,
-                                 unsigned long count, int wait);
+                                 unsigned long count, u64 transid, int wait);
 int btrfs_lookup_data_extent(struct btrfs_root *root, u64 start, u64 len);
 int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root, u64 bytenr,
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 61561c2a3f96..d3aaabbfada0 100644
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -1606,15 +1606,23 @@ int btrfs_inode_delayed_dir_index_count(struct inode *inode)
         return 0;
 }
 
-void btrfs_get_delayed_items(struct inode *inode, struct list_head *ins_list,
-                             struct list_head *del_list)
+bool btrfs_readdir_get_delayed_items(struct inode *inode,
+                                     struct list_head *ins_list,
+                                     struct list_head *del_list)
 {
         struct btrfs_delayed_node *delayed_node;
         struct btrfs_delayed_item *item;
 
         delayed_node = btrfs_get_delayed_node(inode);
         if (!delayed_node)
-                return;
+                return false;
+
+        /*
+         * We can only do one readdir with delayed items at a time because of
+         * item->readdir_list.
+         */
+        inode_unlock_shared(inode);
+        inode_lock(inode);
 
         mutex_lock(&delayed_node->mutex);
         item = __btrfs_first_delayed_insertion_item(delayed_node);
@@ -1641,10 +1649,13 @@ void btrfs_get_delayed_items(struct inode *inode, struct list_head *ins_list,
          * requeue or dequeue this delayed node.
          */
         atomic_dec(&delayed_node->refs);
+
+        return true;
 }
 
-void btrfs_put_delayed_items(struct list_head *ins_list,
-                             struct list_head *del_list)
+void btrfs_readdir_put_delayed_items(struct inode *inode,
+                                     struct list_head *ins_list,
+                                     struct list_head *del_list)
 {
         struct btrfs_delayed_item *curr, *next;
 
@@ -1659,6 +1670,12 @@ void btrfs_put_delayed_items(struct list_head *ins_list,
                 if (atomic_dec_and_test(&curr->refs))
                         kfree(curr);
         }
+
+        /*
+         * The VFS is going to do up_read(), so we need to downgrade back to a
+         * read lock.
+         */
+        downgrade_write(&inode->i_rwsem);
 }
 
 int btrfs_should_delete_dir_index(struct list_head *del_list,
diff --git a/fs/btrfs/delayed-inode.h b/fs/btrfs/delayed-inode.h
index 0167853c84ae..2495b3d4075f 100644
--- a/fs/btrfs/delayed-inode.h
+++ b/fs/btrfs/delayed-inode.h
@@ -137,10 +137,12 @@ void btrfs_kill_all_delayed_nodes(struct btrfs_root *root);
 void btrfs_destroy_delayed_inodes(struct btrfs_root *root);
 
 /* Used for readdir() */
-void btrfs_get_delayed_items(struct inode *inode, struct list_head *ins_list,
-                             struct list_head *del_list);
-void btrfs_put_delayed_items(struct list_head *ins_list,
-                             struct list_head *del_list);
+bool btrfs_readdir_get_delayed_items(struct inode *inode,
+                                     struct list_head *ins_list,
+                                     struct list_head *del_list);
+void btrfs_readdir_put_delayed_items(struct inode *inode,
+                                     struct list_head *ins_list,
+                                     struct list_head *del_list);
 int btrfs_should_delete_dir_index(struct list_head *del_list,
                                   u64 index);
 int btrfs_readdir_delayed_dir_index(struct dir_context *ctx,
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 54cca7a1572b..60ce1190307b 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -2806,7 +2806,7 @@ int open_ctree(struct super_block *sb,
 
         nodesize = btrfs_super_nodesize(disk_super);
         sectorsize = btrfs_super_sectorsize(disk_super);
-        stripesize = btrfs_super_stripesize(disk_super);
+        stripesize = sectorsize;
         fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));
         fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
 
@@ -4133,9 +4133,7 @@ static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
                        btrfs_super_bytes_used(sb));
                 ret = -EINVAL;
         }
-        if (!is_power_of_2(btrfs_super_stripesize(sb)) ||
-                ((btrfs_super_stripesize(sb) != sectorsize) &&
-                        (btrfs_super_stripesize(sb) != 4096))) {
+        if (!is_power_of_2(btrfs_super_stripesize(sb))) {
                 btrfs_err(fs_info, "invalid stripesize %u",
                        btrfs_super_stripesize(sb));
                 ret = -EINVAL;
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 29e5d000bbee..82b912a293ab 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -2835,6 +2835,7 @@ int btrfs_should_throttle_delayed_refs(struct btrfs_trans_handle *trans,
 
 struct async_delayed_refs {
         struct btrfs_root *root;
+        u64 transid;
         int count;
         int error;
         int sync;
@@ -2850,6 +2851,10 @@ static void delayed_ref_async_start(struct btrfs_work *work)
 
         async = container_of(work, struct async_delayed_refs, work);
 
+        /* if the commit is already started, we don't need to wait here */
+        if (btrfs_transaction_blocked(async->root->fs_info))
+                goto done;
+
         trans = btrfs_join_transaction(async->root);
         if (IS_ERR(trans)) {
                 async->error = PTR_ERR(trans);
@@ -2861,10 +2866,15 @@ static void delayed_ref_async_start(struct btrfs_work *work)
          * wait on delayed refs
          */
         trans->sync = true;
+
+        /* Don't bother flushing if we got into a different transaction */
+        if (trans->transid > async->transid)
+                goto end;
+
         ret = btrfs_run_delayed_refs(trans, async->root, async->count);
         if (ret)
                 async->error = ret;
-
+end:
         ret = btrfs_end_transaction(trans, async->root);
         if (ret && !async->error)
                 async->error = ret;
@@ -2876,7 +2886,7 @@ done:
 }
 
 int btrfs_async_run_delayed_refs(struct btrfs_root *root,
-                                 unsigned long count, int wait)
+                                 unsigned long count, u64 transid, int wait)
 {
         struct async_delayed_refs *async;
         int ret;
@@ -2888,6 +2898,7 @@ int btrfs_async_run_delayed_refs(struct btrfs_root *root,
         async->root = root->fs_info->tree_root;
         async->count = count;
         async->error = 0;
+        async->transid = transid;
         if (wait)
                 async->sync = 1;
         else
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index aaee3ef55ed8..75533adef998 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -5342,6 +5342,11 @@ int read_extent_buffer_to_user(struct extent_buffer *eb, void __user *dstv,
         return ret;
 }
 
+/*
+ * return 0 if the item is found within a page.
+ * return 1 if the item spans two pages.
+ * return -EINVAL otherwise.
+ */
 int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
                                unsigned long min_len, char **map,
                                unsigned long *map_start,
@@ -5356,7 +5361,7 @@ int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
                 PAGE_SHIFT;
 
         if (i != end_i)
-                return -EINVAL;
+                return 1;
 
         if (i == 0) {
                 offset = start_offset;
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index e0c9bd3fb02d..2234e88cf674 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1534,30 +1534,30 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
                 reserve_bytes = round_up(write_bytes + sector_offset,
                                 root->sectorsize);
 
-                if ((BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW |
-                                              BTRFS_INODE_PREALLOC)) &&
-                    check_can_nocow(inode, pos, &write_bytes) > 0) {
-                        /*
-                         * For nodata cow case, no need to reserve
-                         * data space.
-                         */
-                        only_release_metadata = true;
-                        /*
-                         * our prealloc extent may be smaller than
-                         * write_bytes, so scale down.
-                         */
-                        num_pages = DIV_ROUND_UP(write_bytes + offset,
-                                                 PAGE_SIZE);
-                        reserve_bytes = round_up(write_bytes + sector_offset,
-                                        root->sectorsize);
-                        goto reserve_metadata;
-                }
-
                 ret = btrfs_check_data_free_space(inode, pos, write_bytes);
-                if (ret < 0)
-                        break;
+                if (ret < 0) {
+                        if ((BTRFS_I(inode)->flags & (BTRFS_INODE_NODATACOW |
+                                                      BTRFS_INODE_PREALLOC)) &&
+                            check_can_nocow(inode, pos, &write_bytes) > 0) {
+                                /*
+                                 * For nodata cow case, no need to reserve
+                                 * data space.
+                                 */
+                                only_release_metadata = true;
+                                /*
+                                 * our prealloc extent may be smaller than
+                                 * write_bytes, so scale down.
+                                 */
+                                num_pages = DIV_ROUND_UP(write_bytes + offset,
+                                                         PAGE_SIZE);
+                                reserve_bytes = round_up(write_bytes +
+                                                         sector_offset,
+                                                         root->sectorsize);
+                        } else {
+                                break;
+                        }
+                }
 
-reserve_metadata:
                 ret = btrfs_delalloc_reserve_metadata(inode, reserve_bytes);
                 if (ret) {
                         if (!only_release_metadata)
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index d2be95cfb6d1..4421954720b8 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4558,6 +4558,7 @@ delete:
                         BUG_ON(ret);
                         if (btrfs_should_throttle_delayed_refs(trans, root))
                                 btrfs_async_run_delayed_refs(root,
+                                                             trans->transid,
                                         trans->delayed_ref_updates * 2, 0);
                         if (be_nice) {
                                 if (truncate_space_check(trans, root,
@@ -5757,6 +5758,7 @@ static int btrfs_real_readdir(struct file *file, struct dir_context *ctx)
         int name_len;
         int is_curr = 0;        /* ctx->pos points to the current index? */
         bool emitted;
+        bool put = false;
 
         /* FIXME, use a real flag for deciding about the key type */
         if (root->fs_info->tree_root == root)
@@ -5774,7 +5776,8 @@ static int btrfs_real_readdir(struct file *file, struct dir_context *ctx)
         if (key_type == BTRFS_DIR_INDEX_KEY) {
                 INIT_LIST_HEAD(&ins_list);
                 INIT_LIST_HEAD(&del_list);
-                btrfs_get_delayed_items(inode, &ins_list, &del_list);
+                put = btrfs_readdir_get_delayed_items(inode, &ins_list,
+                                                      &del_list);
         }
 
         key.type = key_type;
@@ -5921,8 +5924,8 @@ next:
 nopos:
         ret = 0;
 err:
-        if (key_type == BTRFS_DIR_INDEX_KEY)
-                btrfs_put_delayed_items(&ins_list, &del_list);
+        if (put)
+                btrfs_readdir_put_delayed_items(inode, &ins_list, &del_list);
         btrfs_free_path(path);
         return ret;
 }
@@ -10534,7 +10537,7 @@ static const struct inode_operations btrfs_dir_ro_inode_operations = {
 static const struct file_operations btrfs_dir_file_operations = {
         .llseek         = generic_file_llseek,
         .read           = generic_read_dir,
-        .iterate        = btrfs_real_readdir,
+        .iterate_shared = btrfs_real_readdir,
         .unlocked_ioctl = btrfs_ioctl,
 #ifdef CONFIG_COMPAT
         .compat_ioctl   = btrfs_compat_ioctl,
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index e96634a725c3..aca8264f4a49 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -968,6 +968,7 @@ int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
         struct rb_node *prev = NULL;
         struct btrfs_ordered_extent *test;
         int ret = 1;
+        u64 orig_offset = offset;
 
         spin_lock_irq(&tree->lock);
         if (ordered) {
@@ -983,7 +984,7 @@ int btrfs_ordered_update_i_size(struct inode *inode, u64 offset,
 
         /* truncate file */
         if (disk_i_size > i_size) {
-                BTRFS_I(inode)->disk_i_size = i_size;
+                BTRFS_I(inode)->disk_i_size = orig_offset;
                 ret = 0;
                 goto out;
         }
diff --git a/fs/btrfs/tests/btrfs-tests.c b/fs/btrfs/tests/btrfs-tests.c
index 10eb249ef891..02223f3f78f4 100644
--- a/fs/btrfs/tests/btrfs-tests.c
+++ b/fs/btrfs/tests/btrfs-tests.c
@@ -68,7 +68,7 @@ int btrfs_init_test_fs(void)
         if (IS_ERR(test_mnt)) {
                 printk(KERN_ERR "btrfs: cannot mount test file system\n");
                 unregister_filesystem(&test_type);
-                return ret;
+                return PTR_ERR(test_mnt);
         }
         return 0;
 }
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 765845742fde..948aa186b353 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -818,6 +818,7 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
 {
         struct btrfs_transaction *cur_trans = trans->transaction;
         struct btrfs_fs_info *info = root->fs_info;
+        u64 transid = trans->transid;
         unsigned long cur = trans->delayed_ref_updates;
         int lock = (trans->type != TRANS_JOIN_NOLOCK);
         int err = 0;
@@ -905,7 +906,7 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
 
         kmem_cache_free(btrfs_trans_handle_cachep, trans);
         if (must_run_delayed_refs) {
-                btrfs_async_run_delayed_refs(root, cur,
+                btrfs_async_run_delayed_refs(root, cur, transid,
                                              must_run_delayed_refs == 1);
         }
         return err;
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 2f631b58ae00..589f128173b1 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -4694,12 +4694,12 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans,
 
         if (type & BTRFS_BLOCK_GROUP_RAID5) {
                 raid_stripe_len = find_raid56_stripe_len(ndevs - 1,
-                                 btrfs_super_stripesize(info->super_copy));
+                                                extent_root->stripesize);
                 data_stripes = num_stripes - 1;
         }
         if (type & BTRFS_BLOCK_GROUP_RAID6) {
                 raid_stripe_len = find_raid56_stripe_len(ndevs - 2,
-                                 btrfs_super_stripesize(info->super_copy));
+                                                extent_root->stripesize);
                 data_stripes = num_stripes - 2;
         }