[net-next-2.6.git] / fs / btrfs / tree-defrag.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/sched.h>
#include "ctree.h"
#include "disk-io.h"
#include "print-tree.h"
#include "transaction.h"

static void reada_defrag(struct btrfs_root *root,
			 struct extent_buffer *node)
{
	int i;
	u32 nritems;
	u64 bytenr;
	u64 gen;
	u32 blocksize;
	int ret;

	blocksize = btrfs_level_size(root, btrfs_header_level(node) - 1);
	nritems = btrfs_header_nritems(node);
	for (i = 0; i < nritems; i++) {
		bytenr = btrfs_node_blockptr(node, i);
		gen = btrfs_node_ptr_generation(node, i);
		ret = readahead_tree_block(root, bytenr, blocksize, gen);
		if (ret)
			break;
	}
}

static int defrag_walk_down(struct btrfs_trans_handle *trans,
			    struct btrfs_root *root,
			    struct btrfs_path *path, int *level,
			    int cache_only, u64 *last_ret)
{
	struct extent_buffer *next;
	struct extent_buffer *cur;
	u64 bytenr;
	u64 ptr_gen;
	int ret = 0;
	int is_extent = 0;

	WARN_ON(*level < 0);
	WARN_ON(*level >= BTRFS_MAX_LEVEL);

	if (root->fs_info->extent_root == root)
		is_extent = 1;

	if (*level == 1 && cache_only && path->nodes[1] &&
	    !btrfs_buffer_defrag(path->nodes[1])) {
		goto out;
	}
	while(*level > 0) {
		WARN_ON(*level < 0);
		WARN_ON(*level >= BTRFS_MAX_LEVEL);
		cur = path->nodes[*level];

		if (!cache_only && *level > 1 && path->slots[*level] == 0)
			reada_defrag(root, cur);

		if (btrfs_header_level(cur) != *level)
			WARN_ON(1);

		if (path->slots[*level] >=
		    btrfs_header_nritems(cur))
			break;

		if (*level == 1) {
			WARN_ON(btrfs_header_generation(path->nodes[*level]) !=
							trans->transid);
			ret = btrfs_realloc_node(trans, root,
						 path->nodes[*level],
						 path->slots[*level],
						 cache_only, last_ret,
						 &root->defrag_progress);
			if (is_extent)
				btrfs_extent_post_op(trans, root);

			break;
		}
		bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
		ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);

		if (cache_only) {
			next = btrfs_find_tree_block(root, bytenr,
					   btrfs_level_size(root, *level - 1));
			if (!next || !btrfs_buffer_uptodate(next, ptr_gen) ||
			    !btrfs_buffer_defrag(next)) {
				free_extent_buffer(next);
				path->slots[*level]++;
				continue;
			}
		} else {
			next = read_tree_block(root, bytenr,
				       btrfs_level_size(root, *level - 1),
				       ptr_gen);
		}
		ret = btrfs_cow_block(trans, root, next, path->nodes[*level],
				      path->slots[*level], &next);
		BUG_ON(ret);
		if (is_extent)
			btrfs_extent_post_op(trans, root);

		WARN_ON(*level <= 0);
		if (path->nodes[*level-1])
			free_extent_buffer(path->nodes[*level-1]);
		path->nodes[*level-1] = next;
		*level = btrfs_header_level(next);
		path->slots[*level] = 0;
	}
	WARN_ON(*level < 0);
	WARN_ON(*level >= BTRFS_MAX_LEVEL);

	btrfs_clear_buffer_defrag(path->nodes[*level]);
out:
	free_extent_buffer(path->nodes[*level]);
	path->nodes[*level] = NULL;
	*level += 1;
	WARN_ON(ret && ret != -EAGAIN);
	return ret;
}

static int defrag_walk_up(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root,
			  struct btrfs_path *path, int *level,
			  int cache_only)
{
	int i;
	int slot;
	struct extent_buffer *node;

	for(i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
		slot = path->slots[i];
		if (slot < btrfs_header_nritems(path->nodes[i]) - 1) {
			path->slots[i]++;
			*level = i;
			node = path->nodes[i];
			WARN_ON(i == 0);
			btrfs_node_key_to_cpu(node, &root->defrag_progress,
					      path->slots[i]);
			root->defrag_level = i;
			return 0;
		} else {
			btrfs_clear_buffer_defrag(path->nodes[*level]);
			free_extent_buffer(path->nodes[*level]);
			path->nodes[*level] = NULL;
			*level = i + 1;
		}
	}
	return 1;
}

int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
			struct btrfs_root *root, int cache_only)
{
	struct btrfs_path *path = NULL;
	struct extent_buffer *tmp;
	int ret = 0;
	int wret;
	int level;
	int orig_level;
	int i;
	int is_extent = 0;
	u64 last_ret = 0;

	if (root->fs_info->extent_root == root)
		is_extent = 1;

	goto out;

	if (root->ref_cows == 0 && !is_extent)
		goto out;

	if (btrfs_test_opt(root, SSD))
		goto out;

	path = btrfs_alloc_path();
	if (!path)
		return -ENOMEM;

	level = btrfs_header_level(root->node);
	orig_level = level;

	if (level == 0) {
		goto out;
	}
	if (root->defrag_progress.objectid == 0) {
		u32 nritems;

		nritems = btrfs_header_nritems(root->node);
		root->defrag_max.objectid = 0;
		/* from above we know this is not a leaf */
		btrfs_node_key_to_cpu(root->node, &root->defrag_max,
				      nritems - 1);
		extent_buffer_get(root->node);
		ret = btrfs_cow_block(trans, root, root->node, NULL, 0, &tmp);
		BUG_ON(ret);
		path->nodes[level] = root->node;
		path->slots[level] = 0;
		if (is_extent)
			btrfs_extent_post_op(trans, root);
	} else {
		level = root->defrag_level;
		path->lowest_level = level;
		wret = btrfs_search_slot(trans, root, &root->defrag_progress,
					 path, 0, 1);

		if (is_extent)
			btrfs_extent_post_op(trans, root);

		if (wret < 0) {
			ret = wret;
			goto out;
		}

		while(level > 0 && !path->nodes[level])
			level--;

		if (!path->nodes[level]) {
			ret = 0;
			goto out;
		}
	}

	while(1) {
		wret = defrag_walk_down(trans, root, path, &level, cache_only,
					&last_ret);
		if (wret > 0)
			break;
		if (wret < 0)
			ret = wret;

		wret = defrag_walk_up(trans, root, path, &level, cache_only);
		if (wret > 0)
			break;
		if (wret < 0)
			ret = wret;
		else
			ret = -EAGAIN;
		break;
	}
	for (i = 0; i <= orig_level; i++) {
		if (path->nodes[i]) {
			free_extent_buffer(path->nodes[i]);
			path->nodes[i] = NULL;
		}
	}
out:
	if (path)
		btrfs_free_path(path);
	if (ret == -EAGAIN) {
		if (root->defrag_max.objectid > root->defrag_progress.objectid)
			goto done;
		if (root->defrag_max.type > root->defrag_progress.type)
			goto done;
		if (root->defrag_max.offset > root->defrag_progress.offset)
			goto done;
		ret = 0;
	}
done:
	if (ret != -EAGAIN) {
		memset(&root->defrag_progress, 0,
		       sizeof(root->defrag_progress));
	}
	return ret;
}
Commit	Line	Data
6702ed49 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/sched.h>
	20	#include "ctree.h"
	21	#include "disk-io.h"
	22	#include "print-tree.h"
	23	#include "transaction.h"
	24
	25	static void reada_defrag(struct btrfs_root *root,
5f39d397	26	struct extent_buffer *node)
6702ed49 CM	27	{
	28	int i;
	29	u32 nritems;
db94535d	30	u64 bytenr;
ca7a79ad	31	u64 gen;
db94535d	32	u32 blocksize;
6702ed49 CM	33	int ret;
6702ed49 CM	34
db94535d	35	blocksize = btrfs_level_size(root, btrfs_header_level(node) - 1);
5f39d397	36	nritems = btrfs_header_nritems(node);
6702ed49	37	for (i = 0; i < nritems; i++) {
db94535d	38	bytenr = btrfs_node_blockptr(node, i);
ca7a79ad CM	39	gen = btrfs_node_ptr_generation(node, i);
ca7a79ad CM	40	ret = readahead_tree_block(root, bytenr, blocksize, gen);
6702ed49 CM	41	if (ret)
	42	break;
	43	}
	44	}
	45
	46	static int defrag_walk_down(struct btrfs_trans_handle *trans,
	47	struct btrfs_root *root,
	48	struct btrfs_path path, int level,
e9d0b13b	49	int cache_only, u64 *last_ret)
6702ed49	50	{
5f39d397 CM	51	struct extent_buffer *next;
5f39d397 CM	52	struct extent_buffer *cur;
db94535d	53	u64 bytenr;
1259ab75	54	u64 ptr_gen;
6702ed49	55	int ret = 0;
e9d0b13b	56	int is_extent = 0;
6702ed49 CM	57
	58	WARN_ON(*level < 0);
	59	WARN_ON(*level >= BTRFS_MAX_LEVEL);
	60
e9d0b13b CM	61	if (root->fs_info->extent_root == root)
	62	is_extent = 1;
	63
f84a8b36 CM	64	if (*level == 1 && cache_only && path->nodes[1] &&
	65	!btrfs_buffer_defrag(path->nodes[1])) {
	66	goto out;
	67	}
6702ed49 CM	68	while(*level > 0) {
	69	WARN_ON(*level < 0);
	70	WARN_ON(*level >= BTRFS_MAX_LEVEL);
	71	cur = path->nodes[*level];
	72
	73	if (!cache_only && level > 1 && path->slots[level] == 0)
5f39d397	74	reada_defrag(root, cur);
6702ed49	75
5f39d397	76	if (btrfs_header_level(cur) != *level)
6702ed49 CM	77	WARN_ON(1);
	78
	79	if (path->slots[*level] >=
5f39d397	80	btrfs_header_nritems(cur))
6702ed49 CM	81	break;
	82
	83	if (*level == 1) {
7bb86316 CM	84	WARN_ON(btrfs_header_generation(path->nodes[*level]) !=
7bb86316 CM	85	trans->transid);
6702ed49 CM	86	ret = btrfs_realloc_node(trans, root,
6702ed49 CM	87	path->nodes[*level],
a6b6e75e CM	88	path->slots[*level],
	89	cache_only, last_ret,
	90	&root->defrag_progress);
e9d0b13b CM	91	if (is_extent)
	92	btrfs_extent_post_op(trans, root);
	93
6702ed49 CM	94	break;
6702ed49 CM	95	}
db94535d	96	bytenr = btrfs_node_blockptr(cur, path->slots[*level]);
1259ab75	97	ptr_gen = btrfs_node_ptr_generation(cur, path->slots[*level]);
6702ed49 CM	98
6702ed49 CM	99	if (cache_only) {
db94535d CM	100	next = btrfs_find_tree_block(root, bytenr,
db94535d CM	101	btrfs_level_size(root, *level - 1));
1259ab75	102	if (!next \|\| !btrfs_buffer_uptodate(next, ptr_gen) \|\|
cf786e79	103	!btrfs_buffer_defrag(next)) {
5f39d397	104	free_extent_buffer(next);
6702ed49 CM	105	path->slots[*level]++;
	106	continue;
	107	}
	108	} else {
db94535d	109	next = read_tree_block(root, bytenr,
ca7a79ad	110	btrfs_level_size(root, *level - 1),
1259ab75	111	ptr_gen);
6702ed49 CM	112	}
	113	ret = btrfs_cow_block(trans, root, next, path->nodes[*level],
	114	path->slots[*level], &next);
	115	BUG_ON(ret);
e9d0b13b CM	116	if (is_extent)
	117	btrfs_extent_post_op(trans, root);
	118
6702ed49 CM	119	WARN_ON(*level <= 0);
6702ed49 CM	120	if (path->nodes[*level-1])
5f39d397	121	free_extent_buffer(path->nodes[*level-1]);
6702ed49	122	path->nodes[*level-1] = next;
5f39d397	123	*level = btrfs_header_level(next);
6702ed49 CM	124	path->slots[*level] = 0;
	125	}
	126	WARN_ON(*level < 0);
	127	WARN_ON(*level >= BTRFS_MAX_LEVEL);
6b80053d CM	128
6b80053d CM	129	btrfs_clear_buffer_defrag(path->nodes[*level]);
f84a8b36	130	out:
5f39d397	131	free_extent_buffer(path->nodes[*level]);
6702ed49 CM	132	path->nodes[*level] = NULL;
6702ed49 CM	133	*level += 1;
a6b6e75e CM	134	WARN_ON(ret && ret != -EAGAIN);
a6b6e75e CM	135	return ret;
6702ed49 CM	136	}
	137
	138	static int defrag_walk_up(struct btrfs_trans_handle *trans,
	139	struct btrfs_root *root,
	140	struct btrfs_path path, int level,
	141	int cache_only)
	142	{
	143	int i;
	144	int slot;
5f39d397	145	struct extent_buffer *node;
6702ed49 CM	146
	147	for(i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) {
	148	slot = path->slots[i];
5f39d397	149	if (slot < btrfs_header_nritems(path->nodes[i]) - 1) {
6702ed49 CM	150	path->slots[i]++;
6702ed49 CM	151	*level = i;
5f39d397	152	node = path->nodes[i];
6702ed49	153	WARN_ON(i == 0);
5f39d397 CM	154	btrfs_node_key_to_cpu(node, &root->defrag_progress,
5f39d397 CM	155	path->slots[i]);
6702ed49 CM	156	root->defrag_level = i;
	157	return 0;
	158	} else {
6b80053d	159	btrfs_clear_buffer_defrag(path->nodes[*level]);
5f39d397	160	free_extent_buffer(path->nodes[*level]);
6702ed49 CM	161	path->nodes[*level] = NULL;
	162	*level = i + 1;
	163	}
	164	}
	165	return 1;
	166	}
	167
	168	int btrfs_defrag_leaves(struct btrfs_trans_handle *trans,
	169	struct btrfs_root *root, int cache_only)
	170	{
	171	struct btrfs_path *path = NULL;
5f39d397	172	struct extent_buffer *tmp;
6702ed49 CM	173	int ret = 0;
	174	int wret;
	175	int level;
	176	int orig_level;
	177	int i;
e9d0b13b CM	178	int is_extent = 0;
	179	u64 last_ret = 0;
	180
	181	if (root->fs_info->extent_root == root)
	182	is_extent = 1;
6702ed49	183
925baedd CM	184	goto out;
925baedd CM	185
e9d0b13b	186	if (root->ref_cows == 0 && !is_extent)
6702ed49	187	goto out;
5f39d397	188
9afbb0b7 CM	189	if (btrfs_test_opt(root, SSD))
	190	goto out;
	191
6702ed49 CM	192	path = btrfs_alloc_path();
	193	if (!path)
	194	return -ENOMEM;
	195
5f39d397	196	level = btrfs_header_level(root->node);
6702ed49	197	orig_level = level;
0f1ebbd1	198
6702ed49 CM	199	if (level == 0) {
	200	goto out;
	201	}
	202	if (root->defrag_progress.objectid == 0) {
0ef3e66b CM	203	u32 nritems;
	204
	205	nritems = btrfs_header_nritems(root->node);
	206	root->defrag_max.objectid = 0;
	207	/* from above we know this is not a leaf */
	208	btrfs_node_key_to_cpu(root->node, &root->defrag_max,
	209	nritems - 1);
5f39d397	210	extent_buffer_get(root->node);
6702ed49 CM	211	ret = btrfs_cow_block(trans, root, root->node, NULL, 0, &tmp);
6702ed49 CM	212	BUG_ON(ret);
6702ed49 CM	213	path->nodes[level] = root->node;
6702ed49 CM	214	path->slots[level] = 0;
e9d0b13b CM	215	if (is_extent)
e9d0b13b CM	216	btrfs_extent_post_op(trans, root);
6702ed49 CM	217	} else {
	218	level = root->defrag_level;
	219	path->lowest_level = level;
	220	wret = btrfs_search_slot(trans, root, &root->defrag_progress,
	221	path, 0, 1);
	222
e9d0b13b CM	223	if (is_extent)
e9d0b13b CM	224	btrfs_extent_post_op(trans, root);
5f39d397	225
6702ed49 CM	226	if (wret < 0) {
	227	ret = wret;
	228	goto out;
	229	}
5f39d397	230
6702ed49 CM	231	while(level > 0 && !path->nodes[level])
6702ed49 CM	232	level--;
5f39d397	233
6702ed49 CM	234	if (!path->nodes[level]) {
	235	ret = 0;
	236	goto out;
	237	}
	238	}
	239
	240	while(1) {
e9d0b13b CM	241	wret = defrag_walk_down(trans, root, path, &level, cache_only,
e9d0b13b CM	242	&last_ret);
6702ed49 CM	243	if (wret > 0)
	244	break;
	245	if (wret < 0)
	246	ret = wret;
	247
	248	wret = defrag_walk_up(trans, root, path, &level, cache_only);
	249	if (wret > 0)
	250	break;
	251	if (wret < 0)
	252	ret = wret;
081e9573 CM	253	else
081e9573 CM	254	ret = -EAGAIN;
409eb95d	255	break;
6702ed49 CM	256	}
	257	for (i = 0; i <= orig_level; i++) {
	258	if (path->nodes[i]) {
5f39d397	259	free_extent_buffer(path->nodes[i]);
0f82731f	260	path->nodes[i] = NULL;
6702ed49 CM	261	}
	262	}
	263	out:
	264	if (path)
	265	btrfs_free_path(path);
0ef3e66b CM	266	if (ret == -EAGAIN) {
	267	if (root->defrag_max.objectid > root->defrag_progress.objectid)
	268	goto done;
	269	if (root->defrag_max.type > root->defrag_progress.type)
	270	goto done;
	271	if (root->defrag_max.offset > root->defrag_progress.offset)
	272	goto done;
	273	ret = 0;
	274	}
	275	done:
6702ed49 CM	276	if (ret != -EAGAIN) {
	277	memset(&root->defrag_progress, 0,
	278	sizeof(root->defrag_progress));
	279	}
	280	return ret;
	281	}