52 files changed, 716 insertions, 556 deletions
diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 8f7d1237b7a0..a383c18e74e8 100644
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -179,61 +179,74 @@ static int __add_prelim_ref(struct list_head *head, u64 root_id,
 static int add_all_parents(struct btrfs_root *root, struct btrfs_path *path,
                                struct ulist *parents, int level,
-                                struct btrfs_key *key, u64 time_seq,
+                                struct btrfs_key *key_for_search, u64 time_seq,
                                u64 wanted_disk_byte,
                                const u64 *extent_item_pos)
 {
-        int ret;
+        int ret = 0;
-        int slot = path->slots[level];
+        int slot;
-        struct extent_buffer *eb = path->nodes[level];
+        struct extent_buffer *eb;
+        struct btrfs_key key;
        struct btrfs_file_extent_item *fi;
        struct extent_inode_elem *eie = NULL;
        u64 disk_byte;
-        u64 wanted_objectid = key->objectid;
-add_parent:
+        if (level != 0) {
-        if (level == 0 && extent_item_pos) {
+                eb = path->nodes[level];
-                fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
+                ret = ulist_add(parents, eb->start, 0, GFP_NOFS);
-                ret = check_extent_in_eb(key, eb, fi, *extent_item_pos, &eie);
                if (ret < 0)
                        return ret;
-        }
-        ret = ulist_add(parents, eb->start, (unsigned long)eie, GFP_NOFS);
-        if (ret < 0)
-                return ret;
-        if (level != 0)
                return 0;
+        }
        /*
-         * if the current leaf is full with EXTENT_DATA items, we must
+         * We normally enter this function with the path already pointing to
-         * check the next one if that holds a reference as well.
+         * the first item to check. But sometimes, we may enter it with
-         * ref->count cannot be used to skip this check.
+         * slot==nritems. In that case, go to the next leaf before we continue.
-         * repeat this until we don't find any additional EXTENT_DATA items.
         */
-        while (1) {
+        if (path->slots[0] >= btrfs_header_nritems(path->nodes[0]))
-                eie = NULL;
                ret = btrfs_next_old_leaf(root, path, time_seq);
-                if (ret < 0)
-                        return ret;
-                if (ret)
-                        return 0;
+        while (!ret) {
                eb = path->nodes[0];
-                for (slot = 0; slot < btrfs_header_nritems(eb); ++slot) {
+                slot = path->slots[0];
-                        btrfs_item_key_to_cpu(eb, key, slot);
-                        if (key->objectid != wanted_objectid ||
+                btrfs_item_key_to_cpu(eb, &key, slot);
-                            key->type != BTRFS_EXTENT_DATA_KEY)
-                                return 0;
+                if (key.objectid != key_for_search->objectid ||
-                        fi = btrfs_item_ptr(eb, slot,
+                    key.type != BTRFS_EXTENT_DATA_KEY)
-                                                struct btrfs_file_extent_item);
+                        break;
-                        disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
-                        if (disk_byte == wanted_disk_byte)
+                fi = btrfs_item_ptr(eb, slot, struct btrfs_file_extent_item);
-                                goto add_parent;
+                disk_byte = btrfs_file_extent_disk_bytenr(eb, fi);
+                if (disk_byte == wanted_disk_byte) {
+                        eie = NULL;
+                        if (extent_item_pos) {
+                                ret = check_extent_in_eb(&key, eb, fi,
+                                                *extent_item_pos,
+                                                &eie);
+                                if (ret < 0)
+                                        break;
+                        }
+                        if (!ret) {
+                                ret = ulist_add(parents, eb->start,
+                                                (unsigned long)eie, GFP_NOFS);
+                                if (ret < 0)
+                                        break;
+                                if (!extent_item_pos) {
+                                        ret = btrfs_next_old_leaf(root, path,
+                                                        time_seq);
+                                        continue;
+                                }
+                        }
                }
+                ret = btrfs_next_old_item(root, path, time_seq);
        }
-        return 0;
+        if (ret > 0)
+                ret = 0;
+        return ret;
 }
 /*
@@ -250,7 +263,6 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
        struct btrfs_path *path;
        struct btrfs_root *root;
        struct btrfs_key root_key;
-        struct btrfs_key key = {0};
        struct extent_buffer *eb;
        int ret = 0;
        int root_level;
@@ -289,17 +301,19 @@ static int __resolve_indirect_ref(struct btrfs_fs_info *fs_info,
                goto out;
        eb = path->nodes[level];
-        if (!eb) {
+        while (!eb) {
-                WARN_ON(1);
+                if (!level) {
-                ret = 1;
+                        WARN_ON(1);
-                goto out;
+                        ret = 1;
+                        goto out;
+                }
+                level--;
+                eb = path->nodes[level];
        }
-        if (level == 0)
+        ret = add_all_parents(root, path, parents, level, &ref->key_for_search,
-                btrfs_item_key_to_cpu(eb, &key, path->slots[0]);
+                                time_seq, ref->wanted_disk_byte,
+                                extent_item_pos);
-        ret = add_all_parents(root, path, parents, level, &key, time_seq,
-                                ref->wanted_disk_byte, extent_item_pos);
 out:
        btrfs_free_path(path);
        return ret;
@@ -825,6 +839,7 @@ again:
                        }
                        ret = __add_delayed_refs(head, delayed_ref_seq,
                                                 &prefs_delayed);
+                        mutex_unlock(&head->mutex);
                        if (ret) {
                                spin_unlock(&delayed_refs->lock);
                                goto out;
@@ -918,8 +933,6 @@ again:
        }
 out:
-        if (head)
-                mutex_unlock(&head->mutex);
        btrfs_free_path(path);
        while (!list_empty(&prefs)) {
                ref = list_first_entry(&prefs, struct __prelim_ref, list);
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 15cbc2bf4ff0..8206b3900587 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -1024,11 +1024,18 @@ __tree_mod_log_oldest_root(struct btrfs_fs_info *fs_info,
                if (!looped && !tm)
                        return 0;
                /*
-                 * we must have key remove operations in the log before the
+                 * if there are no tree operation for the oldest root, we simply
-                 * replace operation.
+                 * return it. this should only happen if that (old) root is at
+                 * level 0.
                 */
-                BUG_ON(!tm);
+                if (!tm)
+                        break;
+                /*
+                 * if there's an operation that's not a root replacement, we
+                 * found the oldest version of our root. normally, we'll find a
+                 * MOD_LOG_KEY_REMOVE_WHILE_FREEING operation here.
+                 */
                if (tm->op != MOD_LOG_ROOT_REPLACE)
                        break;
@@ -1087,11 +1094,7 @@ __tree_mod_log_rewind(struct extent_buffer *eb, u64 time_seq,
                                                      tm->generation);
                        break;
                case MOD_LOG_KEY_ADD:
-                        if (tm->slot != n - 1) {
+                        /* if a move operation is needed it's in the log */
-                                o_dst = btrfs_node_key_ptr_offset(tm->slot);
-                                o_src = btrfs_node_key_ptr_offset(tm->slot + 1);
-                                memmove_extent_buffer(eb, o_dst, o_src, p_size);
-                        }
                        n--;
                        break;
                case MOD_LOG_MOVE_KEYS:
@@ -1192,16 +1195,8 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
        }
        tm = tree_mod_log_search(root->fs_info, logical, time_seq);
-        /*
-         * there was an item in the log when __tree_mod_log_oldest_root
-         * returned. this one must not go away, because the time_seq passed to
-         * us must be blocking its removal.
-         */
-        BUG_ON(!tm);
        if (old_root)
-                eb = alloc_dummy_extent_buffer(tm->index << PAGE_CACHE_SHIFT,
+                eb = alloc_dummy_extent_buffer(logical, root->nodesize);
-                                               root->nodesize);
        else
                eb = btrfs_clone_extent_buffer(root->node);
        btrfs_tree_read_unlock(root->node);
@@ -1216,7 +1211,10 @@ get_old_root(struct btrfs_root *root, u64 time_seq)
                btrfs_set_header_level(eb, old_root->level);
                btrfs_set_header_generation(eb, old_generation);
        }
-        __tree_mod_log_rewind(eb, time_seq, tm);
+        if (tm)
+                __tree_mod_log_rewind(eb, time_seq, tm);
+        else
+                WARN_ON(btrfs_header_level(eb) != 0);
        extent_buffer_get(eb);
        return eb;
@@ -2995,7 +2993,7 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans,
 static void insert_ptr(struct btrfs_trans_handle *trans,
                       struct btrfs_root *root, struct btrfs_path *path,
                       struct btrfs_disk_key *key, u64 bytenr,
-                       int slot, int level, int tree_mod_log)
+                       int slot, int level)
 {
        struct extent_buffer *lower;
        int nritems;
@@ -3008,7 +3006,7 @@ static void insert_ptr(struct btrfs_trans_handle *trans,
        BUG_ON(slot > nritems);
        BUG_ON(nritems == BTRFS_NODEPTRS_PER_BLOCK(root));
        if (slot != nritems) {
-                if (tree_mod_log && level)
+                if (level)
                        tree_mod_log_eb_move(root->fs_info, lower, slot + 1,
                                             slot, nritems - slot);
                memmove_extent_buffer(lower,
@@ -3016,7 +3014,7 @@ static void insert_ptr(struct btrfs_trans_handle *trans,
                              btrfs_node_key_ptr_offset(slot),
                              (nritems - slot) * sizeof(struct btrfs_key_ptr));
        }
-        if (tree_mod_log && level) {
+        if (level) {
                ret = tree_mod_log_insert_key(root->fs_info, lower, slot,
                                              MOD_LOG_KEY_ADD);
                BUG_ON(ret < 0);
@@ -3104,7 +3102,7 @@ static noinline int split_node(struct btrfs_trans_handle *trans,
        btrfs_mark_buffer_dirty(split);
        insert_ptr(trans, root, path, &disk_key, split->start,
-                   path->slots[level + 1] + 1, level + 1, 1);
+                   path->slots[level + 1] + 1, level + 1);
        if (path->slots[level] >= mid) {
                path->slots[level] -= mid;
@@ -3641,7 +3639,7 @@ static noinline void copy_for_split(struct btrfs_trans_handle *trans,
        btrfs_set_header_nritems(l, mid);
        btrfs_item_key(right, &disk_key, 0);
        insert_ptr(trans, root, path, &disk_key, right->start,
-                   path->slots[1] + 1, 1, 0);
+                   path->slots[1] + 1, 1);
        btrfs_mark_buffer_dirty(right);
        btrfs_mark_buffer_dirty(l);
@@ -3848,7 +3846,7 @@ again:
                if (mid <= slot) {
                        btrfs_set_header_nritems(right, 0);
                        insert_ptr(trans, root, path, &disk_key, right->start,
-                                   path->slots[1] + 1, 1, 0);
+                                   path->slots[1] + 1, 1);
                        btrfs_tree_unlock(path->nodes[0]);
                        free_extent_buffer(path->nodes[0]);
                        path->nodes[0] = right;
@@ -3857,7 +3855,7 @@ again:
                } else {
                        btrfs_set_header_nritems(right, 0);
                        insert_ptr(trans, root, path, &disk_key, right->start,
-                                          path->slots[1], 1, 0);
+                                          path->slots[1], 1);
                        btrfs_tree_unlock(path->nodes[0]);
                        free_extent_buffer(path->nodes[0]);
                        path->nodes[0] = right;
@@ -5121,6 +5119,18 @@ again:
                if (!path->skip_locking) {
                        ret = btrfs_try_tree_read_lock(next);
+                        if (!ret && time_seq) {
+                                /*
+                                 * If we don't get the lock, we may be racing
+                                 * with push_leaf_left, holding that lock while
+                                 * itself waiting for the leaf we've currently
+                                 * locked. To solve this situation, we give up
+                                 * on our lock and cycle.
+                                 */
+                                btrfs_release_path(path);
+                                cond_resched();
+                                goto again;
+                        }
                        if (!ret) {
                                btrfs_set_path_blocking(path);
                                btrfs_tree_read_lock(next);
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index 8b73b2d4deb7..fa5c45b39075 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -2755,13 +2755,18 @@ static inline int btrfs_insert_empty_item(struct btrfs_trans_handle *trans,
 int btrfs_next_leaf(struct btrfs_root *root, struct btrfs_path *path);
 int btrfs_next_old_leaf(struct btrfs_root *root, struct btrfs_path *path,
                        u64 time_seq);
-static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
+static inline int btrfs_next_old_item(struct btrfs_root *root,
+                                      struct btrfs_path *p, u64 time_seq)
 {
        ++p->slots[0];
        if (p->slots[0] >= btrfs_header_nritems(p->nodes[0]))
-                return btrfs_next_leaf(root, p);
+                return btrfs_next_old_leaf(root, p, time_seq);
        return 0;
 }
+static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p)
+{
+        return btrfs_next_old_item(root, p, 0);
+}
 int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path);
 int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf);
 int __must_check btrfs_drop_snapshot(struct btrfs_root *root,
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index e1890b1d3075..2936ca49b3b4 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -2354,12 +2354,17 @@ retry_root_backup:
                                  BTRFS_CSUM_TREE_OBJECTID, csum_root);
        if (ret)
                goto recovery_tree_root;
        csum_root->track_dirty = 1;
        fs_info->generation = generation;
        fs_info->last_trans_committed = generation;
+        ret = btrfs_recover_balance(fs_info);
+        if (ret) {
+                printk(KERN_WARNING "btrfs: failed to recover balance\n");
+                goto fail_block_groups;
+        }
        ret = btrfs_init_dev_stats(fs_info);
        if (ret) {
                printk(KERN_ERR "btrfs: failed to init dev_stats: %d\n",
@@ -2485,20 +2490,23 @@ retry_root_backup:
                goto fail_trans_kthread;
        }
-        if (!(sb->s_flags & MS_RDONLY)) {
+        if (sb->s_flags & MS_RDONLY)
-                down_read(&fs_info->cleanup_work_sem);
+                return 0;
-                err = btrfs_orphan_cleanup(fs_info->fs_root);
-                if (!err)
-                        err = btrfs_orphan_cleanup(fs_info->tree_root);
-                up_read(&fs_info->cleanup_work_sem);
-                if (!err)
+        down_read(&fs_info->cleanup_work_sem);
-                        err = btrfs_recover_balance(fs_info->tree_root);
+        if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
+            (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
+                up_read(&fs_info->cleanup_work_sem);
+                close_ctree(tree_root);
+                return ret;
+        }
+        up_read(&fs_info->cleanup_work_sem);
-                if (err) {
+        ret = btrfs_resume_balance_async(fs_info);
-                        close_ctree(tree_root);
+        if (ret) {
-                        return err;
+                printk(KERN_WARNING "btrfs: failed to resume balance\n");
-                }
+                close_ctree(tree_root);
+                return ret;
        }
        return 0;
@@ -3426,6 +3434,7 @@ int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
                                mutex_unlock(&head->mutex);
                                btrfs_put_delayed_ref(ref);
+                                spin_lock(&delayed_refs->lock);
                                continue;
                        }
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 4b5a1e1bdefb..6e1d36702ff7 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -2347,12 +2347,10 @@ next:
        return count;
 }
 static void wait_for_more_refs(struct btrfs_delayed_ref_root *delayed_refs,
-                        unsigned long num_refs)
+                               unsigned long num_refs,
+                               struct list_head *first_seq)
 {
-        struct list_head *first_seq = delayed_refs->seq_head.next;
        spin_unlock(&delayed_refs->lock);
        pr_debug("waiting for more refs (num %ld, first %p)\n",
                 num_refs, first_seq);
@@ -2381,6 +2379,7 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
        struct btrfs_delayed_ref_root *delayed_refs;
        struct btrfs_delayed_ref_node *ref;
        struct list_head cluster;
+        struct list_head *first_seq = NULL;
        int ret;
        u64 delayed_start;
        int run_all = count == (unsigned long)-1;
@@ -2436,8 +2435,10 @@ again:
                                 */
                                consider_waiting = 1;
                                num_refs = delayed_refs->num_entries;
+                                first_seq = root->fs_info->tree_mod_seq_list.next;
                        } else {
-                                wait_for_more_refs(delayed_refs, num_refs);
+                                wait_for_more_refs(delayed_refs,
+                                                   num_refs, first_seq);
                                /*
                                 * after waiting, things have changed. we
                                 * dropped the lock and someone else might have
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index aaa12c1eb348..01c21b6c6d43 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -3324,6 +3324,7 @@ static int extent_write_cache_pages(struct extent_io_tree *tree,
                             writepage_t writepage, void *data,
                             void (*flush_fn)(void *))
 {
+        struct inode *inode = mapping->host;
        int ret = 0;
        int done = 0;
        int nr_to_write_done = 0;
@@ -3334,6 +3335,18 @@ static int extent_write_cache_pages(struct extent_io_tree *tree,
        int scanned = 0;
        int tag;
+        /*
+         * We have to hold onto the inode so that ordered extents can do their
+         * work when the IO finishes.  The alternative to this is failing to add
+         * an ordered extent if the igrab() fails there and that is a huge pain
+         * to deal with, so instead just hold onto the inode throughout the
+         * writepages operation.  If it fails here we are freeing up the inode
+         * anyway and we'd rather not waste our time writing out stuff that is
+         * going to be truncated anyway.
+         */
+        if (!igrab(inode))
+                return 0;
        pagevec_init(&pvec, 0);
        if (wbc->range_cyclic) {
                index = mapping->writeback_index; /* Start from prev offset */
@@ -3428,6 +3441,7 @@ retry:
                index = 0;
                goto retry;
        }
+        btrfs_add_delayed_iput(inode);
        return ret;
 }
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 70dc8ca73e25..9aa01ec2138d 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -1334,7 +1334,6 @@ static ssize_t __btrfs_direct_write(struct kiocb *iocb,
                                    loff_t *ppos, size_t count, size_t ocount)
 {
        struct file *file = iocb->ki_filp;
-        struct inode *inode = fdentry(file)->d_inode;
        struct iov_iter i;
        ssize_t written;
        ssize_t written_buffered;
@@ -1344,18 +1343,6 @@ static ssize_t __btrfs_direct_write(struct kiocb *iocb,
        written = generic_file_direct_write(iocb, iov, &nr_segs, pos, ppos,
                                            count, ocount);
-        /*
-         * the generic O_DIRECT will update in-memory i_size after the
-         * DIOs are done.  But our endio handlers that update the on
-         * disk i_size never update past the in memory i_size.  So we
-         * need one more update here to catch any additions to the
-         * file
-         */
-        if (inode->i_size != BTRFS_I(inode)->disk_i_size) {
-                btrfs_ordered_update_i_size(inode, inode->i_size, NULL);
-                mark_inode_dirty(inode);
-        }
        if (written < 0 || written == count)
                return written;
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 81296c57405a..6c4e2baa9290 100644
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -1543,29 +1543,26 @@ again:
        end = bitmap_info->offset + (u64)(BITS_PER_BITMAP * ctl->unit) - 1;
        /*
-         * XXX - this can go away after a few releases.
+         * We need to search for bits in this bitmap.  We could only cover some
-         *
+         * of the extent in this bitmap thanks to how we add space, so we need
-         * since the only user of btrfs_remove_free_space is the tree logging
+         * to search for as much as it as we can and clear that amount, and then
-         * stuff, and the only way to test that is under crash conditions, we
+         * go searching for the next bit.
-         * want to have this debug stuff here just in case somethings not
-         * working.  Search the bitmap for the space we are trying to use to
-         * make sure its actually there.  If its not there then we need to stop
-         * because something has gone wrong.
         */
        search_start = *offset;
-        search_bytes = *bytes;
+        search_bytes = ctl->unit;
        search_bytes = min(search_bytes, end - search_start + 1);
        ret = search_bitmap(ctl, bitmap_info, &search_start, &search_bytes);
        BUG_ON(ret < 0 || search_start != *offset);
-        if (*offset > bitmap_info->offset && *offset + *bytes > end) {
+        /* We may have found more bits than what we need */
-                bitmap_clear_bits(ctl, bitmap_info, *offset, end - *offset + 1);
+        search_bytes = min(search_bytes, *bytes);
-                *bytes -= end - *offset + 1;
-                *offset = end + 1;
+        /* Cannot clear past the end of the bitmap */
-        } else if (*offset >= bitmap_info->offset && *offset + *bytes <= end) {
+        search_bytes = min(search_bytes, end - search_start + 1);
-                bitmap_clear_bits(ctl, bitmap_info, *offset, *bytes);
-                *bytes = 0;
+        bitmap_clear_bits(ctl, bitmap_info, search_start, search_bytes);
-        }
+        *offset += search_bytes;
+        *bytes -= search_bytes;
        if (*bytes) {
                struct rb_node *next = rb_next(&bitmap_info->offset_index);
@@ -1596,7 +1593,7 @@ again:
                 * everything over again.
                 */
                search_start = *offset;
-                search_bytes = *bytes;
+                search_bytes = ctl->unit;
                ret = search_bitmap(ctl, bitmap_info, &search_start,
                                    &search_bytes);
                if (ret < 0 || search_start != *offset)
@@ -1879,12 +1876,14 @@ int btrfs_remove_free_space(struct btrfs_block_group_cache *block_group,
 {
        struct btrfs_free_space_ctl *ctl = block_group->free_space_ctl;
        struct btrfs_free_space *info;
-        struct btrfs_free_space *next_info = NULL;
        int ret = 0;
        spin_lock(&ctl->tree_lock);
 again:
+        if (!bytes)
+                goto out_lock;
        info = tree_search_offset(ctl, offset, 0, 0);
        if (!info) {
                /*
@@ -1905,88 +1904,48 @@ again:
                }
        }
-        if (info->bytes < bytes && rb_next(&info->offset_index)) {
+        if (!info->bitmap) {
-                u64 end;
-                next_info = rb_entry(rb_next(&info->offset_index),
-                                             struct btrfs_free_space,
-                                             offset_index);
-                if (next_info->bitmap)
-                        end = next_info->offset +
-                              BITS_PER_BITMAP * ctl->unit - 1;
-                else
-                        end = next_info->offset + next_info->bytes;
-                if (next_info->bytes < bytes ||
-                    next_info->offset > offset || offset > end) {
-                        printk(KERN_CRIT "Found free space at %llu, size %llu,"
-                              " trying to use %llu\n",
-                              (unsigned long long)info->offset,
-                              (unsigned long long)info->bytes,
-                              (unsigned long long)bytes);
-                        WARN_ON(1);
-                        ret = -EINVAL;
-                        goto out_lock;
-                }
-                info = next_info;
-        }
-        if (info->bytes == bytes) {
                unlink_free_space(ctl, info);
-                if (info->bitmap) {
+                if (offset == info->offset) {
-                        kfree(info->bitmap);
+                        u64 to_free = min(bytes, info->bytes);
-                        ctl->total_bitmaps--;
-                }
+                        info->bytes -= to_free;
-                kmem_cache_free(btrfs_free_space_cachep, info);
+                        info->offset += to_free;
-                ret = 0;
+                        if (info->bytes) {
-                goto out_lock;
+                                ret = link_free_space(ctl, info);
-        }
+                                WARN_ON(ret);
+                        } else {
-        if (!info->bitmap && info->offset == offset) {
+                                kmem_cache_free(btrfs_free_space_cachep, info);
-                unlink_free_space(ctl, info);
+                        }
-                info->offset += bytes;
-                info->bytes -= bytes;
-                ret = link_free_space(ctl, info);
-                WARN_ON(ret);
-                goto out_lock;
-        }
-        if (!info->bitmap && info->offset <= offset &&
+                        offset += to_free;
-            info->offset + info->bytes >= offset + bytes) {
+                        bytes -= to_free;
-                u64 old_start = info->offset;
+                        goto again;
-                /*
+                } else {
-                 * we're freeing space in the middle of the info,
+                        u64 old_end = info->bytes + info->offset;
-                 * this can happen during tree log replay
-                 *
-                 * first unlink the old info and then
-                 * insert it again after the hole we're creating
-                 */
-                unlink_free_space(ctl, info);
-                if (offset + bytes < info->offset + info->bytes) {
-                        u64 old_end = info->offset + info->bytes;
-                        info->offset = offset + bytes;
+                        info->bytes = offset - info->offset;
-                        info->bytes = old_end - info->offset;
                        ret = link_free_space(ctl, info);
                        WARN_ON(ret);
                        if (ret)
                                goto out_lock;
-                } else {
-                        /* the hole we're creating ends at the end
-                         * of the info struct, just free the info
-                         */
-                        kmem_cache_free(btrfs_free_space_cachep, info);
-                }
-                spin_unlock(&ctl->tree_lock);
-                /* step two, insert a new info struct to cover
+                        /* Not enough bytes in this entry to satisfy us */
-                 * anything before the hole
+                        if (old_end < offset + bytes) {
-                 */
+                                bytes -= old_end - offset;
-                ret = btrfs_add_free_space(block_group, old_start,
+                                offset = old_end;
-                                           offset - old_start);
+                                goto again;
-                WARN_ON(ret); /* -ENOMEM */
+                        } else if (old_end == offset + bytes) {
-                goto out;
+                                /* all done */
+                                goto out_lock;
+                        }
+                        spin_unlock(&ctl->tree_lock);
+                        ret = btrfs_add_free_space(block_group, offset + bytes,
+                                                   old_end - (offset + bytes));
+                        WARN_ON(ret);
+                        goto out;
+                }
        }
        ret = remove_from_bitmap(ctl, info, &offset, &bytes);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index a4f02501da40..a7d1921ac76b 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -987,7 +987,7 @@ static noinline void async_cow_start(struct btrfs_work *work)
                            async_cow->start, async_cow->end, async_cow,
                            &num_added);
        if (num_added == 0) {
-                iput(async_cow->inode);
+                btrfs_add_delayed_iput(async_cow->inode);
                async_cow->inode = NULL;
        }
 }
@@ -1023,7 +1023,7 @@ static noinline void async_cow_free(struct btrfs_work *work)
        struct async_cow *async_cow;
        async_cow = container_of(work, struct async_cow, work);
        if (async_cow->inode)
-                iput(async_cow->inode);
+                btrfs_add_delayed_iput(async_cow->inode);
        kfree(async_cow);
 }
@@ -3754,7 +3754,7 @@ void btrfs_evict_inode(struct inode *inode)
        btrfs_wait_ordered_range(inode, 0, (u64)-1);
        if (root->fs_info->log_root_recovering) {
-                BUG_ON(!test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
+                BUG_ON(test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
                                 &BTRFS_I(inode)->runtime_flags));
                goto no_delete;
        }
@@ -5876,8 +5876,17 @@ map:
        bh_result->b_size = len;
        bh_result->b_bdev = em->bdev;
        set_buffer_mapped(bh_result);
-        if (create && !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
+        if (create) {
-                set_buffer_new(bh_result);
+                if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags))
+                        set_buffer_new(bh_result);
+                /*
+                 * Need to update the i_size under the extent lock so buffered
+                 * readers will get the updated i_size when we unlock.
+                 */
+                if (start + len > i_size_read(inode))
+                        i_size_write(inode, start + len);
+        }
        free_extent_map(em);
@@ -6360,12 +6369,48 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb,
                 */
                ordered = btrfs_lookup_ordered_range(inode, lockstart,
                                                     lockend - lockstart + 1);
-                if (!ordered)
+                /*
+                 * We need to make sure there are no buffered pages in this
+                 * range either, we could have raced between the invalidate in
+                 * generic_file_direct_write and locking the extent.  The
+                 * invalidate needs to happen so that reads after a write do not
+                 * get stale data.
+                 */
+                if (!ordered && (!writing ||
+                    !test_range_bit(&BTRFS_I(inode)->io_tree,
+                                    lockstart, lockend, EXTENT_UPTODATE, 0,
+                                    cached_state)))
                        break;
                unlock_extent_cached(&BTRFS_I(inode)->io_tree, lockstart, lockend,
                                     &cached_state, GFP_NOFS);
-                btrfs_start_ordered_extent(inode, ordered, 1);
-                btrfs_put_ordered_extent(ordered);
+                if (ordered) {
+                        btrfs_start_ordered_extent(inode, ordered, 1);
+                        btrfs_put_ordered_extent(ordered);
+                } else {
+                        /* Screw you mmap */
+                        ret = filemap_write_and_wait_range(file->f_mapping,
+                                                           lockstart,
+                                                           lockend);
+                        if (ret)
+                                goto out;
+                        /*
+                         * If we found a page that couldn't be invalidated just
+                         * fall back to buffered.
+                         */
+                        ret = invalidate_inode_pages2_range(file->f_mapping,
+                                        lockstart >> PAGE_CACHE_SHIFT,
+                                        lockend >> PAGE_CACHE_SHIFT);
+                        if (ret) {
+                                if (ret == -EBUSY)
+                                        ret = 0;
+                                goto out;
+                        }
+                }
                cond_resched();
        }
diff --git a/fs/btrfs/ioctl.h b/fs/btrfs/ioctl.h
index 497c530724cf..e440aa653c30 100644
--- a/fs/btrfs/ioctl.h
+++ b/fs/btrfs/ioctl.h
@@ -339,7 +339,7 @@ struct btrfs_ioctl_get_dev_stats {
 #define BTRFS_IOC_WAIT_SYNC  _IOW(BTRFS_IOCTL_MAGIC, 22, __u64)
 #define BTRFS_IOC_SNAP_CREATE_V2 _IOW(BTRFS_IOCTL_MAGIC, 23, \
                                   struct btrfs_ioctl_vol_args_v2)
-#define BTRFS_IOC_SUBVOL_GETFLAGS _IOW(BTRFS_IOCTL_MAGIC, 25, __u64)
+#define BTRFS_IOC_SUBVOL_GETFLAGS _IOR(BTRFS_IOCTL_MAGIC, 25, __u64)
 #define BTRFS_IOC_SUBVOL_SETFLAGS _IOW(BTRFS_IOCTL_MAGIC, 26, __u64)
 #define BTRFS_IOC_SCRUB _IOWR(BTRFS_IOCTL_MAGIC, 27, \
                              struct btrfs_ioctl_scrub_args)
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 0eb9a4da069e..e23991574fdf 100644
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -1187,6 +1187,10 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data)
                if (ret)
                        goto restore;
+                ret = btrfs_resume_balance_async(fs_info);
+                if (ret)
+                        goto restore;
                sb->s_flags &= ~MS_RDONLY;
        }
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 2017d0ff511c..8abeae4224f9 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -690,6 +690,8 @@ static noinline int drop_one_dir_item(struct btrfs_trans_handle *trans,
        kfree(name);
        iput(inode);
+        btrfs_run_delayed_items(trans, root);
        return ret;
 }
@@ -895,6 +897,7 @@ again:
                                ret = btrfs_unlink_inode(trans, root, dir,
                                                         inode, victim_name,
                                                         victim_name_len);
+                                btrfs_run_delayed_items(trans, root);
                        }
                        kfree(victim_name);
                        ptr = (unsigned long)(victim_ref + 1) + victim_name_len;
@@ -1475,6 +1478,9 @@ again:
                        ret = btrfs_unlink_inode(trans, root, dir, inode,
                                                 name, name_len);
                        BUG_ON(ret);
+                        btrfs_run_delayed_items(trans, root);
                        kfree(name);
                        iput(inode);
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index 8a3d2594b807..ecaad40e7ef4 100644
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -2845,31 +2845,48 @@ out:
 static int balance_kthread(void *data)
 {
-        struct btrfs_balance_control *bctl =
+        struct btrfs_fs_info *fs_info = data;
-                        (struct btrfs_balance_control *)data;
-        struct btrfs_fs_info *fs_info = bctl->fs_info;
        int ret = 0;
        mutex_lock(&fs_info->volume_mutex);
        mutex_lock(&fs_info->balance_mutex);
-        set_balance_control(bctl);
+        if (fs_info->balance_ctl) {
-        if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) {
-                printk(KERN_INFO "btrfs: force skipping balance\n");
-        } else {
                printk(KERN_INFO "btrfs: continuing balance\n");
-                ret = btrfs_balance(bctl, NULL);
+                ret = btrfs_balance(fs_info->balance_ctl, NULL);
        }
        mutex_unlock(&fs_info->balance_mutex);
        mutex_unlock(&fs_info->volume_mutex);
        return ret;
 }
-int btrfs_recover_balance(struct btrfs_root *tree_root)
+int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info)
 {
        struct task_struct *tsk;
+        spin_lock(&fs_info->balance_lock);
+        if (!fs_info->balance_ctl) {
+                spin_unlock(&fs_info->balance_lock);
+                return 0;
+        }
+        spin_unlock(&fs_info->balance_lock);
+        if (btrfs_test_opt(fs_info->tree_root, SKIP_BALANCE)) {
+                printk(KERN_INFO "btrfs: force skipping balance\n");
+                return 0;
+        }
+        tsk = kthread_run(balance_kthread, fs_info, "btrfs-balance");
+        if (IS_ERR(tsk))
+                return PTR_ERR(tsk);
+        return 0;
+}
+int btrfs_recover_balance(struct btrfs_fs_info *fs_info)
+{
        struct btrfs_balance_control *bctl;
        struct btrfs_balance_item *item;
        struct btrfs_disk_balance_args disk_bargs;
@@ -2882,29 +2899,30 @@ int btrfs_recover_balance(struct btrfs_root *tree_root)
        if (!path)
                return -ENOMEM;
-        bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
-        if (!bctl) {
-                ret = -ENOMEM;
-                goto out;
-        }
        key.objectid = BTRFS_BALANCE_OBJECTID;
        key.type = BTRFS_BALANCE_ITEM_KEY;
        key.offset = 0;
-        ret = btrfs_search_slot(NULL, tree_root, &key, path, 0, 0);
+        ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
        if (ret < 0)
-                goto out_bctl;
+                goto out;
        if (ret > 0) { /* ret = -ENOENT; */
                ret = 0;
-                goto out_bctl;
+                goto out;
+        }
+        bctl = kzalloc(sizeof(*bctl), GFP_NOFS);
+        if (!bctl) {
+                ret = -ENOMEM;
+                goto out;
        }
        leaf = path->nodes[0];
        item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_balance_item);
-        bctl->fs_info = tree_root->fs_info;
+        bctl->fs_info = fs_info;
-        bctl->flags = btrfs_balance_flags(leaf, item) | BTRFS_BALANCE_RESUME;
+        bctl->flags = btrfs_balance_flags(leaf, item);
+        bctl->flags |= BTRFS_BALANCE_RESUME;
        btrfs_balance_data(leaf, item, &disk_bargs);
        btrfs_disk_balance_args_to_cpu(&bctl->data, &disk_bargs);
@@ -2913,14 +2931,13 @@ int btrfs_recover_balance(struct btrfs_root *tree_root)
        btrfs_balance_sys(leaf, item, &disk_bargs);
        btrfs_disk_balance_args_to_cpu(&bctl->sys, &disk_bargs);
-        tsk = kthread_run(balance_kthread, bctl, "btrfs-balance");
+        mutex_lock(&fs_info->volume_mutex);
-        if (IS_ERR(tsk))
+        mutex_lock(&fs_info->balance_mutex);
-                ret = PTR_ERR(tsk);
-        else
-                goto out;
-out_bctl:
+        set_balance_control(bctl);
-        kfree(bctl);
+        mutex_unlock(&fs_info->balance_mutex);
+        mutex_unlock(&fs_info->volume_mutex);
 out:
        btrfs_free_path(path);
        return ret;
@@ -4061,16 +4078,18 @@ static void btrfs_end_bio(struct bio *bio, int err)
                        BUG_ON(stripe_index >= bbio->num_stripes);
                        dev = bbio->stripes[stripe_index].dev;
-                        if (bio->bi_rw & WRITE)
+                        if (dev->bdev) {
-                                btrfs_dev_stat_inc(dev,
+                                if (bio->bi_rw & WRITE)
-                                                   BTRFS_DEV_STAT_WRITE_ERRS);
+                                        btrfs_dev_stat_inc(dev,
-                        else
+                                                BTRFS_DEV_STAT_WRITE_ERRS);
-                                btrfs_dev_stat_inc(dev,
+                                else
-                                                   BTRFS_DEV_STAT_READ_ERRS);
+                                        btrfs_dev_stat_inc(dev,
-                        if ((bio->bi_rw & WRITE_FLUSH) == WRITE_FLUSH)
+                                                BTRFS_DEV_STAT_READ_ERRS);
-                                btrfs_dev_stat_inc(dev,
+                                if ((bio->bi_rw & WRITE_FLUSH) == WRITE_FLUSH)
-                                                   BTRFS_DEV_STAT_FLUSH_ERRS);
+                                        btrfs_dev_stat_inc(dev,
-                        btrfs_dev_stat_print_on_error(dev);
+                                                BTRFS_DEV_STAT_FLUSH_ERRS);
+                                btrfs_dev_stat_print_on_error(dev);
+                        }
                }
        }
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h
index 74366f27a76b..95f6637614db 100644
--- a/fs/btrfs/volumes.h
+++ b/fs/btrfs/volumes.h
@@ -281,7 +281,8 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size);
 int btrfs_init_new_device(struct btrfs_root *root, char *path);
 int btrfs_balance(struct btrfs_balance_control *bctl,
                  struct btrfs_ioctl_balance_args *bargs);
-int btrfs_recover_balance(struct btrfs_root *tree_root);
+int btrfs_resume_balance_async(struct btrfs_fs_info *fs_info);
+int btrfs_recover_balance(struct btrfs_fs_info *fs_info);
 int btrfs_pause_balance(struct btrfs_fs_info *fs_info);
 int btrfs_cancel_balance(struct btrfs_fs_info *fs_info);
 int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset);
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 173b1d22e59b..8b67304e4b80 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -54,7 +54,12 @@
        (CONGESTION_ON_THRESH(congestion_kb) -                          \
         (CONGESTION_ON_THRESH(congestion_kb) >> 2))
+static inline struct ceph_snap_context *page_snap_context(struct page *page)
+{
+        if (PagePrivate(page))
+                return (void *)page->private;
+        return NULL;
+}
 /*
 * Dirty a page.  Optimistically adjust accounting, on the assumption
@@ -142,10 +147,9 @@ static void ceph_invalidatepage(struct page *page, unsigned long offset)
 {
        struct inode *inode;
        struct ceph_inode_info *ci;
-        struct ceph_snap_context *snapc = (void *)page->private;
+        struct ceph_snap_context *snapc = page_snap_context(page);
        BUG_ON(!PageLocked(page));
-        BUG_ON(!page->private);
        BUG_ON(!PagePrivate(page));
        BUG_ON(!page->mapping);
@@ -182,7 +186,6 @@ static int ceph_releasepage(struct page *page, gfp_t g)
        struct inode *inode = page->mapping ? page->mapping->host : NULL;
        dout("%p releasepage %p idx %lu\n", inode, page, page->index);
        WARN_ON(PageDirty(page));
-        WARN_ON(page->private);
        WARN_ON(PagePrivate(page));
        return 0;
 }
@@ -443,7 +446,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
        osdc = &fsc->client->osdc;
        /* verify this is a writeable snap context */
-        snapc = (void *)page->private;
+        snapc = page_snap_context(page);
        if (snapc == NULL) {
                dout("writepage %p page %p not dirty?\n", inode, page);
                goto out;
@@ -451,7 +454,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
        oldest = get_oldest_context(inode, &snap_size);
        if (snapc->seq > oldest->seq) {
                dout("writepage %p page %p snapc %p not writeable - noop\n",
-                     inode, page, (void *)page->private);
+                     inode, page, snapc);
                /* we should only noop if called by kswapd */
                WARN_ON((current->flags & PF_MEMALLOC) == 0);
                ceph_put_snap_context(oldest);
@@ -591,7 +594,7 @@ static void writepages_finish(struct ceph_osd_request *req,
                        clear_bdi_congested(&fsc->backing_dev_info,
                                            BLK_RW_ASYNC);
-                ceph_put_snap_context((void *)page->private);
+                ceph_put_snap_context(page_snap_context(page));
                page->private = 0;
                ClearPagePrivate(page);
                dout("unlocking %d %p\n", i, page);
@@ -795,7 +798,7 @@ get_more_pages:
                        }
                        /* only if matching snap context */
-                        pgsnapc = (void *)page->private;
+                        pgsnapc = page_snap_context(page);
                        if (pgsnapc->seq > snapc->seq) {
                                dout("page snapc %p %lld > oldest %p %lld\n",
                                     pgsnapc, pgsnapc->seq, snapc, snapc->seq);
@@ -984,7 +987,7 @@ retry_locked:
        BUG_ON(!ci->i_snap_realm);
        down_read(&mdsc->snap_rwsem);
        BUG_ON(!ci->i_snap_realm->cached_context);
-        snapc = (void *)page->private;
+        snapc = page_snap_context(page);
        if (snapc && snapc != ci->i_head_snapc) {
                /*
                 * this page is already dirty in another (older) snap
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 78db68a5cf44..0ae86ddf2213 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -1653,24 +1653,26 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                         * If yes, we have encountered a double deliminator
                         * reset the NULL character to the deliminator
                         */
-                        if (tmp_end < end && tmp_end[1] == delim)
+                        if (tmp_end < end && tmp_end[1] == delim) {
                                tmp_end[0] = delim;
-                        /* Keep iterating until we get to a single deliminator
+                                /* Keep iterating until we get to a single
-                         * OR the end
+                                 * deliminator OR the end
-                         */
+                                 */
-                        while ((tmp_end = strchr(tmp_end, delim)) != NULL &&
+                                while ((tmp_end = strchr(tmp_end, delim))
-                               (tmp_end[1] == delim)) {
+                                        != NULL && (tmp_end[1] == delim)) {
-                                tmp_end = (char *) &tmp_end[2];
+                                                tmp_end = (char *) &tmp_end[2];
-                        }
+                                }
-                        /* Reset var options to point to next element */
+                                /* Reset var options to point to next element */
-                        if (tmp_end) {
+                                if (tmp_end) {
-                                tmp_end[0] = '\0';
+                                        tmp_end[0] = '\0';
-                                options = (char *) &tmp_end[1];
+                                        options = (char *) &tmp_end[1];
-                        } else
+                                } else
-                                /* Reached the end of the mount option string */
+                                        /* Reached the end of the mount option
-                                options = end;
+                                         * string */
+                                        options = end;
+                        }
                        /* Now build new password string */
                        temp_len = strlen(value);
@@ -3493,18 +3495,15 @@ cifs_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *pvolume_info)
         * MS-CIFS indicates that servers are only limited by the client's
         * bufsize for reads, testing against win98se shows that it throws
         * INVALID_PARAMETER errors if you try to request too large a read.
+         * OS/2 just sends back short reads.
         *
-         * If the server advertises a MaxBufferSize of less than one page,
+         * If the server doesn't advertise CAP_LARGE_READ_X, then assume that
-         * assume that it also can't satisfy reads larger than that either.
+         * it can't handle a read request larger than its MaxBufferSize either.
-         *
-         * FIXME: Is there a better heuristic for this?
         */
        if (tcon->unix_ext && (unix_cap & CIFS_UNIX_LARGE_READ_CAP))
                defsize = CIFS_DEFAULT_IOSIZE;
        else if (server->capabilities & CAP_LARGE_READ_X)
                defsize = CIFS_DEFAULT_NON_POSIX_RSIZE;
-        else if (server->maxBuf >= PAGE_CACHE_SIZE)
-                defsize = CIFSMaxBufSize;
        else
                defsize = server->maxBuf - sizeof(READ_RSP);
diff --git a/fs/ecryptfs/kthread.c b/fs/ecryptfs/kthread.c
index 69f994a7d524..0dbe58a8b172 100644
--- a/fs/ecryptfs/kthread.c
+++ b/fs/ecryptfs/kthread.c
@@ -149,7 +149,7 @@ int ecryptfs_privileged_open(struct file **lower_file,
        (*lower_file) = dentry_open(lower_dentry, lower_mnt, flags, cred);
        if (!IS_ERR(*lower_file))
                goto out;
-        if (flags & O_RDONLY) {
+        if ((flags & O_ACCMODE) == O_RDONLY) {
                rc = PTR_ERR((*lower_file));
                goto out;
        }
diff --git a/fs/ecryptfs/miscdev.c b/fs/ecryptfs/miscdev.c
index 3a06f4043df4..c0038f6566d4 100644
--- a/fs/ecryptfs/miscdev.c
+++ b/fs/ecryptfs/miscdev.c
@@ -49,7 +49,10 @@ ecryptfs_miscdev_poll(struct file *file, poll_table *pt)
        mutex_lock(&ecryptfs_daemon_hash_mux);
        /* TODO: Just use file->private_data? */
        rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns());
-        BUG_ON(rc || !daemon);
+        if (rc || !daemon) {
+                mutex_unlock(&ecryptfs_daemon_hash_mux);
+                return -EINVAL;
+        }
        mutex_lock(&daemon->mux);
        mutex_unlock(&ecryptfs_daemon_hash_mux);
        if (daemon->flags & ECRYPTFS_DAEMON_ZOMBIE) {
@@ -122,6 +125,7 @@ ecryptfs_miscdev_open(struct inode *inode, struct file *file)
                goto out_unlock_daemon;
        }
        daemon->flags |= ECRYPTFS_DAEMON_MISCDEV_OPEN;
+        file->private_data = daemon;
        atomic_inc(&ecryptfs_num_miscdev_opens);
 out_unlock_daemon:
        mutex_unlock(&daemon->mux);
@@ -152,9 +156,9 @@ ecryptfs_miscdev_release(struct inode *inode, struct file *file)
        mutex_lock(&ecryptfs_daemon_hash_mux);
        rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns());
-        BUG_ON(rc || !daemon);
+        if (rc || !daemon)
+                daemon = file->private_data;
        mutex_lock(&daemon->mux);
-        BUG_ON(daemon->pid != task_pid(current));
        BUG_ON(!(daemon->flags & ECRYPTFS_DAEMON_MISCDEV_OPEN));
        daemon->flags &= ~ECRYPTFS_DAEMON_MISCDEV_OPEN;
        atomic_dec(&ecryptfs_num_miscdev_opens);
@@ -191,31 +195,32 @@ int ecryptfs_send_miscdev(char *data, size_t data_size,
                          struct ecryptfs_msg_ctx *msg_ctx, u8 msg_type,
                          u16 msg_flags, struct ecryptfs_daemon *daemon)
 {
-        int rc = 0;
+        struct ecryptfs_message *msg;
-        mutex_lock(&msg_ctx->mux);
+        msg = kmalloc((sizeof(*msg) + data_size), GFP_KERNEL);
-        msg_ctx->msg = kmalloc((sizeof(*msg_ctx->msg) + data_size),
+        if (!msg) {
-                               GFP_KERNEL);
-        if (!msg_ctx->msg) {
-                rc = -ENOMEM;
                printk(KERN_ERR "%s: Out of memory whilst attempting "
                       "to kmalloc(%zd, GFP_KERNEL)\n", __func__,
-                       (sizeof(*msg_ctx->msg) + data_size));
+                       (sizeof(*msg) + data_size));
-                goto out_unlock;
+                return -ENOMEM;
        }
+        mutex_lock(&msg_ctx->mux);
+        msg_ctx->msg = msg;
        msg_ctx->msg->index = msg_ctx->index;
        msg_ctx->msg->data_len = data_size;
        msg_ctx->type = msg_type;
        memcpy(msg_ctx->msg->data, data, data_size);
        msg_ctx->msg_size = (sizeof(*msg_ctx->msg) + data_size);
-        mutex_lock(&daemon->mux);
        list_add_tail(&msg_ctx->daemon_out_list, &daemon->msg_ctx_out_queue);
+        mutex_unlock(&msg_ctx->mux);
+        mutex_lock(&daemon->mux);
        daemon->num_queued_msg_ctx++;
        wake_up_interruptible(&daemon->wait);
        mutex_unlock(&daemon->mux);
-out_unlock:
-        mutex_unlock(&msg_ctx->mux);
+        return 0;
-        return rc;
 }
 /*
@@ -269,8 +274,16 @@ ecryptfs_miscdev_read(struct file *file, char __user *buf, size_t count,
        mutex_lock(&ecryptfs_daemon_hash_mux);
        /* TODO: Just use file->private_data? */
        rc = ecryptfs_find_daemon_by_euid(&daemon, euid, current_user_ns());
-        BUG_ON(rc || !daemon);
+        if (rc || !daemon) {
+                mutex_unlock(&ecryptfs_daemon_hash_mux);
+                return -EINVAL;
+        }
        mutex_lock(&daemon->mux);
+        if (task_pid(current) != daemon->pid) {
+                mutex_unlock(&daemon->mux);
+                mutex_unlock(&ecryptfs_daemon_hash_mux);
+                return -EPERM;
+        }
        if (daemon->flags & ECRYPTFS_DAEMON_ZOMBIE) {
                rc = 0;
                mutex_unlock(&ecryptfs_daemon_hash_mux);
@@ -307,9 +320,6 @@ check_list:
                 * message from the queue; try again */
                goto check_list;
        }
-        BUG_ON(euid != daemon->euid);
-        BUG_ON(current_user_ns() != daemon->user_ns);
-        BUG_ON(task_pid(current) != daemon->pid);
        msg_ctx = list_first_entry(&daemon->msg_ctx_out_queue,
                                   struct ecryptfs_msg_ctx, daemon_out_list);
        BUG_ON(!msg_ctx);
diff --git a/fs/exec.c b/fs/exec.c
index a79786a8d2c8..da27b91ff1e8 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -819,10 +819,10 @@ static int exec_mmap(struct mm_struct *mm)
        /* Notify parent that we're no longer interested in the old VM */
        tsk = current;
        old_mm = current->mm;
-        sync_mm_rss(old_mm);
        mm_release(tsk, old_mm);
        if (old_mm) {
+                sync_mm_rss(old_mm);
                /*
                 * Make sure that if there is a core dump in progress
                 * for the old mm, we get out and die instead of going
diff --git a/fs/hfsplus/ioctl.c b/fs/hfsplus/ioctl.c
index c640ba57074b..09addc8615fa 100644
--- a/fs/hfsplus/ioctl.c
+++ b/fs/hfsplus/ioctl.c
@@ -31,6 +31,7 @@ static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags)
        struct hfsplus_sb_info *sbi = HFSPLUS_SB(inode->i_sb);
        struct hfsplus_vh *vh = sbi->s_vhdr;
        struct hfsplus_vh *bvh = sbi->s_backup_vhdr;
+        u32 cnid = (unsigned long)dentry->d_fsdata;
        if (!capable(CAP_SYS_ADMIN))
                return -EPERM;
@@ -41,8 +42,12 @@ static int hfsplus_ioctl_bless(struct file *file, int __user *user_flags)
        vh->finder_info[0] = bvh->finder_info[0] =
                cpu_to_be32(parent_ino(dentry));
-        /* Bootloader */
+        /*
-        vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(inode->i_ino);
+         * Bootloader. Just using the inode here breaks in the case of
+         * hard links - the firmware wants the ID of the hard link file,
+         * but the inode points at the indirect inode
+         */
+        vh->finder_info[1] = bvh->finder_info[1] = cpu_to_be32(cnid);
        /* Per spec, the OS X system folder - same as finder_info[0] here */
        vh->finder_info[5] = bvh->finder_info[5] =
diff --git a/fs/hfsplus/wrapper.c b/fs/hfsplus/wrapper.c
index 7daf4b852d1c..90effcccca9a 100644
--- a/fs/hfsplus/wrapper.c
+++ b/fs/hfsplus/wrapper.c
@@ -56,7 +56,7 @@ int hfsplus_submit_bio(struct super_block *sb, sector_t sector,
        DECLARE_COMPLETION_ONSTACK(wait);
        struct bio *bio;
        int ret = 0;
-        unsigned int io_size;
+        u64 io_size;
        loff_t start;
        int offset;
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 17ba6b995659..f005b5bebdc7 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -207,7 +207,6 @@ error_0:
 static void nfs4_shutdown_session(struct nfs_client *clp)
 {
        if (nfs4_has_session(clp)) {
-                nfs4_deviceid_purge_client(clp);
                nfs4_destroy_session(clp->cl_session);
                nfs4_destroy_clientid(clp);
        }
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 3168f6e3d4d4..9a4cbfc85d81 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -490,6 +490,7 @@ static void nfs_direct_write_reschedule(struct nfs_direct_req *dreq)
                        dreq->error = -EIO;
                        spin_unlock(cinfo.lock);
                }
+                nfs_release_request(req);
        }
        nfs_pageio_complete(&desc);
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index b5b86a05059c..864c51e4b400 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -57,6 +57,11 @@ unsigned int nfs_idmap_cache_timeout = 600;
 static const struct cred *id_resolver_cache;
 static struct key_type key_type_id_resolver_legacy;
+struct idmap {
+        struct rpc_pipe         *idmap_pipe;
+        struct key_construction *idmap_key_cons;
+        struct mutex            idmap_mutex;
+};
 /**
 * nfs_fattr_init_names - initialise the nfs_fattr owner_name/group_name fields
@@ -310,9 +315,11 @@ static ssize_t nfs_idmap_get_key(const char *name, size_t namelen,
                                            name, namelen, type, data,
                                            data_size, NULL);
        if (ret < 0) {
+                mutex_lock(&idmap->idmap_mutex);
                ret = nfs_idmap_request_key(&key_type_id_resolver_legacy,
                                            name, namelen, type, data,
                                            data_size, idmap);
+                mutex_unlock(&idmap->idmap_mutex);
        }
        return ret;
 }
@@ -354,11 +361,6 @@ static int nfs_idmap_lookup_id(const char *name, size_t namelen, const char *typ
 /* idmap classic begins here */
 module_param(nfs_idmap_cache_timeout, int, 0644);
-struct idmap {
-        struct rpc_pipe         *idmap_pipe;
-        struct key_construction *idmap_key_cons;
-};
 enum {
        Opt_find_uid, Opt_find_gid, Opt_find_user, Opt_find_group, Opt_find_err
 };
@@ -469,6 +471,7 @@ nfs_idmap_new(struct nfs_client *clp)
                return error;
        }
        idmap->idmap_pipe = pipe;
+        mutex_init(&idmap->idmap_mutex);
        clp->cl_idmap = idmap;
        return 0;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index e605d695dbcb..f7296983eba6 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -1530,7 +1530,6 @@ static inline void nfs4_init_once(struct nfs_inode *nfsi)
        nfsi->delegation_state = 0;
        init_rwsem(&nfsi->rwsem);
        nfsi->layout = NULL;
-        atomic_set(&nfsi->commit_info.rpcs_out, 0);
 #endif
 }
@@ -1545,6 +1544,7 @@ static void init_once(void *foo)
        INIT_LIST_HEAD(&nfsi->commit_info.list);
        nfsi->npages = 0;
        nfsi->commit_info.ncommit = 0;
+        atomic_set(&nfsi->commit_info.rpcs_out, 0);
        atomic_set(&nfsi->silly_count, 1);
        INIT_HLIST_HEAD(&nfsi->silly_list);
        init_waitqueue_head(&nfsi->waitqueue);
diff --git a/fs/nfs/pnfs.c b/fs/nfs/pnfs.c
index b8323aa7b543..bbc49caa7a82 100644
--- a/fs/nfs/pnfs.c
+++ b/fs/nfs/pnfs.c
@@ -70,6 +70,10 @@ find_pnfs_driver(u32 id)
        spin_lock(&pnfs_spinlock);
        local = find_pnfs_driver_locked(id);
+        if (local != NULL && !try_module_get(local->owner)) {
+                dprintk("%s: Could not grab reference on module\n", __func__);
+                local = NULL;
+        }
        spin_unlock(&pnfs_spinlock);
        return local;
 }
@@ -80,6 +84,9 @@ unset_pnfs_layoutdriver(struct nfs_server *nfss)
        if (nfss->pnfs_curr_ld) {
                if (nfss->pnfs_curr_ld->clear_layoutdriver)
                        nfss->pnfs_curr_ld->clear_layoutdriver(nfss);
+                /* Decrement the MDS count. Purge the deviceid cache if zero */
+                if (atomic_dec_and_test(&nfss->nfs_client->cl_mds_count))
+                        nfs4_deviceid_purge_client(nfss->nfs_client);
                module_put(nfss->pnfs_curr_ld->owner);
        }
        nfss->pnfs_curr_ld = NULL;
@@ -115,10 +122,6 @@ set_pnfs_layoutdriver(struct nfs_server *server, const struct nfs_fh *mntfh,
                        goto out_no_driver;
                }
        }
-        if (!try_module_get(ld_type->owner)) {
-                dprintk("%s: Could not grab reference on module\n", __func__);
-                goto out_no_driver;
-        }
        server->pnfs_curr_ld = ld_type;
        if (ld_type->set_layoutdriver
            && ld_type->set_layoutdriver(server, mntfh)) {
@@ -127,6 +130,8 @@ set_pnfs_layoutdriver(struct nfs_server *server, const struct nfs_fh *mntfh,
                module_put(ld_type->owner);
                goto out_no_driver;
        }
+        /* Bump the MDS count */
+        atomic_inc(&server->nfs_client->cl_mds_count);
        dprintk("%s: pNFS module for %u set\n", __func__, id);
        return;
diff --git a/fs/nilfs2/gcinode.c b/fs/nilfs2/gcinode.c
index 08a07a218d26..57ceaf33d177 100644
--- a/fs/nilfs2/gcinode.c
+++ b/fs/nilfs2/gcinode.c
@@ -191,6 +191,8 @@ void nilfs_remove_all_gcinodes(struct the_nilfs *nilfs)
        while (!list_empty(head)) {
                ii = list_first_entry(head, struct nilfs_inode_info, i_dirty);
                list_del_init(&ii->i_dirty);
+                truncate_inode_pages(&ii->vfs_inode.i_data, 0);
+                nilfs_btnode_cache_clear(&ii->i_btnode_cache);
                iput(&ii->vfs_inode);
        }
 }
diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index 0e72ad6f22aa..88e11fb346b6 100644
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -2309,6 +2309,8 @@ nilfs_remove_written_gcinodes(struct the_nilfs *nilfs, struct list_head *head)
                if (!test_bit(NILFS_I_UPDATED, &ii->i_state))
                        continue;
                list_del_init(&ii->i_dirty);
+                truncate_inode_pages(&ii->vfs_inode.i_data, 0);
+                nilfs_btnode_cache_clear(&ii->i_btnode_cache);
                iput(&ii->vfs_inode);
        }
 }
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 81a4cd22f80b..4f7795fb5fc0 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -456,7 +456,7 @@ static void ocfs2_update_lock_stats(struct ocfs2_lock_res *res, int level,
        stats->ls_gets++;
        stats->ls_total += ktime_to_ns(kt);
        /* overflow */
-        if (unlikely(stats->ls_gets) == 0) {
+        if (unlikely(stats->ls_gets == 0)) {
                stats->ls_gets++;
                stats->ls_total = ktime_to_ns(kt);
        }
@@ -3932,6 +3932,8 @@ unqueue:
 static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
                                        struct ocfs2_lock_res *lockres)
 {
+        unsigned long flags;
        assert_spin_locked(&lockres->l_lock);
        if (lockres->l_flags & OCFS2_LOCK_FREEING) {
@@ -3945,21 +3947,22 @@ static void ocfs2_schedule_blocked_lock(struct ocfs2_super *osb,
        lockres_or_flags(lockres, OCFS2_LOCK_QUEUED);
-        spin_lock(&osb->dc_task_lock);
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        if (list_empty(&lockres->l_blocked_list)) {
                list_add_tail(&lockres->l_blocked_list,
                              &osb->blocked_lock_list);
                osb->blocked_lock_count++;
        }
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
 }
 static void ocfs2_downconvert_thread_do_work(struct ocfs2_super *osb)
 {
        unsigned long processed;
+        unsigned long flags;
        struct ocfs2_lock_res *lockres;
-        spin_lock(&osb->dc_task_lock);
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        /* grab this early so we know to try again if a state change and
         * wake happens part-way through our work  */
        osb->dc_work_sequence = osb->dc_wake_sequence;
@@ -3972,38 +3975,40 @@ static void ocfs2_downconvert_thread_do_work(struct ocfs2_super *osb)
                                     struct ocfs2_lock_res, l_blocked_list);
                list_del_init(&lockres->l_blocked_list);
                osb->blocked_lock_count--;
-                spin_unlock(&osb->dc_task_lock);
+                spin_unlock_irqrestore(&osb->dc_task_lock, flags);
                BUG_ON(!processed);
                processed--;
                ocfs2_process_blocked_lock(osb, lockres);
-                spin_lock(&osb->dc_task_lock);
+                spin_lock_irqsave(&osb->dc_task_lock, flags);
        }
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
 }
 static int ocfs2_downconvert_thread_lists_empty(struct ocfs2_super *osb)
 {
        int empty = 0;
+        unsigned long flags;
-        spin_lock(&osb->dc_task_lock);
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        if (list_empty(&osb->blocked_lock_list))
                empty = 1;
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
        return empty;
 }
 static int ocfs2_downconvert_thread_should_wake(struct ocfs2_super *osb)
 {
        int should_wake = 0;
+        unsigned long flags;
-        spin_lock(&osb->dc_task_lock);
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        if (osb->dc_work_sequence != osb->dc_wake_sequence)
                should_wake = 1;
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
        return should_wake;
 }
@@ -4033,10 +4038,12 @@ static int ocfs2_downconvert_thread(void *arg)
 void ocfs2_wake_downconvert_thread(struct ocfs2_super *osb)
 {
-        spin_lock(&osb->dc_task_lock);
+        unsigned long flags;
+        spin_lock_irqsave(&osb->dc_task_lock, flags);
        /* make sure the voting thread gets a swipe at whatever changes
         * the caller may have made to the voting state */
        osb->dc_wake_sequence++;
-        spin_unlock(&osb->dc_task_lock);
+        spin_unlock_irqrestore(&osb->dc_task_lock, flags);
        wake_up(&osb->dc_event);
 }
diff --git a/fs/ocfs2/extent_map.c b/fs/ocfs2/extent_map.c
index 2f5b92ef0e53..70b5863a2d64 100644
--- a/fs/ocfs2/extent_map.c
+++ b/fs/ocfs2/extent_map.c
@@ -923,8 +923,6 @@ out_unlock:
        ocfs2_inode_unlock(inode, 0);
 out:
-        if (ret && ret != -ENXIO)
-                ret = -ENXIO;
        return ret;
 }
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 061591a3ab08..98513c8ed589 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -2422,8 +2422,10 @@ out_dio:
                unaligned_dio = 0;
        }
-        if (unaligned_dio)
+        if (unaligned_dio) {
+                ocfs2_iocb_clear_unaligned_aio(iocb);
                atomic_dec(&OCFS2_I(inode)->ip_unaligned_aio);
+        }
 out:
        if (rw_level != -1)
diff --git a/fs/ocfs2/quota_global.c b/fs/ocfs2/quota_global.c
index 92fcd575775a..0a86e302655f 100644
--- a/fs/ocfs2/quota_global.c
+++ b/fs/ocfs2/quota_global.c
@@ -399,8 +399,6 @@ int ocfs2_global_read_info(struct super_block *sb, int type)
                              msecs_to_jiffies(oinfo->dqi_syncms));
 out_err:
-        if (status)
-                mlog_errno(status);
        return status;
 out_unlock:
        ocfs2_unlock_global_qf(oinfo, 0);
diff --git a/fs/open.c b/fs/open.c
index d6c79a0dffc7..1540632d8387 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -397,10 +397,10 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
 {
        struct file *file;
        struct inode *inode;
-        int error;
+        int error, fput_needed;
        error = -EBADF;
-        file = fget(fd);
+        file = fget_raw_light(fd, &fput_needed);
        if (!file)
                goto out;
@@ -414,7 +414,7 @@ SYSCALL_DEFINE1(fchdir, unsigned int, fd)
        if (!error)
                set_fs_pwd(current->fs, &file->f_path);
 out_putf:
-        fput(file);
+        fput_light(file, fput_needed);
 out:
        return error;
 }
diff --git a/fs/pstore/inode.c b/fs/pstore/inode.c
index aeb19e68e086..11a2aa2a56c4 100644
--- a/fs/pstore/inode.c
+++ b/fs/pstore/inode.c
@@ -258,7 +258,7 @@ fail:
        return rc;
 }
-int pstore_fill_super(struct super_block *sb, void *data, int silent)
+static int pstore_fill_super(struct super_block *sb, void *data, int silent)
 {
        struct inode *inode;
diff --git a/fs/pstore/platform.c b/fs/pstore/platform.c
index 82c585f715e3..03ce7a9b81cc 100644
--- a/fs/pstore/platform.c
+++ b/fs/pstore/platform.c
@@ -94,20 +94,15 @@ static const char *get_reason_str(enum kmsg_dump_reason reason)
 * as we can from the end of the buffer.
 */
 static void pstore_dump(struct kmsg_dumper *dumper,
-            enum kmsg_dump_reason reason,
+                        enum kmsg_dump_reason reason)
-            const char *s1, unsigned long l1,
-            const char *s2, unsigned long l2)
 {
-        unsigned long   s1_start, s2_start;
+        unsigned long   total = 0;
-        unsigned long   l1_cpy, l2_cpy;
-        unsigned long   size, total = 0;
-        char            *dst;
        const char      *why;
        u64             id;
-        int             hsize, ret;
        unsigned int    part = 1;
        unsigned long   flags = 0;
        int             is_locked = 0;
+        int             ret;
        why = get_reason_str(reason);
@@ -119,30 +114,25 @@ static void pstore_dump(struct kmsg_dumper *dumper,
                spin_lock_irqsave(&psinfo->buf_lock, flags);
        oopscount++;
        while (total < kmsg_bytes) {
+                char *dst;
+                unsigned long size;
+                int hsize;
+                size_t len;
                dst = psinfo->buf;
                hsize = sprintf(dst, "%s#%d Part%d\n", why, oopscount, part);
                size = psinfo->bufsize - hsize;
                dst += hsize;
-                l2_cpy = min(l2, size);
+                if (!kmsg_dump_get_buffer(dumper, true, dst, size, &len))
-                l1_cpy = min(l1, size - l2_cpy);
-                if (l1_cpy + l2_cpy == 0)
                        break;
-                s2_start = l2 - l2_cpy;
-                s1_start = l1 - l1_cpy;
-                memcpy(dst, s1 + s1_start, l1_cpy);
-                memcpy(dst + l1_cpy, s2 + s2_start, l2_cpy);
                ret = psinfo->write(PSTORE_TYPE_DMESG, reason, &id, part,
-                                   hsize + l1_cpy + l2_cpy, psinfo);
+                                    hsize + len, psinfo);
                if (ret == 0 && reason == KMSG_DUMP_OOPS && pstore_is_mounted())
                        pstore_new_entry = 1;
-                l1 -= l1_cpy;
-                l2 -= l2_cpy;
+                total += hsize + len;
-                total += l1_cpy + l2_cpy;
                part++;
        }
        if (in_nmi()) {
diff --git a/fs/pstore/ram.c b/fs/pstore/ram.c
index 9123cce28c1e..453030f9c5bc 100644
--- a/fs/pstore/ram.c
+++ b/fs/pstore/ram.c
@@ -106,6 +106,8 @@ static ssize_t ramoops_pstore_read(u64 *id, enum pstore_type_id *type,
        time->tv_sec = 0;
        time->tv_nsec = 0;
+        /* Update old/shadowed buffer. */
+        persistent_ram_save_old(prz);
        size = persistent_ram_old_size(prz);
        *buf = kmalloc(size, GFP_KERNEL);
        if (*buf == NULL)
@@ -184,6 +186,7 @@ static int ramoops_pstore_erase(enum pstore_type_id type, u64 id,
                return -EINVAL;
        persistent_ram_free_old(cxt->przs[id]);
+        persistent_ram_zap(cxt->przs[id]);
        return 0;
 }
diff --git a/fs/pstore/ram_core.c b/fs/pstore/ram_core.c
index 31f8d184f3a0..c5fbdbbf81ac 100644
--- a/fs/pstore/ram_core.c
+++ b/fs/pstore/ram_core.c
@@ -250,23 +250,24 @@ static void notrace persistent_ram_update(struct persistent_ram_zone *prz,
        persistent_ram_update_ecc(prz, start, count);
 }
-static void __init
+void persistent_ram_save_old(struct persistent_ram_zone *prz)
-persistent_ram_save_old(struct persistent_ram_zone *prz)
 {
        struct persistent_ram_buffer *buffer = prz->buffer;
        size_t size = buffer_size(prz);
        size_t start = buffer_start(prz);
-        char *dest;
-        persistent_ram_ecc_old(prz);
+        if (!size)
+                return;
-        dest = kmalloc(size, GFP_KERNEL);
+        if (!prz->old_log) {
-        if (dest == NULL) {
+                persistent_ram_ecc_old(prz);
+                prz->old_log = kmalloc(size, GFP_KERNEL);
+        }
+        if (!prz->old_log) {
                pr_err("persistent_ram: failed to allocate buffer\n");
                return;
        }
-        prz->old_log = dest;
        prz->old_log_size = size;
        memcpy(prz->old_log, &buffer->data[start], size - start);
        memcpy(prz->old_log + size - start, &buffer->data[0], start);
@@ -319,6 +320,13 @@ void persistent_ram_free_old(struct persistent_ram_zone *prz)
        prz->old_log_size = 0;
 }
+void persistent_ram_zap(struct persistent_ram_zone *prz)
+{
+        atomic_set(&prz->buffer->start, 0);
+        atomic_set(&prz->buffer->size, 0);
+        persistent_ram_update_header_ecc(prz);
+}
 static void *persistent_ram_vmap(phys_addr_t start, size_t size)
 {
        struct page **pages;
@@ -405,6 +413,7 @@ static int __init persistent_ram_post_init(struct persistent_ram_zone *prz, bool
                                " size %zu, start %zu\n",
                               buffer_size(prz), buffer_start(prz));
                        persistent_ram_save_old(prz);
+                        return 0;
                }
        } else {
                pr_info("persistent_ram: no valid data in buffer"
@@ -412,8 +421,7 @@ static int __init persistent_ram_post_init(struct persistent_ram_zone *prz, bool
        }
        prz->buffer->sig = PERSISTENT_RAM_SIG;
-        atomic_set(&prz->buffer->start, 0);
+        persistent_ram_zap(prz);
-        atomic_set(&prz->buffer->size, 0);
        return 0;
 }
@@ -448,7 +456,6 @@ struct persistent_ram_zone * __init persistent_ram_new(phys_addr_t start,
                goto err;
        persistent_ram_post_init(prz, ecc);
-        persistent_ram_update_header_ecc(prz);
        return prz;
 err:
diff --git a/fs/splice.c b/fs/splice.c
index c9f1318a3b82..7bf08fa22ec9 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -273,13 +273,16 @@ void spd_release_page(struct splice_pipe_desc *spd, unsigned int i)
 * Check if we need to grow the arrays holding pages and partial page
 * descriptions.
 */
-int splice_grow_spd(struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
+int splice_grow_spd(const struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
 {
-        if (pipe->buffers <= PIPE_DEF_BUFFERS)
+        unsigned int buffers = ACCESS_ONCE(pipe->buffers);
+        spd->nr_pages_max = buffers;
+        if (buffers <= PIPE_DEF_BUFFERS)
                return 0;
-        spd->pages = kmalloc(pipe->buffers * sizeof(struct page *), GFP_KERNEL);
+        spd->pages = kmalloc(buffers * sizeof(struct page *), GFP_KERNEL);
-        spd->partial = kmalloc(pipe->buffers * sizeof(struct partial_page), GFP_KERNEL);
+        spd->partial = kmalloc(buffers * sizeof(struct partial_page), GFP_KERNEL);
        if (spd->pages && spd->partial)
                return 0;
@@ -289,10 +292,9 @@ int splice_grow_spd(struct pipe_inode_info *pipe, struct splice_pipe_desc *spd)
        return -ENOMEM;
 }
-void splice_shrink_spd(struct pipe_inode_info *pipe,
+void splice_shrink_spd(struct splice_pipe_desc *spd)
-                       struct splice_pipe_desc *spd)
 {
-        if (pipe->buffers <= PIPE_DEF_BUFFERS)
+        if (spd->nr_pages_max <= PIPE_DEF_BUFFERS)
                return;
        kfree(spd->pages);
@@ -315,6 +317,7 @@ __generic_file_splice_read(struct file *in, loff_t *ppos,
        struct splice_pipe_desc spd = {
                .pages = pages,
                .partial = partial,
+                .nr_pages_max = PIPE_DEF_BUFFERS,
                .flags = flags,
                .ops = &page_cache_pipe_buf_ops,
                .spd_release = spd_release_page,
@@ -326,7 +329,7 @@ __generic_file_splice_read(struct file *in, loff_t *ppos,
        index = *ppos >> PAGE_CACHE_SHIFT;
        loff = *ppos & ~PAGE_CACHE_MASK;
        req_pages = (len + loff + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-        nr_pages = min(req_pages, pipe->buffers);
+        nr_pages = min(req_pages, spd.nr_pages_max);
        /*
         * Lookup the (hopefully) full range of pages we need.
@@ -497,7 +500,7 @@ fill_it:
        if (spd.nr_pages)
                error = splice_to_pipe(pipe, &spd);
-        splice_shrink_spd(pipe, &spd);
+        splice_shrink_spd(&spd);
        return error;
 }
@@ -598,6 +601,7 @@ ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
        struct splice_pipe_desc spd = {
                .pages = pages,
                .partial = partial,
+                .nr_pages_max = PIPE_DEF_BUFFERS,
                .flags = flags,
                .ops = &default_pipe_buf_ops,
                .spd_release = spd_release_page,
@@ -608,8 +612,8 @@ ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
        res = -ENOMEM;
        vec = __vec;
-        if (pipe->buffers > PIPE_DEF_BUFFERS) {
+        if (spd.nr_pages_max > PIPE_DEF_BUFFERS) {
-                vec = kmalloc(pipe->buffers * sizeof(struct iovec), GFP_KERNEL);
+                vec = kmalloc(spd.nr_pages_max * sizeof(struct iovec), GFP_KERNEL);
                if (!vec)
                        goto shrink_ret;
        }
@@ -617,7 +621,7 @@ ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
        offset = *ppos & ~PAGE_CACHE_MASK;
        nr_pages = (len + offset + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-        for (i = 0; i < nr_pages && i < pipe->buffers && len; i++) {
+        for (i = 0; i < nr_pages && i < spd.nr_pages_max && len; i++) {
                struct page *page;
                page = alloc_page(GFP_USER);
@@ -665,7 +669,7 @@ ssize_t default_file_splice_read(struct file *in, loff_t *ppos,
 shrink_ret:
        if (vec != __vec)
                kfree(vec);
-        splice_shrink_spd(pipe, &spd);
+        splice_shrink_spd(&spd);
        return res;
 err:
@@ -1614,6 +1618,7 @@ static long vmsplice_to_pipe(struct file *file, const struct iovec __user *iov,
        struct splice_pipe_desc spd = {
                .pages = pages,
                .partial = partial,
+                .nr_pages_max = PIPE_DEF_BUFFERS,
                .flags = flags,
                .ops = &user_page_pipe_buf_ops,
                .spd_release = spd_release_page,
@@ -1629,13 +1634,13 @@ static long vmsplice_to_pipe(struct file *file, const struct iovec __user *iov,
        spd.nr_pages = get_iovec_page_array(iov, nr_segs, spd.pages,
                                            spd.partial, false,
-                                            pipe->buffers);
+                                            spd.nr_pages_max);
        if (spd.nr_pages <= 0)
                ret = spd.nr_pages;
        else
                ret = splice_to_pipe(pipe, &spd);
-        splice_shrink_spd(pipe, &spd);
+        splice_shrink_spd(&spd);
        return ret;
 }
diff --git a/fs/ubifs/debug.c b/fs/ubifs/debug.c
index 84a7e6f3c046..92df3b081539 100644
--- a/fs/ubifs/debug.c
+++ b/fs/ubifs/debug.c
@@ -2918,7 +2918,7 @@ int dbg_debugfs_init_fs(struct ubifs_info *c)
        struct dentry *dent;
        struct ubifs_debug_info *d = c->dbg;
-        if (!IS_ENABLED(DEBUG_FS))
+        if (!IS_ENABLED(CONFIG_DEBUG_FS))
                return 0;
        n = snprintf(d->dfs_dir_name, UBIFS_DFS_DIR_LEN + 1, UBIFS_DFS_DIR_NAME,
@@ -3013,7 +3013,7 @@ out:
 */
 void dbg_debugfs_exit_fs(struct ubifs_info *c)
 {
-        if (IS_ENABLED(DEBUG_FS))
+        if (IS_ENABLED(CONFIG_DEBUG_FS))
                debugfs_remove_recursive(c->dbg->dfs_dir);
 }
@@ -3099,7 +3099,7 @@ int dbg_debugfs_init(void)
        const char *fname;
        struct dentry *dent;
-        if (!IS_ENABLED(DEBUG_FS))
+        if (!IS_ENABLED(CONFIG_DEBUG_FS))
                return 0;
        fname = "ubifs";
@@ -3166,7 +3166,7 @@ out:
 */
 void dbg_debugfs_exit(void)
 {
-        if (IS_ENABLED(DEBUG_FS))
+        if (IS_ENABLED(CONFIG_DEBUG_FS))
                debugfs_remove_recursive(dfs_rootdir);
 }
diff --git a/fs/ubifs/find.c b/fs/ubifs/find.c
index 2559d174e004..28ec13af28d9 100644
--- a/fs/ubifs/find.c
+++ b/fs/ubifs/find.c
@@ -939,8 +939,8 @@ static int find_dirtiest_idx_leb(struct ubifs_info *c)
        }
        dbg_find("LEB %d, dirty %d and free %d flags %#x", lp->lnum, lp->dirty,
                 lp->free, lp->flags);
-        ubifs_assert(lp->flags | LPROPS_TAKEN);
+        ubifs_assert(lp->flags & LPROPS_TAKEN);
-        ubifs_assert(lp->flags | LPROPS_INDEX);
+        ubifs_assert(lp->flags & LPROPS_INDEX);
        return lnum;
 }
diff --git a/fs/udf/super.c b/fs/udf/super.c
index ac8a348dcb69..8d86a8706c0e 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -56,6 +56,7 @@
 #include <linux/seq_file.h>
 #include <linux/bitmap.h>
 #include <linux/crc-itu-t.h>
+#include <linux/log2.h>
 #include <asm/byteorder.h>
 #include "udf_sb.h"
@@ -1215,16 +1216,65 @@ out_bh:
        return ret;
 }
+static int udf_load_sparable_map(struct super_block *sb,
+                                 struct udf_part_map *map,
+                                 struct sparablePartitionMap *spm)
+{
+        uint32_t loc;
+        uint16_t ident;
+        struct sparingTable *st;
+        struct udf_sparing_data *sdata = &map->s_type_specific.s_sparing;
+        int i;
+        struct buffer_head *bh;
+        map->s_partition_type = UDF_SPARABLE_MAP15;
+        sdata->s_packet_len = le16_to_cpu(spm->packetLength);
+        if (!is_power_of_2(sdata->s_packet_len)) {
+                udf_err(sb, "error loading logical volume descriptor: "
+                        "Invalid packet length %u\n",
+                        (unsigned)sdata->s_packet_len);
+                return -EIO;
+        }
+        if (spm->numSparingTables > 4) {
+                udf_err(sb, "error loading logical volume descriptor: "
+                        "Too many sparing tables (%d)\n",
+                        (int)spm->numSparingTables);
+                return -EIO;
+        }
+        for (i = 0; i < spm->numSparingTables; i++) {
+                loc = le32_to_cpu(spm->locSparingTable[i]);
+                bh = udf_read_tagged(sb, loc, loc, &ident);
+                if (!bh)
+                        continue;
+                st = (struct sparingTable *)bh->b_data;
+                if (ident != 0 ||
+                    strncmp(st->sparingIdent.ident, UDF_ID_SPARING,
+                            strlen(UDF_ID_SPARING)) ||
+                    sizeof(*st) + le16_to_cpu(st->reallocationTableLen) >
+                                                        sb->s_blocksize) {
+                        brelse(bh);
+                        continue;
+                }
+                sdata->s_spar_map[i] = bh;
+        }
+        map->s_partition_func = udf_get_pblock_spar15;
+        return 0;
+}
 static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                               struct kernel_lb_addr *fileset)
 {
        struct logicalVolDesc *lvd;
-        int i, j, offset;
+        int i, offset;
        uint8_t type;
        struct udf_sb_info *sbi = UDF_SB(sb);
        struct genericPartitionMap *gpm;
        uint16_t ident;
        struct buffer_head *bh;
+        unsigned int table_len;
        int ret = 0;
        bh = udf_read_tagged(sb, block, block, &ident);
@@ -1232,15 +1282,20 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                return 1;
        BUG_ON(ident != TAG_IDENT_LVD);
        lvd = (struct logicalVolDesc *)bh->b_data;
+        table_len = le32_to_cpu(lvd->mapTableLength);
-        i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
+        if (sizeof(*lvd) + table_len > sb->s_blocksize) {
-        if (i != 0) {
+                udf_err(sb, "error loading logical volume descriptor: "
-                ret = i;
+                        "Partition table too long (%u > %lu)\n", table_len,
+                        sb->s_blocksize - sizeof(*lvd));
                goto out_bh;
        }
+        ret = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
+        if (ret)
+                goto out_bh;
        for (i = 0, offset = 0;
-             i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
+             i < sbi->s_partitions && offset < table_len;
             i++, offset += gpm->partitionMapLength) {
                struct udf_part_map *map = &sbi->s_partmaps[i];
                gpm = (struct genericPartitionMap *)
@@ -1275,38 +1330,9 @@ static int udf_load_logicalvol(struct super_block *sb, sector_t block,
                        } else if (!strncmp(upm2->partIdent.ident,
                                                UDF_ID_SPARABLE,
                                                strlen(UDF_ID_SPARABLE))) {
-                                uint32_t loc;
+                                if (udf_load_sparable_map(sb, map,
-                                struct sparingTable *st;
+                                    (struct sparablePartitionMap *)gpm) < 0)
-                                struct sparablePartitionMap *spm =
+                                        goto out_bh;
-                                        (struct sparablePartitionMap *)gpm;
-                                map->s_partition_type = UDF_SPARABLE_MAP15;
-                                map->s_type_specific.s_sparing.s_packet_len =
-                                                le16_to_cpu(spm->packetLength);
-                                for (j = 0; j < spm->numSparingTables; j++) {
-                                        struct buffer_head *bh2;
-                                        loc = le32_to_cpu(
-                                                spm->locSparingTable[j]);
-                                        bh2 = udf_read_tagged(sb, loc, loc,
-                                                             &ident);
-                                        map->s_type_specific.s_sparing.
-                                                        s_spar_map[j] = bh2;
-                                        if (bh2 == NULL)
-                                                continue;
-                                        st = (struct sparingTable *)bh2->b_data;
-                                        if (ident != 0 || strncmp(
-                                                st->sparingIdent.ident,
-                                                UDF_ID_SPARING,
-                                                strlen(UDF_ID_SPARING))) {
-                                                brelse(bh2);
-                                                map->s_type_specific.s_sparing.
-                                                        s_spar_map[j] = NULL;
-                                        }
-                                }
-                                map->s_partition_func = udf_get_pblock_spar15;
                        } else if (!strncmp(upm2->partIdent.ident,
                                                UDF_ID_METADATA,
                                                strlen(UDF_ID_METADATA))) {
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index 229641fb8e67..9d1aeb7e2734 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -1080,6 +1080,7 @@ restart:
                        goto restart;
                }
+                xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);
                trace_xfs_alloc_size_neither(args);
                args->agbno = NULLAGBLOCK;
                return 0;
@@ -2441,7 +2442,7 @@ xfs_alloc_vextent(
        DECLARE_COMPLETION_ONSTACK(done);
        args->done = &done;
-        INIT_WORK(&args->work, xfs_alloc_vextent_worker);
+        INIT_WORK_ONSTACK(&args->work, xfs_alloc_vextent_worker);
        queue_work(xfs_alloc_wq, &args->work);
        wait_for_completion(&done);
        return args->result;
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index ae31c313a79e..8dad722c0041 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -981,10 +981,15 @@ xfs_vm_writepage(
                                imap_valid = 0;
                        }
                } else {
-                        if (PageUptodate(page)) {
+                        if (PageUptodate(page))
                                ASSERT(buffer_mapped(bh));
-                                imap_valid = 0;
+                        /*
-                        }
+                         * This buffer is not uptodate and will not be
+                         * written to disk.  Ensure that we will put any
+                         * subsequent writeable buffers into a new
+                         * ioend.
+                         */
+                        imap_valid = 0;
                        continue;
                }
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 172d3cc8f8cb..a4beb421018a 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -201,14 +201,7 @@ xfs_buf_alloc(
        bp->b_length = numblks;
        bp->b_io_length = numblks;
        bp->b_flags = flags;
+        bp->b_bn = blkno;
-        /*
-         * We do not set the block number here in the buffer because we have not
-         * finished initialising the buffer. We insert the buffer into the cache
-         * in this state, so this ensures that we are unable to do IO on a
-         * buffer that hasn't been fully initialised.
-         */
-        bp->b_bn = XFS_BUF_DADDR_NULL;
        atomic_set(&bp->b_pin_count, 0);
        init_waitqueue_head(&bp->b_waiters);
@@ -567,11 +560,6 @@ xfs_buf_get(
        if (bp != new_bp)
                xfs_buf_free(new_bp);
-        /*
-         * Now we have a workable buffer, fill in the block number so
-         * that we can do IO on it.
-         */
-        bp->b_bn = blkno;
        bp->b_io_length = bp->b_length;
 found:
@@ -772,7 +760,7 @@ xfs_buf_get_uncached(
        int                     error, i;
        xfs_buf_t               *bp;
-        bp = xfs_buf_alloc(target, 0, numblks, 0);
+        bp = xfs_buf_alloc(target, XFS_BUF_DADDR_NULL, numblks, 0);
        if (unlikely(bp == NULL))
                goto fail;
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 6cdbf90c6f7b..d041d47d9d86 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -505,6 +505,14 @@ xfs_inode_item_push(
        }
        /*
+         * Stale inode items should force out the iclog.
+         */
+        if (ip->i_flags & XFS_ISTALE) {
+                rval = XFS_ITEM_PINNED;
+                goto out_unlock;
+        }
+        /*
         * Someone else is already flushing the inode.  Nothing we can do
         * here but wait for the flush to finish and remove the item from
         * the AIL.
@@ -514,15 +522,6 @@ xfs_inode_item_push(
                goto out_unlock;
        }
-        /*
-         * Stale inode items should force out the iclog.
-         */
-        if (ip->i_flags & XFS_ISTALE) {
-                xfs_ifunlock(ip);
-                xfs_iunlock(ip, XFS_ILOCK_SHARED);
-                return XFS_ITEM_PINNED;
-        }
        ASSERT(iip->ili_fields != 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
        ASSERT(iip->ili_logged == 0 || XFS_FORCED_SHUTDOWN(ip->i_mount));
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index f30d9807dc48..d90d4a388609 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -38,13 +38,21 @@
 kmem_zone_t     *xfs_log_ticket_zone;
 /* Local miscellaneous function prototypes */
-STATIC int       xlog_commit_record(struct log *log, struct xlog_ticket *ticket,
+STATIC int
-                                    xlog_in_core_t **, xfs_lsn_t *);
+xlog_commit_record(
+        struct xlog             *log,
+        struct xlog_ticket      *ticket,
+        struct xlog_in_core     **iclog,
+        xfs_lsn_t               *commitlsnp);
 STATIC xlog_t *  xlog_alloc_log(xfs_mount_t     *mp,
                                xfs_buftarg_t   *log_target,
                                xfs_daddr_t     blk_offset,
                                int             num_bblks);
-STATIC int       xlog_space_left(struct log *log, atomic64_t *head);
+STATIC int
+xlog_space_left(
+        struct xlog             *log,
+        atomic64_t              *head);
 STATIC int       xlog_sync(xlog_t *log, xlog_in_core_t *iclog);
 STATIC void      xlog_dealloc_log(xlog_t *log);
@@ -64,8 +72,10 @@ STATIC void xlog_state_switch_iclogs(xlog_t		*log,
                                     int                eventual_size);
 STATIC void xlog_state_want_sync(xlog_t *log, xlog_in_core_t *iclog);
-STATIC void xlog_grant_push_ail(struct log      *log,
+STATIC void
-                                int             need_bytes);
+xlog_grant_push_ail(
+        struct xlog     *log,
+        int             need_bytes);
 STATIC void xlog_regrant_reserve_log_space(xlog_t        *log,
                                           xlog_ticket_t *ticket);
 STATIC void xlog_ungrant_log_space(xlog_t        *log,
@@ -73,7 +83,9 @@ STATIC void xlog_ungrant_log_space(xlog_t	 *log,
 #if defined(DEBUG)
 STATIC void     xlog_verify_dest_ptr(xlog_t *log, char *ptr);
-STATIC void     xlog_verify_grant_tail(struct log *log);
+STATIC void
+xlog_verify_grant_tail(
+        struct xlog     *log);
 STATIC void     xlog_verify_iclog(xlog_t *log, xlog_in_core_t *iclog,
                                  int count, boolean_t syncing);
 STATIC void     xlog_verify_tail_lsn(xlog_t *log, xlog_in_core_t *iclog,
@@ -89,9 +101,9 @@ STATIC int	xlog_iclogs_empty(xlog_t *log);
 static void
 xlog_grant_sub_space(
-        struct log      *log,
+        struct xlog             *log,
-        atomic64_t      *head,
+        atomic64_t              *head,
-        int             bytes)
+        int                     bytes)
 {
        int64_t head_val = atomic64_read(head);
        int64_t new, old;
@@ -115,9 +127,9 @@ xlog_grant_sub_space(
 static void
 xlog_grant_add_space(
-        struct log      *log,
+        struct xlog             *log,
-        atomic64_t      *head,
+        atomic64_t              *head,
-        int             bytes)
+        int                     bytes)
 {
        int64_t head_val = atomic64_read(head);
        int64_t new, old;
@@ -165,7 +177,7 @@ xlog_grant_head_wake_all(
 static inline int
 xlog_ticket_reservation(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_grant_head  *head,
        struct xlog_ticket      *tic)
 {
@@ -182,7 +194,7 @@ xlog_ticket_reservation(
 STATIC bool
 xlog_grant_head_wake(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_grant_head  *head,
        int                     *free_bytes)
 {
@@ -204,7 +216,7 @@ xlog_grant_head_wake(
 STATIC int
 xlog_grant_head_wait(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_grant_head  *head,
        struct xlog_ticket      *tic,
        int                     need_bytes)
@@ -256,7 +268,7 @@ shutdown:
 */
 STATIC int
 xlog_grant_head_check(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_grant_head  *head,
        struct xlog_ticket      *tic,
        int                     *need_bytes)
@@ -323,7 +335,7 @@ xfs_log_regrant(
        struct xfs_mount        *mp,
        struct xlog_ticket      *tic)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        int                     need_bytes;
        int                     error = 0;
@@ -389,7 +401,7 @@ xfs_log_reserve(
        bool                    permanent,
        uint                    t_type)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        struct xlog_ticket      *tic;
        int                     need_bytes;
        int                     error = 0;
@@ -465,7 +477,7 @@ xfs_log_done(
        struct xlog_in_core     **iclog,
        uint                    flags)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        xfs_lsn_t               lsn = 0;
        if (XLOG_FORCED_SHUTDOWN(log) ||
@@ -810,6 +822,7 @@ xfs_log_unmount_write(xfs_mount_t *mp)
 void
 xfs_log_unmount(xfs_mount_t *mp)
 {
+        cancel_delayed_work_sync(&mp->m_sync_work);
        xfs_trans_ail_destroy(mp);
        xlog_dealloc_log(mp->m_log);
 }
@@ -838,7 +851,7 @@ void
 xfs_log_space_wake(
        struct xfs_mount        *mp)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        int                     free_bytes;
        if (XLOG_FORCED_SHUTDOWN(log))
@@ -916,7 +929,7 @@ xfs_lsn_t
 xlog_assign_tail_lsn_locked(
        struct xfs_mount        *mp)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        struct xfs_log_item     *lip;
        xfs_lsn_t               tail_lsn;
@@ -965,7 +978,7 @@ xlog_assign_tail_lsn(
 */
 STATIC int
 xlog_space_left(
-        struct log      *log,
+        struct xlog     *log,
        atomic64_t      *head)
 {
        int             free_bytes;
@@ -1277,7 +1290,7 @@ out:
 */
 STATIC int
 xlog_commit_record(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_ticket      *ticket,
        struct xlog_in_core     **iclog,
        xfs_lsn_t               *commitlsnp)
@@ -1311,7 +1324,7 @@ xlog_commit_record(
 */
 STATIC void
 xlog_grant_push_ail(
-        struct log      *log,
+        struct xlog     *log,
        int             need_bytes)
 {
        xfs_lsn_t       threshold_lsn = 0;
@@ -1790,7 +1803,7 @@ xlog_write_start_rec(
 static xlog_op_header_t *
 xlog_write_setup_ophdr(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_op_header   *ophdr,
        struct xlog_ticket      *ticket,
        uint                    flags)
@@ -1873,7 +1886,7 @@ xlog_write_setup_copy(
 static int
 xlog_write_copy_finish(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_in_core     *iclog,
        uint                    flags,
        int                     *record_cnt,
@@ -1958,7 +1971,7 @@ xlog_write_copy_finish(
 */
 int
 xlog_write(
-        struct log              *log,
+        struct xlog             *log,
        struct xfs_log_vec      *log_vector,
        struct xlog_ticket      *ticket,
        xfs_lsn_t               *start_lsn,
@@ -2821,7 +2834,7 @@ _xfs_log_force(
        uint                    flags,
        int                     *log_flushed)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        struct xlog_in_core     *iclog;
        xfs_lsn_t               lsn;
@@ -2969,7 +2982,7 @@ _xfs_log_force_lsn(
        uint                    flags,
        int                     *log_flushed)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        struct xlog_in_core     *iclog;
        int                     already_slept = 0;
@@ -3147,7 +3160,7 @@ xfs_log_ticket_get(
 */
 xlog_ticket_t *
 xlog_ticket_alloc(
-        struct log      *log,
+        struct xlog     *log,
        int             unit_bytes,
        int             cnt,
        char            client,
@@ -3278,7 +3291,7 @@ xlog_ticket_alloc(
 */
 void
 xlog_verify_dest_ptr(
-        struct log      *log,
+        struct xlog     *log,
        char            *ptr)
 {
        int i;
@@ -3307,7 +3320,7 @@ xlog_verify_dest_ptr(
 */
 STATIC void
 xlog_verify_grant_tail(
-        struct log      *log)
+        struct xlog     *log)
 {
        int             tail_cycle, tail_blocks;
        int             cycle, space;
diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
index 7d6197c58493..ddc4529d07d3 100644
--- a/fs/xfs/xfs_log_cil.c
+++ b/fs/xfs/xfs_log_cil.c
@@ -44,7 +44,7 @@
 */
 static struct xlog_ticket *
 xlog_cil_ticket_alloc(
-        struct log      *log)
+        struct xlog     *log)
 {
        struct xlog_ticket *tic;
@@ -72,7 +72,7 @@ xlog_cil_ticket_alloc(
 */
 void
 xlog_cil_init_post_recovery(
-        struct log      *log)
+        struct xlog     *log)
 {
        log->l_cilp->xc_ctx->ticket = xlog_cil_ticket_alloc(log);
        log->l_cilp->xc_ctx->sequence = 1;
@@ -182,7 +182,7 @@ xlog_cil_prepare_log_vecs(
 */
 STATIC void
 xfs_cil_prepare_item(
-        struct log              *log,
+        struct xlog             *log,
        struct xfs_log_vec      *lv,
        int                     *len,
        int                     *diff_iovecs)
@@ -231,7 +231,7 @@ xfs_cil_prepare_item(
 */
 static void
 xlog_cil_insert_items(
-        struct log              *log,
+        struct xlog             *log,
        struct xfs_log_vec      *log_vector,
        struct xlog_ticket      *ticket)
 {
@@ -373,7 +373,7 @@ xlog_cil_committed(
 */
 STATIC int
 xlog_cil_push(
-        struct log              *log)
+        struct xlog             *log)
 {
        struct xfs_cil          *cil = log->l_cilp;
        struct xfs_log_vec      *lv;
@@ -601,7 +601,7 @@ xlog_cil_push_work(
 */
 static void
 xlog_cil_push_background(
-        struct log      *log)
+        struct xlog     *log)
 {
        struct xfs_cil  *cil = log->l_cilp;
@@ -629,7 +629,7 @@ xlog_cil_push_background(
 static void
 xlog_cil_push_foreground(
-        struct log      *log,
+        struct xlog     *log,
        xfs_lsn_t       push_seq)
 {
        struct xfs_cil  *cil = log->l_cilp;
@@ -683,7 +683,7 @@ xfs_log_commit_cil(
        xfs_lsn_t               *commit_lsn,
        int                     flags)
 {
-        struct log              *log = mp->m_log;
+        struct xlog             *log = mp->m_log;
        int                     log_flags = 0;
        struct xfs_log_vec      *log_vector;
@@ -754,7 +754,7 @@ xfs_log_commit_cil(
 */
 xfs_lsn_t
 xlog_cil_force_lsn(
-        struct log      *log,
+        struct xlog     *log,
        xfs_lsn_t       sequence)
 {
        struct xfs_cil          *cil = log->l_cilp;
@@ -833,7 +833,7 @@ xfs_log_item_in_current_chkpt(
 */
 int
 xlog_cil_init(
-        struct log      *log)
+        struct xlog     *log)
 {
        struct xfs_cil  *cil;
        struct xfs_cil_ctx *ctx;
@@ -869,7 +869,7 @@ xlog_cil_init(
 void
 xlog_cil_destroy(
-        struct log      *log)
+        struct xlog     *log)
 {
        if (log->l_cilp->xc_ctx) {
                if (log->l_cilp->xc_ctx->ticket)
diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index 5bc33261f5be..72eba2201b14 100644
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -19,7 +19,7 @@
 #define __XFS_LOG_PRIV_H__
 struct xfs_buf;
-struct log;
+struct xlog;
 struct xlog_ticket;
 struct xfs_mount;
@@ -352,7 +352,7 @@ typedef struct xlog_in_core {
        struct xlog_in_core     *ic_next;
        struct xlog_in_core     *ic_prev;
        struct xfs_buf          *ic_bp;
-        struct log              *ic_log;
+        struct xlog             *ic_log;
        int                     ic_size;
        int                     ic_offset;
        int                     ic_bwritecnt;
@@ -409,7 +409,7 @@ struct xfs_cil_ctx {
 * operations almost as efficient as the old logging methods.
 */
 struct xfs_cil {
-        struct log              *xc_log;
+        struct xlog             *xc_log;
        struct list_head        xc_cil;
        spinlock_t              xc_cil_lock;
        struct xfs_cil_ctx      *xc_ctx;
@@ -487,7 +487,7 @@ struct xlog_grant_head {
 * overflow 31 bits worth of byte offset, so using a byte number will mean
 * that round off problems won't occur when releasing partial reservations.
 */
-typedef struct log {
+typedef struct xlog {
        /* The following fields don't need locking */
        struct xfs_mount        *l_mp;          /* mount point */
        struct xfs_ail          *l_ailp;        /* AIL log is working with */
@@ -553,9 +553,14 @@ extern int	 xlog_recover_finish(xlog_t *log);
 extern void      xlog_pack_data(xlog_t *log, xlog_in_core_t *iclog, int);
 extern kmem_zone_t *xfs_log_ticket_zone;
-struct xlog_ticket *xlog_ticket_alloc(struct log *log, int unit_bytes,
+struct xlog_ticket *
-                                int count, char client, bool permanent,
+xlog_ticket_alloc(
-                                xfs_km_flags_t alloc_flags);
+        struct xlog     *log,
+        int             unit_bytes,
+        int             count,
+        char            client,
+        bool            permanent,
+        xfs_km_flags_t  alloc_flags);
 static inline void
@@ -567,9 +572,14 @@ xlog_write_adv_cnt(void **ptr, int *len, int *off, size_t bytes)
 }
 void    xlog_print_tic_res(struct xfs_mount *mp, struct xlog_ticket *ticket);
-int     xlog_write(struct log *log, struct xfs_log_vec *log_vector,
+int
-                                struct xlog_ticket *tic, xfs_lsn_t *start_lsn,
+xlog_write(
-                                xlog_in_core_t **commit_iclog, uint flags);
+        struct xlog             *log,
+        struct xfs_log_vec      *log_vector,
+        struct xlog_ticket      *tic,
+        xfs_lsn_t               *start_lsn,
+        struct xlog_in_core     **commit_iclog,
+        uint                    flags);
 /*
 * When we crack an atomic LSN, we sample it first so that the value will not
@@ -629,17 +639,23 @@ xlog_assign_grant_head(atomic64_t *head, int cycle, int space)
 /*
 * Committed Item List interfaces
 */
-int     xlog_cil_init(struct log *log);
+int
-void    xlog_cil_init_post_recovery(struct log *log);
+xlog_cil_init(struct xlog *log);
-void    xlog_cil_destroy(struct log *log);
+void
+xlog_cil_init_post_recovery(struct xlog *log);
+void
+xlog_cil_destroy(struct xlog *log);
 /*
 * CIL force routines
 */
-xfs_lsn_t xlog_cil_force_lsn(struct log *log, xfs_lsn_t sequence);
+xfs_lsn_t
+xlog_cil_force_lsn(
+        struct xlog *log,
+        xfs_lsn_t sequence);
 static inline void
-xlog_cil_force(struct log *log)
+xlog_cil_force(struct xlog *log)
 {
        xlog_cil_force_lsn(log, log->l_cilp->xc_current_sequence);
 }
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index ca386909131a..a7be98abd6a9 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -1471,8 +1471,8 @@ xlog_recover_add_item(
 STATIC int
 xlog_recover_add_to_cont_trans(
-        struct log              *log,
+        struct xlog             *log,
-        xlog_recover_t          *trans,
+        struct xlog_recover     *trans,
        xfs_caddr_t             dp,
        int                     len)
 {
@@ -1517,8 +1517,8 @@ xlog_recover_add_to_cont_trans(
 */
 STATIC int
 xlog_recover_add_to_trans(
-        struct log              *log,
+        struct xlog             *log,
-        xlog_recover_t          *trans,
+        struct xlog_recover     *trans,
        xfs_caddr_t             dp,
        int                     len)
 {
@@ -1588,8 +1588,8 @@ xlog_recover_add_to_trans(
 */
 STATIC int
 xlog_recover_reorder_trans(
-        struct log              *log,
+        struct xlog             *log,
-        xlog_recover_t          *trans,
+        struct xlog_recover     *trans,
        int                     pass)
 {
        xlog_recover_item_t     *item, *n;
@@ -1642,8 +1642,8 @@ xlog_recover_reorder_trans(
 */
 STATIC int
 xlog_recover_buffer_pass1(
-        struct log              *log,
+        struct xlog                     *log,
-        xlog_recover_item_t     *item)
+        struct xlog_recover_item        *item)
 {
        xfs_buf_log_format_t    *buf_f = item->ri_buf[0].i_addr;
        struct list_head        *bucket;
@@ -1696,7 +1696,7 @@ xlog_recover_buffer_pass1(
 */
 STATIC int
 xlog_check_buffer_cancelled(
-        struct log              *log,
+        struct xlog             *log,
        xfs_daddr_t             blkno,
        uint                    len,
        ushort                  flags)
@@ -2689,9 +2689,9 @@ xlog_recover_free_trans(
 STATIC int
 xlog_recover_commit_pass1(
-        struct log              *log,
+        struct xlog                     *log,
-        struct xlog_recover     *trans,
+        struct xlog_recover             *trans,
-        xlog_recover_item_t     *item)
+        struct xlog_recover_item        *item)
 {
        trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS1);
@@ -2716,10 +2716,10 @@ xlog_recover_commit_pass1(
 STATIC int
 xlog_recover_commit_pass2(
-        struct log              *log,
+        struct xlog                     *log,
-        struct xlog_recover     *trans,
+        struct xlog_recover             *trans,
-        struct list_head        *buffer_list,
+        struct list_head                *buffer_list,
-        xlog_recover_item_t     *item)
+        struct xlog_recover_item        *item)
 {
        trace_xfs_log_recover_item_recover(log, trans, item, XLOG_RECOVER_PASS2);
@@ -2753,7 +2753,7 @@ xlog_recover_commit_pass2(
 */
 STATIC int
 xlog_recover_commit_trans(
-        struct log              *log,
+        struct xlog             *log,
        struct xlog_recover     *trans,
        int                     pass)
 {
@@ -2793,8 +2793,8 @@ out:
 STATIC int
 xlog_recover_unmount_trans(
-        struct log              *log,
+        struct xlog             *log,
-        xlog_recover_t          *trans)
+        struct xlog_recover     *trans)
 {
        /* Do nothing now */
        xfs_warn(log->l_mp, "%s: Unmount LR", __func__);
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 8b89c5ac72d9..90c1fc9eaea4 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -53,7 +53,7 @@ typedef struct xfs_trans_reservations {
 #include "xfs_sync.h"
-struct log;
+struct xlog;
 struct xfs_mount_args;
 struct xfs_inode;
 struct xfs_bmbt_irec;
@@ -133,7 +133,7 @@ typedef struct xfs_mount {
        uint                    m_readio_blocks; /* min read size blocks */
        uint                    m_writeio_log;  /* min write size log bytes */
        uint                    m_writeio_blocks; /* min write size blocks */
-        struct log              *m_log;         /* log specific stuff */
+        struct xlog             *m_log;         /* log specific stuff */
        int                     m_logbufs;      /* number of log buffers */
        int                     m_logbsize;     /* size of each log buffer */
        uint                    m_rsumlevels;   /* rt summary levels */
diff --git a/fs/xfs/xfs_sync.c b/fs/xfs/xfs_sync.c
index c9d3409c5ca3..1e9ee064dbb2 100644
--- a/fs/xfs/xfs_sync.c
+++ b/fs/xfs/xfs_sync.c
@@ -386,23 +386,23 @@ xfs_sync_worker(
         * We shouldn't write/force the log if we are in the mount/unmount
         * process or on a read only filesystem. The workqueue still needs to be
         * active in both cases, however, because it is used for inode reclaim
-         * during these times.  Use the s_umount semaphore to provide exclusion
+         * during these times.  Use the MS_ACTIVE flag to avoid doing anything
-         * with unmount.
+         * during mount.  Doing work during unmount is avoided by calling
+         * cancel_delayed_work_sync on this work queue before tearing down
+         * the ail and the log in xfs_log_unmount.
         */
-        if (down_read_trylock(&mp->m_super->s_umount)) {
+        if (!(mp->m_super->s_flags & MS_ACTIVE) &&
-                if (!(mp->m_flags & XFS_MOUNT_RDONLY)) {
+            !(mp->m_flags & XFS_MOUNT_RDONLY)) {
-                        /* dgc: errors ignored here */
+                /* dgc: errors ignored here */
-                        if (mp->m_super->s_frozen == SB_UNFROZEN &&
+                if (mp->m_super->s_frozen == SB_UNFROZEN &&
-                            xfs_log_need_covered(mp))
+                    xfs_log_need_covered(mp))
-                                error = xfs_fs_log_dummy(mp);
+                        error = xfs_fs_log_dummy(mp);
-                        else
+                else
-                                xfs_log_force(mp, 0);
+                        xfs_log_force(mp, 0);
-                        /* start pushing all the metadata that is currently
+                /* start pushing all the metadata that is currently
-                         * dirty */
+                 * dirty */
-                        xfs_ail_push_all(mp->m_ail);
+                xfs_ail_push_all(mp->m_ail);
-                }
-                up_read(&mp->m_super->s_umount);
        }
        /* queue us up again */
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 7cf9d3529e51..caf5dabfd553 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -32,7 +32,7 @@ struct xfs_da_node_entry;
 struct xfs_dquot;
 struct xfs_log_item;
 struct xlog_ticket;
-struct log;
+struct xlog;
 struct xlog_recover;
 struct xlog_recover_item;
 struct xfs_buf_log_format;
@@ -762,7 +762,7 @@ DEFINE_DQUOT_EVENT(xfs_dqflush_force);
 DEFINE_DQUOT_EVENT(xfs_dqflush_done);
 DECLARE_EVENT_CLASS(xfs_loggrant_class,
-        TP_PROTO(struct log *log, struct xlog_ticket *tic),
+        TP_PROTO(struct xlog *log, struct xlog_ticket *tic),
        TP_ARGS(log, tic),
        TP_STRUCT__entry(
                __field(dev_t, dev)
@@ -830,7 +830,7 @@ DECLARE_EVENT_CLASS(xfs_loggrant_class,
 #define DEFINE_LOGGRANT_EVENT(name) \
 DEFINE_EVENT(xfs_loggrant_class, name, \
-        TP_PROTO(struct log *log, struct xlog_ticket *tic), \
+        TP_PROTO(struct xlog *log, struct xlog_ticket *tic), \
        TP_ARGS(log, tic))
 DEFINE_LOGGRANT_EVENT(xfs_log_done_nonperm);
 DEFINE_LOGGRANT_EVENT(xfs_log_done_perm);
@@ -1664,7 +1664,7 @@ DEFINE_SWAPEXT_EVENT(xfs_swap_extent_before);
 DEFINE_SWAPEXT_EVENT(xfs_swap_extent_after);
 DECLARE_EVENT_CLASS(xfs_log_recover_item_class,
-        TP_PROTO(struct log *log, struct xlog_recover *trans,
+        TP_PROTO(struct xlog *log, struct xlog_recover *trans,
                struct xlog_recover_item *item, int pass),
        TP_ARGS(log, trans, item, pass),
        TP_STRUCT__entry(
@@ -1698,7 +1698,7 @@ DECLARE_EVENT_CLASS(xfs_log_recover_item_class,
 #define DEFINE_LOG_RECOVER_ITEM(name) \
 DEFINE_EVENT(xfs_log_recover_item_class, name, \
-        TP_PROTO(struct log *log, struct xlog_recover *trans, \
+        TP_PROTO(struct xlog *log, struct xlog_recover *trans, \
                struct xlog_recover_item *item, int pass), \
        TP_ARGS(log, trans, item, pass))
@@ -1709,7 +1709,7 @@ DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_reorder_tail);
 DEFINE_LOG_RECOVER_ITEM(xfs_log_recover_item_recover);
 DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class,
-        TP_PROTO(struct log *log, struct xfs_buf_log_format *buf_f),
+        TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f),
        TP_ARGS(log, buf_f),
        TP_STRUCT__entry(
                __field(dev_t, dev)
@@ -1739,7 +1739,7 @@ DECLARE_EVENT_CLASS(xfs_log_recover_buf_item_class,
 #define DEFINE_LOG_RECOVER_BUF_ITEM(name) \
 DEFINE_EVENT(xfs_log_recover_buf_item_class, name, \
-        TP_PROTO(struct log *log, struct xfs_buf_log_format *buf_f), \
+        TP_PROTO(struct xlog *log, struct xfs_buf_log_format *buf_f), \
        TP_ARGS(log, buf_f))
 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_not_cancel);
@@ -1752,7 +1752,7 @@ DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_reg_buf);
 DEFINE_LOG_RECOVER_BUF_ITEM(xfs_log_recover_buf_dquot_buf);
 DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class,
-        TP_PROTO(struct log *log, struct xfs_inode_log_format *in_f),
+        TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f),
        TP_ARGS(log, in_f),
        TP_STRUCT__entry(
                __field(dev_t, dev)
@@ -1790,7 +1790,7 @@ DECLARE_EVENT_CLASS(xfs_log_recover_ino_item_class,
 )
 #define DEFINE_LOG_RECOVER_INO_ITEM(name) \
 DEFINE_EVENT(xfs_log_recover_ino_item_class, name, \
-        TP_PROTO(struct log *log, struct xfs_inode_log_format *in_f), \
+        TP_PROTO(struct xlog *log, struct xfs_inode_log_format *in_f), \
        TP_ARGS(log, in_f))
 DEFINE_LOG_RECOVER_INO_ITEM(xfs_log_recover_inode_recover);