35 files changed, 362 insertions, 199 deletions

diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index d84089349c82..2e667868e0d2 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -1228,6 +1228,7 @@ static void reada_for_search(struct btrfs_root *root,
         u32 nr;
         u32 blocksize;
         u32 nscan = 0;
+        bool map = true;
 
         if (level != 1)
                 return;
@@ -1249,8 +1250,11 @@ static void reada_for_search(struct btrfs_root *root,
 
         nritems = btrfs_header_nritems(node);
         nr = slot;
+        if (node->map_token || path->skip_locking)
+                map = false;
+
         while (1) {
-                if (!node->map_token) {
+                if (map && !node->map_token) {
                         unsigned long offset = btrfs_node_key_ptr_offset(nr);
                         map_private_extent_buffer(node, offset,
                                                   sizeof(struct btrfs_key_ptr),
@@ -1277,7 +1281,7 @@ static void reada_for_search(struct btrfs_root *root,
                 if ((search <= target && target - search <= 65536) ||
                     (search > target && search - target <= 65536)) {
                         gen = btrfs_node_ptr_generation(node, nr);
-                        if (node->map_token) {
+                        if (map && node->map_token) {
                                 unmap_extent_buffer(node, node->map_token,
                                                     KM_USER1);
                                 node->map_token = NULL;
@@ -1289,7 +1293,7 @@ static void reada_for_search(struct btrfs_root *root,
                 if ((nread > 65536 || nscan > 32))
                         break;
         }
-        if (node->map_token) {
+        if (map && node->map_token) {
                 unmap_extent_buffer(node, node->map_token, KM_USER1);
                 node->map_token = NULL;
         }
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index a203d363184d..9f68c6898653 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1668,8 +1668,6 @@ struct btrfs_root *open_ctree(struct super_block *sb,
         init_waitqueue_head(&fs_info->scrub_pause_wait);
         init_rwsem(&fs_info->scrub_super_lock);
         fs_info->scrub_workers_refcnt = 0;
-        btrfs_init_workers(&fs_info->scrub_workers, "scrub",
-                           fs_info->thread_pool_size, &fs_info->generic_worker);
 
         sb->s_blocksize = 4096;
         sb->s_blocksize_bits = blksize_bits(4096);
@@ -2911,9 +2909,8 @@ static int btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
 
         INIT_LIST_HEAD(&splice);
 
-        list_splice_init(&root->fs_info->delalloc_inodes, &splice);
-
         spin_lock(&root->fs_info->delalloc_lock);
+        list_splice_init(&root->fs_info->delalloc_inodes, &splice);
 
         while (!list_empty(&splice)) {
                 btrfs_inode = list_entry(splice.next, struct btrfs_inode,
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 5b9b6b6df242..b42efc2ded51 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -3089,6 +3089,13 @@ alloc:
                         }
                         goto again;
                 }
+
+                /*
+                 * If we have less pinned bytes than we want to allocate then
+                 * don't bother committing the transaction, it won't help us.
+                 */
+                if (data_sinfo->bytes_pinned < bytes)
+                        committed = 1;
                 spin_unlock(&data_sinfo->lock);
 
                 /* commit the current transaction and try again */
@@ -5211,9 +5218,7 @@ loop:
          * LOOP_NO_EMPTY_SIZE, set empty_size and empty_cluster to 0 and try
          *                      again
          */
-        if (!ins->objectid && loop < LOOP_NO_EMPTY_SIZE &&
-            (found_uncached_bg || empty_size || empty_cluster ||
-             allowed_chunk_alloc)) {
+        if (!ins->objectid && loop < LOOP_NO_EMPTY_SIZE) {
                 index = 0;
                 if (loop == LOOP_FIND_IDEAL && found_uncached_bg) {
                         found_uncached_bg = false;
@@ -5253,32 +5258,36 @@ loop:
                         goto search;
                 }
 
-                if (loop < LOOP_CACHING_WAIT) {
-                        loop++;
-                        goto search;
-                }
+                loop++;
 
                 if (loop == LOOP_ALLOC_CHUNK) {
-                        empty_size = 0;
-                        empty_cluster = 0;
-                }
+                       if (allowed_chunk_alloc) {
+                                ret = do_chunk_alloc(trans, root, num_bytes +
+                                                     2 * 1024 * 1024, data,
+                                                     CHUNK_ALLOC_LIMITED);
+                                allowed_chunk_alloc = 0;
+                                if (ret == 1)
+                                        done_chunk_alloc = 1;
+                        } else if (!done_chunk_alloc &&
+                                   space_info->force_alloc ==
+                                   CHUNK_ALLOC_NO_FORCE) {
+                                space_info->force_alloc = CHUNK_ALLOC_LIMITED;
+                        }
 
-                if (allowed_chunk_alloc) {
-                        ret = do_chunk_alloc(trans, root, num_bytes +
-                                             2 * 1024 * 1024, data,
-                                             CHUNK_ALLOC_LIMITED);
-                        allowed_chunk_alloc = 0;
-                        done_chunk_alloc = 1;
-                } else if (!done_chunk_alloc &&
-                           space_info->force_alloc == CHUNK_ALLOC_NO_FORCE) {
-                        space_info->force_alloc = CHUNK_ALLOC_LIMITED;
+                       /*
+                        * We didn't allocate a chunk, go ahead and drop the
+                        * empty size and loop again.
+                        */
+                       if (!done_chunk_alloc)
+                               loop = LOOP_NO_EMPTY_SIZE;
                 }
 
-                if (loop < LOOP_NO_EMPTY_SIZE) {
-                        loop++;
-                        goto search;
+                if (loop == LOOP_NO_EMPTY_SIZE) {
+                        empty_size = 0;
+                        empty_cluster = 0;
                 }
-                ret = -ENOSPC;
+
+                goto search;
         } else if (!ins->objectid) {
                 ret = -ENOSPC;
         } else if (ins->objectid) {
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 4e8445a4757c..a11a92ee2d30 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -126,9 +126,9 @@ struct extent_buffer {
         unsigned long map_len;
         struct page *first_page;
         unsigned long bflags;
-        atomic_t refs;
         struct list_head leak_list;
         struct rcu_head rcu_head;
+        atomic_t refs;
 
         /* the spinlock is used to protect most operations */
         spinlock_t lock;
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index ad144736a5fd..9f985a429877 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -250,7 +250,7 @@ int __load_free_space_cache(struct btrfs_root *root, struct inode *inode,
         pgoff_t index = 0;
         unsigned long first_page_offset;
         int num_checksums;
-        int ret = 0, ret2;
+        int ret = 0;
 
         INIT_LIST_HEAD(&bitmaps);
 
@@ -421,11 +421,10 @@ int __load_free_space_cache(struct btrfs_root *root, struct inode *inode,
                                         goto free_cache;
                                 }
                                 spin_lock(&ctl->tree_lock);
-                                ret2 = link_free_space(ctl, e);
+                                ret = link_free_space(ctl, e);
                                 ctl->total_bitmaps++;
                                 ctl->op->recalc_thresholds(ctl);
                                 spin_unlock(&ctl->tree_lock);
-                                list_add_tail(&e->list, &bitmaps);
                                 if (ret) {
                                         printk(KERN_ERR "Duplicate entries in "
                                                "free space cache, dumping\n");
@@ -434,6 +433,7 @@ int __load_free_space_cache(struct btrfs_root *root, struct inode *inode,
                                         page_cache_release(page);
                                         goto free_cache;
                                 }
+                                list_add_tail(&e->list, &bitmaps);
                         }
 
                         num_entries--;
@@ -1417,6 +1417,23 @@ again:
         return 0;
 }
 
+static u64 add_bytes_to_bitmap(struct btrfs_free_space_ctl *ctl,
+                               struct btrfs_free_space *info, u64 offset,
+                               u64 bytes)
+{
+        u64 bytes_to_set = 0;
+        u64 end;
+
+        end = info->offset + (u64)(BITS_PER_BITMAP * ctl->unit);
+
+        bytes_to_set = min(end - offset, bytes);
+
+        bitmap_set_bits(ctl, info, offset, bytes_to_set);
+
+        return bytes_to_set;
+
+}
+
 static bool use_bitmap(struct btrfs_free_space_ctl *ctl,
                       struct btrfs_free_space *info)
 {
@@ -1453,12 +1470,18 @@ static bool use_bitmap(struct btrfs_free_space_ctl *ctl,
         return true;
 }
 
+static struct btrfs_free_space_op free_space_op = {
+        .recalc_thresholds      = recalculate_thresholds,
+        .use_bitmap             = use_bitmap,
+};
+
 static int insert_into_bitmap(struct btrfs_free_space_ctl *ctl,
                               struct btrfs_free_space *info)
 {
         struct btrfs_free_space *bitmap_info;
+        struct btrfs_block_group_cache *block_group = NULL;
         int added = 0;
-        u64 bytes, offset, end;
+        u64 bytes, offset, bytes_added;
         int ret;
 
         bytes = info->bytes;
@@ -1467,7 +1490,49 @@ static int insert_into_bitmap(struct btrfs_free_space_ctl *ctl,
         if (!ctl->op->use_bitmap(ctl, info))
                 return 0;
 
+        if (ctl->op == &free_space_op)
+                block_group = ctl->private;
 again:
+        /*
+         * Since we link bitmaps right into the cluster we need to see if we
+         * have a cluster here, and if so and it has our bitmap we need to add
+         * the free space to that bitmap.
+         */
+        if (block_group && !list_empty(&block_group->cluster_list)) {
+                struct btrfs_free_cluster *cluster;
+                struct rb_node *node;
+                struct btrfs_free_space *entry;
+
+                cluster = list_entry(block_group->cluster_list.next,
+                                     struct btrfs_free_cluster,
+                                     block_group_list);
+                spin_lock(&cluster->lock);
+                node = rb_first(&cluster->root);
+                if (!node) {
+                        spin_unlock(&cluster->lock);
+                        goto no_cluster_bitmap;
+                }
+
+                entry = rb_entry(node, struct btrfs_free_space, offset_index);
+                if (!entry->bitmap) {
+                        spin_unlock(&cluster->lock);
+                        goto no_cluster_bitmap;
+                }
+
+                if (entry->offset == offset_to_bitmap(ctl, offset)) {
+                        bytes_added = add_bytes_to_bitmap(ctl, entry,
+                                                          offset, bytes);
+                        bytes -= bytes_added;
+                        offset += bytes_added;
+                }
+                spin_unlock(&cluster->lock);
+                if (!bytes) {
+                        ret = 1;
+                        goto out;
+                }
+        }
+
+no_cluster_bitmap:
         bitmap_info = tree_search_offset(ctl, offset_to_bitmap(ctl, offset),
                                          1, 0);
         if (!bitmap_info) {
@@ -1475,19 +1540,10 @@ again:
                 goto new_bitmap;
         }
 
-        end = bitmap_info->offset + (u64)(BITS_PER_BITMAP * ctl->unit);
-
-        if (offset >= bitmap_info->offset && offset + bytes > end) {
-                bitmap_set_bits(ctl, bitmap_info, offset, end - offset);
-                bytes -= end - offset;
-                offset = end;
-                added = 0;
-        } else if (offset >= bitmap_info->offset && offset + bytes <= end) {
-                bitmap_set_bits(ctl, bitmap_info, offset, bytes);
-                bytes = 0;
-        } else {
-                BUG();
-        }
+        bytes_added = add_bytes_to_bitmap(ctl, bitmap_info, offset, bytes);
+        bytes -= bytes_added;
+        offset += bytes_added;
+        added = 0;
 
         if (!bytes) {
                 ret = 1;
@@ -1766,11 +1822,6 @@ void btrfs_dump_free_space(struct btrfs_block_group_cache *block_group,
                "\n", count);
 }
 
-static struct btrfs_free_space_op free_space_op = {
-        .recalc_thresholds      = recalculate_thresholds,
-        .use_bitmap             = use_bitmap,
-};
-
 void btrfs_init_free_space_ctl(struct btrfs_block_group_cache *block_group)
 {
         struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
@@ -2142,9 +2193,11 @@ again:
 /*
  * This searches the block group for just extents to fill the cluster with.
  */
-static int setup_cluster_no_bitmap(struct btrfs_block_group_cache *block_group,
-                                   struct btrfs_free_cluster *cluster,
-                                   u64 offset, u64 bytes, u64 min_bytes)
+static noinline int
+setup_cluster_no_bitmap(struct btrfs_block_group_cache *block_group,
+                        struct btrfs_free_cluster *cluster,
+                        struct list_head *bitmaps, u64 offset, u64 bytes,
+                        u64 min_bytes)
 {
         struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
         struct btrfs_free_space *first = NULL;
@@ -2166,6 +2219,8 @@ static int setup_cluster_no_bitmap(struct btrfs_block_group_cache *block_group,
          * extent entry.
          */
         while (entry->bitmap) {
+                if (list_empty(&entry->list))
+                        list_add_tail(&entry->list, bitmaps);
                 node = rb_next(&entry->offset_index);
                 if (!node)
                         return -ENOSPC;
@@ -2185,8 +2240,12 @@ static int setup_cluster_no_bitmap(struct btrfs_block_group_cache *block_group,
                         return -ENOSPC;
                 entry = rb_entry(node, struct btrfs_free_space, offset_index);
 
-                if (entry->bitmap)
+                if (entry->bitmap) {
+                        if (list_empty(&entry->list))
+                                list_add_tail(&entry->list, bitmaps);
                         continue;
+                }
+
                 /*
                  * we haven't filled the empty size and the window is
                  * very large.  reset and try again
@@ -2238,9 +2297,11 @@ static int setup_cluster_no_bitmap(struct btrfs_block_group_cache *block_group,
  * This specifically looks for bitmaps that may work in the cluster, we assume
  * that we have already failed to find extents that will work.
  */
-static int setup_cluster_bitmap(struct btrfs_block_group_cache *block_group,
-                                struct btrfs_free_cluster *cluster,
-                                u64 offset, u64 bytes, u64 min_bytes)
+static noinline int
+setup_cluster_bitmap(struct btrfs_block_group_cache *block_group,
+                     struct btrfs_free_cluster *cluster,
+                     struct list_head *bitmaps, u64 offset, u64 bytes,
+                     u64 min_bytes)
 {
         struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
         struct btrfs_free_space *entry;
@@ -2250,10 +2311,39 @@ static int setup_cluster_bitmap(struct btrfs_block_group_cache *block_group,
         if (ctl->total_bitmaps == 0)
                 return -ENOSPC;
 
+        /*
+         * First check our cached list of bitmaps and see if there is an entry
+         * here that will work.
+         */
+        list_for_each_entry(entry, bitmaps, list) {
+                if (entry->bytes < min_bytes)
+                        continue;
+                ret = btrfs_bitmap_cluster(block_group, entry, cluster, offset,
+                                           bytes, min_bytes);
+                if (!ret)
+                        return 0;
+        }
+
+        /*
+         * If we do have entries on our list and we are here then we didn't find
+         * anything, so go ahead and get the next entry after the last entry in
+         * this list and start the search from there.
+         */
+        if (!list_empty(bitmaps)) {
+                entry = list_entry(bitmaps->prev, struct btrfs_free_space,
+                                   list);
+                node = rb_next(&entry->offset_index);
+                if (!node)
+                        return -ENOSPC;
+                entry = rb_entry(node, struct btrfs_free_space, offset_index);
+                goto search;
+        }
+
         entry = tree_search_offset(ctl, offset_to_bitmap(ctl, offset), 0, 1);
         if (!entry)
                 return -ENOSPC;
 
+search:
         node = &entry->offset_index;
         do {
                 entry = rb_entry(node, struct btrfs_free_space, offset_index);
@@ -2284,6 +2374,8 @@ int btrfs_find_space_cluster(struct btrfs_trans_handle *trans,
                              u64 offset, u64 bytes, u64 empty_size)
 {
         struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
+        struct list_head bitmaps;
+        struct btrfs_free_space *entry, *tmp;
         u64 min_bytes;
         int ret;
 
@@ -2322,11 +2414,16 @@ int btrfs_find_space_cluster(struct btrfs_trans_handle *trans,
                 goto out;
         }
 
-        ret = setup_cluster_no_bitmap(block_group, cluster, offset, bytes,
-                                      min_bytes);
+        INIT_LIST_HEAD(&bitmaps);
+        ret = setup_cluster_no_bitmap(block_group, cluster, &bitmaps, offset,
+                                      bytes, min_bytes);
         if (ret)
-                ret = setup_cluster_bitmap(block_group, cluster, offset,
-                                           bytes, min_bytes);
+                ret = setup_cluster_bitmap(block_group, cluster, &bitmaps,
+                                           offset, bytes, min_bytes);
+
+        /* Clear our temporary list */
+        list_for_each_entry_safe(entry, tmp, &bitmaps, list)
+                list_del_init(&entry->list);
 
         if (!ret) {
                 atomic_inc(&block_group->count);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index ebf95f7a44d6..751ddf8fc58a 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1986,7 +1986,7 @@ static int btrfs_readpage_end_io_hook(struct page *page, u64 start, u64 end,
         }
 
         if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)
-                return 0;
+                goto good;
 
         if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID &&
             test_range_bit(io_tree, start, end, EXTENT_NODATASUM, 1, NULL)) {
@@ -3646,7 +3646,7 @@ void btrfs_evict_inode(struct inode *inode)
         btrfs_i_size_write(inode, 0);
 
         while (1) {
-                trans = btrfs_start_transaction(root, 0);
+                trans = btrfs_join_transaction(root);
                 BUG_ON(IS_ERR(trans));
                 trans->block_rsv = root->orphan_block_rsv;
 
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index ac37040e426a..b793d112d1f6 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -2054,29 +2054,34 @@ static long btrfs_ioctl_rm_dev(struct btrfs_root *root, void __user *arg)
 
 static long btrfs_ioctl_fs_info(struct btrfs_root *root, void __user *arg)
 {
-        struct btrfs_ioctl_fs_info_args fi_args;
+        struct btrfs_ioctl_fs_info_args *fi_args;
         struct btrfs_device *device;
         struct btrfs_device *next;
         struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
+        int ret = 0;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EPERM;
 
-        fi_args.num_devices = fs_devices->num_devices;
-        fi_args.max_id = 0;
-        memcpy(&fi_args.fsid, root->fs_info->fsid, sizeof(fi_args.fsid));
+        fi_args = kzalloc(sizeof(*fi_args), GFP_KERNEL);
+        if (!fi_args)
+                return -ENOMEM;
+
+        fi_args->num_devices = fs_devices->num_devices;
+        memcpy(&fi_args->fsid, root->fs_info->fsid, sizeof(fi_args->fsid));
 
         mutex_lock(&fs_devices->device_list_mutex);
         list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) {
-                if (device->devid > fi_args.max_id)
-                        fi_args.max_id = device->devid;
+                if (device->devid > fi_args->max_id)
+                        fi_args->max_id = device->devid;
         }
         mutex_unlock(&fs_devices->device_list_mutex);
 
-        if (copy_to_user(arg, &fi_args, sizeof(fi_args)))
-                return -EFAULT;
+        if (copy_to_user(arg, fi_args, sizeof(*fi_args)))
+                ret = -EFAULT;
 
-        return 0;
+        kfree(fi_args);
+        return ret;
 }
 
 static long btrfs_ioctl_dev_info(struct btrfs_root *root, void __user *arg)
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index df50fd1eca8f..a8d03d5efb5d 100644
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -16,13 +16,7 @@
  * Boston, MA 021110-1307, USA.
  */
 
-#include <linux/sched.h>
-#include <linux/pagemap.h>
-#include <linux/writeback.h>
 #include <linux/blkdev.h>
-#include <linux/rbtree.h>
-#include <linux/slab.h>
-#include <linux/workqueue.h>
 #include "ctree.h"
 #include "volumes.h"
 #include "disk-io.h"
@@ -804,18 +798,12 @@ static noinline_for_stack int scrub_stripe(struct scrub_dev *sdev,
 
                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
                 if (ret < 0)
-                        goto out;
-
-                l = path->nodes[0];
-                slot = path->slots[0];
-                btrfs_item_key_to_cpu(l, &key, slot);
-                if (key.objectid != logical) {
-                        ret = btrfs_previous_item(root, path, 0,
-                                                  BTRFS_EXTENT_ITEM_KEY);
-                        if (ret < 0)
-                                goto out;
-                }
+                        goto out_noplug;
 
+                /*
+                 * we might miss half an extent here, but that doesn't matter,
+                 * as it's only the prefetch
+                 */
                 while (1) {
                         l = path->nodes[0];
                         slot = path->slots[0];
@@ -824,7 +812,7 @@ static noinline_for_stack int scrub_stripe(struct scrub_dev *sdev,
                                 if (ret == 0)
                                         continue;
                                 if (ret < 0)
-                                        goto out;
+                                        goto out_noplug;
 
                                 break;
                         }
@@ -906,15 +894,20 @@ again:
                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
                 if (ret < 0)
                         goto out;
-
-                l = path->nodes[0];
-                slot = path->slots[0];
-                btrfs_item_key_to_cpu(l, &key, slot);
-                if (key.objectid != logical) {
+                if (ret > 0) {
                         ret = btrfs_previous_item(root, path, 0,
                                                   BTRFS_EXTENT_ITEM_KEY);
                         if (ret < 0)
                                 goto out;
+                        if (ret > 0) {
+                                /* there's no smaller item, so stick with the
+                                 * larger one */
+                                btrfs_release_path(path);
+                                ret = btrfs_search_slot(NULL, root, &key,
+                                                        path, 0, 0);
+                                if (ret < 0)
+                                        goto out;
+                        }
                 }
 
                 while (1) {
@@ -989,6 +982,7 @@ next:
 
 out:
         blk_finish_plug(&plug);
+out_noplug:
         btrfs_free_path(path);
         return ret < 0 ? ret : 0;
 }
@@ -1064,8 +1058,15 @@ int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
         while (1) {
                 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
                 if (ret < 0)
-                        goto out;
-                ret = 0;
+                        break;
+                if (ret > 0) {
+                        if (path->slots[0] >=
+                            btrfs_header_nritems(path->nodes[0])) {
+                                ret = btrfs_next_leaf(root, path);
+                                if (ret)
+                                        break;
+                        }
+                }
 
                 l = path->nodes[0];
                 slot = path->slots[0];
@@ -1075,7 +1076,7 @@ int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
                 if (found_key.objectid != sdev->dev->devid)
                         break;
 
-                if (btrfs_key_type(&key) != BTRFS_DEV_EXTENT_KEY)
+                if (btrfs_key_type(&found_key) != BTRFS_DEV_EXTENT_KEY)
                         break;
 
                 if (found_key.offset >= end)
@@ -1104,7 +1105,7 @@ int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
                 cache = btrfs_lookup_block_group(fs_info, chunk_offset);
                 if (!cache) {
                         ret = -ENOENT;
-                        goto out;
+                        break;
                 }
                 ret = scrub_chunk(sdev, chunk_tree, chunk_objectid,
                                   chunk_offset, length);
@@ -1116,9 +1117,13 @@ int scrub_enumerate_chunks(struct scrub_dev *sdev, u64 start, u64 end)
                 btrfs_release_path(path);
         }
 
-out:
         btrfs_free_path(path);
-        return ret;
+
+        /*
+         * ret can still be 1 from search_slot or next_leaf,
+         * that's not an error
+         */
+        return ret < 0 ? ret : 0;
 }
 
 static noinline_for_stack int scrub_supers(struct scrub_dev *sdev)
@@ -1155,8 +1160,12 @@ static noinline_for_stack int scrub_workers_get(struct btrfs_root *root)
         struct btrfs_fs_info *fs_info = root->fs_info;
 
         mutex_lock(&fs_info->scrub_lock);
-        if (fs_info->scrub_workers_refcnt == 0)
+        if (fs_info->scrub_workers_refcnt == 0) {
+                btrfs_init_workers(&fs_info->scrub_workers, "scrub",
+                           fs_info->thread_pool_size, &fs_info->generic_worker);
+                fs_info->scrub_workers.idle_thresh = 4;
                 btrfs_start_workers(&fs_info->scrub_workers, 1);
+        }
         ++fs_info->scrub_workers_refcnt;
         mutex_unlock(&fs_info->scrub_lock);
 
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 117e74e3604b..0bb4ebbb71b7 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -825,7 +825,7 @@ static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
         } else {
                 char b[BDEVNAME_SIZE];
 
-                s->s_flags = flags;
+                s->s_flags = flags | MS_NOSEC;
                 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
                 error = btrfs_fill_super(s, fs_devices, data,
                                          flags & MS_SILENT ? 1 : 0);
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index dd719662340e..2b3590b9fe98 100644
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -349,7 +349,7 @@ int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
                                             list) {
                         if (t->in_commit) {
                                 if (t->commit_done)
-                                        goto out;
+                                        break;
                                 cur_trans = t;
                                 atomic_inc(&cur_trans->use_count);
                                 break;
@@ -1118,8 +1118,11 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
                 wait_current_trans_commit_start_and_unblock(root, cur_trans);
         else
                 wait_current_trans_commit_start(root, cur_trans);
-        put_transaction(cur_trans);
 
+        if (current->journal_info == trans)
+                current->journal_info = NULL;
+
+        put_transaction(cur_trans);
         return 0;
 }
 
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index da541dfca2e3..1efa56e18f9b 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -689,12 +689,8 @@ int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder,
         transid = btrfs_super_generation(disk_super);
         if (disk_super->label[0])
                 printk(KERN_INFO "device label %s ", disk_super->label);
-        else {
-                /* FIXME, make a readl uuid parser */
-                printk(KERN_INFO "device fsid %llx-%llx ",
-                       *(unsigned long long *)disk_super->fsid,
-                       *(unsigned long long *)(disk_super->fsid + 8));
-        }
+        else
+                printk(KERN_INFO "device fsid %pU ", disk_super->fsid);
         printk(KERN_CONT "devid %llu transid %llu %s\n",
                (unsigned long long)devid, (unsigned long long)transid, path);
         ret = device_list_add(path, disk_super, devid, fs_devices_ret);
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 33da49dc3cc6..5a3953db8118 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -453,7 +453,7 @@ static int ceph_writepage(struct page *page, struct writeback_control *wbc)
         int err;
         struct inode *inode = page->mapping->host;
         BUG_ON(!inode);
-        igrab(inode);
+        ihold(inode);
         err = writepage_nounlock(page, wbc);
         unlock_page(page);
         iput(inode);
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 1f72b00447c4..f605753c8fe9 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -2940,14 +2940,12 @@ void ceph_flush_dirty_caps(struct ceph_mds_client *mdsc)
         while (!list_empty(&mdsc->cap_dirty)) {
                 ci = list_first_entry(&mdsc->cap_dirty, struct ceph_inode_info,
                                       i_dirty_item);
-                inode = igrab(&ci->vfs_inode);
+                inode = &ci->vfs_inode;
+                ihold(inode);
                 dout("flush_dirty_caps %p\n", inode);
                 spin_unlock(&mdsc->cap_dirty_lock);
-                if (inode) {
-                        ceph_check_caps(ci, CHECK_CAPS_NODELAY|CHECK_CAPS_FLUSH,
-                                        NULL);
-                        iput(inode);
-                }
+                ceph_check_caps(ci, CHECK_CAPS_NODELAY|CHECK_CAPS_FLUSH, NULL);
+                iput(inode);
                 spin_lock(&mdsc->cap_dirty_lock);
         }
         spin_unlock(&mdsc->cap_dirty_lock);
diff --git a/fs/ceph/dir.c b/fs/ceph/dir.c
index 33729e822bb9..ef8f08c343e8 100644
--- a/fs/ceph/dir.c
+++ b/fs/ceph/dir.c
@@ -308,7 +308,8 @@ more:
                 req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
                 if (IS_ERR(req))
                         return PTR_ERR(req);
-                req->r_inode = igrab(inode);
+                req->r_inode = inode;
+                ihold(inode);
                 req->r_dentry = dget(filp->f_dentry);
                 /* hints to request -> mds selection code */
                 req->r_direct_mode = USE_AUTH_MDS;
@@ -787,10 +788,12 @@ static int ceph_link(struct dentry *old_dentry, struct inode *dir,
         req->r_dentry_drop = CEPH_CAP_FILE_SHARED;
         req->r_dentry_unless = CEPH_CAP_FILE_EXCL;
         err = ceph_mdsc_do_request(mdsc, dir, req);
-        if (err)
+        if (err) {
                 d_drop(dentry);
-        else if (!req->r_reply_info.head->is_dentry)
-                d_instantiate(dentry, igrab(old_dentry->d_inode));
+        } else if (!req->r_reply_info.head->is_dentry) {
+                ihold(old_dentry->d_inode);
+                d_instantiate(dentry, old_dentry->d_inode);
+        }
         ceph_mdsc_put_request(req);
         return err;
 }
diff --git a/fs/ceph/export.c b/fs/ceph/export.c
index a610d3d67488..f67b687550de 100644
--- a/fs/ceph/export.c
+++ b/fs/ceph/export.c
@@ -109,7 +109,7 @@ static struct dentry *__fh_to_dentry(struct super_block *sb,
                 err = ceph_mdsc_do_request(mdsc, NULL, req);
                 inode = req->r_target_inode;
                 if (inode)
-                        igrab(inode);
+                        ihold(inode);
                 ceph_mdsc_put_request(req);
                 if (!inode)
                         return ERR_PTR(-ESTALE);
@@ -167,7 +167,7 @@ static struct dentry *__cfh_to_dentry(struct super_block *sb,
                 err = ceph_mdsc_do_request(mdsc, NULL, req);
                 inode = req->r_target_inode;
                 if (inode)
-                        igrab(inode);
+                        ihold(inode);
                 ceph_mdsc_put_request(req);
                 if (!inode)
                         return ERR_PTR(err ? err : -ESTALE);
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index 203252d88d9f..9542f07d0b93 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -191,7 +191,8 @@ int ceph_open(struct inode *inode, struct file *file)
                 err = PTR_ERR(req);
                 goto out;
         }
-        req->r_inode = igrab(inode);
+        req->r_inode = inode;
+        ihold(inode);
         req->r_num_caps = 1;
         err = ceph_mdsc_do_request(mdsc, parent_inode, req);
         if (!err)
@@ -282,7 +283,7 @@ int ceph_release(struct inode *inode, struct file *file)
 static int striped_read(struct inode *inode,
                         u64 off, u64 len,
                         struct page **pages, int num_pages,
-                        int *checkeof, bool align_to_pages,
+                        int *checkeof, bool o_direct,
                         unsigned long buf_align)
 {
         struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
@@ -307,7 +308,7 @@ static int striped_read(struct inode *inode,
         io_align = off & ~PAGE_MASK;
 
 more:
-        if (align_to_pages)
+        if (o_direct)
                 page_align = (pos - io_align + buf_align) & ~PAGE_MASK;
         else
                 page_align = pos & ~PAGE_MASK;
@@ -317,10 +318,10 @@ more:
                                   ci->i_truncate_seq,
                                   ci->i_truncate_size,
                                   page_pos, pages_left, page_align);
-        hit_stripe = this_len < left;
-        was_short = ret >= 0 && ret < this_len;
         if (ret == -ENOENT)
                 ret = 0;
+        hit_stripe = this_len < left;
+        was_short = ret >= 0 && ret < this_len;
         dout("striped_read %llu~%u (read %u) got %d%s%s\n", pos, left, read,
              ret, hit_stripe ? " HITSTRIPE" : "", was_short ? " SHORT" : "");
 
@@ -345,20 +346,22 @@ more:
         }
 
         if (was_short) {
-                /* was original extent fully inside i_size? */
-                if (pos + left <= inode->i_size) {
-                        dout("zero tail\n");
-                        ceph_zero_page_vector_range(page_off + read, len - read,
+                /* did we bounce off eof? */
+                if (pos + left > inode->i_size)
+                        *checkeof = 1;
+
+                /* zero trailing bytes (inside i_size) */
+                if (left > 0 && pos < inode->i_size) {
+                        if (pos + left > inode->i_size)
+                                left = inode->i_size - pos;
+
+                        dout("zero tail %d\n", left);
+                        ceph_zero_page_vector_range(page_off + read, left,
                                                     pages);
-                        read = len;
-                        goto out;
+                        read += left;
                 }
-
-                /* check i_size */
-                *checkeof = 1;
         }
 
-out:
         if (ret >= 0)
                 ret = read;
         dout("striped_read returns %d\n", ret);
@@ -658,7 +661,7 @@ out:
 
                 /* hit EOF or hole? */
                 if (statret == 0 && *ppos < inode->i_size) {
-                        dout("aio_read sync_read hit hole, reading more\n");
+                        dout("aio_read sync_read hit hole, ppos %lld < size %lld, reading more\n", *ppos, inode->i_size);
                         read += ret;
                         base += ret;
                         len -= ret;
diff --git a/fs/ceph/inode.c b/fs/ceph/inode.c
index 70b6a4839c38..d8858e96ab18 100644
--- a/fs/ceph/inode.c
+++ b/fs/ceph/inode.c
@@ -1101,10 +1101,10 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
                                 goto done;
                         }
                         req->r_dentry = dn;  /* may have spliced */
-                        igrab(in);
+                        ihold(in);
                 } else if (ceph_ino(in) == vino.ino &&
                            ceph_snap(in) == vino.snap) {
-                        igrab(in);
+                        ihold(in);
                 } else {
                         dout(" %p links to %p %llx.%llx, not %llx.%llx\n",
                              dn, in, ceph_ino(in), ceph_snap(in),
@@ -1144,7 +1144,7 @@ int ceph_fill_trace(struct super_block *sb, struct ceph_mds_request *req,
                         goto done;
                 }
                 req->r_dentry = dn;  /* may have spliced */
-                igrab(in);
+                ihold(in);
                 rinfo->head->is_dentry = 1;  /* fool notrace handlers */
         }
 
@@ -1328,7 +1328,7 @@ void ceph_queue_writeback(struct inode *inode)
         if (queue_work(ceph_inode_to_client(inode)->wb_wq,
                        &ceph_inode(inode)->i_wb_work)) {
                 dout("ceph_queue_writeback %p\n", inode);
-                igrab(inode);
+                ihold(inode);
         } else {
                 dout("ceph_queue_writeback %p failed\n", inode);
         }
@@ -1353,7 +1353,7 @@ void ceph_queue_invalidate(struct inode *inode)
         if (queue_work(ceph_inode_to_client(inode)->pg_inv_wq,
                        &ceph_inode(inode)->i_pg_inv_work)) {
                 dout("ceph_queue_invalidate %p\n", inode);
-                igrab(inode);
+                ihold(inode);
         } else {
                 dout("ceph_queue_invalidate %p failed\n", inode);
         }
@@ -1477,7 +1477,7 @@ void ceph_queue_vmtruncate(struct inode *inode)
         if (queue_work(ceph_sb_to_client(inode->i_sb)->trunc_wq,
                        &ci->i_vmtruncate_work)) {
                 dout("ceph_queue_vmtruncate %p\n", inode);
-                igrab(inode);
+                ihold(inode);
         } else {
                 dout("ceph_queue_vmtruncate %p failed, pending=%d\n",
                      inode, ci->i_truncate_pending);
@@ -1738,7 +1738,8 @@ int ceph_setattr(struct dentry *dentry, struct iattr *attr)
                 __mark_inode_dirty(inode, inode_dirty_flags);
 
         if (mask) {
-                req->r_inode = igrab(inode);
+                req->r_inode = inode;
+                ihold(inode);
                 req->r_inode_drop = release;
                 req->r_args.setattr.mask = cpu_to_le32(mask);
                 req->r_num_caps = 1;
@@ -1779,7 +1780,8 @@ int ceph_do_getattr(struct inode *inode, int mask)
         req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_GETATTR, USE_ANY_MDS);
         if (IS_ERR(req))
                 return PTR_ERR(req);
-        req->r_inode = igrab(inode);
+        req->r_inode = inode;
+        ihold(inode);
         req->r_num_caps = 1;
         req->r_args.getattr.mask = cpu_to_le32(mask);
         err = ceph_mdsc_do_request(mdsc, NULL, req);
diff --git a/fs/ceph/ioctl.c b/fs/ceph/ioctl.c
index 8888c9ba68db..ef0b5f48e13a 100644
--- a/fs/ceph/ioctl.c
+++ b/fs/ceph/ioctl.c
@@ -73,7 +73,8 @@ static long ceph_ioctl_set_layout(struct file *file, void __user *arg)
                                        USE_AUTH_MDS);
         if (IS_ERR(req))
                 return PTR_ERR(req);
-        req->r_inode = igrab(inode);
+        req->r_inode = inode;
+        ihold(inode);
         req->r_inode_drop = CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL;
 
         req->r_args.setlayout.layout.fl_stripe_unit =
@@ -135,7 +136,8 @@ static long ceph_ioctl_set_layout_policy (struct file *file, void __user *arg)
 
         if (IS_ERR(req))
                 return PTR_ERR(req);
-        req->r_inode = igrab(inode);
+        req->r_inode = inode;
+        ihold(inode);
 
         req->r_args.setlayout.layout.fl_stripe_unit =
                         cpu_to_le32(l.stripe_unit);
diff --git a/fs/ceph/locks.c b/fs/ceph/locks.c
index 476b329867d4..80576d05d687 100644
--- a/fs/ceph/locks.c
+++ b/fs/ceph/locks.c
@@ -23,7 +23,8 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct file *file,
         req = ceph_mdsc_create_request(mdsc, operation, USE_AUTH_MDS);
         if (IS_ERR(req))
                 return PTR_ERR(req);
-        req->r_inode = igrab(inode);
+        req->r_inode = inode;
+        ihold(inode);
 
         /* mds requires start and length rather than start and end */
         if (LLONG_MAX == fl->fl_end)
@@ -32,11 +33,10 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct file *file,
                 length = fl->fl_end - fl->fl_start + 1;
 
         dout("ceph_lock_message: rule: %d, op: %d, pid: %llu, start: %llu, "
-             "length: %llu, wait: %d, type`: %d", (int)lock_type,
+             "length: %llu, wait: %d, type: %d", (int)lock_type,
              (int)operation, (u64)fl->fl_pid, fl->fl_start,
              length, wait, fl->fl_type);
 
-
         req->r_args.filelock_change.rule = lock_type;
         req->r_args.filelock_change.type = cmd;
         req->r_args.filelock_change.pid = cpu_to_le64((u64)fl->fl_pid);
@@ -70,7 +70,7 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct file *file,
         }
         ceph_mdsc_put_request(req);
         dout("ceph_lock_message: rule: %d, op: %d, pid: %llu, start: %llu, "
-             "length: %llu, wait: %d, type`: %d, err code %d", (int)lock_type,
+             "length: %llu, wait: %d, type: %d, err code %d", (int)lock_type,
              (int)operation, (u64)fl->fl_pid, fl->fl_start,
              length, wait, fl->fl_type, err);
         return err;
@@ -109,16 +109,20 @@ int ceph_lock(struct file *file, int cmd, struct file_lock *fl)
                         dout("mds locked, locking locally");
                         err = posix_lock_file(file, fl, NULL);
                         if (err && (CEPH_MDS_OP_SETFILELOCK == op)) {
-                                /* undo! This should only happen if the kernel detects
-                                 * local deadlock. */
+                                /* undo! This should only happen if
+                                 * the kernel detects local
+                                 * deadlock. */
                                 ceph_lock_message(CEPH_LOCK_FCNTL, op, file,
                                                   CEPH_LOCK_UNLOCK, 0, fl);
-                                dout("got %d on posix_lock_file, undid lock", err);
+                                dout("got %d on posix_lock_file, undid lock",
+                                     err);
                         }
                 }
 
-        } else {
-                dout("mds returned error code %d", err);
+        } else if (err == -ERESTARTSYS) {
+                dout("undoing lock\n");
+                ceph_lock_message(CEPH_LOCK_FCNTL, op, file,
+                                  CEPH_LOCK_UNLOCK, 0, fl);
         }
         return err;
 }
@@ -155,8 +159,11 @@ int ceph_flock(struct file *file, int cmd, struct file_lock *fl)
                                           file, CEPH_LOCK_UNLOCK, 0, fl);
                         dout("got %d on flock_lock_file_wait, undid lock", err);
                 }
-        } else {
-                dout("mds error code %d", err);
+        } else if (err == -ERESTARTSYS) {
+                dout("undoing lock\n");
+                ceph_lock_message(CEPH_LOCK_FLOCK,
+                                  CEPH_MDS_OP_SETFILELOCK,
+                                  file, CEPH_LOCK_UNLOCK, 0, fl);
         }
         return err;
 }
diff --git a/fs/ceph/snap.c b/fs/ceph/snap.c
index 24067d68a554..54b14de2e729 100644
--- a/fs/ceph/snap.c
+++ b/fs/ceph/snap.c
@@ -722,7 +722,7 @@ static void flush_snaps(struct ceph_mds_client *mdsc)
                 ci = list_first_entry(&mdsc->snap_flush_list,
                                 struct ceph_inode_info, i_snap_flush_item);
                 inode = &ci->vfs_inode;
-                igrab(inode);
+                ihold(inode);
                 spin_unlock(&mdsc->snap_flush_lock);
                 spin_lock(&inode->i_lock);
                 __ceph_flush_snaps(ci, &session, 0);
diff --git a/fs/ceph/xattr.c b/fs/ceph/xattr.c
index f2b628696180..f42d730f1b66 100644
--- a/fs/ceph/xattr.c
+++ b/fs/ceph/xattr.c
@@ -665,7 +665,8 @@ static int ceph_sync_setxattr(struct dentry *dentry, const char *name,
                 err = PTR_ERR(req);
                 goto out;
         }
-        req->r_inode = igrab(inode);
+        req->r_inode = inode;
+        ihold(inode);
         req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
         req->r_num_caps = 1;
         req->r_args.setxattr.flags = cpu_to_le32(flags);
@@ -795,7 +796,8 @@ static int ceph_send_removexattr(struct dentry *dentry, const char *name)
                                        USE_AUTH_MDS);
         if (IS_ERR(req))
                 return PTR_ERR(req);
-        req->r_inode = igrab(inode);
+        req->r_inode = inode;
+        ihold(inode);
         req->r_inode_drop = CEPH_CAP_XATTR_SHARED;
         req->r_num_caps = 1;
         req->r_path2 = kstrdup(name, GFP_NOFS);
diff --git a/fs/cifs/Kconfig b/fs/cifs/Kconfig
index 1cd4c3a1862d..53ed1ad2c112 100644
--- a/fs/cifs/Kconfig
+++ b/fs/cifs/Kconfig
@@ -7,6 +7,7 @@ config CIFS
         select CRYPTO_MD5
         select CRYPTO_HMAC
         select CRYPTO_ARC4
+        select CRYPTO_ECB
         select CRYPTO_DES
         help
           This is the client VFS module for the Common Internet File System
@@ -148,7 +149,7 @@ config CIFS_FSCACHE
 
 config CIFS_ACL
           bool "Provide CIFS ACL support (EXPERIMENTAL)"
-          depends on EXPERIMENTAL && CIFS_XATTR
+          depends on EXPERIMENTAL && CIFS_XATTR && KEYS
           help
             Allows to fetch CIFS/NTFS ACL from the server.  The DACL blob
             is handed over to the application/caller.
diff --git a/fs/cifs/cifsencrypt.c b/fs/cifs/cifsencrypt.c
index dfbd9f1f373d..5a0ee7f2af06 100644
--- a/fs/cifs/cifsencrypt.c
+++ b/fs/cifs/cifsencrypt.c
@@ -184,7 +184,7 @@ int cifs_verify_signature(struct smb_hdr *cifs_pdu,
         if (cifs_pdu == NULL || server == NULL)
                 return -EINVAL;
 
-        if (cifs_pdu->Command == SMB_COM_NEGOTIATE)
+        if (!server->session_estab)
                 return 0;
 
         if (cifs_pdu->Command == SMB_COM_LOCKING_ANDX) {
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 6d88b82537c3..bb659eb73810 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -784,7 +784,7 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                          struct smb_vol *vol)
 {
         char *value, *data, *end;
-        char *mountdata_copy, *options;
+        char *mountdata_copy = NULL, *options;
         unsigned int  temp_len, i, j;
         char separator[2];
         short int override_uid = -1;
@@ -1391,7 +1391,7 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                                 "/proc/fs/cifs/LookupCacheEnabled to 0\n");
                 } else if (strnicmp(data, "fsc", 3) == 0) {
 #ifndef CONFIG_CIFS_FSCACHE
-                        cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE"
+                        cERROR(1, "FS-Cache support needs CONFIG_CIFS_FSCACHE "
                                   "kernel config option set");
                         goto cifs_parse_mount_err;
 #endif
@@ -1976,7 +1976,7 @@ cifs_get_smb_ses(struct TCP_Server_Info *server, struct smb_vol *volume_info)
                 warned_on_ntlm = true;
                 cERROR(1, "default security mechanism requested.  The default "
                         "security mechanism will be upgraded from ntlm to "
-                        "ntlmv2 in kernel release 2.6.41");
+                        "ntlmv2 in kernel release 3.1");
         }
         ses->overrideSecFlg = volume_info->secFlg;
 
diff --git a/fs/dcookies.c b/fs/dcookies.c
index a21cabdbd87b..dda0dc702d1b 100644
--- a/fs/dcookies.c
+++ b/fs/dcookies.c
@@ -178,6 +178,8 @@ SYSCALL_DEFINE(lookup_dcookie)(u64 cookie64, char __user * buf, size_t len)
         /* FIXME: (deleted) ? */
         path = d_path(&dcs->path, kbuf, PAGE_SIZE);
 
+        mutex_unlock(&dcookie_mutex);
+
         if (IS_ERR(path)) {
                 err = PTR_ERR(path);
                 goto out_free;
@@ -194,6 +196,7 @@ SYSCALL_DEFINE(lookup_dcookie)(u64 cookie64, char __user * buf, size_t len)
 
 out_free:
         kfree(kbuf);
+        return err;
 out:
         mutex_unlock(&dcookie_mutex);
         return err;
diff --git a/fs/exec.c b/fs/exec.c
index ea5f748906a8..97e0d52d72fd 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -1093,6 +1093,7 @@ int flush_old_exec(struct linux_binprm * bprm)
 
         bprm->mm = NULL;                /* We're using it now */
 
+        set_fs(USER_DS);
         current->flags &= ~(PF_RANDOMIZE | PF_KTHREAD);
         flush_thread();
         current->personality &= ~bprm->per_clear;
@@ -1357,10 +1358,6 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
         if (retval)
                 return retval;
 
-        /* kernel module loader fixup */
-        /* so we don't try to load run modprobe in kernel space. */
-        set_fs(USER_DS);
-
         retval = audit_bprm(bprm);
         if (retval)
                 return retval;
diff --git a/fs/fat/file.c b/fs/fat/file.c
index 7257752b6d5d..7018e1d8902d 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -102,7 +102,7 @@ static int fat_ioctl_set_attributes(struct file *file, u32 __user *user_attr)
                 if (attr & ATTR_SYS)
                         inode->i_flags |= S_IMMUTABLE;
                 else
-                        inode->i_flags &= S_IMMUTABLE;
+                        inode->i_flags &= ~S_IMMUTABLE;
         }
 
         fat_save_attrs(inode, attr);
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index cc6ec4b2f0ff..38f84cd48b67 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -921,6 +921,8 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
         if (sb->s_flags & MS_MANDLOCK)
                 goto err;
 
+        sb->s_flags &= ~MS_NOSEC;
+
         if (!parse_fuse_opt((char *) data, &d, is_bdev))
                 goto err;
 
diff --git a/fs/gfs2/glock.c b/fs/gfs2/glock.c
index 2792a790e50b..1c1336e7b3b2 100644
--- a/fs/gfs2/glock.c
+++ b/fs/gfs2/glock.c
@@ -663,14 +663,19 @@ static void glock_work_func(struct work_struct *work)
                 drop_ref = 1;
         }
         spin_lock(&gl->gl_spin);
-        if (test_and_clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
+        if (test_bit(GLF_PENDING_DEMOTE, &gl->gl_flags) &&
             gl->gl_state != LM_ST_UNLOCKED &&
             gl->gl_demote_state != LM_ST_EXCLUSIVE) {
                 unsigned long holdtime, now = jiffies;
+
                 holdtime = gl->gl_tchange + gl->gl_ops->go_min_hold_time;
                 if (time_before(now, holdtime))
                         delay = holdtime - now;
-                set_bit(delay ? GLF_PENDING_DEMOTE : GLF_DEMOTE, &gl->gl_flags);
+
+                if (!delay) {
+                        clear_bit(GLF_PENDING_DEMOTE, &gl->gl_flags);
+                        set_bit(GLF_DEMOTE, &gl->gl_flags);
+                }
         }
         run_queue(gl, 0);
         spin_unlock(&gl->gl_spin);
diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index 278e3fb40b71..583636f745e5 100644
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -1123,7 +1123,7 @@ int lmLogOpen(struct super_block *sb)
         bdev = blkdev_get_by_dev(sbi->logdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
                                  log);
         if (IS_ERR(bdev)) {
-                rc = -PTR_ERR(bdev);
+                rc = PTR_ERR(bdev);
                 goto free;
         }
 
diff --git a/fs/namei.c b/fs/namei.c
index e2e4e8d032ee..9802345df5e7 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2624,6 +2624,10 @@ static long do_rmdir(int dfd, const char __user *pathname)
         error = PTR_ERR(dentry);
         if (IS_ERR(dentry))
                 goto exit2;
+        if (!dentry->d_inode) {
+                error = -ENOENT;
+                goto exit3;
+        }
         error = mnt_want_write(nd.path.mnt);
         if (error)
                 goto exit3;
@@ -2709,11 +2713,10 @@ static long do_unlinkat(int dfd, const char __user *pathname)
         error = PTR_ERR(dentry);
         if (!IS_ERR(dentry)) {
                 /* Why not before? Because we want correct error value */
-                if (nd.last.name[nd.last.len])
-                        goto slashes;
                 inode = dentry->d_inode;
-                if (inode)
-                        ihold(inode);
+                if (nd.last.name[nd.last.len] || !inode)
+                        goto slashes;
+                ihold(inode);
                 error = mnt_want_write(nd.path.mnt);
                 if (error)
                         goto exit2;
diff --git a/fs/nilfs2/btree.c b/fs/nilfs2/btree.c
index 7eafe468a29c..b2e3ff347620 100644
--- a/fs/nilfs2/btree.c
+++ b/fs/nilfs2/btree.c
@@ -1346,6 +1346,11 @@ static void nilfs_btree_shrink(struct nilfs_bmap *btree,
         path[level].bp_bh = NULL;
 }
 
+static void nilfs_btree_nop(struct nilfs_bmap *btree,
+                            struct nilfs_btree_path *path,
+                            int level, __u64 *keyp, __u64 *ptrp)
+{
+}
 
 static int nilfs_btree_prepare_delete(struct nilfs_bmap *btree,
                                       struct nilfs_btree_path *path,
@@ -1356,20 +1361,19 @@ static int nilfs_btree_prepare_delete(struct nilfs_bmap *btree,
         struct buffer_head *bh;
         struct nilfs_btree_node *node, *parent, *sib;
         __u64 sibptr;
-        int pindex, level, ncmin, ncmax, ncblk, ret;
+        int pindex, dindex, level, ncmin, ncmax, ncblk, ret;
 
         ret = 0;
         stats->bs_nblocks = 0;
         ncmin = NILFS_BTREE_NODE_NCHILDREN_MIN(nilfs_btree_node_size(btree));
         ncblk = nilfs_btree_nchildren_per_block(btree);
 
-        for (level = NILFS_BTREE_LEVEL_NODE_MIN;
+        for (level = NILFS_BTREE_LEVEL_NODE_MIN, dindex = path[level].bp_index;
              level < nilfs_btree_height(btree) - 1;
              level++) {
                 node = nilfs_btree_get_nonroot_node(path, level);
                 path[level].bp_oldreq.bpr_ptr =
-                        nilfs_btree_node_get_ptr(node, path[level].bp_index,
-                                                 ncblk);
+                        nilfs_btree_node_get_ptr(node, dindex, ncblk);
                 ret = nilfs_bmap_prepare_end_ptr(btree,
                                                  &path[level].bp_oldreq, dat);
                 if (ret < 0)
@@ -1383,6 +1387,7 @@ static int nilfs_btree_prepare_delete(struct nilfs_bmap *btree,
 
                 parent = nilfs_btree_get_node(btree, path, level + 1, &ncmax);
                 pindex = path[level + 1].bp_index;
+                dindex = pindex;
 
                 if (pindex > 0) {
                         /* left sibling */
@@ -1421,6 +1426,14 @@ static int nilfs_btree_prepare_delete(struct nilfs_bmap *btree,
                                 path[level].bp_sib_bh = bh;
                                 path[level].bp_op = nilfs_btree_concat_right;
                                 stats->bs_nblocks++;
+                                /*
+                                 * When merging right sibling node
+                                 * into the current node, pointer to
+                                 * the right sibling node must be
+                                 * terminated instead.  The adjustment
+                                 * below is required for that.
+                                 */
+                                dindex = pindex + 1;
                                 /* continue; */
                         }
                 } else {
@@ -1431,29 +1444,31 @@ static int nilfs_btree_prepare_delete(struct nilfs_bmap *btree,
                             NILFS_BTREE_ROOT_NCHILDREN_MAX) {
                                 path[level].bp_op = nilfs_btree_shrink;
                                 stats->bs_nblocks += 2;
+                                level++;
+                                path[level].bp_op = nilfs_btree_nop;
+                                goto shrink_root_child;
                         } else {
                                 path[level].bp_op = nilfs_btree_do_delete;
                                 stats->bs_nblocks++;
+                                goto out;
                         }
-
-                        goto out;
-
                 }
         }
 
+        /* child of the root node is deleted */
+        path[level].bp_op = nilfs_btree_do_delete;
+        stats->bs_nblocks++;
+
+shrink_root_child:
         node = nilfs_btree_get_root(btree);
         path[level].bp_oldreq.bpr_ptr =
-                nilfs_btree_node_get_ptr(node, path[level].bp_index,
+                nilfs_btree_node_get_ptr(node, dindex,
                                          NILFS_BTREE_ROOT_NCHILDREN_MAX);
 
         ret = nilfs_bmap_prepare_end_ptr(btree, &path[level].bp_oldreq, dat);
         if (ret < 0)
                 goto err_out_child_node;
 
-        /* child of the root node is deleted */
-        path[level].bp_op = nilfs_btree_do_delete;
-        stats->bs_nblocks++;
-
         /* success */
  out:
         *levelp = level;
diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index 141646e88fb5..bb24ab6c282f 100644
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -2573,7 +2573,7 @@ static struct nilfs_sc_info *nilfs_segctor_new(struct super_block *sb,
         sci->sc_watermark = NILFS_SC_DEFAULT_WATERMARK;
 
         if (nilfs->ns_interval)
-                sci->sc_interval = nilfs->ns_interval;
+                sci->sc_interval = HZ * nilfs->ns_interval;
         if (nilfs->ns_watermark)
                 sci->sc_watermark = nilfs->ns_watermark;
         return sci;
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index cdbaf5e97308..56f61027236b 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -1072,7 +1072,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
 
         sb->s_magic = OCFS2_SUPER_MAGIC;
 
-        sb->s_flags = (sb->s_flags & ~MS_POSIXACL) |
+        sb->s_flags = (sb->s_flags & ~(MS_POSIXACL | MS_NOSEC)) |
                 ((osb->s_mount_opt & OCFS2_MOUNT_POSIX_ACL) ? MS_POSIXACL : 0);
 
         /* Hard readonly mode only if: bdev_read_only, MS_RDONLY,
diff --git a/fs/super.c b/fs/super.c
index c75593953c52..ab3d672db0de 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -822,7 +822,7 @@ struct dentry *mount_bdev(struct file_system_type *fs_type,
         } else {
                 char b[BDEVNAME_SIZE];
 
-                s->s_flags = flags;
+                s->s_flags = flags | MS_NOSEC;
                 s->s_mode = mode;
                 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
                 sb_set_blocksize(s, block_size(bdev));