1 files changed, 141 insertions, 178 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 61b16c641ce0..f6ab6f5e635a 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -89,7 +89,7 @@ static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
 
 static int btrfs_setsize(struct inode *inode, loff_t newsize);
 static int btrfs_truncate(struct inode *inode);
-static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end);
+static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent);
 static noinline int cow_file_range(struct inode *inode,
                                    struct page *locked_page,
                                    u64 start, u64 end, int *page_started,
@@ -257,10 +257,13 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,
         ret = insert_inline_extent(trans, root, inode, start,
                                    inline_len, compressed_size,
                                    compress_type, compressed_pages);
-        if (ret) {
+        if (ret && ret != -ENOSPC) {
                 btrfs_abort_transaction(trans, root, ret);
                 return ret;
+        } else if (ret == -ENOSPC) {
+                return 1;
         }
+
         btrfs_delalloc_release_metadata(inode, end + 1 - start);
         btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);
         return 0;
@@ -1572,11 +1575,11 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
         if (btrfs_is_free_space_inode(root, inode))
                 metadata = 2;
 
-        ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
-        if (ret)
-                return ret;
-
         if (!(rw & REQ_WRITE)) {
+                ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata);
+                if (ret)
+                        return ret;
+
                 if (bio_flags & EXTENT_BIO_COMPRESSED) {
                         return btrfs_submit_compressed_read(inode, bio,
                                                     mirror_num, bio_flags);
@@ -1815,25 +1818,24 @@ out:
  * an ordered extent if the range of bytes in the file it covers are
  * fully written.
  */
-static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
+static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
 {
+        struct inode *inode = ordered_extent->inode;
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans = NULL;
-        struct btrfs_ordered_extent *ordered_extent = NULL;
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct extent_state *cached_state = NULL;
         int compress_type = 0;
         int ret;
         bool nolock;
 
-        ret = btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
-                                             end - start + 1);
-        if (!ret)
-                return 0;
-        BUG_ON(!ordered_extent); /* Logic error */
-
         nolock = btrfs_is_free_space_inode(root, inode);
 
+        if (test_bit(BTRFS_ORDERED_IOERR, &ordered_extent->flags)) {
+                ret = -EIO;
+                goto out;
+        }
+
         if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
                 BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */
                 ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
@@ -1889,12 +1891,10 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
                                    ordered_extent->file_offset,
                                    ordered_extent->len);
         }
-        unlock_extent_cached(io_tree, ordered_extent->file_offset,
-                             ordered_extent->file_offset +
-                             ordered_extent->len - 1, &cached_state, GFP_NOFS);
+
         if (ret < 0) {
                 btrfs_abort_transaction(trans, root, ret);
-                goto out;
+                goto out_unlock;
         }
 
         add_pending_csums(trans, inode, ordered_extent->file_offset,
@@ -1905,10 +1905,14 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
                 ret = btrfs_update_inode_fallback(trans, root, inode);
                 if (ret) { /* -ENOMEM or corruption */
                         btrfs_abort_transaction(trans, root, ret);
-                        goto out;
+                        goto out_unlock;
                 }
         }
         ret = 0;
+out_unlock:
+        unlock_extent_cached(io_tree, ordered_extent->file_offset,
+                             ordered_extent->file_offset +
+                             ordered_extent->len - 1, &cached_state, GFP_NOFS);
 out:
         if (root != root->fs_info->tree_root)
                 btrfs_delalloc_release_metadata(inode, ordered_extent->len);
@@ -1919,26 +1923,57 @@ out:
                         btrfs_end_transaction(trans, root);
         }
 
+        if (ret)
+                clear_extent_uptodate(io_tree, ordered_extent->file_offset,
+                                      ordered_extent->file_offset +
+                                      ordered_extent->len - 1, NULL, GFP_NOFS);
+
+        /*
+         * This needs to be dont to make sure anybody waiting knows we are done
+         * upating everything for this ordered extent.
+         */
+        btrfs_remove_ordered_extent(inode, ordered_extent);
+
         /* once for us */
         btrfs_put_ordered_extent(ordered_extent);
         /* once for the tree */
         btrfs_put_ordered_extent(ordered_extent);
 
-        return 0;
-out_unlock:
-        unlock_extent_cached(io_tree, ordered_extent->file_offset,
-                             ordered_extent->file_offset +
-                             ordered_extent->len - 1, &cached_state, GFP_NOFS);
-        goto out;
+        return ret;
+}
+
+static void finish_ordered_fn(struct btrfs_work *work)
+{
+        struct btrfs_ordered_extent *ordered_extent;
+        ordered_extent = container_of(work, struct btrfs_ordered_extent, work);
+        btrfs_finish_ordered_io(ordered_extent);
 }
 
 static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
                                 struct extent_state *state, int uptodate)
 {
+        struct inode *inode = page->mapping->host;
+        struct btrfs_root *root = BTRFS_I(inode)->root;
+        struct btrfs_ordered_extent *ordered_extent = NULL;
+        struct btrfs_workers *workers;
+
         trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
 
         ClearPagePrivate2(page);
-        return btrfs_finish_ordered_io(page->mapping->host, start, end);
+        if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
+                                            end - start + 1, uptodate))
+                return 0;
+
+        ordered_extent->work.func = finish_ordered_fn;
+        ordered_extent->work.flags = 0;
+
+        if (btrfs_is_free_space_inode(root, inode))
+                workers = &root->fs_info->endio_freespace_worker;
+        else
+                workers = &root->fs_info->endio_write_workers;
+        btrfs_queue_worker(workers, &ordered_extent->work);
+
+        return 0;
 }
 
 /*
@@ -2072,12 +2107,12 @@ void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans,
         struct btrfs_block_rsv *block_rsv;
         int ret;
 
-        if (!list_empty(&root->orphan_list) ||
+        if (atomic_read(&root->orphan_inodes) ||
             root->orphan_cleanup_state != ORPHAN_CLEANUP_DONE)
                 return;
 
         spin_lock(&root->orphan_lock);
-        if (!list_empty(&root->orphan_list)) {
+        if (atomic_read(&root->orphan_inodes)) {
                 spin_unlock(&root->orphan_lock);
                 return;
         }
@@ -2134,8 +2169,8 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
                 block_rsv = NULL;
         }
 
-        if (list_empty(&BTRFS_I(inode)->i_orphan)) {
-                list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
+        if (!test_and_set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
+                              &BTRFS_I(inode)->runtime_flags)) {
 #if 0
                 /*
                  * For proper ENOSPC handling, we should do orphan
@@ -2148,12 +2183,12 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
                         insert = 1;
 #endif
                 insert = 1;
+                atomic_dec(&root->orphan_inodes);
         }
 
-        if (!BTRFS_I(inode)->orphan_meta_reserved) {
-                BTRFS_I(inode)->orphan_meta_reserved = 1;
+        if (!test_and_set_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
+                              &BTRFS_I(inode)->runtime_flags))
                 reserve = 1;
-        }
         spin_unlock(&root->orphan_lock);
 
         /* grab metadata reservation from transaction handle */
@@ -2166,6 +2201,8 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
         if (insert >= 1) {
                 ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode));
                 if (ret && ret != -EEXIST) {
+                        clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
+                                  &BTRFS_I(inode)->runtime_flags);
                         btrfs_abort_transaction(trans, root, ret);
                         return ret;
                 }
@@ -2196,15 +2233,13 @@ int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
         int ret = 0;
 
         spin_lock(&root->orphan_lock);
-        if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
-                list_del_init(&BTRFS_I(inode)->i_orphan);
+        if (test_and_clear_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
+                               &BTRFS_I(inode)->runtime_flags))
                 delete_item = 1;
-        }
 
-        if (BTRFS_I(inode)->orphan_meta_reserved) {
-                BTRFS_I(inode)->orphan_meta_reserved = 0;
+        if (test_and_clear_bit(BTRFS_INODE_ORPHAN_META_RESERVED,
+                               &BTRFS_I(inode)->runtime_flags))
                 release_rsv = 1;
-        }
         spin_unlock(&root->orphan_lock);
 
         if (trans && delete_item) {
@@ -2212,8 +2247,10 @@ int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode)
                 BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
         }
 
-        if (release_rsv)
+        if (release_rsv) {
                 btrfs_orphan_release_metadata(inode);
+                atomic_dec(&root->orphan_inodes);
+        }
 
         return 0;
 }
@@ -2341,6 +2378,8 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)
                                 ret = PTR_ERR(trans);
                                 goto out;
                         }
+                        printk(KERN_ERR "auto deleting %Lu\n",
+                               found_key.objectid);
                         ret = btrfs_del_orphan_item(trans, root,
                                                     found_key.objectid);
                         BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */
@@ -2352,9 +2391,8 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)
                  * add this inode to the orphan list so btrfs_orphan_del does
                  * the proper thing when we hit it
                  */
-                spin_lock(&root->orphan_lock);
-                list_add(&BTRFS_I(inode)->i_orphan, &root->orphan_list);
-                spin_unlock(&root->orphan_lock);
+                set_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
+                        &BTRFS_I(inode)->runtime_flags);
 
                 /* if we have links, this was a truncate, lets do that */
                 if (inode->i_nlink) {
@@ -2510,7 +2548,7 @@ static void btrfs_read_locked_inode(struct inode *inode)
 
         inode_set_bytes(inode, btrfs_inode_nbytes(leaf, inode_item));
         BTRFS_I(inode)->generation = btrfs_inode_generation(leaf, inode_item);
-        BTRFS_I(inode)->sequence = btrfs_inode_sequence(leaf, inode_item);
+        inode->i_version = btrfs_inode_sequence(leaf, inode_item);
         inode->i_generation = BTRFS_I(inode)->generation;
         inode->i_rdev = 0;
         rdev = btrfs_inode_rdev(leaf, inode_item);
@@ -2594,7 +2632,7 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
 
         btrfs_set_inode_nbytes(leaf, item, inode_get_bytes(inode));
         btrfs_set_inode_generation(leaf, item, BTRFS_I(inode)->generation);
-        btrfs_set_inode_sequence(leaf, item, BTRFS_I(inode)->sequence);
+        btrfs_set_inode_sequence(leaf, item, inode->i_version);
         btrfs_set_inode_transid(leaf, item, trans->transid);
         btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
         btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
@@ -2752,6 +2790,8 @@ err:
                 goto out;
 
         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
+        inode_inc_iversion(inode);
+        inode_inc_iversion(dir);
         inode->i_ctime = dir->i_mtime = dir->i_ctime = CURRENT_TIME;
         btrfs_update_inode(trans, root, dir);
 out:
@@ -3089,6 +3129,7 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans,
         }
 
         btrfs_i_size_write(dir, dir->i_size - name_len * 2);
+        inode_inc_iversion(dir);
         dir->i_mtime = dir->i_ctime = CURRENT_TIME;
         ret = btrfs_update_inode(trans, root, dir);
         if (ret)
@@ -3607,7 +3648,8 @@ static int btrfs_setsize(struct inode *inode, loff_t newsize)
                  * any new writes get down to disk quickly.
                  */
                 if (newsize == 0)
-                        BTRFS_I(inode)->ordered_data_close = 1;
+                        set_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
+                                &BTRFS_I(inode)->runtime_flags);
 
                 /* we don't support swapfiles, so vmtruncate shouldn't fail */
                 truncate_setsize(inode, newsize);
@@ -3638,6 +3680,7 @@ static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
 
         if (attr->ia_valid) {
                 setattr_copy(inode, attr);
+                inode_inc_iversion(inode);
                 err = btrfs_dirty_inode(inode);
 
                 if (!err && attr->ia_valid & ATTR_MODE)
@@ -3671,7 +3714,8 @@ void btrfs_evict_inode(struct inode *inode)
         btrfs_wait_ordered_range(inode, 0, (u64)-1);
 
         if (root->fs_info->log_root_recovering) {
-                BUG_ON(!list_empty(&BTRFS_I(inode)->i_orphan));
+                BUG_ON(!test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
+                                 &BTRFS_I(inode)->runtime_flags));
                 goto no_delete;
         }
 
@@ -3756,7 +3800,7 @@ void btrfs_evict_inode(struct inode *inode)
         btrfs_end_transaction(trans, root);
         btrfs_btree_balance_dirty(root, nr);
 no_delete:
-        end_writeback(inode);
+        clear_inode(inode);
         return;
 }
 
@@ -4066,7 +4110,7 @@ static struct inode *new_simple_dir(struct super_block *s,
 
         BTRFS_I(inode)->root = root;
         memcpy(&BTRFS_I(inode)->location, key, sizeof(*key));
-        BTRFS_I(inode)->dummy_inode = 1;
+        set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
 
         inode->i_ino = BTRFS_EMPTY_SUBVOL_DIR_OBJECTID;
         inode->i_op = &btrfs_dir_ro_inode_operations;
@@ -4370,7 +4414,7 @@ int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
         int ret = 0;
         bool nolock = false;
 
-        if (BTRFS_I(inode)->dummy_inode)
+        if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
                 return 0;
 
         if (btrfs_fs_closing(root->fs_info) && btrfs_is_free_space_inode(root, inode))
@@ -4403,7 +4447,7 @@ int btrfs_dirty_inode(struct inode *inode)
         struct btrfs_trans_handle *trans;
         int ret;
 
-        if (BTRFS_I(inode)->dummy_inode)
+        if (test_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags))
                 return 0;
 
         trans = btrfs_join_transaction(root);
@@ -4431,46 +4475,18 @@ int btrfs_dirty_inode(struct inode *inode)
  * This is a copy of file_update_time.  We need this so we can return error on
  * ENOSPC for updating the inode in the case of file write and mmap writes.
  */
-int btrfs_update_time(struct file *file)
+static int btrfs_update_time(struct inode *inode, struct timespec *now,
+                             int flags)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
-        struct timespec now;
-        int ret;
-        enum { S_MTIME = 1, S_CTIME = 2, S_VERSION = 4 } sync_it = 0;
-
-        /* First try to exhaust all avenues to not sync */
-        if (IS_NOCMTIME(inode))
-                return 0;
-
-        now = current_fs_time(inode->i_sb);
-        if (!timespec_equal(&inode->i_mtime, &now))
-                sync_it = S_MTIME;
-
-        if (!timespec_equal(&inode->i_ctime, &now))
-                sync_it |= S_CTIME;
-
-        if (IS_I_VERSION(inode))
-                sync_it |= S_VERSION;
-
-        if (!sync_it)
-                return 0;
-
-        /* Finally allowed to write? Takes lock. */
-        if (mnt_want_write_file(file))
-                return 0;
-
-        /* Only change inode inside the lock region */
-        if (sync_it & S_VERSION)
+        if (flags & S_VERSION)
                 inode_inc_iversion(inode);
-        if (sync_it & S_CTIME)
-                inode->i_ctime = now;
-        if (sync_it & S_MTIME)
-                inode->i_mtime = now;
-        ret = btrfs_dirty_inode(inode);
-        if (!ret)
-                mark_inode_dirty_sync(inode);
-        mnt_drop_write(file->f_path.mnt);
-        return ret;
+        if (flags & S_CTIME)
+                inode->i_ctime = *now;
+        if (flags & S_MTIME)
+                inode->i_mtime = *now;
+        if (flags & S_ATIME)
+                inode->i_atime = *now;
+        return btrfs_dirty_inode(inode);
 }
 
 /*
@@ -4730,6 +4746,7 @@ int btrfs_add_link(struct btrfs_trans_handle *trans,
 
         btrfs_i_size_write(parent_inode, parent_inode->i_size +
                            name_len * 2);
+        inode_inc_iversion(parent_inode);
         parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
         ret = btrfs_update_inode(trans, root, parent_inode);
         if (ret)
@@ -4937,6 +4954,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
         }
 
         btrfs_inc_nlink(inode);
+        inode_inc_iversion(inode);
         inode->i_ctime = CURRENT_TIME;
         ihold(inode);
 
@@ -5903,9 +5921,7 @@ static void btrfs_endio_direct_write(struct bio *bio, int err)
         struct btrfs_dio_private *dip = bio->bi_private;
         struct inode *inode = dip->inode;
         struct btrfs_root *root = BTRFS_I(inode)->root;
-        struct btrfs_trans_handle *trans;
         struct btrfs_ordered_extent *ordered = NULL;
-        struct extent_state *cached_state = NULL;
         u64 ordered_offset = dip->logical_offset;
         u64 ordered_bytes = dip->bytes;
         int ret;
@@ -5915,73 +5931,14 @@ static void btrfs_endio_direct_write(struct bio *bio, int err)
 again:
         ret = btrfs_dec_test_first_ordered_pending(inode, &ordered,
                                                    &ordered_offset,
-                                                   ordered_bytes);
+                                                   ordered_bytes, !err);
         if (!ret)
                 goto out_test;
 
-        BUG_ON(!ordered);
-
-        trans = btrfs_join_transaction(root);
-        if (IS_ERR(trans)) {
-                err = -ENOMEM;
-                goto out;
-        }
-        trans->block_rsv = &root->fs_info->delalloc_block_rsv;
-
-        if (test_bit(BTRFS_ORDERED_NOCOW, &ordered->flags)) {
-                ret = btrfs_ordered_update_i_size(inode, 0, ordered);
-                if (!ret)
-                        err = btrfs_update_inode_fallback(trans, root, inode);
-                goto out;
-        }
-
-        lock_extent_bits(&BTRFS_I(inode)->io_tree, ordered->file_offset,
-                         ordered->file_offset + ordered->len - 1, 0,
-                         &cached_state);
-
-        if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags)) {
-                ret = btrfs_mark_extent_written(trans, inode,
-                                                ordered->file_offset,
-                                                ordered->file_offset +
-                                                ordered->len);
-                if (ret) {
-                        err = ret;
-                        goto out_unlock;
-                }
-        } else {
-                ret = insert_reserved_file_extent(trans, inode,
-                                                  ordered->file_offset,
-                                                  ordered->start,
-                                                  ordered->disk_len,
-                                                  ordered->len,
-                                                  ordered->len,
-                                                  0, 0, 0,
-                                                  BTRFS_FILE_EXTENT_REG);
-                unpin_extent_cache(&BTRFS_I(inode)->extent_tree,
-                                   ordered->file_offset, ordered->len);
-                if (ret) {
-                        err = ret;
-                        WARN_ON(1);
-                        goto out_unlock;
-                }
-        }
-
-        add_pending_csums(trans, inode, ordered->file_offset, &ordered->list);
-        ret = btrfs_ordered_update_i_size(inode, 0, ordered);
-        if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags))
-                btrfs_update_inode_fallback(trans, root, inode);
-        ret = 0;
-out_unlock:
-        unlock_extent_cached(&BTRFS_I(inode)->io_tree, ordered->file_offset,
-                             ordered->file_offset + ordered->len - 1,
-                             &cached_state, GFP_NOFS);
-out:
-        btrfs_delalloc_release_metadata(inode, ordered->len);
-        btrfs_end_transaction(trans, root);
-        ordered_offset = ordered->file_offset + ordered->len;
-        btrfs_put_ordered_extent(ordered);
-        btrfs_put_ordered_extent(ordered);
-
+        ordered->work.func = finish_ordered_fn;
+        ordered->work.flags = 0;
+        btrfs_queue_worker(&root->fs_info->endio_write_workers,
+                           &ordered->work);
 out_test:
         /*
          * our bio might span multiple ordered extents.  If we haven't
@@ -5990,12 +5947,12 @@ out_test:
         if (ordered_offset < dip->logical_offset + dip->bytes) {
                 ordered_bytes = dip->logical_offset + dip->bytes -
                         ordered_offset;
+                ordered = NULL;
                 goto again;
         }
 out_done:
         bio->bi_private = dip->private;
 
-        kfree(dip->csums);
         kfree(dip);
 
         /* If we had an error make sure to clear the uptodate flag */
@@ -6063,9 +6020,12 @@ static inline int __btrfs_submit_dio_bio(struct bio *bio, struct inode *inode,
         int ret;
 
         bio_get(bio);
-        ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
-        if (ret)
-                goto err;
+
+        if (!write) {
+                ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
+                if (ret)
+                        goto err;
+        }
 
         if (skip_sum)
                 goto map;
@@ -6485,13 +6445,13 @@ static int btrfs_releasepage(struct page *page, gfp_t gfp_flags)
 
 static void btrfs_invalidatepage(struct page *page, unsigned long offset)
 {
+        struct inode *inode = page->mapping->host;
         struct extent_io_tree *tree;
         struct btrfs_ordered_extent *ordered;
         struct extent_state *cached_state = NULL;
         u64 page_start = page_offset(page);
         u64 page_end = page_start + PAGE_CACHE_SIZE - 1;
 
-
         /*
          * we have the page locked, so new writeback can't start,
          * and the dirty bit won't be cleared while we are here.
@@ -6501,13 +6461,13 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset)
          */
         wait_on_page_writeback(page);
 
-        tree = &BTRFS_I(page->mapping->host)->io_tree;
+        tree = &BTRFS_I(inode)->io_tree;
         if (offset) {
                 btrfs_releasepage(page, GFP_NOFS);
                 return;
         }
         lock_extent_bits(tree, page_start, page_end, 0, &cached_state);
-        ordered = btrfs_lookup_ordered_extent(page->mapping->host,
+        ordered = btrfs_lookup_ordered_extent(inode,
                                            page_offset(page));
         if (ordered) {
                 /*
@@ -6522,9 +6482,10 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset)
                  * whoever cleared the private bit is responsible
                  * for the finish_ordered_io
                  */
-                if (TestClearPagePrivate2(page)) {
-                        btrfs_finish_ordered_io(page->mapping->host,
-                                                page_start, page_end);
+                if (TestClearPagePrivate2(page) &&
+                    btrfs_dec_test_ordered_pending(inode, &ordered, page_start,
+                                                   PAGE_CACHE_SIZE, 1)) {
+                        btrfs_finish_ordered_io(ordered);
                 }
                 btrfs_put_ordered_extent(ordered);
                 cached_state = NULL;
@@ -6576,7 +6537,7 @@ int btrfs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
 
         ret  = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE);
         if (!ret) {
-                ret = btrfs_update_time(vma->vm_file);
+                ret = file_update_time(vma->vm_file);
                 reserved = 1;
         }
         if (ret) {
@@ -6771,7 +6732,8 @@ static int btrfs_truncate(struct inode *inode)
          * using truncate to replace the contents of the file will
          * end up with a zero length file after a crash.
          */
-        if (inode->i_size == 0 && BTRFS_I(inode)->ordered_data_close)
+        if (inode->i_size == 0 && test_bit(BTRFS_INODE_ORDERED_DATA_CLOSE,
+                                           &BTRFS_I(inode)->runtime_flags))
                 btrfs_add_ordered_operation(trans, root, inode);
 
         while (1) {
@@ -6894,7 +6856,6 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         ei->root = NULL;
         ei->space_info = NULL;
         ei->generation = 0;
-        ei->sequence = 0;
         ei->last_trans = 0;
         ei->last_sub_trans = 0;
         ei->logged_trans = 0;
@@ -6909,11 +6870,7 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         ei->outstanding_extents = 0;
         ei->reserved_extents = 0;
 
-        ei->ordered_data_close = 0;
-        ei->orphan_meta_reserved = 0;
-        ei->dummy_inode = 0;
-        ei->in_defrag = 0;
-        ei->delalloc_meta_reserved = 0;
+        ei->runtime_flags = 0;
         ei->force_compress = BTRFS_COMPRESS_NONE;
 
         ei->delayed_node = NULL;
@@ -6927,7 +6884,6 @@ struct inode *btrfs_alloc_inode(struct super_block *sb)
         mutex_init(&ei->log_mutex);
         mutex_init(&ei->delalloc_mutex);
         btrfs_ordered_inode_tree_init(&ei->ordered_tree);
-        INIT_LIST_HEAD(&ei->i_orphan);
         INIT_LIST_HEAD(&ei->delalloc_inodes);
         INIT_LIST_HEAD(&ei->ordered_operations);
         RB_CLEAR_NODE(&ei->rb_node);
@@ -6972,13 +6928,12 @@ void btrfs_destroy_inode(struct inode *inode)
                 spin_unlock(&root->fs_info->ordered_extent_lock);
         }
 
-        spin_lock(&root->orphan_lock);
-        if (!list_empty(&BTRFS_I(inode)->i_orphan)) {
+        if (test_bit(BTRFS_INODE_HAS_ORPHAN_ITEM,
+                     &BTRFS_I(inode)->runtime_flags)) {
                 printk(KERN_INFO "BTRFS: inode %llu still on the orphan list\n",
                        (unsigned long long)btrfs_ino(inode));
-                list_del_init(&BTRFS_I(inode)->i_orphan);
+                atomic_dec(&root->orphan_inodes);
         }
-        spin_unlock(&root->orphan_lock);
 
         while (1) {
                 ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
@@ -7193,6 +7148,9 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (new_inode && new_inode->i_size && S_ISREG(old_inode->i_mode))
                 btrfs_add_ordered_operation(trans, root, old_inode);
 
+        inode_inc_iversion(old_dir);
+        inode_inc_iversion(new_dir);
+        inode_inc_iversion(old_inode);
         old_dir->i_ctime = old_dir->i_mtime = ctime;
         new_dir->i_ctime = new_dir->i_mtime = ctime;
         old_inode->i_ctime = ctime;
@@ -7219,6 +7177,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
         }
 
         if (new_inode) {
+                inode_inc_iversion(new_inode);
                 new_inode->i_ctime = CURRENT_TIME;
                 if (unlikely(btrfs_ino(new_inode) ==
                              BTRFS_EMPTY_SUBVOL_DIR_OBJECTID)) {
@@ -7490,6 +7449,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                 cur_offset += ins.offset;
                 *alloc_hint = ins.objectid + ins.offset;
 
+                inode_inc_iversion(inode);
                 inode->i_ctime = CURRENT_TIME;
                 BTRFS_I(inode)->flags |= BTRFS_INODE_PREALLOC;
                 if (!(mode & FALLOC_FL_KEEP_SIZE) &&
@@ -7647,6 +7607,7 @@ static const struct inode_operations btrfs_file_inode_operations = {
         .permission     = btrfs_permission,
         .fiemap         = btrfs_fiemap,
         .get_acl        = btrfs_get_acl,
+        .update_time    = btrfs_update_time,
 };
 static const struct inode_operations btrfs_special_inode_operations = {
         .getattr        = btrfs_getattr,
@@ -7657,6 +7618,7 @@ static const struct inode_operations btrfs_special_inode_operations = {
         .listxattr      = btrfs_listxattr,
         .removexattr    = btrfs_removexattr,
         .get_acl        = btrfs_get_acl,
+        .update_time    = btrfs_update_time,
 };
 static const struct inode_operations btrfs_symlink_inode_operations = {
         .readlink       = generic_readlink,
@@ -7670,6 +7632,7 @@ static const struct inode_operations btrfs_symlink_inode_operations = {
         .listxattr      = btrfs_listxattr,
         .removexattr    = btrfs_removexattr,
         .get_acl        = btrfs_get_acl,
+        .update_time    = btrfs_update_time,
 };
 
 const struct dentry_operations btrfs_dentry_operations = {