fs/btrfs/extent-io.c

19 	cache_tree_init(&tree->state);
26 	struct extent_state *state;
28 	state = malloc(sizeof(*state));
29 	if (!state)
31 	state->cache_node.objectid = 0;
32 	state->refs = 1;
33 	state->state = 0;
34 	state->xprivate = 0;
35 	return state;
38 static void btrfs_free_extent_state(struct extent_state *state)
40 	state->refs--;
41 	BUG_ON(state->refs < 0);
42 	if (state->refs == 0)
43 		free(state);
57 	cache_tree_free_extents(&tree->state, free_extent_state_func);
60 static inline void update_extent_state(struct extent_state *state)
62 	state->cache_node.start = state->start;
63 	state->cache_node.size = state->end + 1 - state->start;
68  * Any extents with matching state are merged together into a single
69  * extent in the tree. Extents with EXTENT_IO in their state field are
73 		       struct extent_state *state)
78 	if (state->state & EXTENT_IOBITS)
81 	other_node = prev_cache_extent(&state->cache_node);
85 		if (other->end == state->start - 1 &&
86 		    other->state == state->state) {
87 			state->start = other->start;
88 			update_extent_state(state);
89 			remove_cache_extent(&tree->state, &other->cache_node);
93 	other_node = next_cache_extent(&state->cache_node);
97 		if (other->start == state->end + 1 &&
98 		    other->state == state->state) {
99 			other->start = state->start;
101 			remove_cache_extent(&tree->state, &state->cache_node);
102 			btrfs_free_extent_state(state);
113 			struct extent_state *state, u64 start, u64 end,
119 	state->state |= bits;
120 	state->start = start;
121 	state->end = end;
122 	update_extent_state(state);
123 	ret = insert_cache_extent(&tree->state, &state->cache_node);
125 	merge_state(tree, state);
130  * split a given extent state struct in two, inserting the preallocated
140 	prealloc->state = orig->state;
144 	ret = insert_cache_extent(&tree->state, &prealloc->cache_node);
153 			    struct extent_state *state, int bits)
155 	int ret = state->state & bits;
157 	state->state &= ~bits;
158 	if (state->state == 0) {
159 		remove_cache_extent(&tree->state, &state->cache_node);
160 		btrfs_free_extent_state(state);
162 		merge_state(tree, state);
228 	struct extent_state *state;
246 	node = search_cache_extent(&tree->state, start);
249 	state = container_of(node, struct extent_state, cache_node);
250 	if (state->start > end)
252 	last_end = state->end;
256 	 *  | state | or
257 	 *  | ------------- state -------------- |
269 	if (state->start < start) {
270 		err = split_state(tree, state, prealloc, start);
275 		if (state->end <= end) {
276 			set |= clear_state_bit(tree, state, bits);
281 			start = state->start;
287 	 *                        | state |
291 	if (state->start <= end && state->end > end) {
292 		err = split_state(tree, state, prealloc, end + 1);
300 	start = state->end + 1;
301 	set |= clear_state_bit(tree, state, bits);
322 	struct extent_state *state;
339 	node = search_cache_extent(&tree->state, start);
347 	state = container_of(node, struct extent_state, cache_node);
348 	last_start = state->start;
349 	last_end = state->end;
353 	 * | state |
357 	if (state->start == start && state->end <= end) {
358 		state->state |= bits;
359 		merge_state(tree, state);
367 	 * | state |
369 	 * | ------------- state -------------- |
381 	if (state->start < start) {
382 		err = split_state(tree, state, prealloc, start);
387 		if (state->end <= end) {
388 			state->state |= bits;
389 			start = state->end + 1;
390 			merge_state(tree, state);
395 			start = state->start;
401 	 *     | state | or               | state |
406 	if (state->start > start) {
423 	 * | ---------- state ---------- |
427 	err = split_state(tree, state, prealloc, end + 1);
430 	state->state |= bits;
457 	struct extent_state *state;
464 	node = search_cache_extent(&tree->state, start);
469 		state = container_of(node, struct extent_state, cache_node);
470 		if (state->end >= start && (state->state & bits)) {
471 			*start_ret = state->start;
472 			*end_ret = state->end;
487 	struct extent_state *state = NULL;
491 	node = search_cache_extent(&tree->state, start);
493 		state = container_of(node, struct extent_state, cache_node);
495 		if (filled && state->start > start) {
499 		if (state->start > end)
501 		if (state->state & bits) {
509 		start = state->end + 1;
525 	struct extent_state *state;
528 	node = search_cache_extent(&tree->state, start);
533 	state = container_of(node, struct extent_state, cache_node);
534 	if (state->start != start) {
538 	state->xprivate = private;
546 	struct extent_state *state;
549 	node = search_cache_extent(&tree->state, start);
554 	state = container_of(node, struct extent_state, cache_node);
555 	if (state->start != start) {
559 	*private = state->xprivate;