38 files changed, 645 insertions, 297 deletions
diff --git a/fs/btrfs/async-thread.c b/fs/btrfs/async-thread.c
index 282ca085c2fb..c0861e781cdb 100644
--- a/fs/btrfs/async-thread.c
+++ b/fs/btrfs/async-thread.c
@@ -64,6 +64,51 @@ struct btrfs_worker_thread {
 };
 /*
+ * btrfs_start_workers uses kthread_run, which can block waiting for memory
+ * for a very long time.  It will actually throttle on page writeback,
+ * and so it may not make progress until after our btrfs worker threads
+ * process all of the pending work structs in their queue
+ *
+ * This means we can't use btrfs_start_workers from inside a btrfs worker
+ * thread that is used as part of cleaning dirty memory, which pretty much
+ * involves all of the worker threads.
+ *
+ * Instead we have a helper queue who never has more than one thread
+ * where we scheduler thread start operations.  This worker_start struct
+ * is used to contain the work and hold a pointer to the queue that needs
+ * another worker.
+ */
+struct worker_start {
+        struct btrfs_work work;
+        struct btrfs_workers *queue;
+};
+static void start_new_worker_func(struct btrfs_work *work)
+{
+        struct worker_start *start;
+        start = container_of(work, struct worker_start, work);
+        btrfs_start_workers(start->queue, 1);
+        kfree(start);
+}
+static int start_new_worker(struct btrfs_workers *queue)
+{
+        struct worker_start *start;
+        int ret;
+        start = kzalloc(sizeof(*start), GFP_NOFS);
+        if (!start)
+                return -ENOMEM;
+        start->work.func = start_new_worker_func;
+        start->queue = queue;
+        ret = btrfs_queue_worker(queue->atomic_worker_start, &start->work);
+        if (ret)
+                kfree(start);
+        return ret;
+}
+/*
 * helper function to move a thread onto the idle list after it
 * has finished some requests.
 */
@@ -118,11 +163,13 @@ static void check_pending_worker_creates(struct btrfs_worker_thread *worker)
                goto out;
        workers->atomic_start_pending = 0;
-        if (workers->num_workers >= workers->max_workers)
+        if (workers->num_workers + workers->num_workers_starting >=
+            workers->max_workers)
                goto out;
+        workers->num_workers_starting += 1;
        spin_unlock_irqrestore(&workers->lock, flags);
-        btrfs_start_workers(workers, 1);
+        start_new_worker(workers);
        return;
 out:
@@ -390,9 +437,11 @@ int btrfs_stop_workers(struct btrfs_workers *workers)
 /*
 * simple init on struct btrfs_workers
 */
-void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max)
+void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max,
+                        struct btrfs_workers *async_helper)
 {
        workers->num_workers = 0;
+        workers->num_workers_starting = 0;
        INIT_LIST_HEAD(&workers->worker_list);
        INIT_LIST_HEAD(&workers->idle_list);
        INIT_LIST_HEAD(&workers->order_list);
@@ -404,14 +453,15 @@ void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max)
        workers->name = name;
        workers->ordered = 0;
        workers->atomic_start_pending = 0;
-        workers->atomic_worker_start = 0;
+        workers->atomic_worker_start = async_helper;
 }
 /*
 * starts new worker threads.  This does not enforce the max worker
 * count in case you need to temporarily go past it.
 */
-int btrfs_start_workers(struct btrfs_workers *workers, int num_workers)
+static int __btrfs_start_workers(struct btrfs_workers *workers,
+                                 int num_workers)
 {
        struct btrfs_worker_thread *worker;
        int ret = 0;
@@ -444,6 +494,8 @@ int btrfs_start_workers(struct btrfs_workers *workers, int num_workers)
                list_add_tail(&worker->worker_list, &workers->idle_list);
                worker->idle = 1;
                workers->num_workers++;
+                workers->num_workers_starting--;
+                WARN_ON(workers->num_workers_starting < 0);
                spin_unlock_irq(&workers->lock);
        }
        return 0;
@@ -452,6 +504,14 @@ fail:
        return ret;
 }
+int btrfs_start_workers(struct btrfs_workers *workers, int num_workers)
+{
+        spin_lock_irq(&workers->lock);
+        workers->num_workers_starting += num_workers;
+        spin_unlock_irq(&workers->lock);
+        return __btrfs_start_workers(workers, num_workers);
+}
 /*
 * run through the list and find a worker thread that doesn't have a lot
 * to do right now.  This can return null if we aren't yet at the thread
@@ -461,7 +521,10 @@ static struct btrfs_worker_thread *next_worker(struct btrfs_workers *workers)
 {
        struct btrfs_worker_thread *worker;
        struct list_head *next;
-        int enforce_min = workers->num_workers < workers->max_workers;
+        int enforce_min;
+        enforce_min = (workers->num_workers + workers->num_workers_starting) <
+                workers->max_workers;
        /*
         * if we find an idle thread, don't move it to the end of the
@@ -509,15 +572,17 @@ again:
        worker = next_worker(workers);
        if (!worker) {
-                if (workers->num_workers >= workers->max_workers) {
+                if (workers->num_workers + workers->num_workers_starting >=
+                    workers->max_workers) {
                        goto fallback;
                } else if (workers->atomic_worker_start) {
                        workers->atomic_start_pending = 1;
                        goto fallback;
                } else {
+                        workers->num_workers_starting++;
                        spin_unlock_irqrestore(&workers->lock, flags);
                        /* we're below the limit, start another worker */
-                        btrfs_start_workers(workers, 1);
+                        __btrfs_start_workers(workers, 1);
                        goto again;
                }
        }
diff --git a/fs/btrfs/async-thread.h b/fs/btrfs/async-thread.h
index fc089b95ec14..5077746cf85e 100644
--- a/fs/btrfs/async-thread.h
+++ b/fs/btrfs/async-thread.h
@@ -64,6 +64,8 @@ struct btrfs_workers {
        /* current number of running workers */
        int num_workers;
+        int num_workers_starting;
        /* max number of workers allowed.  changed by btrfs_start_workers */
        int max_workers;
@@ -78,9 +80,10 @@ struct btrfs_workers {
        /*
         * are we allowed to sleep while starting workers or are we required
-         * to start them at a later time?
+         * to start them at a later time?  If we can't sleep, this indicates
+         * which queue we need to use to schedule thread creation.
         */
-        int atomic_worker_start;
+        struct btrfs_workers *atomic_worker_start;
        /* list with all the work threads.  The workers on the idle thread
         * may be actively servicing jobs, but they haven't yet hit the
@@ -109,7 +112,8 @@ struct btrfs_workers {
 int btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work);
 int btrfs_start_workers(struct btrfs_workers *workers, int num_workers);
 int btrfs_stop_workers(struct btrfs_workers *workers);
-void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max);
+void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max,
+                        struct btrfs_workers *async_starter);
 int btrfs_requeue_work(struct btrfs_work *work);
 void btrfs_set_work_high_prio(struct btrfs_work *work);
 #endif
diff --git a/fs/btrfs/btrfs_inode.h b/fs/btrfs/btrfs_inode.h
index a54d354cefcb..c71abec0ab90 100644
--- a/fs/btrfs/btrfs_inode.h
+++ b/fs/btrfs/btrfs_inode.h
@@ -128,12 +128,14 @@ struct btrfs_inode {
        u64 last_unlink_trans;
        /*
-         * These two counters are for delalloc metadata reservations.  We keep
+         * Counters to keep track of the number of extent item's we may use due
-         * track of how many extents we've accounted for vs how many extents we
+         * to delalloc and such.  outstanding_extents is the number of extent
-         * have.
+         * items we think we'll end up using, and reserved_extents is the number
+         * of extent items we've reserved metadata for.
         */
-        int delalloc_reserved_extents;
+        spinlock_t accounting_lock;
-        int delalloc_extents;
+        int reserved_extents;
+        int outstanding_extents;
        /*
         * ordered_data_close is set by truncate when a file that used
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index dd8ced9814c4..1bb897ecdeeb 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -691,14 +691,17 @@ struct btrfs_space_info {
        struct list_head list;
+        /* for controlling how we free up space for allocations */
+        wait_queue_head_t allocate_wait;
+        wait_queue_head_t flush_wait;
+        int allocating_chunk;
+        int flushing;
        /* for block groups in our same type */
        struct list_head block_groups;
        spinlock_t lock;
        struct rw_semaphore groups_sem;
        atomic_t caching_threads;
-        int allocating_chunk;
-        wait_queue_head_t wait;
 };
 /*
@@ -907,6 +910,7 @@ struct btrfs_fs_info {
         * A third pool does submit_bio to avoid deadlocking with the other
         * two
         */
+        struct btrfs_workers generic_worker;
        struct btrfs_workers workers;
        struct btrfs_workers delalloc_workers;
        struct btrfs_workers endio_workers;
@@ -914,6 +918,7 @@ struct btrfs_fs_info {
        struct btrfs_workers endio_meta_write_workers;
        struct btrfs_workers endio_write_workers;
        struct btrfs_workers submit_workers;
+        struct btrfs_workers enospc_workers;
        /*
         * fixup workers take dirty pages that didn't properly go through
         * the cow mechanism and make them safe to write.  It happens
@@ -1005,6 +1010,8 @@ struct btrfs_root {
        atomic_t log_commit[2];
        unsigned long log_transid;
        unsigned long log_batch;
+        pid_t log_start_pid;
+        bool log_multiple_pids;
        u64 objectid;
        u64 last_trans;
@@ -2323,7 +2330,7 @@ int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode);
 void btrfs_orphan_cleanup(struct btrfs_root *root);
 int btrfs_cont_expand(struct inode *inode, loff_t size);
 int btrfs_invalidate_inodes(struct btrfs_root *root);
-extern struct dentry_operations btrfs_dentry_operations;
+extern const struct dentry_operations btrfs_dentry_operations;
 /* ioctl.c */
 long btrfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index af0435f79fa6..100551a66c46 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1746,21 +1746,25 @@ struct btrfs_root *open_ctree(struct super_block *sb,
                err = -EINVAL;
                goto fail_iput;
        }
-printk("thread pool is %d\n", fs_info->thread_pool_size);
-        /*
+        btrfs_init_workers(&fs_info->generic_worker,
-         * we need to start all the end_io workers up front because the
+                           "genwork", 1, NULL);
-         * queue work function gets called at interrupt time, and so it
-         * cannot dynamically grow.
-         */
        btrfs_init_workers(&fs_info->workers, "worker",
-                           fs_info->thread_pool_size);
+                           fs_info->thread_pool_size,
+                           &fs_info->generic_worker);
        btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
-                           fs_info->thread_pool_size);
+                           fs_info->thread_pool_size,
+                           &fs_info->generic_worker);
        btrfs_init_workers(&fs_info->submit_workers, "submit",
                           min_t(u64, fs_devices->num_devices,
-                           fs_info->thread_pool_size));
+                           fs_info->thread_pool_size),
+                           &fs_info->generic_worker);
+        btrfs_init_workers(&fs_info->enospc_workers, "enospc",
+                           fs_info->thread_pool_size,
+                           &fs_info->generic_worker);
        /* a higher idle thresh on the submit workers makes it much more
         * likely that bios will be send down in a sane order to the
@@ -1774,15 +1778,20 @@ printk("thread pool is %d\n", fs_info->thread_pool_size);
        fs_info->delalloc_workers.idle_thresh = 2;
        fs_info->delalloc_workers.ordered = 1;
-        btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1);
+        btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
+                           &fs_info->generic_worker);
        btrfs_init_workers(&fs_info->endio_workers, "endio",
-                           fs_info->thread_pool_size);
+                           fs_info->thread_pool_size,
+                           &fs_info->generic_worker);
        btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
-                           fs_info->thread_pool_size);
+                           fs_info->thread_pool_size,
+                           &fs_info->generic_worker);
        btrfs_init_workers(&fs_info->endio_meta_write_workers,
-                           "endio-meta-write", fs_info->thread_pool_size);
+                           "endio-meta-write", fs_info->thread_pool_size,
+                           &fs_info->generic_worker);
        btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
-                           fs_info->thread_pool_size);
+                           fs_info->thread_pool_size,
+                           &fs_info->generic_worker);
        /*
         * endios are largely parallel and should have a very
@@ -1794,12 +1803,8 @@ printk("thread pool is %d\n", fs_info->thread_pool_size);
        fs_info->endio_write_workers.idle_thresh = 2;
        fs_info->endio_meta_write_workers.idle_thresh = 2;
-        fs_info->endio_workers.atomic_worker_start = 1;
-        fs_info->endio_meta_workers.atomic_worker_start = 1;
-        fs_info->endio_write_workers.atomic_worker_start = 1;
-        fs_info->endio_meta_write_workers.atomic_worker_start = 1;
        btrfs_start_workers(&fs_info->workers, 1);
+        btrfs_start_workers(&fs_info->generic_worker, 1);
        btrfs_start_workers(&fs_info->submit_workers, 1);
        btrfs_start_workers(&fs_info->delalloc_workers, 1);
        btrfs_start_workers(&fs_info->fixup_workers, 1);
@@ -1807,6 +1812,7 @@ printk("thread pool is %d\n", fs_info->thread_pool_size);
        btrfs_start_workers(&fs_info->endio_meta_workers, 1);
        btrfs_start_workers(&fs_info->endio_meta_write_workers, 1);
        btrfs_start_workers(&fs_info->endio_write_workers, 1);
+        btrfs_start_workers(&fs_info->enospc_workers, 1);
        fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
        fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
@@ -2012,6 +2018,7 @@ fail_chunk_root:
        free_extent_buffer(chunk_root->node);
        free_extent_buffer(chunk_root->commit_root);
 fail_sb_buffer:
+        btrfs_stop_workers(&fs_info->generic_worker);
        btrfs_stop_workers(&fs_info->fixup_workers);
        btrfs_stop_workers(&fs_info->delalloc_workers);
        btrfs_stop_workers(&fs_info->workers);
@@ -2020,6 +2027,7 @@ fail_sb_buffer:
        btrfs_stop_workers(&fs_info->endio_meta_write_workers);
        btrfs_stop_workers(&fs_info->endio_write_workers);
        btrfs_stop_workers(&fs_info->submit_workers);
+        btrfs_stop_workers(&fs_info->enospc_workers);
 fail_iput:
        invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
        iput(fs_info->btree_inode);
@@ -2437,6 +2445,7 @@ int close_ctree(struct btrfs_root *root)
        iput(fs_info->btree_inode);
+        btrfs_stop_workers(&fs_info->generic_worker);
        btrfs_stop_workers(&fs_info->fixup_workers);
        btrfs_stop_workers(&fs_info->delalloc_workers);
        btrfs_stop_workers(&fs_info->workers);
@@ -2445,6 +2454,7 @@ int close_ctree(struct btrfs_root *root)
        btrfs_stop_workers(&fs_info->endio_meta_write_workers);
        btrfs_stop_workers(&fs_info->endio_write_workers);
        btrfs_stop_workers(&fs_info->submit_workers);
+        btrfs_stop_workers(&fs_info->enospc_workers);
        btrfs_close_devices(fs_info->fs_devices);
        btrfs_mapping_tree_free(&fs_info->mapping_tree);
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 359a754c782c..d0c4d584efad 100644
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -2824,14 +2824,17 @@ int btrfs_unreserve_metadata_for_delalloc(struct btrfs_root *root,
                                           num_items);
        spin_lock(&meta_sinfo->lock);
-        if (BTRFS_I(inode)->delalloc_reserved_extents <=
+        spin_lock(&BTRFS_I(inode)->accounting_lock);
-            BTRFS_I(inode)->delalloc_extents) {
+        if (BTRFS_I(inode)->reserved_extents <=
+            BTRFS_I(inode)->outstanding_extents) {
+                spin_unlock(&BTRFS_I(inode)->accounting_lock);
                spin_unlock(&meta_sinfo->lock);
                return 0;
        }
+        spin_unlock(&BTRFS_I(inode)->accounting_lock);
-        BTRFS_I(inode)->delalloc_reserved_extents--;
+        BTRFS_I(inode)->reserved_extents--;
-        BUG_ON(BTRFS_I(inode)->delalloc_reserved_extents < 0);
+        BUG_ON(BTRFS_I(inode)->reserved_extents < 0);
        if (meta_sinfo->bytes_delalloc < num_bytes) {
                bug = true;
@@ -2864,6 +2867,107 @@ static void check_force_delalloc(struct btrfs_space_info *meta_sinfo)
                meta_sinfo->force_delalloc = 0;
 }
+struct async_flush {
+        struct btrfs_root *root;
+        struct btrfs_space_info *info;
+        struct btrfs_work work;
+};
+static noinline void flush_delalloc_async(struct btrfs_work *work)
+{
+        struct async_flush *async;
+        struct btrfs_root *root;
+        struct btrfs_space_info *info;
+        async = container_of(work, struct async_flush, work);
+        root = async->root;
+        info = async->info;
+        btrfs_start_delalloc_inodes(root);
+        wake_up(&info->flush_wait);
+        btrfs_wait_ordered_extents(root, 0);
+        spin_lock(&info->lock);
+        info->flushing = 0;
+        spin_unlock(&info->lock);
+        wake_up(&info->flush_wait);
+        kfree(async);
+}
+static void wait_on_flush(struct btrfs_space_info *info)
+{
+        DEFINE_WAIT(wait);
+        u64 used;
+        while (1) {
+                prepare_to_wait(&info->flush_wait, &wait,
+                                TASK_UNINTERRUPTIBLE);
+                spin_lock(&info->lock);
+                if (!info->flushing) {
+                        spin_unlock(&info->lock);
+                        break;
+                }
+                used = info->bytes_used + info->bytes_reserved +
+                        info->bytes_pinned + info->bytes_readonly +
+                        info->bytes_super + info->bytes_root +
+                        info->bytes_may_use + info->bytes_delalloc;
+                if (used < info->total_bytes) {
+                        spin_unlock(&info->lock);
+                        break;
+                }
+                spin_unlock(&info->lock);
+                schedule();
+        }
+        finish_wait(&info->flush_wait, &wait);
+}
+static void flush_delalloc(struct btrfs_root *root,
+                                 struct btrfs_space_info *info)
+{
+        struct async_flush *async;
+        bool wait = false;
+        spin_lock(&info->lock);
+        if (!info->flushing) {
+                info->flushing = 1;
+                init_waitqueue_head(&info->flush_wait);
+        } else {
+                wait = true;
+        }
+        spin_unlock(&info->lock);
+        if (wait) {
+                wait_on_flush(info);
+                return;
+        }
+        async = kzalloc(sizeof(*async), GFP_NOFS);
+        if (!async)
+                goto flush;
+        async->root = root;
+        async->info = info;
+        async->work.func = flush_delalloc_async;
+        btrfs_queue_worker(&root->fs_info->enospc_workers,
+                           &async->work);
+        wait_on_flush(info);
+        return;
+flush:
+        btrfs_start_delalloc_inodes(root);
+        btrfs_wait_ordered_extents(root, 0);
+        spin_lock(&info->lock);
+        info->flushing = 0;
+        spin_unlock(&info->lock);
+        wake_up(&info->flush_wait);
+}
 static int maybe_allocate_chunk(struct btrfs_root *root,
                                 struct btrfs_space_info *info)
 {
@@ -2894,7 +2998,7 @@ static int maybe_allocate_chunk(struct btrfs_root *root,
        if (!info->allocating_chunk) {
                info->force_alloc = 1;
                info->allocating_chunk = 1;
-                init_waitqueue_head(&info->wait);
+                init_waitqueue_head(&info->allocate_wait);
        } else {
                wait = true;
        }
@@ -2902,7 +3006,7 @@ static int maybe_allocate_chunk(struct btrfs_root *root,
        spin_unlock(&info->lock);
        if (wait) {
-                wait_event(info->wait,
+                wait_event(info->allocate_wait,
                           !info->allocating_chunk);
                return 1;
        }
@@ -2923,7 +3027,7 @@ out:
        spin_lock(&info->lock);
        info->allocating_chunk = 0;
        spin_unlock(&info->lock);
-        wake_up(&info->wait);
+        wake_up(&info->allocate_wait);
        if (ret)
                return 0;
@@ -2981,21 +3085,20 @@ again:
                        filemap_flush(inode->i_mapping);
                        goto again;
                } else if (flushed == 3) {
-                        btrfs_start_delalloc_inodes(root);
+                        flush_delalloc(root, meta_sinfo);
-                        btrfs_wait_ordered_extents(root, 0);
                        goto again;
                }
                spin_lock(&meta_sinfo->lock);
                meta_sinfo->bytes_delalloc -= num_bytes;
                spin_unlock(&meta_sinfo->lock);
                printk(KERN_ERR "enospc, has %d, reserved %d\n",
-                       BTRFS_I(inode)->delalloc_extents,
+                       BTRFS_I(inode)->outstanding_extents,
-                       BTRFS_I(inode)->delalloc_reserved_extents);
+                       BTRFS_I(inode)->reserved_extents);
                dump_space_info(meta_sinfo, 0, 0);
                return -ENOSPC;
        }
-        BTRFS_I(inode)->delalloc_reserved_extents++;
+        BTRFS_I(inode)->reserved_extents++;
        check_force_delalloc(meta_sinfo);
        spin_unlock(&meta_sinfo->lock);
@@ -3094,8 +3197,7 @@ again:
                }
                if (retries == 2) {
-                        btrfs_start_delalloc_inodes(root);
+                        flush_delalloc(root, meta_sinfo);
-                        btrfs_wait_ordered_extents(root, 0);
                        goto again;
                }
                spin_lock(&meta_sinfo->lock);
@@ -4029,6 +4131,7 @@ static noinline int find_free_extent(struct btrfs_trans_handle *trans,
        int loop = 0;
        bool found_uncached_bg = false;
        bool failed_cluster_refill = false;
+        bool failed_alloc = false;
        WARN_ON(num_bytes < root->sectorsize);
        btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
@@ -4233,14 +4336,23 @@ refill_cluster:
                offset = btrfs_find_space_for_alloc(block_group, search_start,
                                                    num_bytes, empty_size);
-                if (!offset && (cached || (!cached &&
+                /*
-                                           loop == LOOP_CACHING_NOWAIT))) {
+                 * If we didn't find a chunk, and we haven't failed on this
-                        goto loop;
+                 * block group before, and this block group is in the middle of
-                } else if (!offset && (!cached &&
+                 * caching and we are ok with waiting, then go ahead and wait
-                                       loop > LOOP_CACHING_NOWAIT)) {
+                 * for progress to be made, and set failed_alloc to true.
+                 *
+                 * If failed_alloc is true then we've already waited on this
+                 * block group once and should move on to the next block group.
+                 */
+                if (!offset && !failed_alloc && !cached &&
+                    loop > LOOP_CACHING_NOWAIT) {
                        wait_block_group_cache_progress(block_group,
-                                        num_bytes + empty_size);
+                                                num_bytes + empty_size);
+                        failed_alloc = true;
                        goto have_block_group;
+                } else if (!offset) {
+                        goto loop;
                }
 checks:
                search_start = stripe_align(root, offset);
@@ -4288,6 +4400,7 @@ checks:
                break;
 loop:
                failed_cluster_refill = false;
+                failed_alloc = false;
                btrfs_put_block_group(block_group);
        }
        up_read(&space_info->groups_sem);
@@ -4799,6 +4912,7 @@ static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
        u64 bytenr;
        u64 generation;
        u64 refs;
+        u64 flags;
        u64 last = 0;
        u32 nritems;
        u32 blocksize;
@@ -4836,15 +4950,19 @@ static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
                    generation <= root->root_key.offset)
                        continue;
+                /* We don't lock the tree block, it's OK to be racy here */
+                ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
+                                               &refs, &flags);
+                BUG_ON(ret);
+                BUG_ON(refs == 0);
                if (wc->stage == DROP_REFERENCE) {
-                        ret = btrfs_lookup_extent_info(trans, root,
-                                                bytenr, blocksize,
-                                                &refs, NULL);
-                        BUG_ON(ret);
-                        BUG_ON(refs == 0);
                        if (refs == 1)
                                goto reada;
+                        if (wc->level == 1 &&
+                            (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
+                                continue;
                        if (!wc->update_ref ||
                            generation <= root->root_key.offset)
                                continue;
@@ -4853,6 +4971,10 @@ static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
                                                  &wc->update_progress);
                        if (ret < 0)
                                continue;
+                } else {
+                        if (wc->level == 1 &&
+                            (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
+                                continue;
                }
 reada:
                ret = readahead_tree_block(root, bytenr, blocksize,
@@ -4876,7 +4998,7 @@ reada:
 static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
                                   struct btrfs_root *root,
                                   struct btrfs_path *path,
-                                   struct walk_control *wc)
+                                   struct walk_control *wc, int lookup_info)
 {
        int level = wc->level;
        struct extent_buffer *eb = path->nodes[level];
@@ -4891,8 +5013,9 @@ static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
         * when reference count of tree block is 1, it won't increase
         * again. once full backref flag is set, we never clear it.
         */
-        if ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||
+        if (lookup_info &&
-            (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag))) {
+            ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||
+             (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {
                BUG_ON(!path->locks[level]);
                ret = btrfs_lookup_extent_info(trans, root,
                                               eb->start, eb->len,
@@ -4953,7 +5076,7 @@ static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
 static noinline int do_walk_down(struct btrfs_trans_handle *trans,
                                 struct btrfs_root *root,
                                 struct btrfs_path *path,
-                                 struct walk_control *wc)
+                                 struct walk_control *wc, int *lookup_info)
 {
        u64 bytenr;
        u64 generation;
@@ -4973,8 +5096,10 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
         * for the subtree
         */
        if (wc->stage == UPDATE_BACKREF &&
-            generation <= root->root_key.offset)
+            generation <= root->root_key.offset) {
+                *lookup_info = 1;
                return 1;
+        }
        bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
        blocksize = btrfs_level_size(root, level - 1);
@@ -4987,14 +5112,19 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
        btrfs_tree_lock(next);
        btrfs_set_lock_blocking(next);
-        if (wc->stage == DROP_REFERENCE) {
+        ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
-                ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
+                                       &wc->refs[level - 1],
-                                               &wc->refs[level - 1],
+                                       &wc->flags[level - 1]);
-                                               &wc->flags[level - 1]);
+        BUG_ON(ret);
-                BUG_ON(ret);
+        BUG_ON(wc->refs[level - 1] == 0);
-                BUG_ON(wc->refs[level - 1] == 0);
+        *lookup_info = 0;
+        if (wc->stage == DROP_REFERENCE) {
                if (wc->refs[level - 1] > 1) {
+                        if (level == 1 &&
+                            (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
+                                goto skip;
                        if (!wc->update_ref ||
                            generation <= root->root_key.offset)
                                goto skip;
@@ -5008,12 +5138,17 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
                        wc->stage = UPDATE_BACKREF;
                        wc->shared_level = level - 1;
                }
+        } else {
+                if (level == 1 &&
+                    (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
+                        goto skip;
        }
        if (!btrfs_buffer_uptodate(next, generation)) {
                btrfs_tree_unlock(next);
                free_extent_buffer(next);
                next = NULL;
+                *lookup_info = 1;
        }
        if (!next) {
@@ -5036,21 +5171,22 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans,
 skip:
        wc->refs[level - 1] = 0;
        wc->flags[level - 1] = 0;
+        if (wc->stage == DROP_REFERENCE) {
+                if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
+                        parent = path->nodes[level]->start;
+                } else {
+                        BUG_ON(root->root_key.objectid !=
+                               btrfs_header_owner(path->nodes[level]));
+                        parent = 0;
+                }
-        if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
+                ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent,
-                parent = path->nodes[level]->start;
+                                        root->root_key.objectid, level - 1, 0);
-        } else {
+                BUG_ON(ret);
-                BUG_ON(root->root_key.objectid !=
-                       btrfs_header_owner(path->nodes[level]));
-                parent = 0;
        }
-        ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent,
-                                root->root_key.objectid, level - 1, 0);
-        BUG_ON(ret);
        btrfs_tree_unlock(next);
        free_extent_buffer(next);
+        *lookup_info = 1;
        return 1;
 }
@@ -5164,6 +5300,7 @@ static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
                                   struct walk_control *wc)
 {
        int level = wc->level;
+        int lookup_info = 1;
        int ret;
        while (level >= 0) {
@@ -5171,14 +5308,14 @@ static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
                    btrfs_header_nritems(path->nodes[level]))
                        break;
-                ret = walk_down_proc(trans, root, path, wc);
+                ret = walk_down_proc(trans, root, path, wc, lookup_info);
                if (ret > 0)
                        break;
                if (level == 0)
                        break;
-                ret = do_walk_down(trans, root, path, wc);
+                ret = do_walk_down(trans, root, path, wc, &lookup_info);
                if (ret > 0) {
                        path->slots[level]++;
                        continue;
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index de1793ba004a..96577e8bf9fd 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -460,7 +460,8 @@ static int clear_state_bit(struct extent_io_tree *tree,
                            struct extent_state *state, int bits, int wake,
                            int delete)
 {
-        int ret = state->state & bits;
+        int bits_to_clear = bits & ~EXTENT_DO_ACCOUNTING;
+        int ret = state->state & bits_to_clear;
        if ((bits & EXTENT_DIRTY) && (state->state & EXTENT_DIRTY)) {
                u64 range = state->end - state->start + 1;
@@ -468,7 +469,7 @@ static int clear_state_bit(struct extent_io_tree *tree,
                tree->dirty_bytes -= range;
        }
        clear_state_cb(tree, state, bits);
-        state->state &= ~bits;
+        state->state &= ~bits_to_clear;
        if (wake)
                wake_up(&state->wq);
        if (delete || state->state == 0) {
@@ -956,7 +957,8 @@ int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end,
                       gfp_t mask)
 {
        return clear_extent_bit(tree, start, end,
-                                EXTENT_DIRTY | EXTENT_DELALLOC, 0, 0,
+                                EXTENT_DIRTY | EXTENT_DELALLOC |
+                                EXTENT_DO_ACCOUNTING, 0, 0,
                                NULL, mask);
 }
@@ -1401,12 +1403,7 @@ out_failed:
 int extent_clear_unlock_delalloc(struct inode *inode,
                                struct extent_io_tree *tree,
                                u64 start, u64 end, struct page *locked_page,
-                                int unlock_pages,
+                                unsigned long op)
-                                int clear_unlock,
-                                int clear_delalloc, int clear_dirty,
-                                int set_writeback,
-                                int end_writeback,
-                                int set_private2)
 {
        int ret;
        struct page *pages[16];
@@ -1416,17 +1413,21 @@ int extent_clear_unlock_delalloc(struct inode *inode,
        int i;
        int clear_bits = 0;
-        if (clear_unlock)
+        if (op & EXTENT_CLEAR_UNLOCK)
                clear_bits |= EXTENT_LOCKED;
-        if (clear_dirty)
+        if (op & EXTENT_CLEAR_DIRTY)
                clear_bits |= EXTENT_DIRTY;
-        if (clear_delalloc)
+        if (op & EXTENT_CLEAR_DELALLOC)
                clear_bits |= EXTENT_DELALLOC;
+        if (op & EXTENT_CLEAR_ACCOUNTING)
+                clear_bits |= EXTENT_DO_ACCOUNTING;
        clear_extent_bit(tree, start, end, clear_bits, 1, 0, NULL, GFP_NOFS);
-        if (!(unlock_pages || clear_dirty || set_writeback || end_writeback ||
+        if (!(op & (EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
-              set_private2))
+                    EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK |
+                    EXTENT_SET_PRIVATE2)))
                return 0;
        while (nr_pages > 0) {
@@ -1435,20 +1436,20 @@ int extent_clear_unlock_delalloc(struct inode *inode,
                                     nr_pages, ARRAY_SIZE(pages)), pages);
                for (i = 0; i < ret; i++) {
-                        if (set_private2)
+                        if (op & EXTENT_SET_PRIVATE2)
                                SetPagePrivate2(pages[i]);
                        if (pages[i] == locked_page) {
                                page_cache_release(pages[i]);
                                continue;
                        }
-                        if (clear_dirty)
+                        if (op & EXTENT_CLEAR_DIRTY)
                                clear_page_dirty_for_io(pages[i]);
-                        if (set_writeback)
+                        if (op & EXTENT_SET_WRITEBACK)
                                set_page_writeback(pages[i]);
-                        if (end_writeback)
+                        if (op & EXTENT_END_WRITEBACK)
                                end_page_writeback(pages[i]);
-                        if (unlock_pages)
+                        if (op & EXTENT_CLEAR_UNLOCK_PAGE)
                                unlock_page(pages[i]);
                        page_cache_release(pages[i]);
                }
@@ -2714,7 +2715,8 @@ int extent_invalidatepage(struct extent_io_tree *tree,
        lock_extent(tree, start, end, GFP_NOFS);
        wait_on_page_writeback(page);
        clear_extent_bit(tree, start, end,
-                         EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC,
+                         EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
+                         EXTENT_DO_ACCOUNTING,
                         1, 1, NULL, GFP_NOFS);
        return 0;
 }
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index 4794ec891fed..36de250a7b2b 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -15,6 +15,7 @@
 #define EXTENT_BUFFER_FILLED (1 << 8)
 #define EXTENT_BOUNDARY (1 << 9)
 #define EXTENT_NODATASUM (1 << 10)
+#define EXTENT_DO_ACCOUNTING (1 << 11)
 #define EXTENT_IOBITS (EXTENT_LOCKED | EXTENT_WRITEBACK)
 /* flags for bio submission */
@@ -25,6 +26,16 @@
 #define EXTENT_BUFFER_BLOCKING 1
 #define EXTENT_BUFFER_DIRTY 2
+/* these are flags for extent_clear_unlock_delalloc */
+#define EXTENT_CLEAR_UNLOCK_PAGE 0x1
+#define EXTENT_CLEAR_UNLOCK      0x2
+#define EXTENT_CLEAR_DELALLOC    0x4
+#define EXTENT_CLEAR_DIRTY       0x8
+#define EXTENT_SET_WRITEBACK     0x10
+#define EXTENT_END_WRITEBACK     0x20
+#define EXTENT_SET_PRIVATE2      0x40
+#define EXTENT_CLEAR_ACCOUNTING  0x80
 /*
 * page->private values.  Every page that is controlled by the extent
 * map has page->private set to one.
@@ -288,10 +299,5 @@ int extent_range_uptodate(struct extent_io_tree *tree,
 int extent_clear_unlock_delalloc(struct inode *inode,
                                struct extent_io_tree *tree,
                                u64 start, u64 end, struct page *locked_page,
-                                int unlock_page,
+                                unsigned long op);
-                                int clear_unlock,
-                                int clear_delalloc, int clear_dirty,
-                                int set_writeback,
-                                int end_writeback,
-                                int set_private2);
 #endif
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index f19e1259a971..2d623aa0625f 100644
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -878,7 +878,8 @@ again:
                        btrfs_put_ordered_extent(ordered);
                clear_extent_bits(&BTRFS_I(inode)->io_tree, start_pos,
-                                  last_pos - 1, EXTENT_DIRTY | EXTENT_DELALLOC,
+                                  last_pos - 1, EXTENT_DIRTY | EXTENT_DELALLOC |
+                                  EXTENT_DO_ACCOUNTING,
                                  GFP_NOFS);
                unlock_extent(&BTRFS_I(inode)->io_tree,
                              start_pos, last_pos - 1, GFP_NOFS);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 112e5aa85892..9e138b793dc7 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -424,9 +424,12 @@ again:
                         * and free up our temp pages.
                         */
                        extent_clear_unlock_delalloc(inode,
-                                                     &BTRFS_I(inode)->io_tree,
+                             &BTRFS_I(inode)->io_tree,
-                                                     start, end, NULL, 1, 0,
+                             start, end, NULL,
-                                                     0, 1, 1, 1, 0);
+                             EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |
+                             EXTENT_CLEAR_DELALLOC |
+                             EXTENT_CLEAR_ACCOUNTING |
+                             EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);
                        ret = 0;
                        goto free_pages_out;
                }
@@ -637,11 +640,14 @@ static noinline int submit_compressed_extents(struct inode *inode,
                 * clear dirty, set writeback and unlock the pages.
                 */
                extent_clear_unlock_delalloc(inode,
-                                             &BTRFS_I(inode)->io_tree,
+                                &BTRFS_I(inode)->io_tree,
-                                             async_extent->start,
+                                async_extent->start,
-                                             async_extent->start +
+                                async_extent->start +
-                                             async_extent->ram_size - 1,
+                                async_extent->ram_size - 1,
-                                             NULL, 1, 1, 0, 1, 1, 0, 0);
+                                NULL, EXTENT_CLEAR_UNLOCK_PAGE |
+                                EXTENT_CLEAR_UNLOCK |
+                                EXTENT_CLEAR_DELALLOC |
+                                EXTENT_CLEAR_DIRTY | EXTENT_SET_WRITEBACK);
                ret = btrfs_submit_compressed_write(inode,
                                    async_extent->start,
@@ -712,9 +718,15 @@ static noinline int cow_file_range(struct inode *inode,
                                            start, end, 0, NULL);
                if (ret == 0) {
                        extent_clear_unlock_delalloc(inode,
-                                                     &BTRFS_I(inode)->io_tree,
+                                     &BTRFS_I(inode)->io_tree,
-                                                     start, end, NULL, 1, 1,
+                                     start, end, NULL,
-                                                     1, 1, 1, 1, 0);
+                                     EXTENT_CLEAR_UNLOCK_PAGE |
+                                     EXTENT_CLEAR_UNLOCK |
+                                     EXTENT_CLEAR_DELALLOC |
+                                     EXTENT_CLEAR_ACCOUNTING |
+                                     EXTENT_CLEAR_DIRTY |
+                                     EXTENT_SET_WRITEBACK |
+                                     EXTENT_END_WRITEBACK);
                        *nr_written = *nr_written +
                             (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
                        *page_started = 1;
@@ -738,6 +750,8 @@ static noinline int cow_file_range(struct inode *inode,
        btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
        while (disk_num_bytes > 0) {
+                unsigned long op;
                cur_alloc_size = min(disk_num_bytes, root->fs_info->max_extent);
                ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
                                           root->sectorsize, 0, alloc_hint,
@@ -789,10 +803,13 @@ static noinline int cow_file_range(struct inode *inode,
                 * Do set the Private2 bit so we know this page was properly
                 * setup for writepage
                 */
+                op = unlock ? EXTENT_CLEAR_UNLOCK_PAGE : 0;
+                op |= EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
+                        EXTENT_SET_PRIVATE2;
                extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
                                             start, start + ram_size - 1,
-                                             locked_page, unlock, 1,
+                                             locked_page, op);
-                                             1, 0, 0, 0, 1);
                disk_num_bytes -= cur_alloc_size;
                num_bytes -= cur_alloc_size;
                alloc_hint = ins.objectid + ins.offset;
@@ -864,8 +881,8 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page,
        u64 cur_end;
        int limit = 10 * 1024 * 1042;
-        clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED |
+        clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
-                         EXTENT_DELALLOC, 1, 0, NULL, GFP_NOFS);
+                         1, 0, NULL, GFP_NOFS);
        while (start < end) {
                async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);
                async_cow->inode = inode;
@@ -1006,6 +1023,7 @@ next_slot:
                if (found_key.offset > cur_offset) {
                        extent_end = found_key.offset;
+                        extent_type = 0;
                        goto out_check;
                }
@@ -1112,8 +1130,10 @@ out_check:
                BUG_ON(ret);
                extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
-                                        cur_offset, cur_offset + num_bytes - 1,
+                                cur_offset, cur_offset + num_bytes - 1,
-                                        locked_page, 1, 1, 1, 0, 0, 0, 1);
+                                locked_page, EXTENT_CLEAR_UNLOCK_PAGE |
+                                EXTENT_CLEAR_UNLOCK | EXTENT_CLEAR_DELALLOC |
+                                EXTENT_SET_PRIVATE2);
                cur_offset = extent_end;
                if (cur_offset > end)
                        break;
@@ -1178,15 +1198,17 @@ static int btrfs_split_extent_hook(struct inode *inode,
                                        root->fs_info->max_extent);
                /*
-                 * if we break a large extent up then leave delalloc_extents be,
+                 * if we break a large extent up then leave oustanding_extents
-                 * since we've already accounted for the large extent.
+                 * be, since we've already accounted for the large extent.
                 */
                if (div64_u64(new_size + root->fs_info->max_extent - 1,
                              root->fs_info->max_extent) < num_extents)
                        return 0;
        }
-        BTRFS_I(inode)->delalloc_extents++;
+        spin_lock(&BTRFS_I(inode)->accounting_lock);
+        BTRFS_I(inode)->outstanding_extents++;
+        spin_unlock(&BTRFS_I(inode)->accounting_lock);
        return 0;
 }
@@ -1217,7 +1239,9 @@ static int btrfs_merge_extent_hook(struct inode *inode,
        /* we're not bigger than the max, unreserve the space and go */
        if (new_size <= root->fs_info->max_extent) {
-                BTRFS_I(inode)->delalloc_extents--;
+                spin_lock(&BTRFS_I(inode)->accounting_lock);
+                BTRFS_I(inode)->outstanding_extents--;
+                spin_unlock(&BTRFS_I(inode)->accounting_lock);
                return 0;
        }
@@ -1231,7 +1255,9 @@ static int btrfs_merge_extent_hook(struct inode *inode,
                      root->fs_info->max_extent) > num_extents)
                return 0;
-        BTRFS_I(inode)->delalloc_extents--;
+        spin_lock(&BTRFS_I(inode)->accounting_lock);
+        BTRFS_I(inode)->outstanding_extents--;
+        spin_unlock(&BTRFS_I(inode)->accounting_lock);
        return 0;
 }
@@ -1253,7 +1279,9 @@ static int btrfs_set_bit_hook(struct inode *inode, u64 start, u64 end,
        if (!(old & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
                struct btrfs_root *root = BTRFS_I(inode)->root;
-                BTRFS_I(inode)->delalloc_extents++;
+                spin_lock(&BTRFS_I(inode)->accounting_lock);
+                BTRFS_I(inode)->outstanding_extents++;
+                spin_unlock(&BTRFS_I(inode)->accounting_lock);
                btrfs_delalloc_reserve_space(root, inode, end - start + 1);
                spin_lock(&root->fs_info->delalloc_lock);
                BTRFS_I(inode)->delalloc_bytes += end - start + 1;
@@ -1281,8 +1309,12 @@ static int btrfs_clear_bit_hook(struct inode *inode,
        if ((state->state & EXTENT_DELALLOC) && (bits & EXTENT_DELALLOC)) {
                struct btrfs_root *root = BTRFS_I(inode)->root;
-                BTRFS_I(inode)->delalloc_extents--;
+                if (bits & EXTENT_DO_ACCOUNTING) {
-                btrfs_unreserve_metadata_for_delalloc(root, inode, 1);
+                        spin_lock(&BTRFS_I(inode)->accounting_lock);
+                        BTRFS_I(inode)->outstanding_extents--;
+                        spin_unlock(&BTRFS_I(inode)->accounting_lock);
+                        btrfs_unreserve_metadata_for_delalloc(root, inode, 1);
+                }
                spin_lock(&root->fs_info->delalloc_lock);
                if (state->end - state->start + 1 >
@@ -3598,12 +3630,14 @@ static int btrfs_dentry_delete(struct dentry *dentry)
 {
        struct btrfs_root *root;
-        if (!dentry->d_inode)
+        if (!dentry->d_inode && !IS_ROOT(dentry))
-                return 0;
+                dentry = dentry->d_parent;
-        root = BTRFS_I(dentry->d_inode)->root;
+        if (dentry->d_inode) {
-        if (btrfs_root_refs(&root->root_item) == 0)
+                root = BTRFS_I(dentry->d_inode)->root;
-                return 1;
+                if (btrfs_root_refs(&root->root_item) == 0)
+                        return 1;
+        }
        return 0;
 }
@@ -4808,7 +4842,8 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset)
                 */
                clear_extent_bit(tree, page_start, page_end,
                                 EXTENT_DIRTY | EXTENT_DELALLOC |
-                                 EXTENT_LOCKED, 1, 0, NULL, GFP_NOFS);
+                                 EXTENT_LOCKED | EXTENT_DO_ACCOUNTING, 1, 0,
+                                 NULL, GFP_NOFS);
                /*
                 * whoever cleared the private bit is responsible
                 * for the finish_ordered_io
@@ -4821,8 +4856,8 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset)
                lock_extent(tree, page_start, page_end, GFP_NOFS);
        }
        clear_extent_bit(tree, page_start, page_end,
-                 EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC,
+                 EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC |
-                 1, 1, NULL, GFP_NOFS);
+                 EXTENT_DO_ACCOUNTING, 1, 1, NULL, GFP_NOFS);
        __btrfs_releasepage(page, GFP_NOFS);
        ClearPageChecked(page);
@@ -4917,7 +4952,8 @@ again:
         * prepare_pages in the normal write path.
         */
        clear_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end,
-                          EXTENT_DIRTY | EXTENT_DELALLOC, GFP_NOFS);
+                          EXTENT_DIRTY | EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING,
+                          GFP_NOFS);
        ret = btrfs_set_extent_delalloc(inode, page_start, page_end);
        if (ret) {
@@ -5065,8 +5101,9 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
                return NULL;
        ei->last_trans = 0;
        ei->logged_trans = 0;
-        ei->delalloc_extents = 0;
+        ei->outstanding_extents = 0;
-        ei->delalloc_reserved_extents = 0;
+        ei->reserved_extents = 0;
+        spin_lock_init(&ei->accounting_lock);
        btrfs_ordered_inode_tree_init(&ei->ordered_tree);
        INIT_LIST_HEAD(&ei->i_orphan);
        INIT_LIST_HEAD(&ei->ordered_operations);
@@ -5805,6 +5842,6 @@ static const struct inode_operations btrfs_symlink_inode_operations = {
        .removexattr    = btrfs_removexattr,
 };
-struct dentry_operations btrfs_dentry_operations = {
+const struct dentry_operations btrfs_dentry_operations = {
        .d_delete       = btrfs_dentry_delete,
 };
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 9a780c8d0ac8..cdbb054102b9 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -830,6 +830,7 @@ out_up_write:
 out_unlock:
        mutex_unlock(&inode->i_mutex);
        if (!err) {
+                shrink_dcache_sb(root->fs_info->sb);
                btrfs_invalidate_inodes(dest);
                d_delete(dentry);
        }
@@ -1122,8 +1123,10 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                                        datao += off - key.offset;
                                        datal -= off - key.offset;
                                }
-                                if (key.offset + datao + datal > off + len)
-                                        datal = off + len - key.offset - datao;
+                                if (key.offset + datal > off + len)
+                                        datal = off + len - key.offset;
                                /* disko == 0 means it's a hole */
                                if (!disko)
                                        datao = 0;
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 897fba835f89..5799bc46a309 100644
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -306,6 +306,12 @@ int btrfs_remove_ordered_extent(struct inode *inode,
        tree->last = NULL;
        set_bit(BTRFS_ORDERED_COMPLETE, &entry->flags);
+        spin_lock(&BTRFS_I(inode)->accounting_lock);
+        BTRFS_I(inode)->outstanding_extents--;
+        spin_unlock(&BTRFS_I(inode)->accounting_lock);
+        btrfs_unreserve_metadata_for_delalloc(BTRFS_I(inode)->root,
+                                              inode, 1);
        spin_lock(&BTRFS_I(inode)->root->fs_info->ordered_extent_lock);
        list_del_init(&entry->root_extent_list);
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 361ad323faac..cfcc93c93a7b 100644
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -3518,7 +3518,7 @@ int btrfs_relocate_block_group(struct btrfs_root *extent_root, u64 group_start)
        BUG_ON(!rc->block_group);
        btrfs_init_workers(&rc->workers, "relocate",
-                           fs_info->thread_pool_size);
+                           fs_info->thread_pool_size, NULL);
        rc->extent_root = extent_root;
        btrfs_prepare_block_group_relocation(extent_root, rc->block_group);
@@ -3701,7 +3701,7 @@ int btrfs_recover_relocation(struct btrfs_root *root)
        mapping_tree_init(&rc->reloc_root_tree);
        INIT_LIST_HEAD(&rc->reloc_roots);
        btrfs_init_workers(&rc->workers, "relocate",
-                           root->fs_info->thread_pool_size);
+                           root->fs_info->thread_pool_size, NULL);
        rc->extent_root = root->fs_info->extent_root;
        set_reloc_control(rc);
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 7827841b55cb..4edfdc2acc5f 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -137,11 +137,20 @@ static int start_log_trans(struct btrfs_trans_handle *trans,
        mutex_lock(&root->log_mutex);
        if (root->log_root) {
+                if (!root->log_start_pid) {
+                        root->log_start_pid = current->pid;
+                        root->log_multiple_pids = false;
+                } else if (root->log_start_pid != current->pid) {
+                        root->log_multiple_pids = true;
+                }
                root->log_batch++;
                atomic_inc(&root->log_writers);
                mutex_unlock(&root->log_mutex);
                return 0;
        }
+        root->log_multiple_pids = false;
+        root->log_start_pid = current->pid;
        mutex_lock(&root->fs_info->tree_log_mutex);
        if (!root->fs_info->log_root_tree) {
                ret = btrfs_init_log_root_tree(trans, root->fs_info);
@@ -1985,7 +1994,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
        if (atomic_read(&root->log_commit[(index1 + 1) % 2]))
                wait_log_commit(trans, root, root->log_transid - 1);
-        while (1) {
+        while (root->log_multiple_pids) {
                unsigned long batch = root->log_batch;
                mutex_unlock(&root->log_mutex);
                schedule_timeout_uninterruptible(1);
@@ -2011,6 +2020,7 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
        root->log_batch = 0;
        root->log_transid++;
        log->log_transid = root->log_transid;
+        root->log_start_pid = 0;
        smp_mb();
        /*
         * log tree has been flushed to disk, new modifications of
diff --git a/fs/ecryptfs/Kconfig b/fs/ecryptfs/Kconfig
index 8aadb99b7634..1cd6d9d3e29a 100644
--- a/fs/ecryptfs/Kconfig
+++ b/fs/ecryptfs/Kconfig
@@ -1,8 +1,9 @@
 config ECRYPT_FS
        tristate "eCrypt filesystem layer support (EXPERIMENTAL)"
-        depends on EXPERIMENTAL && KEYS && NET
+        depends on EXPERIMENTAL && KEYS && CRYPTO
        select CRYPTO_ECB
        select CRYPTO_CBC
+        select CRYPTO_MD5
        help
          Encrypted filesystem that operates on the VFS layer.  See
          <file:Documentation/filesystems/ecryptfs.txt> to learn more about
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 101fe4c7b1ee..c6ac85d6c701 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -35,6 +35,7 @@
 #include <linux/key.h>
 #include <linux/parser.h>
 #include <linux/fs_stack.h>
+#include <linux/ima.h>
 #include "ecryptfs_kernel.h"
 /**
@@ -118,6 +119,7 @@ int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
        const struct cred *cred = current_cred();
        struct ecryptfs_inode_info *inode_info =
                ecryptfs_inode_to_private(ecryptfs_dentry->d_inode);
+        int opened_lower_file = 0;
        int rc = 0;
        mutex_lock(&inode_info->lower_file_mutex);
@@ -134,9 +136,12 @@ int ecryptfs_init_persistent_file(struct dentry *ecryptfs_dentry)
                               "for lower_dentry [0x%p] and lower_mnt [0x%p]; "
                               "rc = [%d]\n", lower_dentry, lower_mnt, rc);
                        inode_info->lower_file = NULL;
-                }
+                } else
+                        opened_lower_file = 1;
        }
        mutex_unlock(&inode_info->lower_file_mutex);
+        if (opened_lower_file)
+                ima_counts_get(inode_info->lower_file);
        return rc;
 }
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 72743d360509..7a520a862f49 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -2321,7 +2321,18 @@ static int ext3_commit_super(struct super_block *sb,
        if (!sbh)
                return error;
-        es->s_wtime = cpu_to_le32(get_seconds());
+        /*
+         * If the file system is mounted read-only, don't update the
+         * superblock write time.  This avoids updating the superblock
+         * write time when we are mounting the root file system
+         * read/only but we need to replay the journal; at that point,
+         * for people who are east of GMT and who make their clock
+         * tick in localtime for Windows bug-for-bug compatibility,
+         * the clock is set in the future, and this will cause e2fsck
+         * to complain and force a full file system check.
+         */
+        if (!(sb->s_flags & MS_RDONLY))
+                es->s_wtime = cpu_to_le32(get_seconds());
        es->s_free_blocks_count = cpu_to_le32(ext3_count_free_blocks(sb));
        es->s_free_inodes_count = cpu_to_le32(ext3_count_free_inodes(sb));
        BUFFER_TRACE(sbh, "marking dirty");
diff --git a/fs/file.c b/fs/file.c
index f313314f996f..87e129030ab1 100644
--- a/fs/file.c
+++ b/fs/file.c
@@ -10,6 +10,7 @@
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/time.h>
+#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/file.h>
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 63976c0ccc25..99ea196f071f 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -1180,7 +1180,7 @@ static int nfs4_init_client(struct nfs_client *clp,
                                      1, flags & NFS_MOUNT_NORESVPORT);
        if (error < 0)
                goto error;
-        memcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
+        strlcpy(clp->cl_ipaddr, ip_addr, sizeof(clp->cl_ipaddr));
        error = nfs_idmap_new(clp);
        if (error < 0) {
diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c
index 2636c26d56fa..fa3408f20112 100644
--- a/fs/nfs/nfs4namespace.c
+++ b/fs/nfs/nfs4namespace.c
@@ -121,7 +121,7 @@ static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
        mnt_path = nfs4_pathname_string(&location->rootpath, page2, PAGE_SIZE);
        if (IS_ERR(mnt_path))
-                return mnt;
+                return ERR_CAST(mnt_path);
        mountdata->mnt_path = mnt_path;
        maxbuflen = mnt_path - 1 - page2;
@@ -132,15 +132,15 @@ static struct vfsmount *try_location(struct nfs_clone_mount *mountdata,
                if (buf->len <= 0 || buf->len >= maxbuflen)
                        continue;
-                mountdata->addr = (struct sockaddr *)&addr;
                if (memchr(buf->data, IPV6_SCOPE_DELIMITER, buf->len))
                        continue;
-                mountdata->addrlen = nfs_parse_server_name(buf->data,
-                                buf->len,
+                mountdata->addrlen = nfs_parse_server_name(buf->data, buf->len,
-                                mountdata->addr, mountdata->addrlen);
+                                (struct sockaddr *)&addr, sizeof(addr));
                if (mountdata->addrlen == 0)
                        continue;
+                mountdata->addr = (struct sockaddr *)&addr;
                rpc_set_port(mountdata->addr, NFS_PORT);
                memcpy(page2, buf->data, buf->len);
diff --git a/fs/nfs/nfs4renewd.c b/fs/nfs/nfs4renewd.c
index e27c6cef18f2..0156c01c212c 100644
--- a/fs/nfs/nfs4renewd.c
+++ b/fs/nfs/nfs4renewd.c
@@ -127,12 +127,6 @@ nfs4_schedule_state_renewal(struct nfs_client *clp)
 }
 void
-nfs4_renewd_prepare_shutdown(struct nfs_server *server)
-{
-        cancel_delayed_work(&server->nfs_client->cl_renewd);
-}
-void
 nfs4_kill_renewd(struct nfs_client *clp)
 {
        cancel_delayed_work_sync(&clp->cl_renewd);
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 29786d3b9326..a2c18acb8568 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -728,22 +728,24 @@ static void nfs_umount_begin(struct super_block *sb)
        unlock_kernel();
 }
-static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(int flags)
+static struct nfs_parsed_mount_data *nfs_alloc_parsed_mount_data(unsigned int version)
 {
        struct nfs_parsed_mount_data *data;
        data = kzalloc(sizeof(*data), GFP_KERNEL);
        if (data) {
-                data->flags             = flags;
                data->rsize             = NFS_MAX_FILE_IO_SIZE;
                data->wsize             = NFS_MAX_FILE_IO_SIZE;
                data->acregmin          = NFS_DEF_ACREGMIN;
                data->acregmax          = NFS_DEF_ACREGMAX;
                data->acdirmin          = NFS_DEF_ACDIRMIN;
                data->acdirmax          = NFS_DEF_ACDIRMAX;
+                data->mount_server.port = NFS_UNSPEC_PORT;
                data->nfs_server.port   = NFS_UNSPEC_PORT;
+                data->nfs_server.protocol = XPRT_TRANSPORT_TCP;
                data->auth_flavors[0]   = RPC_AUTH_UNIX;
                data->auth_flavor_len   = 1;
+                data->version           = version;
                data->minorversion      = 0;
        }
        return data;
@@ -776,15 +778,13 @@ static int nfs_verify_server_address(struct sockaddr *addr)
 * Select between a default port value and a user-specified port value.
 * If a zero value is set, then autobind will be used.
 */
-static void nfs_set_default_port(struct sockaddr *sap, const int parsed_port,
+static void nfs_set_port(struct sockaddr *sap, int *port,
                                 const unsigned short default_port)
 {
-        unsigned short port = default_port;
+        if (*port == NFS_UNSPEC_PORT)
+                *port = default_port;
-        if (parsed_port != NFS_UNSPEC_PORT)
+        rpc_set_port(sap, *port);
-                port = parsed_port;
-        rpc_set_port(sap, port);
 }
 /*
@@ -1475,7 +1475,7 @@ static int nfs_try_mount(struct nfs_parsed_mount_data *args,
                args->mount_server.addrlen = args->nfs_server.addrlen;
        }
        request.salen = args->mount_server.addrlen;
-        nfs_set_default_port(request.sap, args->mount_server.port, 0);
+        nfs_set_port(request.sap, &args->mount_server.port, 0);
        /*
         * Now ask the mount server to map our export path
@@ -1711,8 +1711,6 @@ static int nfs_validate_mount_data(void *options,
                if (!(data->flags & NFS_MOUNT_TCP))
                        args->nfs_server.protocol = XPRT_TRANSPORT_UDP;
-                else
-                        args->nfs_server.protocol = XPRT_TRANSPORT_TCP;
                /* N.B. caller will free nfs_server.hostname in all cases */
                args->nfs_server.hostname = kstrdup(data->hostname, GFP_KERNEL);
                args->namlen            = data->namlen;
@@ -1767,7 +1765,7 @@ static int nfs_validate_mount_data(void *options,
                        goto out_v4_not_compiled;
 #endif
-                nfs_set_default_port(sap, args->nfs_server.port, 0);
+                nfs_set_port(sap, &args->nfs_server.port, 0);
                nfs_set_mount_transport_protocol(args);
@@ -1848,9 +1846,10 @@ nfs_compare_remount_data(struct nfs_server *nfss,
            data->acdirmin != nfss->acdirmin / HZ ||
            data->acdirmax != nfss->acdirmax / HZ ||
            data->timeo != (10U * nfss->client->cl_timeout->to_initval / HZ) ||
+            data->nfs_server.port != nfss->port ||
            data->nfs_server.addrlen != nfss->nfs_client->cl_addrlen ||
-            memcmp(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
+            !rpc_cmp_addr((struct sockaddr *)&data->nfs_server.address,
-                   data->nfs_server.addrlen) != 0)
+                          (struct sockaddr *)&nfss->nfs_client->cl_addr))
                return -EINVAL;
        return 0;
@@ -1893,6 +1892,7 @@ nfs_remount(struct super_block *sb, int *flags, char *raw_data)
        data->acdirmin = nfss->acdirmin / HZ;
        data->acdirmax = nfss->acdirmax / HZ;
        data->timeo = 10U * nfss->client->cl_timeout->to_initval / HZ;
+        data->nfs_server.port = nfss->port;
        data->nfs_server.addrlen = nfss->nfs_client->cl_addrlen;
        memcpy(&data->nfs_server.address, &nfss->nfs_client->cl_addr,
                data->nfs_server.addrlen);
@@ -2106,7 +2106,7 @@ static int nfs_get_sb(struct file_system_type *fs_type,
        };
        int error = -ENOMEM;
-        data = nfs_alloc_parsed_mount_data(NFS_MOUNT_VER3 | NFS_MOUNT_TCP);
+        data = nfs_alloc_parsed_mount_data(3);
        mntfh = kzalloc(sizeof(*mntfh), GFP_KERNEL);
        if (data == NULL || mntfh == NULL)
                goto out_free_fh;
@@ -2331,7 +2331,7 @@ static int nfs4_validate_text_mount_data(void *options,
 {
        struct sockaddr *sap = (struct sockaddr *)&args->nfs_server.address;
-        nfs_set_default_port(sap, args->nfs_server.port, NFS_PORT);
+        nfs_set_port(sap, &args->nfs_server.port, NFS_PORT);
        nfs_validate_transport_protocol(args);
@@ -2376,7 +2376,6 @@ static int nfs4_validate_mount_data(void *options,
        if (data == NULL)
                goto out_no_data;
-        args->version           = 4;
        switch (data->version) {
        case 1:
                if (data->host_addrlen > sizeof(args->nfs_server.address))
@@ -2660,7 +2659,7 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
        struct nfs_parsed_mount_data *data;
        int error = -ENOMEM;
-        data = nfs_alloc_parsed_mount_data(0);
+        data = nfs_alloc_parsed_mount_data(4);
        if (data == NULL)
                goto out_free_data;
@@ -2690,7 +2689,6 @@ static void nfs4_kill_super(struct super_block *sb)
        dprintk("--> %s\n", __func__);
        nfs_super_return_all_delegations(sb);
        kill_anon_super(sb);
-        nfs4_renewd_prepare_shutdown(server);
        nfs_fscache_release_super_cookie(sb);
        nfs_free_server(server);
        dprintk("<-- %s\n", __func__);
diff --git a/fs/proc/kcore.c b/fs/proc/kcore.c
index 56013371f9f3..a44a7897fd4d 100644
--- a/fs/proc/kcore.c
+++ b/fs/proc/kcore.c
@@ -23,7 +23,6 @@
 #include <asm/io.h>
 #include <linux/list.h>
 #include <linux/ioport.h>
-#include <linux/mm.h>
 #include <linux/memory.h>
 #include <asm/sections.h>
diff --git a/fs/proc/page.c b/fs/proc/page.c
index 2281c2cbfe2b..5033ce0d254b 100644
--- a/fs/proc/page.c
+++ b/fs/proc/page.c
@@ -94,6 +94,7 @@ static const struct file_operations proc_kpagecount_operations = {
 #define KPF_COMPOUND_TAIL       16
 #define KPF_HUGE                17
 #define KPF_UNEVICTABLE         18
+#define KPF_HWPOISON            19
 #define KPF_NOPAGE              20
 #define KPF_KSM                 21
@@ -180,6 +181,10 @@ static u64 get_uflags(struct page *page)
        u |= kpf_copy_bit(k, KPF_UNEVICTABLE,   PG_unevictable);
        u |= kpf_copy_bit(k, KPF_MLOCKED,       PG_mlocked);
+#ifdef CONFIG_MEMORY_FAILURE
+        u |= kpf_copy_bit(k, KPF_HWPOISON,      PG_hwpoison);
+#endif
 #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
        u |= kpf_copy_bit(k, KPF_UNCACHED,      PG_uncached);
 #endif
diff --git a/fs/romfs/storage.c b/fs/romfs/storage.c
index b3208adf8e71..71e2b4d50a0a 100644
--- a/fs/romfs/storage.c
+++ b/fs/romfs/storage.c
@@ -253,11 +253,11 @@ ssize_t romfs_dev_strnlen(struct super_block *sb,
 #ifdef CONFIG_ROMFS_ON_MTD
        if (sb->s_mtd)
-                return romfs_mtd_strnlen(sb, pos, limit);
+                return romfs_mtd_strnlen(sb, pos, maxlen);
 #endif
 #ifdef CONFIG_ROMFS_ON_BLOCK
        if (sb->s_bdev)
-                return romfs_blk_strnlen(sb, pos, limit);
+                return romfs_blk_strnlen(sb, pos, maxlen);
 #endif
        return -EIO;
 }
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 381854461b28..c2e30eea74dc 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -186,19 +186,37 @@ xfs_destroy_ioend(
 }
 /*
+ * If the end of the current ioend is beyond the current EOF,
+ * return the new EOF value, otherwise zero.
+ */
+STATIC xfs_fsize_t
+xfs_ioend_new_eof(
+        xfs_ioend_t             *ioend)
+{
+        xfs_inode_t             *ip = XFS_I(ioend->io_inode);
+        xfs_fsize_t             isize;
+        xfs_fsize_t             bsize;
+        bsize = ioend->io_offset + ioend->io_size;
+        isize = MAX(ip->i_size, ip->i_new_size);
+        isize = MIN(isize, bsize);
+        return isize > ip->i_d.di_size ? isize : 0;
+}
+/*
 * Update on-disk file size now that data has been written to disk.
 * The current in-memory file size is i_size.  If a write is beyond
 * eof i_new_size will be the intended file size until i_size is
 * updated.  If this write does not extend all the way to the valid
 * file size then restrict this update to the end of the write.
 */
 STATIC void
 xfs_setfilesize(
        xfs_ioend_t             *ioend)
 {
        xfs_inode_t             *ip = XFS_I(ioend->io_inode);
        xfs_fsize_t             isize;
-        xfs_fsize_t             bsize;
        ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG);
        ASSERT(ioend->io_type != IOMAP_READ);
@@ -206,16 +224,10 @@ xfs_setfilesize(
        if (unlikely(ioend->io_error))
                return;
-        bsize = ioend->io_offset + ioend->io_size;
        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        isize = xfs_ioend_new_eof(ioend);
-        isize = MAX(ip->i_size, ip->i_new_size);
+        if (isize) {
-        isize = MIN(isize, bsize);
-        if (ip->i_d.di_size < isize) {
                ip->i_d.di_size = isize;
-                ip->i_update_core = 1;
                xfs_mark_inode_dirty_sync(ip);
        }
@@ -404,10 +416,16 @@ xfs_submit_ioend_bio(
        struct bio      *bio)
 {
        atomic_inc(&ioend->io_remaining);
        bio->bi_private = ioend;
        bio->bi_end_io = xfs_end_bio;
+        /*
+         * If the I/O is beyond EOF we mark the inode dirty immediately
+         * but don't update the inode size until I/O completion.
+         */
+        if (xfs_ioend_new_eof(ioend))
+                xfs_mark_inode_dirty_sync(XFS_I(ioend->io_inode));
        submit_bio(WRITE, bio);
        ASSERT(!bio_flagged(bio, BIO_EOPNOTSUPP));
        bio_put(bio);
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 629370974e57..eff61e2732af 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -176,14 +176,7 @@ xfs_file_fsync(
        struct dentry           *dentry,
        int                     datasync)
 {
-        struct inode            *inode = dentry->d_inode;
+        struct xfs_inode        *ip = XFS_I(dentry->d_inode);
-        struct xfs_inode        *ip = XFS_I(inode);
-        int                     error;
-        /* capture size updates in I/O completion before writing the inode. */
-        error = filemap_fdatawait(inode->i_mapping);
-        if (error)
-                return error;
        xfs_iflags_clear(ip, XFS_ITRUNCATED);
        return -xfs_fsync(ip);
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index da0159d99f82..cd42ef78f6b5 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -57,19 +57,22 @@
 #include <linux/fiemap.h>
 /*
- * Bring the atime in the XFS inode uptodate.
+ * Bring the timestamps in the XFS inode uptodate.
- * Used before logging the inode to disk or when the Linux inode goes away.
+ *
+ * Used before writing the inode to disk.
 */
 void
-xfs_synchronize_atime(
+xfs_synchronize_times(
        xfs_inode_t     *ip)
 {
        struct inode    *inode = VFS_I(ip);
-        if (!(inode->i_state & I_CLEAR)) {
+        ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
-                ip->i_d.di_atime.t_sec = (__int32_t)inode->i_atime.tv_sec;
+        ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
-                ip->i_d.di_atime.t_nsec = (__int32_t)inode->i_atime.tv_nsec;
+        ip->i_d.di_ctime.t_sec = (__int32_t)inode->i_ctime.tv_sec;
-        }
+        ip->i_d.di_ctime.t_nsec = (__int32_t)inode->i_ctime.tv_nsec;
+        ip->i_d.di_mtime.t_sec = (__int32_t)inode->i_mtime.tv_sec;
+        ip->i_d.di_mtime.t_nsec = (__int32_t)inode->i_mtime.tv_nsec;
 }
 /*
@@ -106,32 +109,20 @@ xfs_ichgtime(
        if ((flags & XFS_ICHGTIME_MOD) &&
            !timespec_equal(&inode->i_mtime, &tv)) {
                inode->i_mtime = tv;
-                ip->i_d.di_mtime.t_sec = (__int32_t)tv.tv_sec;
-                ip->i_d.di_mtime.t_nsec = (__int32_t)tv.tv_nsec;
                sync_it = 1;
        }
        if ((flags & XFS_ICHGTIME_CHG) &&
            !timespec_equal(&inode->i_ctime, &tv)) {
                inode->i_ctime = tv;
-                ip->i_d.di_ctime.t_sec = (__int32_t)tv.tv_sec;
-                ip->i_d.di_ctime.t_nsec = (__int32_t)tv.tv_nsec;
                sync_it = 1;
        }
        /*
-         * We update the i_update_core field _after_ changing
+         * Update complete - now make sure everyone knows that the inode
-         * the timestamps in order to coordinate properly with
+         * is dirty.
-         * xfs_iflush() so that we don't lose timestamp updates.
-         * This keeps us from having to hold the inode lock
-         * while doing this.  We use the SYNCHRONIZE macro to
-         * ensure that the compiler does not reorder the update
-         * of i_update_core above the timestamp updates above.
         */
-        if (sync_it) {
+        if (sync_it)
-                SYNCHRONIZE();
-                ip->i_update_core = 1;
                xfs_mark_inode_dirty_sync(ip);
-        }
 }
 /*
@@ -506,10 +497,8 @@ xfs_vn_getattr(
        stat->gid = ip->i_d.di_gid;
        stat->ino = ip->i_ino;
        stat->atime = inode->i_atime;
-        stat->mtime.tv_sec = ip->i_d.di_mtime.t_sec;
+        stat->mtime = inode->i_mtime;
-        stat->mtime.tv_nsec = ip->i_d.di_mtime.t_nsec;
+        stat->ctime = inode->i_ctime;
-        stat->ctime.tv_sec = ip->i_d.di_ctime.t_sec;
-        stat->ctime.tv_nsec = ip->i_d.di_ctime.t_nsec;
        stat->blocks =
                XFS_FSB_TO_BB(mp, ip->i_d.di_nblocks + ip->i_delayed_blks);
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index 49e4a6aea73c..072050f8d346 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -667,7 +667,7 @@ start:
                xip->i_new_size = new_size;
        if (likely(!(ioflags & IO_INVIS)))
-                xfs_ichgtime(xip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+                file_update_time(file);
        /*
         * If the offset is beyond the size of the file, we have a couple
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index bdd41c8c342f..18a4b8e11df2 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -977,6 +977,28 @@ xfs_fs_inode_init_once(
 }
 /*
+ * Dirty the XFS inode when mark_inode_dirty_sync() is called so that
+ * we catch unlogged VFS level updates to the inode. Care must be taken
+ * here - the transaction code calls mark_inode_dirty_sync() to mark the
+ * VFS inode dirty in a transaction and clears the i_update_core field;
+ * it must clear the field after calling mark_inode_dirty_sync() to
+ * correctly indicate that the dirty state has been propagated into the
+ * inode log item.
+ *
+ * We need the barrier() to maintain correct ordering between unlogged
+ * updates and the transaction commit code that clears the i_update_core
+ * field. This requires all updates to be completed before marking the
+ * inode dirty.
+ */
+STATIC void
+xfs_fs_dirty_inode(
+        struct inode    *inode)
+{
+        barrier();
+        XFS_I(inode)->i_update_core = 1;
+}
+/*
 * Attempt to flush the inode, this will actually fail
 * if the inode is pinned, but we dirty the inode again
 * at the point when it is unpinned after a log write,
@@ -1126,7 +1148,7 @@ xfs_fs_put_super(
 }
 STATIC int
-xfs_fs_sync_super(
+xfs_fs_sync_fs(
        struct super_block      *sb,
        int                     wait)
 {
@@ -1134,23 +1156,23 @@ xfs_fs_sync_super(
        int                     error;
        /*
-         * Treat a sync operation like a freeze.  This is to work
+         * Not much we can do for the first async pass.  Writing out the
-         * around a race in sync_inodes() which works in two phases
+         * superblock would be counter-productive as we are going to redirty
-         * - an asynchronous flush, which can write out an inode
+         * when writing out other data and metadata (and writing out a single
-         * without waiting for file size updates to complete, and a
+         * block is quite fast anyway).
-         * synchronous flush, which wont do anything because the
+         *
-         * async flush removed the inode's dirty flag.  Also
+         * Try to asynchronously kick off quota syncing at least.
-         * sync_inodes() will not see any files that just have
-         * outstanding transactions to be flushed because we don't
-         * dirty the Linux inode until after the transaction I/O
-         * completes.
         */
-        if (wait || unlikely(sb->s_frozen == SB_FREEZE_WRITE))
+        if (!wait) {
-                error = xfs_quiesce_data(mp);
+                xfs_qm_sync(mp, SYNC_TRYLOCK);
-        else
+                return 0;
-                error = xfs_sync_fsdata(mp, 0);
+        }
+        error = xfs_quiesce_data(mp);
+        if (error)
+                return -error;
-        if (unlikely(laptop_mode)) {
+        if (laptop_mode) {
                int     prev_sync_seq = mp->m_sync_seq;
                /*
@@ -1169,7 +1191,7 @@ xfs_fs_sync_super(
                                mp->m_sync_seq != prev_sync_seq);
        }
-        return -error;
+        return 0;
 }
 STATIC int
@@ -1539,10 +1561,11 @@ xfs_fs_get_sb(
 static const struct super_operations xfs_super_operations = {
        .alloc_inode            = xfs_fs_alloc_inode,
        .destroy_inode          = xfs_fs_destroy_inode,
+        .dirty_inode            = xfs_fs_dirty_inode,
        .write_inode            = xfs_fs_write_inode,
        .clear_inode            = xfs_fs_clear_inode,
        .put_super              = xfs_fs_put_super,
-        .sync_fs                = xfs_fs_sync_super,
+        .sync_fs                = xfs_fs_sync_fs,
        .freeze_fs              = xfs_fs_freeze,
        .statfs                 = xfs_fs_statfs,
        .remount_fs             = xfs_fs_remount,
diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
index 320be6aea492..961df0a22c78 100644
--- a/fs/xfs/linux-2.6/xfs_sync.c
+++ b/fs/xfs/linux-2.6/xfs_sync.c
@@ -309,11 +309,15 @@ xfs_sync_attr(
 STATIC int
 xfs_commit_dummy_trans(
        struct xfs_mount        *mp,
-        uint                    log_flags)
+        uint                    flags)
 {
        struct xfs_inode        *ip = mp->m_rootip;
        struct xfs_trans        *tp;
        int                     error;
+        int                     log_flags = XFS_LOG_FORCE;
+        if (flags & SYNC_WAIT)
+                log_flags |= XFS_LOG_SYNC;
        /*
         * Put a dummy transaction in the log to tell recovery
@@ -331,13 +335,12 @@ xfs_commit_dummy_trans(
        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
        xfs_trans_ihold(tp, ip);
        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-        /* XXX(hch): ignoring the error here.. */
        error = xfs_trans_commit(tp, 0);
        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+        /* the log force ensures this transaction is pushed to disk */
        xfs_log_force(mp, 0, log_flags);
-        return 0;
+        return error;
 }
 int
@@ -385,7 +388,20 @@ xfs_sync_fsdata(
        else
                XFS_BUF_ASYNC(bp);
-        return xfs_bwrite(mp, bp);
+        error = xfs_bwrite(mp, bp);
+        if (error)
+                return error;
+        /*
+         * If this is a data integrity sync make sure all pending buffers
+         * are flushed out for the log coverage check below.
+         */
+        if (flags & SYNC_WAIT)
+                xfs_flush_buftarg(mp->m_ddev_targp, 1);
+        if (xfs_log_need_covered(mp))
+                error = xfs_commit_dummy_trans(mp, flags);
+        return error;
 out_brelse:
        xfs_buf_relse(bp);
@@ -419,14 +435,16 @@ xfs_quiesce_data(
        /* push non-blocking */
        xfs_sync_data(mp, 0);
        xfs_qm_sync(mp, SYNC_TRYLOCK);
-        xfs_filestream_flush(mp);
-        /* push and block */
+        /* push and block till complete */
        xfs_sync_data(mp, SYNC_WAIT);
        xfs_qm_sync(mp, SYNC_WAIT);
+        /* drop inode references pinned by filestreams */
+        xfs_filestream_flush(mp);
        /* write superblock and hoover up shutdown errors */
-        error = xfs_sync_fsdata(mp, 0);
+        error = xfs_sync_fsdata(mp, SYNC_WAIT);
        /* flush data-only devices */
        if (mp->m_rtdev_targp)
@@ -570,8 +588,6 @@ xfs_sync_worker(
                /* dgc: errors ignored here */
                error = xfs_qm_sync(mp, SYNC_TRYLOCK);
                error = xfs_sync_fsdata(mp, SYNC_TRYLOCK);
-                if (xfs_log_need_covered(mp))
-                        error = xfs_commit_dummy_trans(mp, XFS_LOG_FORCE);
        }
        mp->m_sync_seq++;
        wake_up(&mp->m_wait_single_sync_task);
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index 7465f9ee125f..ab89a7e94a0f 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -206,10 +206,10 @@ xfs_swap_extents(
         * process that the file was not changed out from
         * under it.
         */
-        if ((sbp->bs_ctime.tv_sec != ip->i_d.di_ctime.t_sec) ||
+        if ((sbp->bs_ctime.tv_sec != VFS_I(ip)->i_ctime.tv_sec) ||
-            (sbp->bs_ctime.tv_nsec != ip->i_d.di_ctime.t_nsec) ||
+            (sbp->bs_ctime.tv_nsec != VFS_I(ip)->i_ctime.tv_nsec) ||
-            (sbp->bs_mtime.tv_sec != ip->i_d.di_mtime.t_sec) ||
+            (sbp->bs_mtime.tv_sec != VFS_I(ip)->i_mtime.tv_sec) ||
-            (sbp->bs_mtime.tv_nsec != ip->i_d.di_mtime.t_nsec)) {
+            (sbp->bs_mtime.tv_nsec != VFS_I(ip)->i_mtime.tv_nsec)) {
                error = XFS_ERROR(EBUSY);
                goto out_unlock;
        }
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index fa913e459442..41ad537c49e9 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -854,6 +854,7 @@ xfs_dir2_leaf_getdents(
                         */
                        ra_want = howmany(bufsize + mp->m_dirblksize,
                                          mp->m_sb.sb_blocksize) - 1;
+                        ASSERT(ra_want >= 0);
                        /*
                         * If we don't have as many as we want, and we haven't
@@ -1088,7 +1089,8 @@ xfs_dir2_leaf_getdents(
                 */
                ptr += length;
                curoff += length;
-                bufsize -= length;
+                /* bufsize may have just been a guess; don't go negative */
+                bufsize = bufsize > length ? bufsize - length : 0;
        }
        /*
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index c1dc7ef5a1d8..b92a4fa2a0a1 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -3068,9 +3068,9 @@ xfs_iflush_int(
        SYNCHRONIZE();
        /*
-         * Make sure to get the latest atime from the Linux inode.
+         * Make sure to get the latest timestamps from the Linux inode.
         */
-        xfs_synchronize_atime(ip);
+        xfs_synchronize_times(ip);
        if (XFS_TEST_ERROR(be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC,
                               mp, XFS_ERRTAG_IFLUSH_1, XFS_RANDOM_IFLUSH_1)) {
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 0b38b9a869ec..41555de1d1db 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -504,7 +504,7 @@ void		xfs_ichgtime(xfs_inode_t *, int);
 void            xfs_lock_inodes(xfs_inode_t **, int, uint);
 void            xfs_lock_two_inodes(xfs_inode_t *, xfs_inode_t *, uint);
-void            xfs_synchronize_atime(xfs_inode_t *);
+void            xfs_synchronize_times(xfs_inode_t *);
 void            xfs_mark_inode_dirty_sync(xfs_inode_t *);
 #if defined(XFS_INODE_TRACE)
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 47d5b663c37e..9794b876d6ff 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -232,6 +232,15 @@ xfs_inode_item_format(
        nvecs        = 1;
        /*
+         * Make sure the linux inode is dirty. We do this before
+         * clearing i_update_core as the VFS will call back into
+         * XFS here and set i_update_core, so we need to dirty the
+         * inode first so that the ordering of i_update_core and
+         * unlogged modifications still works as described below.
+         */
+        xfs_mark_inode_dirty_sync(ip);
+        /*
         * Clear i_update_core if the timestamps (or any other
         * non-transactional modification) need flushing/logging
         * and we're about to log them with the rest of the core.
@@ -263,14 +272,9 @@ xfs_inode_item_format(
        }
        /*
-         * Make sure to get the latest atime from the Linux inode.
+         * Make sure to get the latest timestamps from the Linux inode.
         */
-        xfs_synchronize_atime(ip);
+        xfs_synchronize_times(ip);
-        /*
-         * make sure the linux inode is dirty
-         */
-        xfs_mark_inode_dirty_sync(ip);
        vecp->i_addr = (xfs_caddr_t)&ip->i_d;
        vecp->i_len  = sizeof(struct xfs_icdinode);
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index b68f9107e26c..62efab2f3839 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -59,6 +59,7 @@ xfs_bulkstat_one_iget(
 {
        xfs_icdinode_t  *dic;   /* dinode core info pointer */
        xfs_inode_t     *ip;            /* incore inode pointer */
+        struct inode    *inode;
        int             error;
        error = xfs_iget(mp, NULL, ino,
@@ -72,6 +73,7 @@ xfs_bulkstat_one_iget(
        ASSERT(ip->i_imap.im_blkno != 0);
        dic = &ip->i_d;
+        inode = VFS_I(ip);
        /* xfs_iget returns the following without needing
         * further change.
@@ -83,16 +85,19 @@ xfs_bulkstat_one_iget(
        buf->bs_uid = dic->di_uid;
        buf->bs_gid = dic->di_gid;
        buf->bs_size = dic->di_size;
        /*
-         * We are reading the atime from the Linux inode because the
+         * We need to read the timestamps from the Linux inode because
-         * dinode might not be uptodate.
+         * the VFS keeps writing directly into the inode structure instead
+         * of telling us about the updates.
         */
-        buf->bs_atime.tv_sec = VFS_I(ip)->i_atime.tv_sec;
+        buf->bs_atime.tv_sec = inode->i_atime.tv_sec;
-        buf->bs_atime.tv_nsec = VFS_I(ip)->i_atime.tv_nsec;
+        buf->bs_atime.tv_nsec = inode->i_atime.tv_nsec;
-        buf->bs_mtime.tv_sec = dic->di_mtime.t_sec;
+        buf->bs_mtime.tv_sec = inode->i_mtime.tv_sec;
-        buf->bs_mtime.tv_nsec = dic->di_mtime.t_nsec;
+        buf->bs_mtime.tv_nsec = inode->i_mtime.tv_nsec;
-        buf->bs_ctime.tv_sec = dic->di_ctime.t_sec;
+        buf->bs_ctime.tv_sec = inode->i_ctime.tv_sec;
-        buf->bs_ctime.tv_nsec = dic->di_ctime.t_nsec;
+        buf->bs_ctime.tv_nsec = inode->i_ctime.tv_nsec;
        buf->bs_xflags = xfs_ip2xflags(ip);
        buf->bs_extsize = dic->di_extsize << mp->m_sb.sb_blocklog;
        buf->bs_extents = dic->di_nextents;
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index a434f287962d..b572f7e840e0 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -2476,12 +2476,6 @@ xfs_reclaim(
        ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
        /*
-         * Make sure the atime in the XFS inode is correct before freeing the
-         * Linux inode.
-         */
-        xfs_synchronize_atime(ip);
-        /*
         * If we have nothing to flush with this inode then complete the
         * teardown now, otherwise break the link between the xfs inode and the
         * linux inode and clean up the xfs inode later. This avoids flushing