[linux-2.6-block.git] / fs / btrfs / ordered-data.c

/*
 * 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/gfp.h>
#include <linux/slab.h>
#include <linux/blkdev.h>
#include "ctree.h"
#include "transaction.h"
#include "btrfs_inode.h"
#include "extent_io.h"


static u64 entry_end(struct btrfs_ordered_extent *entry)
{
	if (entry->file_offset + entry->len < entry->file_offset)
		return (u64)-1;
	return entry->file_offset + entry->len;
}

static struct rb_node *tree_insert(struct rb_root *root, u64 file_offset,
				   struct rb_node *node)
{
	struct rb_node ** p = &root->rb_node;
	struct rb_node * parent = NULL;
	struct btrfs_ordered_extent *entry;

	while(*p) {
		parent = *p;
		entry = rb_entry(parent, struct btrfs_ordered_extent, rb_node);

		if (file_offset < entry->file_offset)
			p = &(*p)->rb_left;
		else if (file_offset >= entry_end(entry))
			p = &(*p)->rb_right;
		else
			return parent;
	}

	rb_link_node(node, parent, p);
	rb_insert_color(node, root);
	return NULL;
}

static struct rb_node *__tree_search(struct rb_root *root, u64 file_offset,
				     struct rb_node **prev_ret)
{
	struct rb_node * n = root->rb_node;
	struct rb_node *prev = NULL;
	struct rb_node *test;
	struct btrfs_ordered_extent *entry;
	struct btrfs_ordered_extent *prev_entry = NULL;

	while(n) {
		entry = rb_entry(n, struct btrfs_ordered_extent, rb_node);
		prev = n;
		prev_entry = entry;

		if (file_offset < entry->file_offset)
			n = n->rb_left;
		else if (file_offset >= entry_end(entry))
			n = n->rb_right;
		else
			return n;
	}
	if (!prev_ret)
		return NULL;

	while(prev && file_offset >= entry_end(prev_entry)) {
		test = rb_next(prev);
		if (!test)
			break;
		prev_entry = rb_entry(test, struct btrfs_ordered_extent,
				      rb_node);
		if (file_offset < entry_end(prev_entry))
			break;

		prev = test;
	}
	if (prev)
		prev_entry = rb_entry(prev, struct btrfs_ordered_extent,
				      rb_node);
	while(prev && file_offset < entry_end(prev_entry)) {
		test = rb_prev(prev);
		if (!test)
			break;
		prev_entry = rb_entry(test, struct btrfs_ordered_extent,
				      rb_node);
		prev = test;
	}
	*prev_ret = prev;
	return NULL;
}

static int offset_in_entry(struct btrfs_ordered_extent *entry, u64 file_offset)
{
	if (file_offset < entry->file_offset ||
	    entry->file_offset + entry->len <= file_offset)
		return 0;
	return 1;
}

static inline struct rb_node *tree_search(struct btrfs_ordered_inode_tree *tree,
					  u64 file_offset)
{
	struct rb_root *root = &tree->tree;
	struct rb_node *prev;
	struct rb_node *ret;
	struct btrfs_ordered_extent *entry;

	if (tree->last) {
		entry = rb_entry(tree->last, struct btrfs_ordered_extent,
				 rb_node);
		if (offset_in_entry(entry, file_offset))
			return tree->last;
	}
	ret = __tree_search(root, file_offset, &prev);
	if (!ret)
		ret = prev;
	if (ret)
		tree->last = ret;
	return ret;
}

int btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
			     u64 start, u64 len)
{
	struct btrfs_ordered_inode_tree *tree;
	struct rb_node *node;
	struct btrfs_ordered_extent *entry;

	tree = &BTRFS_I(inode)->ordered_tree;
	entry = kzalloc(sizeof(*entry), GFP_NOFS);
	if (!entry)
		return -ENOMEM;

	mutex_lock(&tree->mutex);
	entry->file_offset = file_offset;
	entry->start = start;
	entry->len = len;
	entry->inode = inode;
	/* one ref for the tree */
	atomic_set(&entry->refs, 1);
	init_waitqueue_head(&entry->wait);
	INIT_LIST_HEAD(&entry->list);

	node = tree_insert(&tree->tree, file_offset,
			   &entry->rb_node);
	if (node) {
		entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
		atomic_inc(&entry->refs);
	}
	set_extent_ordered(&BTRFS_I(inode)->io_tree, file_offset,
			   entry_end(entry) - 1, GFP_NOFS);

	set_bit(BTRFS_ORDERED_START, &entry->flags);
	mutex_unlock(&tree->mutex);
	BUG_ON(node);
	return 0;
}

int btrfs_add_ordered_sum(struct inode *inode, struct btrfs_ordered_sum *sum)
{
	struct btrfs_ordered_inode_tree *tree;
	struct rb_node *node;
	struct btrfs_ordered_extent *entry;

	tree = &BTRFS_I(inode)->ordered_tree;
	mutex_lock(&tree->mutex);
	node = tree_search(tree, sum->file_offset);
	if (!node) {
search_fail:
printk("add ordered sum failed to find a node for inode %lu offset %Lu\n", inode->i_ino, sum->file_offset);
		node = rb_first(&tree->tree);
		while(node) {
			entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
			printk("entry %Lu %Lu %Lu\n", entry->file_offset, entry->file_offset + entry->len, entry->start);
			node = rb_next(node);
		}
		BUG();
	}
	BUG_ON(!node);

	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	if (!offset_in_entry(entry, sum->file_offset)) {
		goto search_fail;
	}

	list_add_tail(&sum->list, &entry->list);
	mutex_unlock(&tree->mutex);
	return 0;
}

int btrfs_dec_test_ordered_pending(struct inode *inode,
				   u64 file_offset, u64 io_size)
{
	struct btrfs_ordered_inode_tree *tree;
	struct rb_node *node;
	struct btrfs_ordered_extent *entry;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	int ret;

	tree = &BTRFS_I(inode)->ordered_tree;
	mutex_lock(&tree->mutex);
	clear_extent_ordered(io_tree, file_offset, file_offset + io_size - 1,
			     GFP_NOFS);
	node = tree_search(tree, file_offset);
	if (!node) {
		ret = 1;
		goto out;
	}

	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	if (!offset_in_entry(entry, file_offset)) {
		ret = 1;
		goto out;
	}

	ret = test_range_bit(io_tree, entry->file_offset,
			     entry->file_offset + entry->len - 1,
			     EXTENT_ORDERED, 0);
	if (!test_bit(BTRFS_ORDERED_START, &entry->flags)) {
printk("inode %lu not ready yet for extent %Lu %Lu\n", inode->i_ino, entry->file_offset, entry_end(entry));
	}
	if (ret == 0)
		ret = test_and_set_bit(BTRFS_ORDERED_IO_DONE, &entry->flags);
out:
	mutex_unlock(&tree->mutex);
	return ret == 0;
}

int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
{
	if (atomic_dec_and_test(&entry->refs))
		kfree(entry);
	return 0;
}

int btrfs_remove_ordered_extent(struct inode *inode,
				struct btrfs_ordered_extent *entry)
{
	struct btrfs_ordered_inode_tree *tree;
	struct rb_node *node;

	tree = &BTRFS_I(inode)->ordered_tree;
	mutex_lock(&tree->mutex);
	node = &entry->rb_node;
	rb_erase(node, &tree->tree);
	tree->last = NULL;
	set_bit(BTRFS_ORDERED_COMPLETE, &entry->flags);
	mutex_unlock(&tree->mutex);
	wake_up(&entry->wait);
	return 0;
}

void btrfs_wait_ordered_extent(struct inode *inode,
			       struct btrfs_ordered_extent *entry)
{
	u64 start = entry->file_offset;
	u64 end = start + entry->len - 1;
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
	do_sync_file_range(file, start, end, SYNC_FILE_RANGE_WRITE);
#else
	do_sync_mapping_range(inode->i_mapping, start, end,
			      SYNC_FILE_RANGE_WRITE);
#endif
	wait_event(entry->wait,
		   test_bit(BTRFS_ORDERED_COMPLETE, &entry->flags));
}

static void btrfs_start_ordered_extent(struct inode *inode,
			       struct btrfs_ordered_extent *entry, int wait)
{
	u64 start = entry->file_offset;
	u64 end = start + entry->len - 1;

#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
	do_sync_file_range(file, start, end, SYNC_FILE_RANGE_WRITE);
#else
	do_sync_mapping_range(inode->i_mapping, start, end,
			      SYNC_FILE_RANGE_WRITE);
#endif
	if (wait)
		wait_event(entry->wait, test_bit(BTRFS_ORDERED_COMPLETE,
						 &entry->flags));
}

void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
{
	u64 end;
	struct btrfs_ordered_extent *ordered;
	int found;
	int should_wait = 0;

again:
	if (start + len < start)
		end = (u64)-1;
	else
		end = start + len - 1;
	found = 0;
	while(1) {
		ordered = btrfs_lookup_first_ordered_extent(inode, end);
		if (!ordered) {
			break;
		}
		if (ordered->file_offset >= start + len) {
			btrfs_put_ordered_extent(ordered);
			break;
		}
		if (ordered->file_offset + ordered->len < start) {
			btrfs_put_ordered_extent(ordered);
			break;
		}
		btrfs_start_ordered_extent(inode, ordered, should_wait);
		found++;
		end = ordered->file_offset;
		btrfs_put_ordered_extent(ordered);
		if (end == 0)
			break;
		end--;
	}
	if (should_wait && found) {
		should_wait = 0;
		goto again;
	}
}

int btrfs_add_ordered_pending(struct inode *inode,
			      struct btrfs_ordered_extent *ordered,
			      u64 start, u64 len)
{
	WARN_ON(1);
	return 0;
#if 0
	int ret;
	struct btrfs_ordered_inode_tree *tree;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;

	tree = &BTRFS_I(inode)->ordered_tree;
	mutex_lock(&tree->mutex);
	if (test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags)) {
		ret = -EAGAIN;
		goto out;
	}
	set_extent_ordered(io_tree, start, start + len - 1, GFP_NOFS);
	ret = 0;
out:
	mutex_unlock(&tree->mutex);
	return ret;
#endif
}

struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct inode *inode,
							 u64 file_offset)
{
	struct btrfs_ordered_inode_tree *tree;
	struct rb_node *node;
	struct btrfs_ordered_extent *entry = NULL;

	tree = &BTRFS_I(inode)->ordered_tree;
	mutex_lock(&tree->mutex);
	node = tree_search(tree, file_offset);
	if (!node)
		goto out;

	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	if (!offset_in_entry(entry, file_offset))
		entry = NULL;
	if (entry)
		atomic_inc(&entry->refs);
out:
	mutex_unlock(&tree->mutex);
	return entry;
}

struct btrfs_ordered_extent *
btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset)
{
	struct btrfs_ordered_inode_tree *tree;
	struct rb_node *node;
	struct btrfs_ordered_extent *entry = NULL;

	tree = &BTRFS_I(inode)->ordered_tree;
	mutex_lock(&tree->mutex);
	node = tree_search(tree, file_offset);
	if (!node)
		goto out;

	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	atomic_inc(&entry->refs);
out:
	mutex_unlock(&tree->mutex);
	return entry;
}

int btrfs_ordered_update_i_size(struct inode *inode,
				struct btrfs_ordered_extent *ordered)
{
	struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	u64 disk_i_size;
	u64 new_i_size;
	u64 i_size_test;
	struct rb_node *node;
	struct btrfs_ordered_extent *test;

	mutex_lock(&tree->mutex);
	disk_i_size = BTRFS_I(inode)->disk_i_size;

	/*
	 * if the disk i_size is already at the inode->i_size, or
	 * this ordered extent is inside the disk i_size, we're done
	 */
	if (disk_i_size >= inode->i_size ||
	    ordered->file_offset + ordered->len <= disk_i_size) {
		goto out;
	}

	/*
	 * we can't update the disk_isize if there are delalloc bytes
	 * between disk_i_size and  this ordered extent
	 */
	if (test_range_bit(io_tree, disk_i_size,
			   ordered->file_offset + ordered->len - 1,
			   EXTENT_DELALLOC, 0)) {
		goto out;
	}
	/*
	 * walk backward from this ordered extent to disk_i_size.
	 * if we find an ordered extent then we can't update disk i_size
	 * yet
	 */
	while(1) {
		node = rb_prev(&ordered->rb_node);
		if (!node)
			break;
		test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
		if (test->file_offset + test->len <= disk_i_size)
			break;
		if (test->file_offset >= inode->i_size)
			break;
		if (test->file_offset >= disk_i_size)
			goto out;
	}
	new_i_size = min_t(u64, entry_end(ordered), i_size_read(inode));

	/*
	 * at this point, we know we can safely update i_size to at least
	 * the offset from this ordered extent.  But, we need to
	 * walk forward and see if ios from higher up in the file have
	 * finished.
	 */
	node = rb_next(&ordered->rb_node);
	i_size_test = 0;
	if (node) {
		/*
		 * do we have an area where IO might have finished
		 * between our ordered extent and the next one.
		 */
		test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
		if (test->file_offset > entry_end(ordered)) {
			i_size_test = test->file_offset - 1;
		}
	} else {
		i_size_test = i_size_read(inode);
	}

	/*
	 * i_size_test is the end of a region after this ordered
	 * extent where there are no ordered extents.  As long as there
	 * are no delalloc bytes in this area, it is safe to update
	 * disk_i_size to the end of the region.
	 */
	if (i_size_test > entry_end(ordered) &&
	    !test_range_bit(io_tree, entry_end(ordered), i_size_test,
			   EXTENT_DELALLOC, 0)) {
		new_i_size = min_t(u64, i_size_test, i_size_read(inode));
	}
	BTRFS_I(inode)->disk_i_size = new_i_size;
out:
	mutex_unlock(&tree->mutex);
	return 0;
}
Commit	Line	Data
dc17ff8f CM	1	/*
	2	* Copyright (C) 2007 Oracle. All rights reserved.
	3	*
	4	* This program is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU General Public
	6	* License v2 as published by the Free Software Foundation.
	7	*
	8	* This program is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU General Public
	14	* License along with this program; if not, write to the
	15	* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
	16	* Boston, MA 021110-1307, USA.
	17	*/
	18
	19	#include <linux/gfp.h>
	20	#include <linux/slab.h>
d6bfde87	21	#include <linux/blkdev.h>
dc17ff8f CM	22	#include "ctree.h"
	23	#include "transaction.h"
	24	#include "btrfs_inode.h"
e6dcd2dc	25	#include "extent_io.h"
dc17ff8f	26
dc17ff8f	27
e6dcd2dc	28	static u64 entry_end(struct btrfs_ordered_extent *entry)
dc17ff8f	29	{
e6dcd2dc CM	30	if (entry->file_offset + entry->len < entry->file_offset)
	31	return (u64)-1;
	32	return entry->file_offset + entry->len;
dc17ff8f CM	33	}
dc17ff8f CM	34
e6dcd2dc CM	35	static struct rb_node tree_insert(struct rb_root root, u64 file_offset,
e6dcd2dc CM	36	struct rb_node *node)
dc17ff8f CM	37	{
	38	struct rb_node ** p = &root->rb_node;
	39	struct rb_node * parent = NULL;
e6dcd2dc	40	struct btrfs_ordered_extent *entry;
dc17ff8f CM	41
	42	while(*p) {
	43	parent = *p;
e6dcd2dc	44	entry = rb_entry(parent, struct btrfs_ordered_extent, rb_node);
dc17ff8f	45
e6dcd2dc	46	if (file_offset < entry->file_offset)
dc17ff8f	47	p = &(*p)->rb_left;
e6dcd2dc	48	else if (file_offset >= entry_end(entry))
dc17ff8f CM	49	p = &(*p)->rb_right;
	50	else
	51	return parent;
	52	}
	53
	54	rb_link_node(node, parent, p);
	55	rb_insert_color(node, root);
	56	return NULL;
	57	}
	58
e6dcd2dc CM	59	static struct rb_node __tree_search(struct rb_root root, u64 file_offset,
e6dcd2dc CM	60	struct rb_node **prev_ret)
dc17ff8f CM	61	{
	62	struct rb_node * n = root->rb_node;
	63	struct rb_node *prev = NULL;
e6dcd2dc CM	64	struct rb_node *test;
	65	struct btrfs_ordered_extent *entry;
	66	struct btrfs_ordered_extent *prev_entry = NULL;
dc17ff8f CM	67
dc17ff8f CM	68	while(n) {
e6dcd2dc	69	entry = rb_entry(n, struct btrfs_ordered_extent, rb_node);
dc17ff8f CM	70	prev = n;
dc17ff8f CM	71	prev_entry = entry;
dc17ff8f	72
e6dcd2dc	73	if (file_offset < entry->file_offset)
dc17ff8f	74	n = n->rb_left;
e6dcd2dc	75	else if (file_offset >= entry_end(entry))
dc17ff8f CM	76	n = n->rb_right;
	77	else
	78	return n;
	79	}
	80	if (!prev_ret)
	81	return NULL;
	82
e6dcd2dc CM	83	while(prev && file_offset >= entry_end(prev_entry)) {
	84	test = rb_next(prev);
	85	if (!test)
	86	break;
	87	prev_entry = rb_entry(test, struct btrfs_ordered_extent,
	88	rb_node);
	89	if (file_offset < entry_end(prev_entry))
	90	break;
	91
	92	prev = test;
	93	}
	94	if (prev)
	95	prev_entry = rb_entry(prev, struct btrfs_ordered_extent,
	96	rb_node);
	97	while(prev && file_offset < entry_end(prev_entry)) {
	98	test = rb_prev(prev);
	99	if (!test)
	100	break;
	101	prev_entry = rb_entry(test, struct btrfs_ordered_extent,
	102	rb_node);
	103	prev = test;
dc17ff8f CM	104	}
	105	*prev_ret = prev;
	106	return NULL;
	107	}
	108
e6dcd2dc CM	109	static int offset_in_entry(struct btrfs_ordered_extent *entry, u64 file_offset)
	110	{
	111	if (file_offset < entry->file_offset \|\|
	112	entry->file_offset + entry->len <= file_offset)
	113	return 0;
	114	return 1;
	115	}
	116
	117	static inline struct rb_node tree_search(struct btrfs_ordered_inode_tree tree,
	118	u64 file_offset)
dc17ff8f	119	{
e6dcd2dc	120	struct rb_root *root = &tree->tree;
dc17ff8f CM	121	struct rb_node *prev;
dc17ff8f CM	122	struct rb_node *ret;
e6dcd2dc CM	123	struct btrfs_ordered_extent *entry;
	124
	125	if (tree->last) {
	126	entry = rb_entry(tree->last, struct btrfs_ordered_extent,
	127	rb_node);
	128	if (offset_in_entry(entry, file_offset))
	129	return tree->last;
	130	}
	131	ret = __tree_search(root, file_offset, &prev);
dc17ff8f	132	if (!ret)
e6dcd2dc CM	133	ret = prev;
	134	if (ret)
	135	tree->last = ret;
dc17ff8f CM	136	return ret;
	137	}
	138
e6dcd2dc CM	139	int btrfs_add_ordered_extent(struct inode *inode, u64 file_offset,
e6dcd2dc CM	140	u64 start, u64 len)
dc17ff8f	141	{
dc17ff8f	142	struct btrfs_ordered_inode_tree *tree;
e6dcd2dc CM	143	struct rb_node *node;
e6dcd2dc CM	144	struct btrfs_ordered_extent *entry;
dc17ff8f	145
e6dcd2dc CM	146	tree = &BTRFS_I(inode)->ordered_tree;
e6dcd2dc CM	147	entry = kzalloc(sizeof(*entry), GFP_NOFS);
dc17ff8f CM	148	if (!entry)
	149	return -ENOMEM;
	150
e6dcd2dc CM	151	mutex_lock(&tree->mutex);
	152	entry->file_offset = file_offset;
	153	entry->start = start;
	154	entry->len = len;
4d5e74bc	155	entry->inode = inode;
e6dcd2dc CM	156	/* one ref for the tree */
	157	atomic_set(&entry->refs, 1);
	158	init_waitqueue_head(&entry->wait);
	159	INIT_LIST_HEAD(&entry->list);
dc17ff8f	160
e6dcd2dc CM	161	node = tree_insert(&tree->tree, file_offset,
	162	&entry->rb_node);
	163	if (node) {
	164	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	165	atomic_inc(&entry->refs);
	166	}
	167	set_extent_ordered(&BTRFS_I(inode)->io_tree, file_offset,
	168	entry_end(entry) - 1, GFP_NOFS);
1b1e2135	169
e6dcd2dc CM	170	set_bit(BTRFS_ORDERED_START, &entry->flags);
	171	mutex_unlock(&tree->mutex);
	172	BUG_ON(node);
dc17ff8f CM	173	return 0;
	174	}
	175
e6dcd2dc	176	int btrfs_add_ordered_sum(struct inode inode, struct btrfs_ordered_sum sum)
dc17ff8f	177	{
e6dcd2dc	178	struct btrfs_ordered_inode_tree *tree;
dc17ff8f	179	struct rb_node *node;
e6dcd2dc	180	struct btrfs_ordered_extent *entry;
dc17ff8f	181
e6dcd2dc CM	182	tree = &BTRFS_I(inode)->ordered_tree;
	183	mutex_lock(&tree->mutex);
	184	node = tree_search(tree, sum->file_offset);
dc17ff8f	185	if (!node) {
e6dcd2dc CM	186	search_fail:
	187	printk("add ordered sum failed to find a node for inode %lu offset %Lu\n", inode->i_ino, sum->file_offset);
	188	node = rb_first(&tree->tree);
	189	while(node) {
	190	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	191	printk("entry %Lu %Lu %Lu\n", entry->file_offset, entry->file_offset + entry->len, entry->start);
	192	node = rb_next(node);
	193	}
	194	BUG();
dc17ff8f	195	}
e6dcd2dc	196	BUG_ON(!node);
dc17ff8f	197
e6dcd2dc CM	198	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	199	if (!offset_in_entry(entry, sum->file_offset)) {
	200	goto search_fail;
dc17ff8f CM	201	}
dc17ff8f CM	202
e6dcd2dc CM	203	list_add_tail(&sum->list, &entry->list);
	204	mutex_unlock(&tree->mutex);
	205	return 0;
dc17ff8f CM	206	}
dc17ff8f CM	207
e6dcd2dc CM	208	int btrfs_dec_test_ordered_pending(struct inode *inode,
e6dcd2dc CM	209	u64 file_offset, u64 io_size)
dc17ff8f	210	{
e6dcd2dc	211	struct btrfs_ordered_inode_tree *tree;
dc17ff8f	212	struct rb_node *node;
e6dcd2dc CM	213	struct btrfs_ordered_extent *entry;
	214	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	215	int ret;
	216
	217	tree = &BTRFS_I(inode)->ordered_tree;
	218	mutex_lock(&tree->mutex);
	219	clear_extent_ordered(io_tree, file_offset, file_offset + io_size - 1,
	220	GFP_NOFS);
	221	node = tree_search(tree, file_offset);
dc17ff8f	222	if (!node) {
e6dcd2dc CM	223	ret = 1;
e6dcd2dc CM	224	goto out;
dc17ff8f CM	225	}
dc17ff8f CM	226
e6dcd2dc CM	227	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	228	if (!offset_in_entry(entry, file_offset)) {
	229	ret = 1;
	230	goto out;
dc17ff8f	231	}
e6dcd2dc CM	232
	233	ret = test_range_bit(io_tree, entry->file_offset,
	234	entry->file_offset + entry->len - 1,
	235	EXTENT_ORDERED, 0);
	236	if (!test_bit(BTRFS_ORDERED_START, &entry->flags)) {
	237	printk("inode %lu not ready yet for extent %Lu %Lu\n", inode->i_ino, entry->file_offset, entry_end(entry));
dc17ff8f	238	}
e6dcd2dc CM	239	if (ret == 0)
	240	ret = test_and_set_bit(BTRFS_ORDERED_IO_DONE, &entry->flags);
	241	out:
	242	mutex_unlock(&tree->mutex);
	243	return ret == 0;
	244	}
dc17ff8f	245
e6dcd2dc CM	246	int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry)
	247	{
	248	if (atomic_dec_and_test(&entry->refs))
	249	kfree(entry);
	250	return 0;
dc17ff8f	251	}
cee36a03	252
e6dcd2dc CM	253	int btrfs_remove_ordered_extent(struct inode *inode,
e6dcd2dc CM	254	struct btrfs_ordered_extent *entry)
cee36a03	255	{
e6dcd2dc	256	struct btrfs_ordered_inode_tree *tree;
cee36a03	257	struct rb_node *node;
cee36a03	258
e6dcd2dc CM	259	tree = &BTRFS_I(inode)->ordered_tree;
	260	mutex_lock(&tree->mutex);
	261	node = &entry->rb_node;
cee36a03	262	rb_erase(node, &tree->tree);
e6dcd2dc CM	263	tree->last = NULL;
	264	set_bit(BTRFS_ORDERED_COMPLETE, &entry->flags);
	265	mutex_unlock(&tree->mutex);
	266	wake_up(&entry->wait);
	267	return 0;
cee36a03 CM	268	}
cee36a03 CM	269
e6dcd2dc CM	270	void btrfs_wait_ordered_extent(struct inode *inode,
e6dcd2dc CM	271	struct btrfs_ordered_extent *entry)
cee36a03	272	{
e6dcd2dc CM	273	u64 start = entry->file_offset;
	274	u64 end = start + entry->len - 1;
	275	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
	276	do_sync_file_range(file, start, end, SYNC_FILE_RANGE_WRITE);
	277	#else
	278	do_sync_mapping_range(inode->i_mapping, start, end,
	279	SYNC_FILE_RANGE_WRITE);
	280	#endif
	281	wait_event(entry->wait,
	282	test_bit(BTRFS_ORDERED_COMPLETE, &entry->flags));
	283	}
e1b81e67	284
e6dcd2dc CM	285	static void btrfs_start_ordered_extent(struct inode *inode,
	286	struct btrfs_ordered_extent *entry, int wait)
	287	{
	288	u64 start = entry->file_offset;
	289	u64 end = start + entry->len - 1;
e1b81e67	290
e6dcd2dc CM	291	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
	292	do_sync_file_range(file, start, end, SYNC_FILE_RANGE_WRITE);
	293	#else
	294	do_sync_mapping_range(inode->i_mapping, start, end,
	295	SYNC_FILE_RANGE_WRITE);
	296	#endif
	297	if (wait)
	298	wait_event(entry->wait, test_bit(BTRFS_ORDERED_COMPLETE,
	299	&entry->flags));
	300	}
cee36a03	301
e6dcd2dc CM	302	void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
	303	{
	304	u64 end;
	305	struct btrfs_ordered_extent *ordered;
	306	int found;
	307	int should_wait = 0;
	308
	309	again:
	310	if (start + len < start)
	311	end = (u64)-1;
	312	else
	313	end = start + len - 1;
	314	found = 0;
	315	while(1) {
	316	ordered = btrfs_lookup_first_ordered_extent(inode, end);
	317	if (!ordered) {
	318	break;
	319	}
	320	if (ordered->file_offset >= start + len) {
	321	btrfs_put_ordered_extent(ordered);
	322	break;
	323	}
	324	if (ordered->file_offset + ordered->len < start) {
	325	btrfs_put_ordered_extent(ordered);
	326	break;
	327	}
	328	btrfs_start_ordered_extent(inode, ordered, should_wait);
	329	found++;
	330	end = ordered->file_offset;
	331	btrfs_put_ordered_extent(ordered);
	332	if (end == 0)
	333	break;
	334	end--;
	335	}
	336	if (should_wait && found) {
	337	should_wait = 0;
	338	goto again;
cee36a03	339	}
cee36a03 CM	340	}
cee36a03 CM	341
e6dcd2dc CM	342	int btrfs_add_ordered_pending(struct inode *inode,
	343	struct btrfs_ordered_extent *ordered,
	344	u64 start, u64 len)
81d7ed29	345	{
e6dcd2dc	346	WARN_ON(1);
81d7ed29	347	return 0;
e6dcd2dc CM	348	#if 0
	349	int ret;
	350	struct btrfs_ordered_inode_tree *tree;
	351	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	352
	353	tree = &BTRFS_I(inode)->ordered_tree;
	354	mutex_lock(&tree->mutex);
	355	if (test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags)) {
	356	ret = -EAGAIN;
	357	goto out;
	358	}
	359	set_extent_ordered(io_tree, start, start + len - 1, GFP_NOFS);
	360	ret = 0;
	361	out:
	362	mutex_unlock(&tree->mutex);
	363	return ret;
	364	#endif
	365	}
	366
	367	struct btrfs_ordered_extent btrfs_lookup_ordered_extent(struct inode inode,
	368	u64 file_offset)
	369	{
	370	struct btrfs_ordered_inode_tree *tree;
	371	struct rb_node *node;
	372	struct btrfs_ordered_extent *entry = NULL;
	373
	374	tree = &BTRFS_I(inode)->ordered_tree;
	375	mutex_lock(&tree->mutex);
	376	node = tree_search(tree, file_offset);
	377	if (!node)
	378	goto out;
	379
	380	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	381	if (!offset_in_entry(entry, file_offset))
	382	entry = NULL;
	383	if (entry)
	384	atomic_inc(&entry->refs);
	385	out:
	386	mutex_unlock(&tree->mutex);
	387	return entry;
	388	}
	389
	390	struct btrfs_ordered_extent *
	391	btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset)
	392	{
	393	struct btrfs_ordered_inode_tree *tree;
	394	struct rb_node *node;
	395	struct btrfs_ordered_extent *entry = NULL;
	396
	397	tree = &BTRFS_I(inode)->ordered_tree;
	398	mutex_lock(&tree->mutex);
	399	node = tree_search(tree, file_offset);
	400	if (!node)
	401	goto out;
	402
	403	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	404	atomic_inc(&entry->refs);
	405	out:
	406	mutex_unlock(&tree->mutex);
	407	return entry;
81d7ed29	408	}
dbe674a9 CM	409
	410	int btrfs_ordered_update_i_size(struct inode *inode,
	411	struct btrfs_ordered_extent *ordered)
	412	{
	413	struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
	414	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	415	u64 disk_i_size;
	416	u64 new_i_size;
	417	u64 i_size_test;
	418	struct rb_node *node;
	419	struct btrfs_ordered_extent *test;
	420
	421	mutex_lock(&tree->mutex);
	422	disk_i_size = BTRFS_I(inode)->disk_i_size;
	423
	424	/*
	425	* if the disk i_size is already at the inode->i_size, or
	426	* this ordered extent is inside the disk i_size, we're done
	427	*/
	428	if (disk_i_size >= inode->i_size \|\|
	429	ordered->file_offset + ordered->len <= disk_i_size) {
	430	goto out;
	431	}
	432
	433	/*
	434	* we can't update the disk_isize if there are delalloc bytes
	435	* between disk_i_size and this ordered extent
	436	*/
	437	if (test_range_bit(io_tree, disk_i_size,
	438	ordered->file_offset + ordered->len - 1,
	439	EXTENT_DELALLOC, 0)) {
	440	goto out;
	441	}
	442	/*
	443	* walk backward from this ordered extent to disk_i_size.
	444	* if we find an ordered extent then we can't update disk i_size
	445	* yet
	446	*/
	447	while(1) {
	448	node = rb_prev(&ordered->rb_node);
	449	if (!node)
	450	break;
	451	test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	452	if (test->file_offset + test->len <= disk_i_size)
	453	break;
	454	if (test->file_offset >= inode->i_size)
	455	break;
	456	if (test->file_offset >= disk_i_size)
	457	goto out;
	458	}
	459	new_i_size = min_t(u64, entry_end(ordered), i_size_read(inode));
	460
	461	/*
	462	* at this point, we know we can safely update i_size to at least
	463	* the offset from this ordered extent. But, we need to
	464	* walk forward and see if ios from higher up in the file have
	465	* finished.
	466	*/
	467	node = rb_next(&ordered->rb_node);
	468	i_size_test = 0;
	469	if (node) {
	470	/*
	471	* do we have an area where IO might have finished
	472	* between our ordered extent and the next one.
473	*/
474	test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
475	if (test->file_offset > entry_end(ordered)) {
476	i_size_test = test->file_offset - 1;
477	}
478	} else {
479	i_size_test = i_size_read(inode);
480	}
481
482	/*
483	* i_size_test is the end of a region after this ordered
484	* extent where there are no ordered extents. As long as there
485	* are no delalloc bytes in this area, it is safe to update
486	* disk_i_size to the end of the region.
487	*/
488	if (i_size_test > entry_end(ordered) &&
489	!test_range_bit(io_tree, entry_end(ordered), i_size_test,
490	EXTENT_DELALLOC, 0)) {
491	new_i_size = min_t(u64, i_size_test, i_size_read(inode));
492	}
493	BTRFS_I(inode)->disk_i_size = new_i_size;
494	out:
495	mutex_unlock(&tree->mutex);
496	return 0;
497	}