[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)
{
	struct list_head *cur;
	struct btrfs_ordered_sum *sum;

	if (atomic_dec_and_test(&entry->refs)) {
		while(!list_empty(&entry->list)) {
			cur = entry->list.next;
			sum = list_entry(cur, struct btrfs_ordered_sum, list);
			list_del(&sum->list);
			kfree(sum);
		}
		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
	 */
	node = &ordered->rb_node;
	while(1) {
		node = rb_prev(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;
}

int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u32 *sum)
{
	struct btrfs_ordered_sum *ordered_sum;
	struct btrfs_sector_sum *sector_sums;
	struct btrfs_ordered_extent *ordered;
	struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
	struct list_head *cur;
	int ret = 1;
	int index;

	ordered = btrfs_lookup_ordered_extent(inode, offset);
	if (!ordered)
		return 1;

	mutex_lock(&tree->mutex);
	list_for_each_prev(cur, &ordered->list) {
		ordered_sum = list_entry(cur, struct btrfs_ordered_sum, list);
		if (offset >= ordered_sum->file_offset &&
		    offset < ordered_sum->file_offset + ordered_sum->len) {
			index = (offset - ordered_sum->file_offset) /
				BTRFS_I(inode)->root->sectorsize;;
			sector_sums = &ordered_sum->sums;
			*sum = sector_sums[index].sum;
			ret = 0;
			goto out;
		}
	}
out:
	mutex_unlock(&tree->mutex);
	return ret;
}
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)
e6dcd2dc CM	247	{
ba1da2f4 CM	248	struct list_head *cur;
	249	struct btrfs_ordered_sum *sum;
	250
	251	if (atomic_dec_and_test(&entry->refs)) {
	252	while(!list_empty(&entry->list)) {
	253	cur = entry->list.next;
	254	sum = list_entry(cur, struct btrfs_ordered_sum, list);
	255	list_del(&sum->list);
	256	kfree(sum);
	257	}
e6dcd2dc	258	kfree(entry);
ba1da2f4	259	}
e6dcd2dc	260	return 0;
dc17ff8f	261	}
cee36a03	262
e6dcd2dc CM	263	int btrfs_remove_ordered_extent(struct inode *inode,
e6dcd2dc CM	264	struct btrfs_ordered_extent *entry)
cee36a03	265	{
e6dcd2dc	266	struct btrfs_ordered_inode_tree *tree;
cee36a03	267	struct rb_node *node;
cee36a03	268
e6dcd2dc CM	269	tree = &BTRFS_I(inode)->ordered_tree;
	270	mutex_lock(&tree->mutex);
	271	node = &entry->rb_node;
cee36a03	272	rb_erase(node, &tree->tree);
e6dcd2dc CM	273	tree->last = NULL;
	274	set_bit(BTRFS_ORDERED_COMPLETE, &entry->flags);
	275	mutex_unlock(&tree->mutex);
	276	wake_up(&entry->wait);
	277	return 0;
cee36a03 CM	278	}
cee36a03 CM	279
e6dcd2dc CM	280	void btrfs_wait_ordered_extent(struct inode *inode,
e6dcd2dc CM	281	struct btrfs_ordered_extent *entry)
cee36a03	282	{
e6dcd2dc CM	283	u64 start = entry->file_offset;
	284	u64 end = start + entry->len - 1;
	285	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
	286	do_sync_file_range(file, start, end, SYNC_FILE_RANGE_WRITE);
	287	#else
	288	do_sync_mapping_range(inode->i_mapping, start, end,
	289	SYNC_FILE_RANGE_WRITE);
	290	#endif
	291	wait_event(entry->wait,
	292	test_bit(BTRFS_ORDERED_COMPLETE, &entry->flags));
	293	}
e1b81e67	294
e6dcd2dc CM	295	static void btrfs_start_ordered_extent(struct inode *inode,
	296	struct btrfs_ordered_extent *entry, int wait)
	297	{
	298	u64 start = entry->file_offset;
	299	u64 end = start + entry->len - 1;
e1b81e67	300
e6dcd2dc CM	301	#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,22)
	302	do_sync_file_range(file, start, end, SYNC_FILE_RANGE_WRITE);
	303	#else
	304	do_sync_mapping_range(inode->i_mapping, start, end,
	305	SYNC_FILE_RANGE_WRITE);
	306	#endif
	307	if (wait)
	308	wait_event(entry->wait, test_bit(BTRFS_ORDERED_COMPLETE,
	309	&entry->flags));
	310	}
cee36a03	311
e6dcd2dc CM	312	void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len)
	313	{
	314	u64 end;
	315	struct btrfs_ordered_extent *ordered;
	316	int found;
	317	int should_wait = 0;
	318
	319	again:
	320	if (start + len < start)
	321	end = (u64)-1;
	322	else
	323	end = start + len - 1;
	324	found = 0;
	325	while(1) {
	326	ordered = btrfs_lookup_first_ordered_extent(inode, end);
	327	if (!ordered) {
	328	break;
	329	}
	330	if (ordered->file_offset >= start + len) {
	331	btrfs_put_ordered_extent(ordered);
	332	break;
	333	}
	334	if (ordered->file_offset + ordered->len < start) {
	335	btrfs_put_ordered_extent(ordered);
	336	break;
	337	}
	338	btrfs_start_ordered_extent(inode, ordered, should_wait);
	339	found++;
	340	end = ordered->file_offset;
	341	btrfs_put_ordered_extent(ordered);
	342	if (end == 0)
	343	break;
	344	end--;
	345	}
	346	if (should_wait && found) {
	347	should_wait = 0;
	348	goto again;
cee36a03	349	}
cee36a03 CM	350	}
cee36a03 CM	351
e6dcd2dc CM	352	int btrfs_add_ordered_pending(struct inode *inode,
	353	struct btrfs_ordered_extent *ordered,
	354	u64 start, u64 len)
81d7ed29	355	{
e6dcd2dc	356	WARN_ON(1);
81d7ed29	357	return 0;
e6dcd2dc CM	358	#if 0
	359	int ret;
	360	struct btrfs_ordered_inode_tree *tree;
	361	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	362
	363	tree = &BTRFS_I(inode)->ordered_tree;
	364	mutex_lock(&tree->mutex);
	365	if (test_bit(BTRFS_ORDERED_IO_DONE, &ordered->flags)) {
	366	ret = -EAGAIN;
	367	goto out;
	368	}
	369	set_extent_ordered(io_tree, start, start + len - 1, GFP_NOFS);
	370	ret = 0;
	371	out:
	372	mutex_unlock(&tree->mutex);
	373	return ret;
	374	#endif
	375	}
	376
	377	struct btrfs_ordered_extent btrfs_lookup_ordered_extent(struct inode inode,
	378	u64 file_offset)
	379	{
	380	struct btrfs_ordered_inode_tree *tree;
	381	struct rb_node *node;
	382	struct btrfs_ordered_extent *entry = NULL;
	383
	384	tree = &BTRFS_I(inode)->ordered_tree;
	385	mutex_lock(&tree->mutex);
	386	node = tree_search(tree, file_offset);
	387	if (!node)
	388	goto out;
	389
	390	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	391	if (!offset_in_entry(entry, file_offset))
	392	entry = NULL;
	393	if (entry)
	394	atomic_inc(&entry->refs);
	395	out:
	396	mutex_unlock(&tree->mutex);
	397	return entry;
	398	}
	399
	400	struct btrfs_ordered_extent *
	401	btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset)
	402	{
	403	struct btrfs_ordered_inode_tree *tree;
	404	struct rb_node *node;
	405	struct btrfs_ordered_extent *entry = NULL;
	406
	407	tree = &BTRFS_I(inode)->ordered_tree;
	408	mutex_lock(&tree->mutex);
	409	node = tree_search(tree, file_offset);
	410	if (!node)
	411	goto out;
	412
	413	entry = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	414	atomic_inc(&entry->refs);
	415	out:
	416	mutex_unlock(&tree->mutex);
	417	return entry;
81d7ed29	418	}
dbe674a9 CM	419
	420	int btrfs_ordered_update_i_size(struct inode *inode,
	421	struct btrfs_ordered_extent *ordered)
	422	{
	423	struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
	424	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	425	u64 disk_i_size;
	426	u64 new_i_size;
	427	u64 i_size_test;
	428	struct rb_node *node;
	429	struct btrfs_ordered_extent *test;
	430
	431	mutex_lock(&tree->mutex);
	432	disk_i_size = BTRFS_I(inode)->disk_i_size;
	433
	434	/*
	435	* if the disk i_size is already at the inode->i_size, or
	436	* this ordered extent is inside the disk i_size, we're done
	437	*/
	438	if (disk_i_size >= inode->i_size \|\|
	439	ordered->file_offset + ordered->len <= disk_i_size) {
	440	goto out;
	441	}
	442
	443	/*
	444	* we can't update the disk_isize if there are delalloc bytes
	445	* between disk_i_size and this ordered extent
	446	*/
	447	if (test_range_bit(io_tree, disk_i_size,
	448	ordered->file_offset + ordered->len - 1,
	449	EXTENT_DELALLOC, 0)) {
	450	goto out;
	451	}
	452	/*
	453	* walk backward from this ordered extent to disk_i_size.
	454	* if we find an ordered extent then we can't update disk i_size
	455	* yet
	456	*/
ba1da2f4	457	node = &ordered->rb_node;
dbe674a9	458	while(1) {
ba1da2f4	459	node = rb_prev(node);
dbe674a9 CM	460	if (!node)
	461	break;
	462	test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	463	if (test->file_offset + test->len <= disk_i_size)
	464	break;
	465	if (test->file_offset >= inode->i_size)
	466	break;
	467	if (test->file_offset >= disk_i_size)
	468	goto out;
	469	}
	470	new_i_size = min_t(u64, entry_end(ordered), i_size_read(inode));
	471
	472	/*
	473	* at this point, we know we can safely update i_size to at least
	474	* the offset from this ordered extent. But, we need to
	475	* walk forward and see if ios from higher up in the file have
	476	* finished.
	477	*/
	478	node = rb_next(&ordered->rb_node);
	479	i_size_test = 0;
	480	if (node) {
	481	/*
	482	* do we have an area where IO might have finished
	483	* between our ordered extent and the next one.
	484	*/
	485	test = rb_entry(node, struct btrfs_ordered_extent, rb_node);
	486	if (test->file_offset > entry_end(ordered)) {
	487	i_size_test = test->file_offset - 1;
	488	}
	489	} else {
	490	i_size_test = i_size_read(inode);
	491	}
	492
	493	/*
	494	* i_size_test is the end of a region after this ordered
	495	* extent where there are no ordered extents. As long as there
	496	* are no delalloc bytes in this area, it is safe to update
	497	* disk_i_size to the end of the region.
	498	*/
	499	if (i_size_test > entry_end(ordered) &&
	500	!test_range_bit(io_tree, entry_end(ordered), i_size_test,
	501	EXTENT_DELALLOC, 0)) {
	502	new_i_size = min_t(u64, i_size_test, i_size_read(inode));
	503	}
	504	BTRFS_I(inode)->disk_i_size = new_i_size;
	505	out:
	506	mutex_unlock(&tree->mutex);
	507	return 0;
	508	}
ba1da2f4 CM	509
	510	int btrfs_find_ordered_sum(struct inode inode, u64 offset, u32 sum)
	511	{
	512	struct btrfs_ordered_sum *ordered_sum;
	513	struct btrfs_sector_sum *sector_sums;
	514	struct btrfs_ordered_extent *ordered;
	515	struct btrfs_ordered_inode_tree *tree = &BTRFS_I(inode)->ordered_tree;
	516	struct list_head *cur;
	517	int ret = 1;
	518	int index;
	519
	520	ordered = btrfs_lookup_ordered_extent(inode, offset);
	521	if (!ordered)
	522	return 1;
	523
	524	mutex_lock(&tree->mutex);
	525	list_for_each_prev(cur, &ordered->list) {
	526	ordered_sum = list_entry(cur, struct btrfs_ordered_sum, list);
	527	if (offset >= ordered_sum->file_offset &&
	528	offset < ordered_sum->file_offset + ordered_sum->len) {
	529	index = (offset - ordered_sum->file_offset) /
	530	BTRFS_I(inode)->root->sectorsize;;
	531	sector_sums = &ordered_sum->sums;
	532	*sum = sector_sums[index].sum;
	533	ret = 0;
	534	goto out;
	535	}
	536	}
	537	out:
	538	mutex_unlock(&tree->mutex);
	539	return ret;
	540	}
	541