/*
   * Copyright (C) 2007 Oracle.  All rights reserved.
   *
   * This program is free software; you can redistribute it and/or
   * modify it under the terms of the GNU General Public
   * License v2 as published by the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * General Public License for more details.
   *
   * You should have received a copy of the GNU General Public
   * License along with this program; if not, write to the
   * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
   * Boston, MA 021110-1307, USA.
   */

  #include <linux/kernel.h>

  #include <linux/bio.h>

  #include <linux/buffer_head.h>

  #include <linux/file.h>

  #include <linux/fs.h>
  #include <linux/pagemap.h>
  #include <linux/highmem.h>
  #include <linux/time.h>
  #include <linux/init.h>
  #include <linux/string.h>

  #include <linux/backing-dev.h>
  #include <linux/mpage.h>
  #include <linux/swap.h>
  #include <linux/writeback.h>
  #include <linux/statfs.h>
  #include <linux/compat.h>

  #include <linux/bit_spinlock.h>

  #include <linux/xattr.h>

  #include <linux/posix_acl.h>

  #include <linux/falloc.h>

  #include <linux/slab.h>

  #include <linux/ratelimit.h>

  #include <linux/mount.h>

  #include "compat.h"

  #include "ctree.h"
  #include "disk-io.h"
  #include "transaction.h"
  #include "btrfs_inode.h"
  #include "ioctl.h"
  #include "print-tree.h"

  #include "ordered-data.h"

  #include "xattr.h"

  #include "tree-log.h"

  #include "volumes.h"

  #include "compression.h"

  #include "locking.h"

  #include "free-space-cache.h"

  #include "inode-map.h"

  
  struct btrfs_iget_args {
  	u64 ino;
  	struct btrfs_root *root;
  };

  static const struct inode_operations btrfs_dir_inode_operations;
  static const struct inode_operations btrfs_symlink_inode_operations;
  static const struct inode_operations btrfs_dir_ro_inode_operations;
  static const struct inode_operations btrfs_special_inode_operations;
  static const struct inode_operations btrfs_file_inode_operations;

  static const struct address_space_operations btrfs_aops;
  static const struct address_space_operations btrfs_symlink_aops;

  static const struct file_operations btrfs_dir_file_operations;

  static struct extent_io_ops btrfs_extent_io_ops;

  
  static struct kmem_cache *btrfs_inode_cachep;
  struct kmem_cache *btrfs_trans_handle_cachep;
  struct kmem_cache *btrfs_transaction_cachep;

  struct kmem_cache *btrfs_path_cachep;

  struct kmem_cache *btrfs_free_space_cachep;

  
  #define S_SHIFT 12
  static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
  	[S_IFREG >> S_SHIFT]	= BTRFS_FT_REG_FILE,
  	[S_IFDIR >> S_SHIFT]	= BTRFS_FT_DIR,
  	[S_IFCHR >> S_SHIFT]	= BTRFS_FT_CHRDEV,
  	[S_IFBLK >> S_SHIFT]	= BTRFS_FT_BLKDEV,
  	[S_IFIFO >> S_SHIFT]	= BTRFS_FT_FIFO,
  	[S_IFSOCK >> S_SHIFT]	= BTRFS_FT_SOCK,
  	[S_IFLNK >> S_SHIFT]	= BTRFS_FT_SYMLINK,
  };

  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 noinline int cow_file_range(struct inode *inode,
  				   struct page *locked_page,
  				   u64 start, u64 end, int *page_started,
  				   unsigned long *nr_written, int unlock);

  static noinline int btrfs_update_inode_fallback(struct btrfs_trans_handle *trans,
  				struct btrfs_root *root, struct inode *inode);

  static int btrfs_init_inode_security(struct btrfs_trans_handle *trans,

  				     struct inode *inode,  struct inode *dir,
  				     const struct qstr *qstr)

  {
  	int err;

  	err = btrfs_init_acl(trans, inode, dir);

  	if (!err)

  		err = btrfs_xattr_security_init(trans, inode, dir, qstr);

  	return err;
  }

  /*

   * this does all the hard work for inserting an inline extent into
   * the btree.  The caller should have done a btrfs_drop_extents so that
   * no overlapping inline items exist in the btree
   */

  static noinline int insert_inline_extent(struct btrfs_trans_handle *trans,

  				struct btrfs_root *root, struct inode *inode,
  				u64 start, size_t size, size_t compressed_size,

  				int compress_type,

  				struct page **compressed_pages)
  {
  	struct btrfs_key key;
  	struct btrfs_path *path;
  	struct extent_buffer *leaf;
  	struct page *page = NULL;
  	char *kaddr;
  	unsigned long ptr;
  	struct btrfs_file_extent_item *ei;
  	int err = 0;
  	int ret;
  	size_t cur_size = size;
  	size_t datasize;
  	unsigned long offset;

  	if (compressed_size && compressed_pages)

  		cur_size = compressed_size;

  	path = btrfs_alloc_path();
  	if (!path)

  		return -ENOMEM;

  	path->leave_spinning = 1;

  	key.objectid = btrfs_ino(inode);

  	key.offset = start;
  	btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);

  	datasize = btrfs_file_extent_calc_inline_size(cur_size);
  
  	inode_add_bytes(inode, size);
  	ret = btrfs_insert_empty_item(trans, root, path, &key,
  				      datasize);
  	BUG_ON(ret);
  	if (ret) {
  		err = ret;

  		goto fail;
  	}
  	leaf = path->nodes[0];
  	ei = btrfs_item_ptr(leaf, path->slots[0],
  			    struct btrfs_file_extent_item);
  	btrfs_set_file_extent_generation(leaf, ei, trans->transid);
  	btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
  	btrfs_set_file_extent_encryption(leaf, ei, 0);
  	btrfs_set_file_extent_other_encoding(leaf, ei, 0);
  	btrfs_set_file_extent_ram_bytes(leaf, ei, size);
  	ptr = btrfs_file_extent_inline_start(ei);

  	if (compress_type != BTRFS_COMPRESS_NONE) {

  		struct page *cpage;
  		int i = 0;

  		while (compressed_size > 0) {

  			cpage = compressed_pages[i];

  			cur_size = min_t(unsigned long, compressed_size,

  				       PAGE_CACHE_SIZE);

  			kaddr = kmap_atomic(cpage, KM_USER0);

  			write_extent_buffer(leaf, kaddr, ptr, cur_size);

  			kunmap_atomic(kaddr, KM_USER0);

  
  			i++;
  			ptr += cur_size;
  			compressed_size -= cur_size;
  		}
  		btrfs_set_file_extent_compression(leaf, ei,

  						  compress_type);

  	} else {
  		page = find_get_page(inode->i_mapping,
  				     start >> PAGE_CACHE_SHIFT);
  		btrfs_set_file_extent_compression(leaf, ei, 0);
  		kaddr = kmap_atomic(page, KM_USER0);
  		offset = start & (PAGE_CACHE_SIZE - 1);
  		write_extent_buffer(leaf, kaddr + offset, ptr, size);
  		kunmap_atomic(kaddr, KM_USER0);
  		page_cache_release(page);
  	}
  	btrfs_mark_buffer_dirty(leaf);
  	btrfs_free_path(path);

  	/*
  	 * we're an inline extent, so nobody can
  	 * extend the file past i_size without locking
  	 * a page we already have locked.
  	 *
  	 * We must do any isize and inode updates
  	 * before we unlock the pages.  Otherwise we
  	 * could end up racing with unlink.
  	 */

  	BTRFS_I(inode)->disk_i_size = inode->i_size;
  	btrfs_update_inode(trans, root, inode);

  	return 0;
  fail:
  	btrfs_free_path(path);
  	return err;
  }
  
  
  /*
   * conditionally insert an inline extent into the file.  This
   * does the checks required to make sure the data is small enough
   * to fit as an inline extent.
   */

  static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans,

  				 struct btrfs_root *root,
  				 struct inode *inode, u64 start, u64 end,

  				 size_t compressed_size, int compress_type,

  				 struct page **compressed_pages)
  {
  	u64 isize = i_size_read(inode);
  	u64 actual_end = min(end + 1, isize);
  	u64 inline_len = actual_end - start;
  	u64 aligned_end = (end + root->sectorsize - 1) &
  			~((u64)root->sectorsize - 1);
  	u64 hint_byte;
  	u64 data_len = inline_len;
  	int ret;
  
  	if (compressed_size)
  		data_len = compressed_size;
  
  	if (start > 0 ||

  	    actual_end >= PAGE_CACHE_SIZE ||

  	    data_len >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
  	    (!compressed_size &&
  	    (actual_end & (root->sectorsize - 1)) == 0) ||
  	    end + 1 < isize ||
  	    data_len > root->fs_info->max_inline) {
  		return 1;
  	}

  	ret = btrfs_drop_extents(trans, inode, start, aligned_end,

  				 &hint_byte, 1);

  	BUG_ON(ret);
  
  	if (isize > actual_end)
  		inline_len = min_t(u64, isize, actual_end);
  	ret = insert_inline_extent(trans, root, inode, start,
  				   inline_len, compressed_size,

  				   compress_type, compressed_pages);

  	BUG_ON(ret);

  	btrfs_delalloc_release_metadata(inode, end + 1 - start);

  	btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0);

  	return 0;
  }

  struct async_extent {
  	u64 start;
  	u64 ram_size;
  	u64 compressed_size;
  	struct page **pages;
  	unsigned long nr_pages;

  	int compress_type;

  	struct list_head list;
  };
  
  struct async_cow {
  	struct inode *inode;
  	struct btrfs_root *root;
  	struct page *locked_page;
  	u64 start;
  	u64 end;
  	struct list_head extents;
  	struct btrfs_work work;
  };
  
  static noinline int add_async_extent(struct async_cow *cow,
  				     u64 start, u64 ram_size,
  				     u64 compressed_size,
  				     struct page **pages,

  				     unsigned long nr_pages,
  				     int compress_type)

  {
  	struct async_extent *async_extent;
  
  	async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS);

  	BUG_ON(!async_extent);

  	async_extent->start = start;
  	async_extent->ram_size = ram_size;
  	async_extent->compressed_size = compressed_size;
  	async_extent->pages = pages;
  	async_extent->nr_pages = nr_pages;

  	async_extent->compress_type = compress_type;

  	list_add_tail(&async_extent->list, &cow->extents);
  	return 0;
  }

  /*

   * we create compressed extents in two phases.  The first
   * phase compresses a range of pages that have already been
   * locked (both pages and state bits are locked).

   *

   * This is done inside an ordered work queue, and the compression
   * is spread across many cpus.  The actual IO submission is step
   * two, and the ordered work queue takes care of making sure that
   * happens in the same order things were put onto the queue by
   * writepages and friends.

   *

   * If this code finds it can't get good compression, it puts an
   * entry onto the work queue to write the uncompressed bytes.  This
   * makes sure that both compressed inodes and uncompressed inodes
   * are written in the same order that pdflush sent them down.

   */

  static noinline int compress_file_range(struct inode *inode,
  					struct page *locked_page,
  					u64 start, u64 end,
  					struct async_cow *async_cow,
  					int *num_added)

  {
  	struct btrfs_root *root = BTRFS_I(inode)->root;
  	struct btrfs_trans_handle *trans;

  	u64 num_bytes;

  	u64 blocksize = root->sectorsize;

  	u64 actual_end;

  	u64 isize = i_size_read(inode);

  	int ret = 0;

  	struct page **pages = NULL;
  	unsigned long nr_pages;
  	unsigned long nr_pages_ret = 0;
  	unsigned long total_compressed = 0;
  	unsigned long total_in = 0;
  	unsigned long max_compressed = 128 * 1024;

  	unsigned long max_uncompressed = 128 * 1024;

  	int i;
  	int will_compress;

  	int compress_type = root->fs_info->compress_type;

  	/* if this is a small write inside eof, kick off a defragbot */
  	if (end <= BTRFS_I(inode)->disk_i_size && (end - start + 1) < 16 * 1024)
  		btrfs_add_inode_defrag(NULL, inode);

  	actual_end = min_t(u64, isize, end + 1);

  again:
  	will_compress = 0;
  	nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1;
  	nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE);

  	/*
  	 * we don't want to send crud past the end of i_size through
  	 * compression, that's just a waste of CPU time.  So, if the
  	 * end of the file is before the start of our current
  	 * requested range of bytes, we bail out to the uncompressed
  	 * cleanup code that can deal with all of this.
  	 *
  	 * It isn't really the fastest way to fix things, but this is a
  	 * very uncommon corner.
  	 */
  	if (actual_end <= start)
  		goto cleanup_and_bail_uncompressed;

  	total_compressed = actual_end - start;
  
  	/* we want to make sure that amount of ram required to uncompress
  	 * an extent is reasonable, so we limit the total size in ram

  	 * of a compressed extent to 128k.  This is a crucial number
  	 * because it also controls how easily we can spread reads across
  	 * cpus for decompression.
  	 *
  	 * We also want to make sure the amount of IO required to do
  	 * a random read is reasonably small, so we limit the size of
  	 * a compressed extent to 128k.

  	 */
  	total_compressed = min(total_compressed, max_uncompressed);

  	num_bytes = (end - start + blocksize) & ~(blocksize - 1);

  	num_bytes = max(blocksize,  num_bytes);

  	total_in = 0;
  	ret = 0;

  	/*
  	 * we do compression for mount -o compress and when the
  	 * inode has not been flagged as nocompress.  This flag can
  	 * change at any time if we discover bad compression ratios.

  	 */

  	if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS) &&

  	    (btrfs_test_opt(root, COMPRESS) ||

  	     (BTRFS_I(inode)->force_compress) ||
  	     (BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))) {

  		WARN_ON(pages);

  		pages = kzalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);

  		if (!pages) {
  			/* just bail out to the uncompressed code */
  			goto cont;
  		}

  		if (BTRFS_I(inode)->force_compress)
  			compress_type = BTRFS_I(inode)->force_compress;
  
  		ret = btrfs_compress_pages(compress_type,
  					   inode->i_mapping, start,
  					   total_compressed, pages,
  					   nr_pages, &nr_pages_ret,
  					   &total_in,
  					   &total_compressed,
  					   max_compressed);

  
  		if (!ret) {
  			unsigned long offset = total_compressed &
  				(PAGE_CACHE_SIZE - 1);
  			struct page *page = pages[nr_pages_ret - 1];
  			char *kaddr;
  
  			/* zero the tail end of the last page, we might be
  			 * sending it down to disk
  			 */
  			if (offset) {
  				kaddr = kmap_atomic(page, KM_USER0);
  				memset(kaddr + offset, 0,
  				       PAGE_CACHE_SIZE - offset);
  				kunmap_atomic(kaddr, KM_USER0);
  			}
  			will_compress = 1;
  		}
  	}

  cont:

  	if (start == 0) {

  		trans = btrfs_join_transaction(root);

  		BUG_ON(IS_ERR(trans));

  		trans->block_rsv = &root->fs_info->delalloc_block_rsv;

  		/* lets try to make an inline extent */

  		if (ret || total_in < (actual_end - start)) {

  			/* we didn't compress the entire range, try

  			 * to make an uncompressed inline extent.

  			 */
  			ret = cow_file_range_inline(trans, root, inode,

  						    start, end, 0, 0, NULL);

  		} else {

  			/* try making a compressed inline extent */

  			ret = cow_file_range_inline(trans, root, inode,
  						    start, end,

  						    total_compressed,
  						    compress_type, pages);

  		}
  		if (ret == 0) {

  			/*
  			 * inline extent creation worked, we don't need
  			 * to create any more async work items.  Unlock
  			 * and free up our temp pages.
  			 */

  			extent_clear_unlock_delalloc(inode,

  			     &BTRFS_I(inode)->io_tree,
  			     start, end, NULL,
  			     EXTENT_CLEAR_UNLOCK_PAGE | EXTENT_CLEAR_DIRTY |

  			     EXTENT_CLEAR_DELALLOC |

  			     EXTENT_SET_WRITEBACK | EXTENT_END_WRITEBACK);

  
  			btrfs_end_transaction(trans, root);

  			goto free_pages_out;
  		}

  		btrfs_end_transaction(trans, root);

  	}
  
  	if (will_compress) {
  		/*
  		 * we aren't doing an inline extent round the compressed size
  		 * up to a block size boundary so the allocator does sane
  		 * things
  		 */
  		total_compressed = (total_compressed + blocksize - 1) &
  			~(blocksize - 1);
  
  		/*
  		 * one last check to make sure the compression is really a
  		 * win, compare the page count read with the blocks on disk
  		 */
  		total_in = (total_in + PAGE_CACHE_SIZE - 1) &
  			~(PAGE_CACHE_SIZE - 1);
  		if (total_compressed >= total_in) {
  			will_compress = 0;
  		} else {

  			num_bytes = total_in;
  		}
  	}
  	if (!will_compress && pages) {
  		/*
  		 * the compression code ran but failed to make things smaller,
  		 * free any pages it allocated and our page pointer array
  		 */
  		for (i = 0; i < nr_pages_ret; i++) {

  			WARN_ON(pages[i]->mapping);

  			page_cache_release(pages[i]);
  		}
  		kfree(pages);
  		pages = NULL;
  		total_compressed = 0;
  		nr_pages_ret = 0;
  
  		/* flag the file so we don't compress in the future */

  		if (!btrfs_test_opt(root, FORCE_COMPRESS) &&
  		    !(BTRFS_I(inode)->force_compress)) {

  			BTRFS_I(inode)->flags |= BTRFS_INODE_NOCOMPRESS;

  		}

  	}

  	if (will_compress) {
  		*num_added += 1;

  		/* the async work queues will take care of doing actual
  		 * allocation on disk for these compressed pages,
  		 * and will submit them to the elevator.
  		 */
  		add_async_extent(async_cow, start, num_bytes,

  				 total_compressed, pages, nr_pages_ret,
  				 compress_type);

  		if (start + num_bytes < end) {

  			start += num_bytes;
  			pages = NULL;
  			cond_resched();
  			goto again;
  		}
  	} else {

  cleanup_and_bail_uncompressed:

  		/*
  		 * No compression, but we still need to write the pages in
  		 * the file we've been given so far.  redirty the locked
  		 * page if it corresponds to our extent and set things up
  		 * for the async work queue to run cow_file_range to do
  		 * the normal delalloc dance
  		 */
  		if (page_offset(locked_page) >= start &&
  		    page_offset(locked_page) <= end) {
  			__set_page_dirty_nobuffers(locked_page);
  			/* unlocked later on in the async handlers */
  		}

  		add_async_extent(async_cow, start, end - start + 1,
  				 0, NULL, 0, BTRFS_COMPRESS_NONE);

  		*num_added += 1;
  	}

  out:
  	return 0;
  
  free_pages_out:
  	for (i = 0; i < nr_pages_ret; i++) {
  		WARN_ON(pages[i]->mapping);
  		page_cache_release(pages[i]);
  	}

  	kfree(pages);

  
  	goto out;
  }
  
  /*
   * phase two of compressed writeback.  This is the ordered portion
   * of the code, which only gets called in the order the work was
   * queued.  We walk all the async extents created by compress_file_range
   * and send them down to the disk.
   */
  static noinline int submit_compressed_extents(struct inode *inode,
  					      struct async_cow *async_cow)
  {
  	struct async_extent *async_extent;
  	u64 alloc_hint = 0;
  	struct btrfs_trans_handle *trans;
  	struct btrfs_key ins;
  	struct extent_map *em;
  	struct btrfs_root *root = BTRFS_I(inode)->root;
  	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  	struct extent_io_tree *io_tree;

  	int ret = 0;

  
  	if (list_empty(&async_cow->extents))
  		return 0;

  	while (!list_empty(&async_cow->extents)) {

  		async_extent = list_entry(async_cow->extents.next,
  					  struct async_extent, list);
  		list_del(&async_extent->list);

  		io_tree = &BTRFS_I(inode)->io_tree;

  retry:

  		/* did the compression code fall back to uncompressed IO? */
  		if (!async_extent->pages) {
  			int page_started = 0;
  			unsigned long nr_written = 0;
  
  			lock_extent(io_tree, async_extent->start,

  					 async_extent->start +
  					 async_extent->ram_size - 1, GFP_NOFS);

  
  			/* allocate blocks */

  			ret = cow_file_range(inode, async_cow->locked_page,
  					     async_extent->start,
  					     async_extent->start +
  					     async_extent->ram_size - 1,
  					     &page_started, &nr_written, 0);

  
  			/*
  			 * if page_started, cow_file_range inserted an
  			 * inline extent and took care of all the unlocking
  			 * and IO for us.  Otherwise, we need to submit
  			 * all those pages down to the drive.
  			 */

  			if (!page_started && !ret)

  				extent_write_locked_range(io_tree,
  						  inode, async_extent->start,

  						  async_extent->start +

  						  async_extent->ram_size - 1,
  						  btrfs_get_extent,
  						  WB_SYNC_ALL);
  			kfree(async_extent);
  			cond_resched();
  			continue;
  		}
  
  		lock_extent(io_tree, async_extent->start,
  			    async_extent->start + async_extent->ram_size - 1,
  			    GFP_NOFS);

  		trans = btrfs_join_transaction(root);

  		BUG_ON(IS_ERR(trans));

  		trans->block_rsv = &root->fs_info->delalloc_block_rsv;

  		ret = btrfs_reserve_extent(trans, root,
  					   async_extent->compressed_size,
  					   async_extent->compressed_size,
  					   0, alloc_hint,
  					   (u64)-1, &ins, 1);

  		btrfs_end_transaction(trans, root);

  		if (ret) {
  			int i;
  			for (i = 0; i < async_extent->nr_pages; i++) {
  				WARN_ON(async_extent->pages[i]->mapping);
  				page_cache_release(async_extent->pages[i]);
  			}
  			kfree(async_extent->pages);
  			async_extent->nr_pages = 0;
  			async_extent->pages = NULL;
  			unlock_extent(io_tree, async_extent->start,
  				      async_extent->start +
  				      async_extent->ram_size - 1, GFP_NOFS);
  			goto retry;
  		}

  		/*
  		 * here we're doing allocation and writeback of the
  		 * compressed pages
  		 */
  		btrfs_drop_extent_cache(inode, async_extent->start,
  					async_extent->start +
  					async_extent->ram_size - 1, 0);

  		em = alloc_extent_map();

  		BUG_ON(!em);

  		em->start = async_extent->start;
  		em->len = async_extent->ram_size;

  		em->orig_start = em->start;

  		em->block_start = ins.objectid;
  		em->block_len = ins.offset;
  		em->bdev = root->fs_info->fs_devices->latest_bdev;

  		em->compress_type = async_extent->compress_type;

  		set_bit(EXTENT_FLAG_PINNED, &em->flags);
  		set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);

  		while (1) {

  			write_lock(&em_tree->lock);

  			ret = add_extent_mapping(em_tree, em);

  			write_unlock(&em_tree->lock);

  			if (ret != -EEXIST) {
  				free_extent_map(em);
  				break;
  			}
  			btrfs_drop_extent_cache(inode, async_extent->start,
  						async_extent->start +
  						async_extent->ram_size - 1, 0);
  		}

  		ret = btrfs_add_ordered_extent_compress(inode,
  						async_extent->start,
  						ins.objectid,
  						async_extent->ram_size,
  						ins.offset,
  						BTRFS_ORDERED_COMPRESSED,
  						async_extent->compress_type);

  		BUG_ON(ret);

  		/*
  		 * clear dirty, set writeback and unlock the pages.
  		 */
  		extent_clear_unlock_delalloc(inode,

  				&BTRFS_I(inode)->io_tree,
  				async_extent->start,
  				async_extent->start +
  				async_extent->ram_size - 1,
  				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,
  				    async_extent->ram_size,
  				    ins.objectid,
  				    ins.offset, async_extent->pages,
  				    async_extent->nr_pages);

  
  		BUG_ON(ret);

  		alloc_hint = ins.objectid + ins.offset;
  		kfree(async_extent);
  		cond_resched();
  	}

  	return 0;
  }

  static u64 get_extent_allocation_hint(struct inode *inode, u64 start,
  				      u64 num_bytes)
  {
  	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  	struct extent_map *em;
  	u64 alloc_hint = 0;
  
  	read_lock(&em_tree->lock);
  	em = search_extent_mapping(em_tree, start, num_bytes);
  	if (em) {
  		/*
  		 * if block start isn't an actual block number then find the
  		 * first block in this inode and use that as a hint.  If that
  		 * block is also bogus then just don't worry about it.
  		 */
  		if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
  			free_extent_map(em);
  			em = search_extent_mapping(em_tree, 0, 0);
  			if (em && em->block_start < EXTENT_MAP_LAST_BYTE)
  				alloc_hint = em->block_start;
  			if (em)
  				free_extent_map(em);
  		} else {
  			alloc_hint = em->block_start;
  			free_extent_map(em);
  		}
  	}
  	read_unlock(&em_tree->lock);
  
  	return alloc_hint;
  }

  /*
   * when extent_io.c finds a delayed allocation range in the file,
   * the call backs end up in this code.  The basic idea is to
   * allocate extents on disk for the range, and create ordered data structs
   * in ram to track those extents.
   *
   * locked_page is the page that writepage had locked already.  We use
   * it to make sure we don't do extra locks or unlocks.
   *
   * *page_started is set to one if we unlock locked_page and do everything
   * required to start IO on it.  It may be clean and already done with
   * IO when we return.
   */
  static noinline int cow_file_range(struct inode *inode,
  				   struct page *locked_page,
  				   u64 start, u64 end, int *page_started,
  				   unsigned long *nr_written,
  				   int unlock)
  {
  	struct btrfs_root *root = BTRFS_I(inode)->root;
  	struct btrfs_trans_handle *trans;
  	u64 alloc_hint = 0;
  	u64 num_bytes;
  	unsigned long ram_size;
  	u64 disk_num_bytes;
  	u64 cur_alloc_size;
  	u64 blocksize = root->sectorsize;

  	struct btrfs_key ins;
  	struct extent_map *em;
  	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
  	int ret = 0;

  	BUG_ON(btrfs_is_free_space_inode(root, inode));

  	trans = btrfs_join_transaction(root);

  	BUG_ON(IS_ERR(trans));

  	trans->block_rsv = &root->fs_info->delalloc_block_rsv;

  	num_bytes = (end - start + blocksize) & ~(blocksize - 1);
  	num_bytes = max(blocksize,  num_bytes);
  	disk_num_bytes = num_bytes;
  	ret = 0;

  	/* if this is a small write inside eof, kick off defrag */
  	if (end <= BTRFS_I(inode)->disk_i_size && num_bytes < 64 * 1024)
  		btrfs_add_inode_defrag(trans, inode);

  	if (start == 0) {
  		/* lets try to make an inline extent */
  		ret = cow_file_range_inline(trans, root, inode,

  					    start, end, 0, 0, NULL);

  		if (ret == 0) {
  			extent_clear_unlock_delalloc(inode,

  				     &BTRFS_I(inode)->io_tree,
  				     start, end, NULL,
  				     EXTENT_CLEAR_UNLOCK_PAGE |
  				     EXTENT_CLEAR_UNLOCK |
  				     EXTENT_CLEAR_DELALLOC |
  				     EXTENT_CLEAR_DIRTY |
  				     EXTENT_SET_WRITEBACK |
  				     EXTENT_END_WRITEBACK);

  			*nr_written = *nr_written +
  			     (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE;
  			*page_started = 1;
  			ret = 0;
  			goto out;
  		}
  	}
  
  	BUG_ON(disk_num_bytes >

  	       btrfs_super_total_bytes(root->fs_info->super_copy));

  	alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);

  	btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);

  	while (disk_num_bytes > 0) {

  		unsigned long op;

  		cur_alloc_size = disk_num_bytes;

  		ret = btrfs_reserve_extent(trans, root, cur_alloc_size,

  					   root->sectorsize, 0, alloc_hint,

  					   (u64)-1, &ins, 1);

  		BUG_ON(ret);

  		em = alloc_extent_map();

  		BUG_ON(!em);

  		em->start = start;

  		em->orig_start = em->start;

  		ram_size = ins.offset;
  		em->len = ins.offset;

  		em->block_start = ins.objectid;

  		em->block_len = ins.offset;

  		em->bdev = root->fs_info->fs_devices->latest_bdev;

  		set_bit(EXTENT_FLAG_PINNED, &em->flags);

  		while (1) {

  			write_lock(&em_tree->lock);

  			ret = add_extent_mapping(em_tree, em);

  			write_unlock(&em_tree->lock);

  			if (ret != -EEXIST) {
  				free_extent_map(em);
  				break;
  			}
  			btrfs_drop_extent_cache(inode, start,

  						start + ram_size - 1, 0);

  		}

  		cur_alloc_size = ins.offset;

  		ret = btrfs_add_ordered_extent(inode, start, ins.objectid,

  					       ram_size, cur_alloc_size, 0);

  		BUG_ON(ret);

  		if (root->root_key.objectid ==
  		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
  			ret = btrfs_reloc_clone_csums(inode, start,
  						      cur_alloc_size);
  			BUG_ON(ret);
  		}

  		if (disk_num_bytes < cur_alloc_size)

  			break;

  		/* we're not doing compressed IO, don't unlock the first
  		 * page (which the caller expects to stay locked), don't
  		 * clear any dirty bits and don't set any writeback bits

  		 *
  		 * 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, op);

  		disk_num_bytes -= cur_alloc_size;

  		num_bytes -= cur_alloc_size;
  		alloc_hint = ins.objectid + ins.offset;
  		start += cur_alloc_size;

  	}

  out:

  	ret = 0;

  	btrfs_end_transaction(trans, root);

  	return ret;

  }

  /*
   * work queue call back to started compression on a file and pages
   */
  static noinline void async_cow_start(struct btrfs_work *work)
  {
  	struct async_cow *async_cow;
  	int num_added = 0;
  	async_cow = container_of(work, struct async_cow, work);
  
  	compress_file_range(async_cow->inode, async_cow->locked_page,
  			    async_cow->start, async_cow->end, async_cow,
  			    &num_added);
  	if (num_added == 0)
  		async_cow->inode = NULL;
  }
  
  /*
   * work queue call back to submit previously compressed pages
   */
  static noinline void async_cow_submit(struct btrfs_work *work)
  {
  	struct async_cow *async_cow;
  	struct btrfs_root *root;
  	unsigned long nr_pages;
  
  	async_cow = container_of(work, struct async_cow, work);
  
  	root = async_cow->root;
  	nr_pages = (async_cow->end - async_cow->start + PAGE_CACHE_SIZE) >>
  		PAGE_CACHE_SHIFT;
  
  	atomic_sub(nr_pages, &root->fs_info->async_delalloc_pages);
  
  	if (atomic_read(&root->fs_info->async_delalloc_pages) <
  	    5 * 1042 * 1024 &&
  	    waitqueue_active(&root->fs_info->async_submit_wait))
  		wake_up(&root->fs_info->async_submit_wait);

  	if (async_cow->inode)

  		submit_compressed_extents(async_cow->inode, async_cow);

  }

  static noinline void async_cow_free(struct btrfs_work *work)
  {
  	struct async_cow *async_cow;
  	async_cow = container_of(work, struct async_cow, work);
  	kfree(async_cow);
  }
  
  static int cow_file_range_async(struct inode *inode, struct page *locked_page,
  				u64 start, u64 end, int *page_started,
  				unsigned long *nr_written)
  {
  	struct async_cow *async_cow;
  	struct btrfs_root *root = BTRFS_I(inode)->root;
  	unsigned long nr_pages;
  	u64 cur_end;
  	int limit = 10 * 1024 * 1042;

  	clear_extent_bit(&BTRFS_I(inode)->io_tree, start, end, EXTENT_LOCKED,
  			 1, 0, NULL, GFP_NOFS);

  	while (start < end) {

  		async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS);

  		BUG_ON(!async_cow);

  		async_cow->inode = inode;
  		async_cow->root = root;
  		async_cow->locked_page = locked_page;
  		async_cow->start = start;

  		if (BTRFS_I(inode)->flags & BTRFS_INODE_NOCOMPRESS)

  			cur_end = end;
  		else
  			cur_end = min(end, start + 512 * 1024 - 1);
  
  		async_cow->end = cur_end;
  		INIT_LIST_HEAD(&async_cow->extents);
  
  		async_cow->work.func = async_cow_start;
  		async_cow->work.ordered_func = async_cow_submit;
  		async_cow->work.ordered_free = async_cow_free;
  		async_cow->work.flags = 0;

  		nr_pages = (cur_end - start + PAGE_CACHE_SIZE) >>
  			PAGE_CACHE_SHIFT;
  		atomic_add(nr_pages, &root->fs_info->async_delalloc_pages);
  
  		btrfs_queue_worker(&root->fs_info->delalloc_workers,
  				   &async_cow->work);
  
  		if (atomic_read(&root->fs_info->async_delalloc_pages) > limit) {
  			wait_event(root->fs_info->async_submit_wait,
  			   (atomic_read(&root->fs_info->async_delalloc_pages) <
  			    limit));
  		}

  		while (atomic_read(&root->fs_info->async_submit_draining) &&

  		      atomic_read(&root->fs_info->async_delalloc_pages)) {
  			wait_event(root->fs_info->async_submit_wait,
  			  (atomic_read(&root->fs_info->async_delalloc_pages) ==
  			   0));
  		}
  
  		*nr_written += nr_pages;
  		start = cur_end + 1;
  	}
  	*page_started = 1;
  	return 0;

  }

  static noinline int csum_exist_in_range(struct btrfs_root *root,

  					u64 bytenr, u64 num_bytes)
  {
  	int ret;
  	struct btrfs_ordered_sum *sums;
  	LIST_HEAD(list);

  	ret = btrfs_lookup_csums_range(root->fs_info->csum_root, bytenr,

  				       bytenr + num_bytes - 1, &list, 0);

  	if (ret == 0 && list_empty(&list))
  		return 0;
  
  	while (!list_empty(&list)) {
  		sums = list_entry(list.next, struct btrfs_ordered_sum, list);
  		list_del(&sums->list);
  		kfree(sums);
  	}
  	return 1;
  }

  /*
   * when nowcow writeback call back.  This checks for snapshots or COW copies
   * of the extents that exist in the file, and COWs the file as required.
   *
   * If no cow copies or snapshots exist, we write directly to the existing
   * blocks on disk
   */

  static noinline int run_delalloc_nocow(struct inode *inode,
  				       struct page *locked_page,

  			      u64 start, u64 end, int *page_started, int force,
  			      unsigned long *nr_written)

  {

  	struct btrfs_root *root = BTRFS_I(inode)->root;

  	struct btrfs_trans_handle *trans;

  	struct extent_buffer *leaf;

  	struct btrfs_path *path;

  	struct btrfs_file_extent_item *fi;

  	struct btrfs_key found_key;

  	u64 cow_start;
  	u64 cur_offset;
  	u64 extent_end;

  	u64 extent_offset;

  	u64 disk_bytenr;
  	u64 num_bytes;
  	int extent_type;
  	int ret;

  	int type;

  	int nocow;
  	int check_prev = 1;

  	bool nolock;

  	u64 ino = btrfs_ino(inode);

  
  	path = btrfs_alloc_path();

  	if (!path)
  		return -ENOMEM;

  	nolock = btrfs_is_free_space_inode(root, inode);

  
  	if (nolock)

  		trans = btrfs_join_transaction_nolock(root);

  	else

  		trans = btrfs_join_transaction(root);

  	BUG_ON(IS_ERR(trans));

  	trans->block_rsv = &root->fs_info->delalloc_block_rsv;

  	cow_start = (u64)-1;
  	cur_offset = start;
  	while (1) {

  		ret = btrfs_lookup_file_extent(trans, root, path, ino,

  					       cur_offset, 0);
  		BUG_ON(ret < 0);
  		if (ret > 0 && path->slots[0] > 0 && check_prev) {
  			leaf = path->nodes[0];
  			btrfs_item_key_to_cpu(leaf, &found_key,
  					      path->slots[0] - 1);

  			if (found_key.objectid == ino &&

  			    found_key.type == BTRFS_EXTENT_DATA_KEY)
  				path->slots[0]--;
  		}
  		check_prev = 0;
  next_slot:
  		leaf = path->nodes[0];
  		if (path->slots[0] >= btrfs_header_nritems(leaf)) {
  			ret = btrfs_next_leaf(root, path);
  			if (ret < 0)
  				BUG_ON(1);
  			if (ret > 0)
  				break;
  			leaf = path->nodes[0];
  		}

  		nocow = 0;
  		disk_bytenr = 0;

  		num_bytes = 0;

  		btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);

  		if (found_key.objectid > ino ||

  		    found_key.type > BTRFS_EXTENT_DATA_KEY ||
  		    found_key.offset > end)
  			break;
  
  		if (found_key.offset > cur_offset) {
  			extent_end = found_key.offset;

  			extent_type = 0;

  			goto out_check;
  		}
  
  		fi = btrfs_item_ptr(leaf, path->slots[0],
  				    struct btrfs_file_extent_item);
  		extent_type = btrfs_file_extent_type(leaf, fi);

  		if (extent_type == BTRFS_FILE_EXTENT_REG ||
  		    extent_type == BTRFS_FILE_EXTENT_PREALLOC) {

  			disk_bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);

  			extent_offset = btrfs_file_extent_offset(leaf, fi);

  			extent_end = found_key.offset +
  				btrfs_file_extent_num_bytes(leaf, fi);
  			if (extent_end <= start) {
  				path->slots[0]++;
  				goto next_slot;
  			}

  			if (disk_bytenr == 0)
  				goto out_check;

  			if (btrfs_file_extent_compression(leaf, fi) ||
  			    btrfs_file_extent_encryption(leaf, fi) ||
  			    btrfs_file_extent_other_encoding(leaf, fi))
  				goto out_check;

  			if (extent_type == BTRFS_FILE_EXTENT_REG && !force)
  				goto out_check;

  			if (btrfs_extent_readonly(root, disk_bytenr))

  				goto out_check;

  			if (btrfs_cross_ref_exist(trans, root, ino,

  						  found_key.offset -
  						  extent_offset, disk_bytenr))

  				goto out_check;

  			disk_bytenr += extent_offset;

  			disk_bytenr += cur_offset - found_key.offset;
  			num_bytes = min(end + 1, extent_end) - cur_offset;
  			/*
  			 * force cow if csum exists in the range.
  			 * this ensure that csum for a given extent are
  			 * either valid or do not exist.
  			 */
  			if (csum_exist_in_range(root, disk_bytenr, num_bytes))
  				goto out_check;

  			nocow = 1;
  		} else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
  			extent_end = found_key.offset +
  				btrfs_file_extent_inline_len(leaf, fi);
  			extent_end = ALIGN(extent_end, root->sectorsize);
  		} else {
  			BUG_ON(1);
  		}
  out_check:
  		if (extent_end <= start) {
  			path->slots[0]++;
  			goto next_slot;
  		}
  		if (!nocow) {
  			if (cow_start == (u64)-1)
  				cow_start = cur_offset;
  			cur_offset = extent_end;
  			if (cur_offset > end)
  				break;
  			path->slots[0]++;
  			goto next_slot;

  		}

  		btrfs_release_path(path);

  		if (cow_start != (u64)-1) {
  			ret = cow_file_range(inode, locked_page, cow_start,

  					found_key.offset - 1, page_started,
  					nr_written, 1);

  			BUG_ON(ret);
  			cow_start = (u64)-1;

  		}

  		if (extent_type == BTRFS_FILE_EXTENT_PREALLOC) {
  			struct extent_map *em;
  			struct extent_map_tree *em_tree;
  			em_tree = &BTRFS_I(inode)->extent_tree;

  			em = alloc_extent_map();

  			BUG_ON(!em);

  			em->start = cur_offset;

  			em->orig_start = em->start;

  			em->len = num_bytes;
  			em->block_len = num_bytes;
  			em->block_start = disk_bytenr;
  			em->bdev = root->fs_info->fs_devices->latest_bdev;
  			set_bit(EXTENT_FLAG_PINNED, &em->flags);
  			while (1) {

  				write_lock(&em_tree->lock);

  				ret = add_extent_mapping(em_tree, em);

  				write_unlock(&em_tree->lock);

  				if (ret != -EEXIST) {
  					free_extent_map(em);
  					break;
  				}
  				btrfs_drop_extent_cache(inode, em->start,
  						em->start + em->len - 1, 0);
  			}
  			type = BTRFS_ORDERED_PREALLOC;
  		} else {
  			type = BTRFS_ORDERED_NOCOW;
  		}

  
  		ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr,

  					       num_bytes, num_bytes, type);
  		BUG_ON(ret);

  		if (root->root_key.objectid ==
  		    BTRFS_DATA_RELOC_TREE_OBJECTID) {
  			ret = btrfs_reloc_clone_csums(inode, cur_offset,
  						      num_bytes);
  			BUG_ON(ret);
  		}

  		extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,

  				cur_offset, cur_offset + num_bytes - 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;

  	}

  	btrfs_release_path(path);

  
  	if (cur_offset <= end && cow_start == (u64)-1)
  		cow_start = cur_offset;
  	if (cow_start != (u64)-1) {
  		ret = cow_file_range(inode, locked_page, cow_start, end,

  				     page_started, nr_written, 1);

  		BUG_ON(ret);
  	}

  	if (nolock) {
  		ret = btrfs_end_transaction_nolock(trans, root);
  		BUG_ON(ret);
  	} else {
  		ret = btrfs_end_transaction(trans, root);
  		BUG_ON(ret);
  	}

  	btrfs_free_path(path);

  	return 0;

  }

  /*
   * extent_io.c call back to do delayed allocation processing
   */

  static int run_delalloc_range(struct inode *inode, struct page *locked_page,

  			      u64 start, u64 end, int *page_started,
  			      unsigned long *nr_written)

  {

  	int ret;

  	struct btrfs_root *root = BTRFS_I(inode)->root;

  	if (BTRFS_I(inode)->flags & BTRFS_INODE_NODATACOW)

  		ret = run_delalloc_nocow(inode, locked_page, start, end,

  					 page_started, 1, nr_written);

  	else if (BTRFS_I(inode)->flags & BTRFS_INODE_PREALLOC)

  		ret = run_delalloc_nocow(inode, locked_page, start, end,

  					 page_started, 0, nr_written);

  	else if (!btrfs_test_opt(root, COMPRESS) &&

  		 !(BTRFS_I(inode)->force_compress) &&
  		 !(BTRFS_I(inode)->flags & BTRFS_INODE_COMPRESS))

  		ret = cow_file_range(inode, locked_page, start, end,
  				      page_started, nr_written, 1);

  	else

  		ret = cow_file_range_async(inode, locked_page, start, end,

  					   page_started, nr_written);

  	return ret;
  }

  static void btrfs_split_extent_hook(struct inode *inode,
  				    struct extent_state *orig, u64 split)

  {

  	/* not delalloc, ignore it */

  	if (!(orig->state & EXTENT_DELALLOC))

  		return;

  	spin_lock(&BTRFS_I(inode)->lock);
  	BTRFS_I(inode)->outstanding_extents++;
  	spin_unlock(&BTRFS_I(inode)->lock);

  }
  
  /*
   * extent_io.c merge_extent_hook, used to track merged delayed allocation
   * extents so we can keep track of new extents that are just merged onto old
   * extents, such as when we are doing sequential writes, so we can properly
   * account for the metadata space we'll need.
   */

  static void btrfs_merge_extent_hook(struct inode *inode,
  				    struct extent_state *new,
  				    struct extent_state *other)

  {

  	/* not delalloc, ignore it */
  	if (!(other->state & EXTENT_DELALLOC))

  		return;

  	spin_lock(&BTRFS_I(inode)->lock);
  	BTRFS_I(inode)->outstanding_extents--;
  	spin_unlock(&BTRFS_I(inode)->lock);

  }

  /*
   * extent_io.c set_bit_hook, used to track delayed allocation
   * bytes in this file, and to maintain the list of inodes that
   * have pending delalloc work to be done.
   */

  static void btrfs_set_bit_hook(struct inode *inode,
  			       struct extent_state *state, int *bits)

  {

  	/*
  	 * set_bit and clear bit hooks normally require _irqsave/restore

  	 * but in this case, we are only testing for the DELALLOC

  	 * bit, which is only set or cleared with irqs on
  	 */

  	if (!(state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {

  		struct btrfs_root *root = BTRFS_I(inode)->root;

  		u64 len = state->end + 1 - state->start;

  		bool do_list = !btrfs_is_free_space_inode(root, inode);

  		if (*bits & EXTENT_FIRST_DELALLOC) {

  			*bits &= ~EXTENT_FIRST_DELALLOC;

  		} else {
  			spin_lock(&BTRFS_I(inode)->lock);
  			BTRFS_I(inode)->outstanding_extents++;
  			spin_unlock(&BTRFS_I(inode)->lock);
  		}

  		spin_lock(&root->fs_info->delalloc_lock);

  		BTRFS_I(inode)->delalloc_bytes += len;
  		root->fs_info->delalloc_bytes += len;

  		if (do_list && list_empty(&BTRFS_I(inode)->delalloc_inodes)) {

  			list_add_tail(&BTRFS_I(inode)->delalloc_inodes,
  				      &root->fs_info->delalloc_inodes);
  		}

  		spin_unlock(&root->fs_info->delalloc_lock);

  	}

  }

  /*
   * extent_io.c clear_bit_hook, see set_bit_hook for why
   */

  static void btrfs_clear_bit_hook(struct inode *inode,
  				 struct extent_state *state, int *bits)

  {

  	/*
  	 * set_bit and clear bit hooks normally require _irqsave/restore

  	 * but in this case, we are only testing for the DELALLOC

  	 * bit, which is only set or cleared with irqs on
  	 */

  	if ((state->state & EXTENT_DELALLOC) && (*bits & EXTENT_DELALLOC)) {

  		struct btrfs_root *root = BTRFS_I(inode)->root;

  		u64 len = state->end + 1 - state->start;

  		bool do_list = !btrfs_is_free_space_inode(root, inode);

  		if (*bits & EXTENT_FIRST_DELALLOC) {

  			*bits &= ~EXTENT_FIRST_DELALLOC;

  		} else if (!(*bits & EXTENT_DO_ACCOUNTING)) {
  			spin_lock(&BTRFS_I(inode)->lock);
  			BTRFS_I(inode)->outstanding_extents--;
  			spin_unlock(&BTRFS_I(inode)->lock);
  		}

  
  		if (*bits & EXTENT_DO_ACCOUNTING)
  			btrfs_delalloc_release_metadata(inode, len);

  		if (root->root_key.objectid != BTRFS_DATA_RELOC_TREE_OBJECTID
  		    && do_list)

  			btrfs_free_reserved_data_space(inode, len);

  		spin_lock(&root->fs_info->delalloc_lock);

  		root->fs_info->delalloc_bytes -= len;
  		BTRFS_I(inode)->delalloc_bytes -= len;

  		if (do_list && BTRFS_I(inode)->delalloc_bytes == 0 &&

  		    !list_empty(&BTRFS_I(inode)->delalloc_inodes)) {
  			list_del_init(&BTRFS_I(inode)->delalloc_inodes);
  		}

  		spin_unlock(&root->fs_info->delalloc_lock);

  	}

  }

  /*
   * extent_io.c merge_bio_hook, this must check the chunk tree to make sure
   * we don't create bios that span stripes or chunks
   */

  int btrfs_merge_bio_hook(struct page *page, unsigned long offset,

  			 size_t size, struct bio *bio,
  			 unsigned long bio_flags)

  {
  	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
  	struct btrfs_mapping_tree *map_tree;

  	u64 logical = (u64)bio->bi_sector << 9;

  	u64 length = 0;
  	u64 map_length;

  	int ret;

  	if (bio_flags & EXTENT_BIO_COMPRESSED)
  		return 0;

  	length = bio->bi_size;

  	map_tree = &root->fs_info->mapping_tree;
  	map_length = length;

  	ret = btrfs_map_block(map_tree, READ, logical,

  			      &map_length, NULL, 0);

  	if (map_length < length + size)

  		return 1;

  	return ret;

  }

  /*
   * in order to insert checksums into the metadata in large chunks,
   * we wait until bio submission time.   All the pages in the bio are
   * checksummed and sums are attached onto the ordered extent record.
   *
   * At IO completion time the cums attached on the ordered extent record
   * are inserted into the btree
   */

  static int __btrfs_submit_bio_start(struct inode *inode, int rw,
  				    struct bio *bio, int mirror_num,

  				    unsigned long bio_flags,
  				    u64 bio_offset)

  {

  	struct btrfs_root *root = BTRFS_I(inode)->root;

  	int ret = 0;

  	ret = btrfs_csum_one_bio(root, inode, bio, 0, 0);

  	BUG_ON(ret);

  	return 0;
  }

  /*
   * in order to insert checksums into the metadata in large chunks,
   * we wait until bio submission time.   All the pages in the bio are
   * checksummed and sums are attached onto the ordered extent record.
   *
   * At IO completion time the cums attached on the ordered extent record
   * are inserted into the btree
   */

  static int __btrfs_submit_bio_done(struct inode *inode, int rw, struct bio *bio,

  			  int mirror_num, unsigned long bio_flags,
  			  u64 bio_offset)

  {
  	struct btrfs_root *root = BTRFS_I(inode)->root;

  	return btrfs_map_bio(root, rw, bio, mirror_num, 1);

  }

  /*

   * extent_io.c submission hook. This does the right thing for csum calculation
   * on write, or reading the csums from the tree before a read

   */

  static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,

  			  int mirror_num, unsigned long bio_flags,
  			  u64 bio_offset)

  {
  	struct btrfs_root *root = BTRFS_I(inode)->root;
  	int ret = 0;

  	int skip_sum;

  	skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM;

  	if (btrfs_is_free_space_inode(root, inode))

  		ret = btrfs_bio_wq_end_io(root->fs_info, bio, 2);
  	else
  		ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);

  	BUG_ON(ret);

  	if (!(rw & REQ_WRITE)) {

  		if (bio_flags & EXTENT_BIO_COMPRESSED) {

  			return btrfs_submit_compressed_read(inode, bio,
  						    mirror_num, bio_flags);

  		} else if (!skip_sum) {
  			ret = btrfs_lookup_bio_sums(root, inode, bio, NULL);
  			if (ret)
  				return ret;
  		}

  		goto mapit;

  	} else if (!skip_sum) {

  		/* csum items have already been cloned */
  		if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
  			goto mapit;

  		/* we're doing a write, do the async checksumming */
  		return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,

  				   inode, rw, bio, mirror_num,

  				   bio_flags, bio_offset,
  				   __btrfs_submit_bio_start,

  				   __btrfs_submit_bio_done);

  	}

  mapit:

  	return btrfs_map_bio(root, rw, bio, mirror_num, 0);

  }

  /*
   * given a list of ordered sums record them in the inode.  This happens
   * at IO completion time based on sums calculated at bio submission time.
   */

  static noinline int add_pending_csums(struct btrfs_trans_handle *trans,

  			     struct inode *inode, u64 file_offset,
  			     struct list_head *list)
  {

  	struct btrfs_ordered_sum *sum;

  	list_for_each_entry(sum, list, list) {

  		btrfs_csum_file_blocks(trans,
  		       BTRFS_I(inode)->root->fs_info->csum_root, sum);

  	}
  	return 0;
  }

  int btrfs_set_extent_delalloc(struct inode *inode, u64 start, u64 end,
  			      struct extent_state **cached_state)

  {

  	if ((end & (PAGE_CACHE_SIZE - 1)) == 0)

  		WARN_ON(1);

  	return set_extent_delalloc(&BTRFS_I(inode)->io_tree, start, end,

  				   cached_state, GFP_NOFS);

  }

  /* see btrfs_writepage_start_hook for details on why this is required */

  struct btrfs_writepage_fixup {
  	struct page *page;
  	struct btrfs_work work;
  };

  static void btrfs_writepage_fixup_worker(struct btrfs_work *work)

  {
  	struct btrfs_writepage_fixup *fixup;
  	struct btrfs_ordered_extent *ordered;

  	struct extent_state *cached_state = NULL;

  	struct page *page;
  	struct inode *inode;
  	u64 page_start;
  	u64 page_end;
  
  	fixup = container_of(work, struct btrfs_writepage_fixup, work);
  	page = fixup->page;

  again:

  	lock_page(page);
  	if (!page->mapping || !PageDirty(page) || !PageChecked(page)) {
  		ClearPageChecked(page);
  		goto out_page;
  	}
  
  	inode = page->mapping->host;
  	page_start = page_offset(page);
  	page_end = page_offset(page) + PAGE_CACHE_SIZE - 1;

  	lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0,
  			 &cached_state, GFP_NOFS);

  
  	/* already ordered? We're done */

  	if (PagePrivate2(page))

  		goto out;

  
  	ordered = btrfs_lookup_ordered_extent(inode, page_start);
  	if (ordered) {

  		unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start,
  				     page_end, &cached_state, GFP_NOFS);

  		unlock_page(page);
  		btrfs_start_ordered_extent(inode, ordered, 1);
  		goto again;
  	}

  	BUG();

  	btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state);

  	ClearPageChecked(page);
  out:

  	unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end,
  			     &cached_state, GFP_NOFS);

  out_page:
  	unlock_page(page);
  	page_cache_release(page);

  	kfree(fixup);

  }
  
  /*
   * There are a few paths in the higher layers of the kernel that directly
   * set the page dirty bit without asking the filesystem if it is a
   * good idea.  This causes problems because we want to make sure COW
   * properly happens and the data=ordered rules are followed.
   *

   * In our case any range that doesn't have the ORDERED bit set

   * hasn't been properly setup for IO.  We kick off an async process
   * to fix it up.  The async helper will wait for ordered extents, set
   * the delalloc bit and make it safe to write the page.
   */

  static int btrfs_writepage_start_hook(struct page *page, u64 start, u64 end)

  {
  	struct inode *inode = page->mapping->host;
  	struct btrfs_writepage_fixup *fixup;
  	struct btrfs_root *root = BTRFS_I(inode)->root;

  	/* this page is properly in the ordered list */
  	if (TestClearPagePrivate2(page))

  		return 0;
  
  	if (PageChecked(page))
  		return -EAGAIN;
  
  	fixup = kzalloc(sizeof(*fixup), GFP_NOFS);
  	if (!fixup)
  		return -EAGAIN;

  	SetPageChecked(page);
  	page_cache_get(page);
  	fixup->work.func = btrfs_writepage_fixup_worker;
  	fixup->page = page;
  	btrfs_queue_worker(&root->fs_info->fixup_workers, &fixup->work);
  	return -EAGAIN;
  }

  static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
  				       struct inode *inode, u64 file_pos,
  				       u64 disk_bytenr, u64 disk_num_bytes,
  				       u64 num_bytes, u64 ram_bytes,
  				       u8 compression, u8 encryption,
  				       u16 other_encoding, int extent_type)
  {
  	struct btrfs_root *root = BTRFS_I(inode)->root;
  	struct btrfs_file_extent_item *fi;
  	struct btrfs_path *path;
  	struct extent_buffer *leaf;
  	struct btrfs_key ins;
  	u64 hint;
  	int ret;
  
  	path = btrfs_alloc_path();

  	if (!path)
  		return -ENOMEM;

  	path->leave_spinning = 1;

  
  	/*
  	 * we may be replacing one extent in the tree with another.
  	 * The new extent is pinned in the extent map, and we don't want
  	 * to drop it from the cache until it is completely in the btree.
  	 *
  	 * So, tell btrfs_drop_extents to leave this extent in the cache.
  	 * the caller is expected to unpin it and allow it to be merged
  	 * with the others.
  	 */

  	ret = btrfs_drop_extents(trans, inode, file_pos, file_pos + num_bytes,
  				 &hint, 0);

  	BUG_ON(ret);

  	ins.objectid = btrfs_ino(inode);

  	ins.offset = file_pos;
  	ins.type = BTRFS_EXTENT_DATA_KEY;
  	ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi));
  	BUG_ON(ret);
  	leaf = path->nodes[0];
  	fi = btrfs_item_ptr(leaf, path->slots[0],
  			    struct btrfs_file_extent_item);
  	btrfs_set_file_extent_generation(leaf, fi, trans->transid);
  	btrfs_set_file_extent_type(leaf, fi, extent_type);
  	btrfs_set_file_extent_disk_bytenr(leaf, fi, disk_bytenr);
  	btrfs_set_file_extent_disk_num_bytes(leaf, fi, disk_num_bytes);
  	btrfs_set_file_extent_offset(leaf, fi, 0);
  	btrfs_set_file_extent_num_bytes(leaf, fi, num_bytes);
  	btrfs_set_file_extent_ram_bytes(leaf, fi, ram_bytes);
  	btrfs_set_file_extent_compression(leaf, fi, compression);
  	btrfs_set_file_extent_encryption(leaf, fi, encryption);
  	btrfs_set_file_extent_other_encoding(leaf, fi, other_encoding);

  
  	btrfs_unlock_up_safe(path, 1);
  	btrfs_set_lock_blocking(leaf);

  	btrfs_mark_buffer_dirty(leaf);
  
  	inode_add_bytes(inode, num_bytes);

  
  	ins.objectid = disk_bytenr;
  	ins.offset = disk_num_bytes;
  	ins.type = BTRFS_EXTENT_ITEM_KEY;

  	ret = btrfs_alloc_reserved_file_extent(trans, root,
  					root->root_key.objectid,

  					btrfs_ino(inode), file_pos, &ins);

  	BUG_ON(ret);

  	btrfs_free_path(path);

  	return 0;
  }

  /*
   * helper function for btrfs_finish_ordered_io, this
   * just reads in some of the csum leaves to prime them into ram
   * before we start the transaction.  It limits the amount of btree
   * reads required while inside the transaction.
   */

  /* as ordered data IO finishes, this gets called so we can finish
   * 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)

  {

  	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);

  	nolock = btrfs_is_free_space_inode(root, inode);

  	if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) {
  		BUG_ON(!list_empty(&ordered_extent->list));
  		ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent);
  		if (!ret) {

  			if (nolock)

  				trans = btrfs_join_transaction_nolock(root);

  			else

  				trans = btrfs_join_transaction(root);

  			BUG_ON(IS_ERR(trans));

  			trans->block_rsv = &root->fs_info->delalloc_block_rsv;

  			ret = btrfs_update_inode_fallback(trans, root, inode);

  			BUG_ON(ret);