blob: 980d6a3c342c0b06dc2c992f505e4b25625afa4e [file] [log] [blame]
Chris Mason6cbd5572007-06-12 09:07:21 -04001/*
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 */
Zach Brownec6b9102007-07-11 10:00:37 -040018#include <linux/sched.h>
Chris Masonedbd8d42007-12-21 16:27:24 -050019#include <linux/pagemap.h>
Chris Masonec44a352008-04-28 15:29:52 -040020#include <linux/writeback.h>
David Woodhouse21af8042008-08-12 14:13:26 +010021#include <linux/blkdev.h>
Chris Masonb7a9f292009-02-04 09:23:45 -050022#include <linux/sort.h>
Chris Mason4184ea72009-03-10 12:39:20 -040023#include <linux/rcupdate.h>
Josef Bacik817d52f2009-07-13 21:29:25 -040024#include <linux/kthread.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090025#include <linux/slab.h>
Chris Mason4b4e25f2008-11-20 10:22:27 -050026#include "compat.h"
Chris Mason74493f72007-12-11 09:25:06 -050027#include "hash.h"
Chris Masonfec577f2007-02-26 10:40:21 -050028#include "ctree.h"
29#include "disk-io.h"
30#include "print-tree.h"
Chris Masone089f052007-03-16 16:20:31 -040031#include "transaction.h"
Chris Mason0b86a832008-03-24 15:01:56 -040032#include "volumes.h"
Chris Mason925baed2008-06-25 16:01:30 -040033#include "locking.h"
Chris Masonfa9c0d72009-04-03 09:47:43 -040034#include "free-space-cache.h"
Chris Masonfec577f2007-02-26 10:40:21 -050035
Josef Bacikf3465ca2008-11-12 14:19:50 -050036static int update_block_group(struct btrfs_trans_handle *trans,
37 struct btrfs_root *root,
Yan, Zhengf0486c62010-05-16 10:46:25 -040038 u64 bytenr, u64 num_bytes, int alloc);
39static int update_reserved_bytes(struct btrfs_block_group_cache *cache,
40 u64 num_bytes, int reserve, int sinfo);
Yan Zheng5d4f98a2009-06-10 10:45:14 -040041static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
42 struct btrfs_root *root,
43 u64 bytenr, u64 num_bytes, u64 parent,
44 u64 root_objectid, u64 owner_objectid,
45 u64 owner_offset, int refs_to_drop,
46 struct btrfs_delayed_extent_op *extra_op);
47static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
48 struct extent_buffer *leaf,
49 struct btrfs_extent_item *ei);
50static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
51 struct btrfs_root *root,
52 u64 parent, u64 root_objectid,
53 u64 flags, u64 owner, u64 offset,
54 struct btrfs_key *ins, int ref_mod);
55static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
56 struct btrfs_root *root,
57 u64 parent, u64 root_objectid,
58 u64 flags, struct btrfs_disk_key *key,
59 int level, struct btrfs_key *ins);
Josef Bacik6a632092009-02-20 11:00:09 -050060static int do_chunk_alloc(struct btrfs_trans_handle *trans,
61 struct btrfs_root *extent_root, u64 alloc_bytes,
62 u64 flags, int force);
Yan Zheng11833d62009-09-11 16:11:19 -040063static int find_next_key(struct btrfs_path *path, int level,
64 struct btrfs_key *key);
Josef Bacik9ed74f22009-09-11 16:12:44 -040065static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
66 int dump_block_groups);
Josef Bacik6a632092009-02-20 11:00:09 -050067
Josef Bacik817d52f2009-07-13 21:29:25 -040068static noinline int
69block_group_cache_done(struct btrfs_block_group_cache *cache)
70{
71 smp_mb();
72 return cache->cached == BTRFS_CACHE_FINISHED;
73}
74
Josef Bacik0f9dd462008-09-23 13:14:11 -040075static int block_group_bits(struct btrfs_block_group_cache *cache, u64 bits)
76{
77 return (cache->flags & bits) == bits;
78}
79
Josef Bacik11dfe352009-11-13 20:12:59 +000080void btrfs_get_block_group(struct btrfs_block_group_cache *cache)
81{
82 atomic_inc(&cache->count);
83}
84
85void btrfs_put_block_group(struct btrfs_block_group_cache *cache)
86{
Yan, Zhengf0486c62010-05-16 10:46:25 -040087 if (atomic_dec_and_test(&cache->count)) {
88 WARN_ON(cache->pinned > 0);
89 WARN_ON(cache->reserved > 0);
90 WARN_ON(cache->reserved_pinned > 0);
Josef Bacik11dfe352009-11-13 20:12:59 +000091 kfree(cache);
Yan, Zhengf0486c62010-05-16 10:46:25 -040092 }
Josef Bacik11dfe352009-11-13 20:12:59 +000093}
94
Josef Bacik0f9dd462008-09-23 13:14:11 -040095/*
96 * this adds the block group to the fs_info rb tree for the block group
97 * cache
98 */
Christoph Hellwigb2950862008-12-02 09:54:17 -050099static int btrfs_add_block_group_cache(struct btrfs_fs_info *info,
Josef Bacik0f9dd462008-09-23 13:14:11 -0400100 struct btrfs_block_group_cache *block_group)
101{
102 struct rb_node **p;
103 struct rb_node *parent = NULL;
104 struct btrfs_block_group_cache *cache;
105
106 spin_lock(&info->block_group_cache_lock);
107 p = &info->block_group_cache_tree.rb_node;
108
109 while (*p) {
110 parent = *p;
111 cache = rb_entry(parent, struct btrfs_block_group_cache,
112 cache_node);
113 if (block_group->key.objectid < cache->key.objectid) {
114 p = &(*p)->rb_left;
115 } else if (block_group->key.objectid > cache->key.objectid) {
116 p = &(*p)->rb_right;
117 } else {
118 spin_unlock(&info->block_group_cache_lock);
119 return -EEXIST;
120 }
121 }
122
123 rb_link_node(&block_group->cache_node, parent, p);
124 rb_insert_color(&block_group->cache_node,
125 &info->block_group_cache_tree);
126 spin_unlock(&info->block_group_cache_lock);
127
128 return 0;
129}
130
131/*
132 * This will return the block group at or after bytenr if contains is 0, else
133 * it will return the block group that contains the bytenr
134 */
135static struct btrfs_block_group_cache *
136block_group_cache_tree_search(struct btrfs_fs_info *info, u64 bytenr,
137 int contains)
138{
139 struct btrfs_block_group_cache *cache, *ret = NULL;
140 struct rb_node *n;
141 u64 end, start;
142
143 spin_lock(&info->block_group_cache_lock);
144 n = info->block_group_cache_tree.rb_node;
145
146 while (n) {
147 cache = rb_entry(n, struct btrfs_block_group_cache,
148 cache_node);
149 end = cache->key.objectid + cache->key.offset - 1;
150 start = cache->key.objectid;
151
152 if (bytenr < start) {
153 if (!contains && (!ret || start < ret->key.objectid))
154 ret = cache;
155 n = n->rb_left;
156 } else if (bytenr > start) {
157 if (contains && bytenr <= end) {
158 ret = cache;
159 break;
160 }
161 n = n->rb_right;
162 } else {
163 ret = cache;
164 break;
165 }
166 }
Yan Zhengd2fb3432008-12-11 16:30:39 -0500167 if (ret)
Josef Bacik11dfe352009-11-13 20:12:59 +0000168 btrfs_get_block_group(ret);
Josef Bacik0f9dd462008-09-23 13:14:11 -0400169 spin_unlock(&info->block_group_cache_lock);
170
171 return ret;
172}
173
Yan Zheng11833d62009-09-11 16:11:19 -0400174static int add_excluded_extent(struct btrfs_root *root,
175 u64 start, u64 num_bytes)
Josef Bacik817d52f2009-07-13 21:29:25 -0400176{
Yan Zheng11833d62009-09-11 16:11:19 -0400177 u64 end = start + num_bytes - 1;
178 set_extent_bits(&root->fs_info->freed_extents[0],
179 start, end, EXTENT_UPTODATE, GFP_NOFS);
180 set_extent_bits(&root->fs_info->freed_extents[1],
181 start, end, EXTENT_UPTODATE, GFP_NOFS);
182 return 0;
Josef Bacik817d52f2009-07-13 21:29:25 -0400183}
184
Yan Zheng11833d62009-09-11 16:11:19 -0400185static void free_excluded_extents(struct btrfs_root *root,
186 struct btrfs_block_group_cache *cache)
Josef Bacik817d52f2009-07-13 21:29:25 -0400187{
Yan Zheng11833d62009-09-11 16:11:19 -0400188 u64 start, end;
189
190 start = cache->key.objectid;
191 end = start + cache->key.offset - 1;
192
193 clear_extent_bits(&root->fs_info->freed_extents[0],
194 start, end, EXTENT_UPTODATE, GFP_NOFS);
195 clear_extent_bits(&root->fs_info->freed_extents[1],
196 start, end, EXTENT_UPTODATE, GFP_NOFS);
197}
198
199static int exclude_super_stripes(struct btrfs_root *root,
200 struct btrfs_block_group_cache *cache)
201{
Josef Bacik817d52f2009-07-13 21:29:25 -0400202 u64 bytenr;
203 u64 *logical;
204 int stripe_len;
205 int i, nr, ret;
206
Yan, Zheng06b23312009-11-26 09:31:11 +0000207 if (cache->key.objectid < BTRFS_SUPER_INFO_OFFSET) {
208 stripe_len = BTRFS_SUPER_INFO_OFFSET - cache->key.objectid;
209 cache->bytes_super += stripe_len;
210 ret = add_excluded_extent(root, cache->key.objectid,
211 stripe_len);
212 BUG_ON(ret);
213 }
214
Josef Bacik817d52f2009-07-13 21:29:25 -0400215 for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) {
216 bytenr = btrfs_sb_offset(i);
217 ret = btrfs_rmap_block(&root->fs_info->mapping_tree,
218 cache->key.objectid, bytenr,
219 0, &logical, &nr, &stripe_len);
220 BUG_ON(ret);
Yan Zheng11833d62009-09-11 16:11:19 -0400221
Josef Bacik817d52f2009-07-13 21:29:25 -0400222 while (nr--) {
Josef Bacik1b2da372009-09-11 16:11:20 -0400223 cache->bytes_super += stripe_len;
Yan Zheng11833d62009-09-11 16:11:19 -0400224 ret = add_excluded_extent(root, logical[nr],
225 stripe_len);
226 BUG_ON(ret);
Josef Bacik817d52f2009-07-13 21:29:25 -0400227 }
Yan Zheng11833d62009-09-11 16:11:19 -0400228
Josef Bacik817d52f2009-07-13 21:29:25 -0400229 kfree(logical);
230 }
Josef Bacik817d52f2009-07-13 21:29:25 -0400231 return 0;
232}
233
Yan Zheng11833d62009-09-11 16:11:19 -0400234static struct btrfs_caching_control *
235get_caching_control(struct btrfs_block_group_cache *cache)
236{
237 struct btrfs_caching_control *ctl;
238
239 spin_lock(&cache->lock);
240 if (cache->cached != BTRFS_CACHE_STARTED) {
241 spin_unlock(&cache->lock);
242 return NULL;
243 }
244
Josef Bacikdde5abe2010-09-16 16:17:03 -0400245 /* We're loading it the fast way, so we don't have a caching_ctl. */
246 if (!cache->caching_ctl) {
247 spin_unlock(&cache->lock);
248 return NULL;
249 }
250
Yan Zheng11833d62009-09-11 16:11:19 -0400251 ctl = cache->caching_ctl;
252 atomic_inc(&ctl->count);
253 spin_unlock(&cache->lock);
254 return ctl;
255}
256
257static void put_caching_control(struct btrfs_caching_control *ctl)
258{
259 if (atomic_dec_and_test(&ctl->count))
260 kfree(ctl);
261}
262
Josef Bacik0f9dd462008-09-23 13:14:11 -0400263/*
264 * this is only called by cache_block_group, since we could have freed extents
265 * we need to check the pinned_extents for any extents that can't be used yet
266 * since their free space will be released as soon as the transaction commits.
267 */
Josef Bacik817d52f2009-07-13 21:29:25 -0400268static u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
Josef Bacik0f9dd462008-09-23 13:14:11 -0400269 struct btrfs_fs_info *info, u64 start, u64 end)
270{
Josef Bacik817d52f2009-07-13 21:29:25 -0400271 u64 extent_start, extent_end, size, total_added = 0;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400272 int ret;
273
274 while (start < end) {
Yan Zheng11833d62009-09-11 16:11:19 -0400275 ret = find_first_extent_bit(info->pinned_extents, start,
Josef Bacik0f9dd462008-09-23 13:14:11 -0400276 &extent_start, &extent_end,
Yan Zheng11833d62009-09-11 16:11:19 -0400277 EXTENT_DIRTY | EXTENT_UPTODATE);
Josef Bacik0f9dd462008-09-23 13:14:11 -0400278 if (ret)
279 break;
280
Yan, Zheng06b23312009-11-26 09:31:11 +0000281 if (extent_start <= start) {
Josef Bacik0f9dd462008-09-23 13:14:11 -0400282 start = extent_end + 1;
283 } else if (extent_start > start && extent_start < end) {
284 size = extent_start - start;
Josef Bacik817d52f2009-07-13 21:29:25 -0400285 total_added += size;
Josef Bacikea6a4782008-11-20 12:16:16 -0500286 ret = btrfs_add_free_space(block_group, start,
287 size);
Josef Bacik0f9dd462008-09-23 13:14:11 -0400288 BUG_ON(ret);
289 start = extent_end + 1;
290 } else {
291 break;
292 }
293 }
294
295 if (start < end) {
296 size = end - start;
Josef Bacik817d52f2009-07-13 21:29:25 -0400297 total_added += size;
Josef Bacikea6a4782008-11-20 12:16:16 -0500298 ret = btrfs_add_free_space(block_group, start, size);
Josef Bacik0f9dd462008-09-23 13:14:11 -0400299 BUG_ON(ret);
300 }
301
Josef Bacik817d52f2009-07-13 21:29:25 -0400302 return total_added;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400303}
304
Josef Bacik817d52f2009-07-13 21:29:25 -0400305static int caching_kthread(void *data)
Chris Masone37c9e62007-05-09 20:13:14 -0400306{
Josef Bacik817d52f2009-07-13 21:29:25 -0400307 struct btrfs_block_group_cache *block_group = data;
308 struct btrfs_fs_info *fs_info = block_group->fs_info;
Yan Zheng11833d62009-09-11 16:11:19 -0400309 struct btrfs_caching_control *caching_ctl = block_group->caching_ctl;
310 struct btrfs_root *extent_root = fs_info->extent_root;
Chris Masone37c9e62007-05-09 20:13:14 -0400311 struct btrfs_path *path;
Chris Mason5f39d392007-10-15 16:14:19 -0400312 struct extent_buffer *leaf;
Yan Zheng11833d62009-09-11 16:11:19 -0400313 struct btrfs_key key;
Josef Bacik817d52f2009-07-13 21:29:25 -0400314 u64 total_found = 0;
Yan Zheng11833d62009-09-11 16:11:19 -0400315 u64 last = 0;
316 u32 nritems;
317 int ret = 0;
Chris Masonf510cfe2007-10-15 16:14:48 -0400318
Chris Masone37c9e62007-05-09 20:13:14 -0400319 path = btrfs_alloc_path();
320 if (!path)
321 return -ENOMEM;
Yan7d7d6062007-09-14 16:15:28 -0400322
Yan Zheng11833d62009-09-11 16:11:19 -0400323 exclude_super_stripes(extent_root, block_group);
Josef Bacik1b2da372009-09-11 16:11:20 -0400324 spin_lock(&block_group->space_info->lock);
Yan, Zhengf0486c62010-05-16 10:46:25 -0400325 block_group->space_info->bytes_readonly += block_group->bytes_super;
Josef Bacik1b2da372009-09-11 16:11:20 -0400326 spin_unlock(&block_group->space_info->lock);
Yan Zheng11833d62009-09-11 16:11:19 -0400327
Josef Bacik817d52f2009-07-13 21:29:25 -0400328 last = max_t(u64, block_group->key.objectid, BTRFS_SUPER_INFO_OFFSET);
Yan Zheng11833d62009-09-11 16:11:19 -0400329
Chris Mason5cd57b22008-06-25 16:01:30 -0400330 /*
Josef Bacik817d52f2009-07-13 21:29:25 -0400331 * We don't want to deadlock with somebody trying to allocate a new
332 * extent for the extent root while also trying to search the extent
333 * root to add free space. So we skip locking and search the commit
334 * root, since its read-only
Chris Mason5cd57b22008-06-25 16:01:30 -0400335 */
336 path->skip_locking = 1;
Josef Bacik817d52f2009-07-13 21:29:25 -0400337 path->search_commit_root = 1;
338 path->reada = 2;
339
Yan Zhenge4404d62008-12-12 10:03:26 -0500340 key.objectid = last;
Chris Masone37c9e62007-05-09 20:13:14 -0400341 key.offset = 0;
Yan Zheng11833d62009-09-11 16:11:19 -0400342 key.type = BTRFS_EXTENT_ITEM_KEY;
Chris Mason013f1b12009-07-31 14:57:55 -0400343again:
Yan Zheng11833d62009-09-11 16:11:19 -0400344 mutex_lock(&caching_ctl->mutex);
Chris Mason013f1b12009-07-31 14:57:55 -0400345 /* need to make sure the commit_root doesn't disappear */
346 down_read(&fs_info->extent_commit_sem);
347
Yan Zheng11833d62009-09-11 16:11:19 -0400348 ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
Chris Masone37c9e62007-05-09 20:13:14 -0400349 if (ret < 0)
Josef Bacikef8bbdf2008-09-23 13:14:11 -0400350 goto err;
Yan Zhenga512bbf2008-12-08 16:46:26 -0500351
Yan Zheng11833d62009-09-11 16:11:19 -0400352 leaf = path->nodes[0];
353 nritems = btrfs_header_nritems(leaf);
354
Chris Masond3977122009-01-05 21:25:51 -0500355 while (1) {
Josef Bacik817d52f2009-07-13 21:29:25 -0400356 smp_mb();
Yan Zheng11833d62009-09-11 16:11:19 -0400357 if (fs_info->closing > 1) {
Yan Zhengf25784b2009-07-28 08:41:57 -0400358 last = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -0400359 break;
Yan Zhengf25784b2009-07-28 08:41:57 -0400360 }
Josef Bacik817d52f2009-07-13 21:29:25 -0400361
Yan Zheng11833d62009-09-11 16:11:19 -0400362 if (path->slots[0] < nritems) {
363 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
364 } else {
365 ret = find_next_key(path, 0, &key);
366 if (ret)
Chris Masone37c9e62007-05-09 20:13:14 -0400367 break;
Josef Bacik817d52f2009-07-13 21:29:25 -0400368
Yan Zheng11833d62009-09-11 16:11:19 -0400369 caching_ctl->progress = last;
370 btrfs_release_path(extent_root, path);
371 up_read(&fs_info->extent_commit_sem);
372 mutex_unlock(&caching_ctl->mutex);
373 if (btrfs_transaction_in_commit(fs_info))
Chris Masonf36f3042009-07-30 10:04:48 -0400374 schedule_timeout(1);
Yan Zheng11833d62009-09-11 16:11:19 -0400375 else
376 cond_resched();
377 goto again;
378 }
Josef Bacik817d52f2009-07-13 21:29:25 -0400379
Yan Zheng11833d62009-09-11 16:11:19 -0400380 if (key.objectid < block_group->key.objectid) {
381 path->slots[0]++;
Josef Bacik817d52f2009-07-13 21:29:25 -0400382 continue;
Chris Masone37c9e62007-05-09 20:13:14 -0400383 }
Josef Bacik0f9dd462008-09-23 13:14:11 -0400384
Chris Masone37c9e62007-05-09 20:13:14 -0400385 if (key.objectid >= block_group->key.objectid +
Josef Bacik0f9dd462008-09-23 13:14:11 -0400386 block_group->key.offset)
Yan7d7d6062007-09-14 16:15:28 -0400387 break;
Yan7d7d6062007-09-14 16:15:28 -0400388
Yan Zheng11833d62009-09-11 16:11:19 -0400389 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
Josef Bacik817d52f2009-07-13 21:29:25 -0400390 total_found += add_new_free_space(block_group,
391 fs_info, last,
392 key.objectid);
Yan7d7d6062007-09-14 16:15:28 -0400393 last = key.objectid + key.offset;
Josef Bacik817d52f2009-07-13 21:29:25 -0400394
Yan Zheng11833d62009-09-11 16:11:19 -0400395 if (total_found > (1024 * 1024 * 2)) {
396 total_found = 0;
397 wake_up(&caching_ctl->wait);
398 }
Josef Bacik817d52f2009-07-13 21:29:25 -0400399 }
Chris Masone37c9e62007-05-09 20:13:14 -0400400 path->slots[0]++;
401 }
Josef Bacikef8bbdf2008-09-23 13:14:11 -0400402 ret = 0;
Josef Bacik817d52f2009-07-13 21:29:25 -0400403
404 total_found += add_new_free_space(block_group, fs_info, last,
405 block_group->key.objectid +
406 block_group->key.offset);
Yan Zheng11833d62009-09-11 16:11:19 -0400407 caching_ctl->progress = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -0400408
409 spin_lock(&block_group->lock);
Yan Zheng11833d62009-09-11 16:11:19 -0400410 block_group->caching_ctl = NULL;
Josef Bacik817d52f2009-07-13 21:29:25 -0400411 block_group->cached = BTRFS_CACHE_FINISHED;
412 spin_unlock(&block_group->lock);
413
Chris Mason54aa1f42007-06-22 14:16:25 -0400414err:
Chris Masone37c9e62007-05-09 20:13:14 -0400415 btrfs_free_path(path);
Yan Zheng276e6802009-07-30 09:40:40 -0400416 up_read(&fs_info->extent_commit_sem);
Josef Bacik817d52f2009-07-13 21:29:25 -0400417
Yan Zheng11833d62009-09-11 16:11:19 -0400418 free_excluded_extents(extent_root, block_group);
419
420 mutex_unlock(&caching_ctl->mutex);
421 wake_up(&caching_ctl->wait);
422
423 put_caching_control(caching_ctl);
424 atomic_dec(&block_group->space_info->caching_threads);
Josef Bacik11dfe352009-11-13 20:12:59 +0000425 btrfs_put_block_group(block_group);
426
Josef Bacik817d52f2009-07-13 21:29:25 -0400427 return 0;
428}
429
Josef Bacik9d66e232010-08-25 16:54:15 -0400430static int cache_block_group(struct btrfs_block_group_cache *cache,
431 struct btrfs_trans_handle *trans,
432 int load_cache_only)
Josef Bacik817d52f2009-07-13 21:29:25 -0400433{
Yan Zheng11833d62009-09-11 16:11:19 -0400434 struct btrfs_fs_info *fs_info = cache->fs_info;
435 struct btrfs_caching_control *caching_ctl;
Josef Bacik817d52f2009-07-13 21:29:25 -0400436 struct task_struct *tsk;
437 int ret = 0;
438
Yan Zheng11833d62009-09-11 16:11:19 -0400439 smp_mb();
440 if (cache->cached != BTRFS_CACHE_NO)
441 return 0;
442
Josef Bacik9d66e232010-08-25 16:54:15 -0400443 /*
444 * We can't do the read from on-disk cache during a commit since we need
445 * to have the normal tree locking.
446 */
447 if (!trans->transaction->in_commit) {
448 spin_lock(&cache->lock);
449 if (cache->cached != BTRFS_CACHE_NO) {
450 spin_unlock(&cache->lock);
451 return 0;
452 }
453 cache->cached = BTRFS_CACHE_STARTED;
454 spin_unlock(&cache->lock);
455
456 ret = load_free_space_cache(fs_info, cache);
457
458 spin_lock(&cache->lock);
459 if (ret == 1) {
460 cache->cached = BTRFS_CACHE_FINISHED;
461 cache->last_byte_to_unpin = (u64)-1;
462 } else {
463 cache->cached = BTRFS_CACHE_NO;
464 }
465 spin_unlock(&cache->lock);
466 if (ret == 1)
467 return 0;
468 }
469
470 if (load_cache_only)
471 return 0;
472
Yan Zheng11833d62009-09-11 16:11:19 -0400473 caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_KERNEL);
474 BUG_ON(!caching_ctl);
475
476 INIT_LIST_HEAD(&caching_ctl->list);
477 mutex_init(&caching_ctl->mutex);
478 init_waitqueue_head(&caching_ctl->wait);
479 caching_ctl->block_group = cache;
480 caching_ctl->progress = cache->key.objectid;
481 /* one for caching kthread, one for caching block group list */
482 atomic_set(&caching_ctl->count, 2);
483
Josef Bacik817d52f2009-07-13 21:29:25 -0400484 spin_lock(&cache->lock);
485 if (cache->cached != BTRFS_CACHE_NO) {
486 spin_unlock(&cache->lock);
Yan Zheng11833d62009-09-11 16:11:19 -0400487 kfree(caching_ctl);
488 return 0;
Josef Bacik817d52f2009-07-13 21:29:25 -0400489 }
Yan Zheng11833d62009-09-11 16:11:19 -0400490 cache->caching_ctl = caching_ctl;
Josef Bacik817d52f2009-07-13 21:29:25 -0400491 cache->cached = BTRFS_CACHE_STARTED;
492 spin_unlock(&cache->lock);
493
Yan Zheng11833d62009-09-11 16:11:19 -0400494 down_write(&fs_info->extent_commit_sem);
495 list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);
496 up_write(&fs_info->extent_commit_sem);
497
498 atomic_inc(&cache->space_info->caching_threads);
Josef Bacik11dfe352009-11-13 20:12:59 +0000499 btrfs_get_block_group(cache);
Yan Zheng11833d62009-09-11 16:11:19 -0400500
Josef Bacik817d52f2009-07-13 21:29:25 -0400501 tsk = kthread_run(caching_kthread, cache, "btrfs-cache-%llu\n",
502 cache->key.objectid);
503 if (IS_ERR(tsk)) {
504 ret = PTR_ERR(tsk);
505 printk(KERN_ERR "error running thread %d\n", ret);
506 BUG();
507 }
508
Josef Bacikef8bbdf2008-09-23 13:14:11 -0400509 return ret;
Chris Masone37c9e62007-05-09 20:13:14 -0400510}
511
Josef Bacik0f9dd462008-09-23 13:14:11 -0400512/*
513 * return the block group that starts at or after bytenr
514 */
Chris Masond3977122009-01-05 21:25:51 -0500515static struct btrfs_block_group_cache *
516btrfs_lookup_first_block_group(struct btrfs_fs_info *info, u64 bytenr)
Chris Mason0ef3e662008-05-24 14:04:53 -0400517{
Josef Bacik0f9dd462008-09-23 13:14:11 -0400518 struct btrfs_block_group_cache *cache;
Chris Mason0ef3e662008-05-24 14:04:53 -0400519
Josef Bacik0f9dd462008-09-23 13:14:11 -0400520 cache = block_group_cache_tree_search(info, bytenr, 0);
Chris Mason0ef3e662008-05-24 14:04:53 -0400521
Josef Bacik0f9dd462008-09-23 13:14:11 -0400522 return cache;
Chris Mason0ef3e662008-05-24 14:04:53 -0400523}
524
Josef Bacik0f9dd462008-09-23 13:14:11 -0400525/*
Sankar P9f556842009-05-14 13:52:22 -0400526 * return the block group that contains the given bytenr
Josef Bacik0f9dd462008-09-23 13:14:11 -0400527 */
Chris Masond3977122009-01-05 21:25:51 -0500528struct btrfs_block_group_cache *btrfs_lookup_block_group(
529 struct btrfs_fs_info *info,
530 u64 bytenr)
Chris Masonbe744172007-05-06 10:15:01 -0400531{
Josef Bacik0f9dd462008-09-23 13:14:11 -0400532 struct btrfs_block_group_cache *cache;
Chris Masonbe744172007-05-06 10:15:01 -0400533
Josef Bacik0f9dd462008-09-23 13:14:11 -0400534 cache = block_group_cache_tree_search(info, bytenr, 1);
Chris Mason96b51792007-10-15 16:15:19 -0400535
Josef Bacik0f9dd462008-09-23 13:14:11 -0400536 return cache;
Chris Masonbe744172007-05-06 10:15:01 -0400537}
Chris Mason0b86a832008-03-24 15:01:56 -0400538
Josef Bacik0f9dd462008-09-23 13:14:11 -0400539static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,
540 u64 flags)
Chris Mason6324fbf2008-03-24 15:01:59 -0400541{
Josef Bacik0f9dd462008-09-23 13:14:11 -0400542 struct list_head *head = &info->space_info;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400543 struct btrfs_space_info *found;
Chris Mason4184ea72009-03-10 12:39:20 -0400544
Yan, Zhengb742bb82010-05-16 10:46:24 -0400545 flags &= BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_SYSTEM |
546 BTRFS_BLOCK_GROUP_METADATA;
547
Chris Mason4184ea72009-03-10 12:39:20 -0400548 rcu_read_lock();
549 list_for_each_entry_rcu(found, head, list) {
Josef Bacik67377732010-09-16 16:19:09 -0400550 if (found->flags & flags) {
Chris Mason4184ea72009-03-10 12:39:20 -0400551 rcu_read_unlock();
Josef Bacik0f9dd462008-09-23 13:14:11 -0400552 return found;
Chris Mason4184ea72009-03-10 12:39:20 -0400553 }
Josef Bacik0f9dd462008-09-23 13:14:11 -0400554 }
Chris Mason4184ea72009-03-10 12:39:20 -0400555 rcu_read_unlock();
Josef Bacik0f9dd462008-09-23 13:14:11 -0400556 return NULL;
Chris Mason6324fbf2008-03-24 15:01:59 -0400557}
558
Chris Mason4184ea72009-03-10 12:39:20 -0400559/*
560 * after adding space to the filesystem, we need to clear the full flags
561 * on all the space infos.
562 */
563void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
564{
565 struct list_head *head = &info->space_info;
566 struct btrfs_space_info *found;
567
568 rcu_read_lock();
569 list_for_each_entry_rcu(found, head, list)
570 found->full = 0;
571 rcu_read_unlock();
572}
573
Josef Bacik80eb2342008-10-29 14:49:05 -0400574static u64 div_factor(u64 num, int factor)
575{
576 if (factor == 10)
577 return num;
578 num *= factor;
579 do_div(num, 10);
580 return num;
581}
582
Chris Masone5bc2452010-10-26 13:37:56 -0400583static u64 div_factor_fine(u64 num, int factor)
584{
585 if (factor == 100)
586 return num;
587 num *= factor;
588 do_div(num, 100);
589 return num;
590}
591
Yan Zhengd2fb3432008-12-11 16:30:39 -0500592u64 btrfs_find_block_group(struct btrfs_root *root,
593 u64 search_start, u64 search_hint, int owner)
Chris Masoncd1bc462007-04-27 10:08:34 -0400594{
Chris Mason96b51792007-10-15 16:15:19 -0400595 struct btrfs_block_group_cache *cache;
Chris Masoncd1bc462007-04-27 10:08:34 -0400596 u64 used;
Yan Zhengd2fb3432008-12-11 16:30:39 -0500597 u64 last = max(search_hint, search_start);
598 u64 group_start = 0;
Chris Mason31f3c992007-04-30 15:25:45 -0400599 int full_search = 0;
Yan Zhengd2fb3432008-12-11 16:30:39 -0500600 int factor = 9;
Chris Mason0ef3e662008-05-24 14:04:53 -0400601 int wrapped = 0;
Chris Mason31f3c992007-04-30 15:25:45 -0400602again:
Zheng Yane8569812008-09-26 10:05:48 -0400603 while (1) {
604 cache = btrfs_lookup_first_block_group(root->fs_info, last);
Josef Bacik0f9dd462008-09-23 13:14:11 -0400605 if (!cache)
Chris Masoncd1bc462007-04-27 10:08:34 -0400606 break;
Chris Mason96b51792007-10-15 16:15:19 -0400607
Chris Masonc286ac42008-07-22 23:06:41 -0400608 spin_lock(&cache->lock);
Chris Mason96b51792007-10-15 16:15:19 -0400609 last = cache->key.objectid + cache->key.offset;
610 used = btrfs_block_group_used(&cache->item);
611
Yan Zhengd2fb3432008-12-11 16:30:39 -0500612 if ((full_search || !cache->ro) &&
613 block_group_bits(cache, BTRFS_BLOCK_GROUP_METADATA)) {
Zheng Yane8569812008-09-26 10:05:48 -0400614 if (used + cache->pinned + cache->reserved <
Yan Zhengd2fb3432008-12-11 16:30:39 -0500615 div_factor(cache->key.offset, factor)) {
616 group_start = cache->key.objectid;
Chris Masonc286ac42008-07-22 23:06:41 -0400617 spin_unlock(&cache->lock);
Chris Masonfa9c0d72009-04-03 09:47:43 -0400618 btrfs_put_block_group(cache);
Chris Mason8790d502008-04-03 16:29:03 -0400619 goto found;
620 }
Chris Masoncd1bc462007-04-27 10:08:34 -0400621 }
Chris Masonc286ac42008-07-22 23:06:41 -0400622 spin_unlock(&cache->lock);
Chris Masonfa9c0d72009-04-03 09:47:43 -0400623 btrfs_put_block_group(cache);
Chris Masonde428b62007-05-18 13:28:27 -0400624 cond_resched();
Chris Masoncd1bc462007-04-27 10:08:34 -0400625 }
Chris Mason0ef3e662008-05-24 14:04:53 -0400626 if (!wrapped) {
627 last = search_start;
628 wrapped = 1;
629 goto again;
630 }
631 if (!full_search && factor < 10) {
Chris Masonbe744172007-05-06 10:15:01 -0400632 last = search_start;
Chris Mason31f3c992007-04-30 15:25:45 -0400633 full_search = 1;
Chris Mason0ef3e662008-05-24 14:04:53 -0400634 factor = 10;
Chris Mason31f3c992007-04-30 15:25:45 -0400635 goto again;
636 }
Chris Masonbe744172007-05-06 10:15:01 -0400637found:
Yan Zhengd2fb3432008-12-11 16:30:39 -0500638 return group_start;
Chris Mason925baed2008-06-25 16:01:30 -0400639}
Josef Bacik0f9dd462008-09-23 13:14:11 -0400640
Chris Masone02119d2008-09-05 16:13:11 -0400641/* simple helper to search for an existing extent at a given offset */
Zheng Yan31840ae2008-09-23 13:14:14 -0400642int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
Chris Masone02119d2008-09-05 16:13:11 -0400643{
644 int ret;
645 struct btrfs_key key;
Zheng Yan31840ae2008-09-23 13:14:14 -0400646 struct btrfs_path *path;
Chris Masone02119d2008-09-05 16:13:11 -0400647
Zheng Yan31840ae2008-09-23 13:14:14 -0400648 path = btrfs_alloc_path();
649 BUG_ON(!path);
Chris Masone02119d2008-09-05 16:13:11 -0400650 key.objectid = start;
651 key.offset = len;
652 btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
653 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
654 0, 0);
Zheng Yan31840ae2008-09-23 13:14:14 -0400655 btrfs_free_path(path);
Chris Mason7bb86312007-12-11 09:25:06 -0500656 return ret;
657}
658
Chris Masond8d5f3e2007-12-11 12:42:00 -0500659/*
Yan, Zhenga22285a2010-05-16 10:48:46 -0400660 * helper function to lookup reference count and flags of extent.
661 *
662 * the head node for delayed ref is used to store the sum of all the
663 * reference count modifications queued up in the rbtree. the head
664 * node may also store the extent flags to set. This way you can check
665 * to see what the reference count and extent flags would be if all of
666 * the delayed refs are not processed.
667 */
668int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
669 struct btrfs_root *root, u64 bytenr,
670 u64 num_bytes, u64 *refs, u64 *flags)
671{
672 struct btrfs_delayed_ref_head *head;
673 struct btrfs_delayed_ref_root *delayed_refs;
674 struct btrfs_path *path;
675 struct btrfs_extent_item *ei;
676 struct extent_buffer *leaf;
677 struct btrfs_key key;
678 u32 item_size;
679 u64 num_refs;
680 u64 extent_flags;
681 int ret;
682
683 path = btrfs_alloc_path();
684 if (!path)
685 return -ENOMEM;
686
687 key.objectid = bytenr;
688 key.type = BTRFS_EXTENT_ITEM_KEY;
689 key.offset = num_bytes;
690 if (!trans) {
691 path->skip_locking = 1;
692 path->search_commit_root = 1;
693 }
694again:
695 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
696 &key, path, 0, 0);
697 if (ret < 0)
698 goto out_free;
699
700 if (ret == 0) {
701 leaf = path->nodes[0];
702 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
703 if (item_size >= sizeof(*ei)) {
704 ei = btrfs_item_ptr(leaf, path->slots[0],
705 struct btrfs_extent_item);
706 num_refs = btrfs_extent_refs(leaf, ei);
707 extent_flags = btrfs_extent_flags(leaf, ei);
708 } else {
709#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
710 struct btrfs_extent_item_v0 *ei0;
711 BUG_ON(item_size != sizeof(*ei0));
712 ei0 = btrfs_item_ptr(leaf, path->slots[0],
713 struct btrfs_extent_item_v0);
714 num_refs = btrfs_extent_refs_v0(leaf, ei0);
715 /* FIXME: this isn't correct for data */
716 extent_flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
717#else
718 BUG();
719#endif
720 }
721 BUG_ON(num_refs == 0);
722 } else {
723 num_refs = 0;
724 extent_flags = 0;
725 ret = 0;
726 }
727
728 if (!trans)
729 goto out;
730
731 delayed_refs = &trans->transaction->delayed_refs;
732 spin_lock(&delayed_refs->lock);
733 head = btrfs_find_delayed_ref_head(trans, bytenr);
734 if (head) {
735 if (!mutex_trylock(&head->mutex)) {
736 atomic_inc(&head->node.refs);
737 spin_unlock(&delayed_refs->lock);
738
739 btrfs_release_path(root->fs_info->extent_root, path);
740
741 mutex_lock(&head->mutex);
742 mutex_unlock(&head->mutex);
743 btrfs_put_delayed_ref(&head->node);
744 goto again;
745 }
746 if (head->extent_op && head->extent_op->update_flags)
747 extent_flags |= head->extent_op->flags_to_set;
748 else
749 BUG_ON(num_refs == 0);
750
751 num_refs += head->node.ref_mod;
752 mutex_unlock(&head->mutex);
753 }
754 spin_unlock(&delayed_refs->lock);
755out:
756 WARN_ON(num_refs == 0);
757 if (refs)
758 *refs = num_refs;
759 if (flags)
760 *flags = extent_flags;
761out_free:
762 btrfs_free_path(path);
763 return ret;
764}
765
766/*
Chris Masond8d5f3e2007-12-11 12:42:00 -0500767 * Back reference rules. Back refs have three main goals:
768 *
769 * 1) differentiate between all holders of references to an extent so that
770 * when a reference is dropped we can make sure it was a valid reference
771 * before freeing the extent.
772 *
773 * 2) Provide enough information to quickly find the holders of an extent
774 * if we notice a given block is corrupted or bad.
775 *
776 * 3) Make it easy to migrate blocks for FS shrinking or storage pool
777 * maintenance. This is actually the same as #2, but with a slightly
778 * different use case.
779 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400780 * There are two kinds of back refs. The implicit back refs is optimized
781 * for pointers in non-shared tree blocks. For a given pointer in a block,
782 * back refs of this kind provide information about the block's owner tree
783 * and the pointer's key. These information allow us to find the block by
784 * b-tree searching. The full back refs is for pointers in tree blocks not
785 * referenced by their owner trees. The location of tree block is recorded
786 * in the back refs. Actually the full back refs is generic, and can be
787 * used in all cases the implicit back refs is used. The major shortcoming
788 * of the full back refs is its overhead. Every time a tree block gets
789 * COWed, we have to update back refs entry for all pointers in it.
790 *
791 * For a newly allocated tree block, we use implicit back refs for
792 * pointers in it. This means most tree related operations only involve
793 * implicit back refs. For a tree block created in old transaction, the
794 * only way to drop a reference to it is COW it. So we can detect the
795 * event that tree block loses its owner tree's reference and do the
796 * back refs conversion.
797 *
798 * When a tree block is COW'd through a tree, there are four cases:
799 *
800 * The reference count of the block is one and the tree is the block's
801 * owner tree. Nothing to do in this case.
802 *
803 * The reference count of the block is one and the tree is not the
804 * block's owner tree. In this case, full back refs is used for pointers
805 * in the block. Remove these full back refs, add implicit back refs for
806 * every pointers in the new block.
807 *
808 * The reference count of the block is greater than one and the tree is
809 * the block's owner tree. In this case, implicit back refs is used for
810 * pointers in the block. Add full back refs for every pointers in the
811 * block, increase lower level extents' reference counts. The original
812 * implicit back refs are entailed to the new block.
813 *
814 * The reference count of the block is greater than one and the tree is
815 * not the block's owner tree. Add implicit back refs for every pointer in
816 * the new block, increase lower level extents' reference count.
817 *
818 * Back Reference Key composing:
819 *
820 * The key objectid corresponds to the first byte in the extent,
821 * The key type is used to differentiate between types of back refs.
822 * There are different meanings of the key offset for different types
823 * of back refs.
824 *
Chris Masond8d5f3e2007-12-11 12:42:00 -0500825 * File extents can be referenced by:
826 *
827 * - multiple snapshots, subvolumes, or different generations in one subvol
Zheng Yan31840ae2008-09-23 13:14:14 -0400828 * - different files inside a single subvolume
Chris Masond8d5f3e2007-12-11 12:42:00 -0500829 * - different offsets inside a file (bookend extents in file.c)
830 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400831 * The extent ref structure for the implicit back refs has fields for:
Chris Masond8d5f3e2007-12-11 12:42:00 -0500832 *
833 * - Objectid of the subvolume root
Chris Masond8d5f3e2007-12-11 12:42:00 -0500834 * - objectid of the file holding the reference
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400835 * - original offset in the file
836 * - how many bookend extents
Zheng Yan31840ae2008-09-23 13:14:14 -0400837 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400838 * The key offset for the implicit back refs is hash of the first
839 * three fields.
Chris Masond8d5f3e2007-12-11 12:42:00 -0500840 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400841 * The extent ref structure for the full back refs has field for:
Chris Masond8d5f3e2007-12-11 12:42:00 -0500842 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400843 * - number of pointers in the tree leaf
Chris Masond8d5f3e2007-12-11 12:42:00 -0500844 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400845 * The key offset for the implicit back refs is the first byte of
846 * the tree leaf
Chris Masond8d5f3e2007-12-11 12:42:00 -0500847 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400848 * When a file extent is allocated, The implicit back refs is used.
849 * the fields are filled in:
Chris Masond8d5f3e2007-12-11 12:42:00 -0500850 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400851 * (root_key.objectid, inode objectid, offset in file, 1)
852 *
853 * When a file extent is removed file truncation, we find the
854 * corresponding implicit back refs and check the following fields:
855 *
856 * (btrfs_header_owner(leaf), inode objectid, offset in file)
Chris Masond8d5f3e2007-12-11 12:42:00 -0500857 *
858 * Btree extents can be referenced by:
859 *
860 * - Different subvolumes
Chris Masond8d5f3e2007-12-11 12:42:00 -0500861 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400862 * Both the implicit back refs and the full back refs for tree blocks
863 * only consist of key. The key offset for the implicit back refs is
864 * objectid of block's owner tree. The key offset for the full back refs
865 * is the first byte of parent block.
Chris Masond8d5f3e2007-12-11 12:42:00 -0500866 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400867 * When implicit back refs is used, information about the lowest key and
868 * level of the tree block are required. These information are stored in
869 * tree block info structure.
Chris Masond8d5f3e2007-12-11 12:42:00 -0500870 */
Zheng Yan31840ae2008-09-23 13:14:14 -0400871
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400872#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
873static int convert_extent_item_v0(struct btrfs_trans_handle *trans,
874 struct btrfs_root *root,
875 struct btrfs_path *path,
876 u64 owner, u32 extra_size)
Chris Mason74493f72007-12-11 09:25:06 -0500877{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400878 struct btrfs_extent_item *item;
879 struct btrfs_extent_item_v0 *ei0;
880 struct btrfs_extent_ref_v0 *ref0;
881 struct btrfs_tree_block_info *bi;
Zheng Yan31840ae2008-09-23 13:14:14 -0400882 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400883 struct btrfs_key key;
884 struct btrfs_key found_key;
885 u32 new_size = sizeof(*item);
886 u64 refs;
Chris Mason74493f72007-12-11 09:25:06 -0500887 int ret;
888
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400889 leaf = path->nodes[0];
890 BUG_ON(btrfs_item_size_nr(leaf, path->slots[0]) != sizeof(*ei0));
Chris Mason74493f72007-12-11 09:25:06 -0500891
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400892 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
893 ei0 = btrfs_item_ptr(leaf, path->slots[0],
894 struct btrfs_extent_item_v0);
895 refs = btrfs_extent_refs_v0(leaf, ei0);
896
897 if (owner == (u64)-1) {
898 while (1) {
899 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
900 ret = btrfs_next_leaf(root, path);
901 if (ret < 0)
902 return ret;
903 BUG_ON(ret > 0);
904 leaf = path->nodes[0];
905 }
906 btrfs_item_key_to_cpu(leaf, &found_key,
907 path->slots[0]);
908 BUG_ON(key.objectid != found_key.objectid);
909 if (found_key.type != BTRFS_EXTENT_REF_V0_KEY) {
910 path->slots[0]++;
911 continue;
912 }
913 ref0 = btrfs_item_ptr(leaf, path->slots[0],
914 struct btrfs_extent_ref_v0);
915 owner = btrfs_ref_objectid_v0(leaf, ref0);
916 break;
917 }
918 }
919 btrfs_release_path(root, path);
920
921 if (owner < BTRFS_FIRST_FREE_OBJECTID)
922 new_size += sizeof(*bi);
923
924 new_size -= sizeof(*ei0);
925 ret = btrfs_search_slot(trans, root, &key, path,
926 new_size + extra_size, 1);
Zheng Yan31840ae2008-09-23 13:14:14 -0400927 if (ret < 0)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400928 return ret;
929 BUG_ON(ret);
930
931 ret = btrfs_extend_item(trans, root, path, new_size);
932 BUG_ON(ret);
933
934 leaf = path->nodes[0];
935 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
936 btrfs_set_extent_refs(leaf, item, refs);
937 /* FIXME: get real generation */
938 btrfs_set_extent_generation(leaf, item, 0);
939 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
940 btrfs_set_extent_flags(leaf, item,
941 BTRFS_EXTENT_FLAG_TREE_BLOCK |
942 BTRFS_BLOCK_FLAG_FULL_BACKREF);
943 bi = (struct btrfs_tree_block_info *)(item + 1);
944 /* FIXME: get first key of the block */
945 memset_extent_buffer(leaf, 0, (unsigned long)bi, sizeof(*bi));
946 btrfs_set_tree_block_level(leaf, bi, (int)owner);
947 } else {
948 btrfs_set_extent_flags(leaf, item, BTRFS_EXTENT_FLAG_DATA);
949 }
950 btrfs_mark_buffer_dirty(leaf);
951 return 0;
952}
953#endif
954
955static u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset)
956{
957 u32 high_crc = ~(u32)0;
958 u32 low_crc = ~(u32)0;
959 __le64 lenum;
960
961 lenum = cpu_to_le64(root_objectid);
David Woodhouse163e7832009-04-19 13:02:41 +0100962 high_crc = crc32c(high_crc, &lenum, sizeof(lenum));
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400963 lenum = cpu_to_le64(owner);
David Woodhouse163e7832009-04-19 13:02:41 +0100964 low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400965 lenum = cpu_to_le64(offset);
David Woodhouse163e7832009-04-19 13:02:41 +0100966 low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400967
968 return ((u64)high_crc << 31) ^ (u64)low_crc;
969}
970
971static u64 hash_extent_data_ref_item(struct extent_buffer *leaf,
972 struct btrfs_extent_data_ref *ref)
973{
974 return hash_extent_data_ref(btrfs_extent_data_ref_root(leaf, ref),
975 btrfs_extent_data_ref_objectid(leaf, ref),
976 btrfs_extent_data_ref_offset(leaf, ref));
977}
978
979static int match_extent_data_ref(struct extent_buffer *leaf,
980 struct btrfs_extent_data_ref *ref,
981 u64 root_objectid, u64 owner, u64 offset)
982{
983 if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||
984 btrfs_extent_data_ref_objectid(leaf, ref) != owner ||
985 btrfs_extent_data_ref_offset(leaf, ref) != offset)
986 return 0;
987 return 1;
988}
989
990static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans,
991 struct btrfs_root *root,
992 struct btrfs_path *path,
993 u64 bytenr, u64 parent,
994 u64 root_objectid,
995 u64 owner, u64 offset)
996{
997 struct btrfs_key key;
998 struct btrfs_extent_data_ref *ref;
999 struct extent_buffer *leaf;
1000 u32 nritems;
1001 int ret;
1002 int recow;
1003 int err = -ENOENT;
1004
1005 key.objectid = bytenr;
1006 if (parent) {
1007 key.type = BTRFS_SHARED_DATA_REF_KEY;
1008 key.offset = parent;
1009 } else {
1010 key.type = BTRFS_EXTENT_DATA_REF_KEY;
1011 key.offset = hash_extent_data_ref(root_objectid,
1012 owner, offset);
1013 }
1014again:
1015 recow = 0;
1016 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1017 if (ret < 0) {
1018 err = ret;
1019 goto fail;
1020 }
1021
1022 if (parent) {
1023 if (!ret)
1024 return 0;
1025#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1026 key.type = BTRFS_EXTENT_REF_V0_KEY;
1027 btrfs_release_path(root, path);
1028 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1029 if (ret < 0) {
1030 err = ret;
1031 goto fail;
1032 }
1033 if (!ret)
1034 return 0;
1035#endif
1036 goto fail;
Zheng Yan31840ae2008-09-23 13:14:14 -04001037 }
1038
1039 leaf = path->nodes[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001040 nritems = btrfs_header_nritems(leaf);
1041 while (1) {
1042 if (path->slots[0] >= nritems) {
1043 ret = btrfs_next_leaf(root, path);
1044 if (ret < 0)
1045 err = ret;
1046 if (ret)
1047 goto fail;
1048
1049 leaf = path->nodes[0];
1050 nritems = btrfs_header_nritems(leaf);
1051 recow = 1;
1052 }
1053
1054 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1055 if (key.objectid != bytenr ||
1056 key.type != BTRFS_EXTENT_DATA_REF_KEY)
1057 goto fail;
1058
1059 ref = btrfs_item_ptr(leaf, path->slots[0],
1060 struct btrfs_extent_data_ref);
1061
1062 if (match_extent_data_ref(leaf, ref, root_objectid,
1063 owner, offset)) {
1064 if (recow) {
1065 btrfs_release_path(root, path);
1066 goto again;
1067 }
1068 err = 0;
1069 break;
1070 }
1071 path->slots[0]++;
Zheng Yan31840ae2008-09-23 13:14:14 -04001072 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001073fail:
1074 return err;
Zheng Yan31840ae2008-09-23 13:14:14 -04001075}
1076
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001077static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,
1078 struct btrfs_root *root,
1079 struct btrfs_path *path,
1080 u64 bytenr, u64 parent,
1081 u64 root_objectid, u64 owner,
1082 u64 offset, int refs_to_add)
Zheng Yan31840ae2008-09-23 13:14:14 -04001083{
1084 struct btrfs_key key;
1085 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001086 u32 size;
Zheng Yan31840ae2008-09-23 13:14:14 -04001087 u32 num_refs;
1088 int ret;
1089
1090 key.objectid = bytenr;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001091 if (parent) {
1092 key.type = BTRFS_SHARED_DATA_REF_KEY;
1093 key.offset = parent;
1094 size = sizeof(struct btrfs_shared_data_ref);
Zheng Yan31840ae2008-09-23 13:14:14 -04001095 } else {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001096 key.type = BTRFS_EXTENT_DATA_REF_KEY;
1097 key.offset = hash_extent_data_ref(root_objectid,
1098 owner, offset);
1099 size = sizeof(struct btrfs_extent_data_ref);
Zheng Yan31840ae2008-09-23 13:14:14 -04001100 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001101
1102 ret = btrfs_insert_empty_item(trans, root, path, &key, size);
1103 if (ret && ret != -EEXIST)
1104 goto fail;
1105
1106 leaf = path->nodes[0];
1107 if (parent) {
1108 struct btrfs_shared_data_ref *ref;
1109 ref = btrfs_item_ptr(leaf, path->slots[0],
1110 struct btrfs_shared_data_ref);
1111 if (ret == 0) {
1112 btrfs_set_shared_data_ref_count(leaf, ref, refs_to_add);
1113 } else {
1114 num_refs = btrfs_shared_data_ref_count(leaf, ref);
1115 num_refs += refs_to_add;
1116 btrfs_set_shared_data_ref_count(leaf, ref, num_refs);
1117 }
1118 } else {
1119 struct btrfs_extent_data_ref *ref;
1120 while (ret == -EEXIST) {
1121 ref = btrfs_item_ptr(leaf, path->slots[0],
1122 struct btrfs_extent_data_ref);
1123 if (match_extent_data_ref(leaf, ref, root_objectid,
1124 owner, offset))
1125 break;
1126 btrfs_release_path(root, path);
1127 key.offset++;
1128 ret = btrfs_insert_empty_item(trans, root, path, &key,
1129 size);
1130 if (ret && ret != -EEXIST)
1131 goto fail;
1132
1133 leaf = path->nodes[0];
1134 }
1135 ref = btrfs_item_ptr(leaf, path->slots[0],
1136 struct btrfs_extent_data_ref);
1137 if (ret == 0) {
1138 btrfs_set_extent_data_ref_root(leaf, ref,
1139 root_objectid);
1140 btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
1141 btrfs_set_extent_data_ref_offset(leaf, ref, offset);
1142 btrfs_set_extent_data_ref_count(leaf, ref, refs_to_add);
1143 } else {
1144 num_refs = btrfs_extent_data_ref_count(leaf, ref);
1145 num_refs += refs_to_add;
1146 btrfs_set_extent_data_ref_count(leaf, ref, num_refs);
1147 }
1148 }
1149 btrfs_mark_buffer_dirty(leaf);
1150 ret = 0;
1151fail:
Chris Mason7bb86312007-12-11 09:25:06 -05001152 btrfs_release_path(root, path);
1153 return ret;
Chris Mason74493f72007-12-11 09:25:06 -05001154}
1155
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001156static noinline int remove_extent_data_ref(struct btrfs_trans_handle *trans,
1157 struct btrfs_root *root,
1158 struct btrfs_path *path,
1159 int refs_to_drop)
Zheng Yan31840ae2008-09-23 13:14:14 -04001160{
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001161 struct btrfs_key key;
1162 struct btrfs_extent_data_ref *ref1 = NULL;
1163 struct btrfs_shared_data_ref *ref2 = NULL;
Zheng Yan31840ae2008-09-23 13:14:14 -04001164 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001165 u32 num_refs = 0;
Zheng Yan31840ae2008-09-23 13:14:14 -04001166 int ret = 0;
1167
1168 leaf = path->nodes[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001169 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1170
1171 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1172 ref1 = btrfs_item_ptr(leaf, path->slots[0],
1173 struct btrfs_extent_data_ref);
1174 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1175 } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1176 ref2 = btrfs_item_ptr(leaf, path->slots[0],
1177 struct btrfs_shared_data_ref);
1178 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1179#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1180 } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1181 struct btrfs_extent_ref_v0 *ref0;
1182 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1183 struct btrfs_extent_ref_v0);
1184 num_refs = btrfs_ref_count_v0(leaf, ref0);
1185#endif
1186 } else {
1187 BUG();
1188 }
1189
Chris Mason56bec292009-03-13 10:10:06 -04001190 BUG_ON(num_refs < refs_to_drop);
1191 num_refs -= refs_to_drop;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001192
Zheng Yan31840ae2008-09-23 13:14:14 -04001193 if (num_refs == 0) {
1194 ret = btrfs_del_item(trans, root, path);
1195 } else {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001196 if (key.type == BTRFS_EXTENT_DATA_REF_KEY)
1197 btrfs_set_extent_data_ref_count(leaf, ref1, num_refs);
1198 else if (key.type == BTRFS_SHARED_DATA_REF_KEY)
1199 btrfs_set_shared_data_ref_count(leaf, ref2, num_refs);
1200#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1201 else {
1202 struct btrfs_extent_ref_v0 *ref0;
1203 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1204 struct btrfs_extent_ref_v0);
1205 btrfs_set_ref_count_v0(leaf, ref0, num_refs);
1206 }
1207#endif
Zheng Yan31840ae2008-09-23 13:14:14 -04001208 btrfs_mark_buffer_dirty(leaf);
1209 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001210 return ret;
1211}
1212
1213static noinline u32 extent_data_ref_count(struct btrfs_root *root,
1214 struct btrfs_path *path,
1215 struct btrfs_extent_inline_ref *iref)
1216{
1217 struct btrfs_key key;
1218 struct extent_buffer *leaf;
1219 struct btrfs_extent_data_ref *ref1;
1220 struct btrfs_shared_data_ref *ref2;
1221 u32 num_refs = 0;
1222
1223 leaf = path->nodes[0];
1224 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1225 if (iref) {
1226 if (btrfs_extent_inline_ref_type(leaf, iref) ==
1227 BTRFS_EXTENT_DATA_REF_KEY) {
1228 ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);
1229 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1230 } else {
1231 ref2 = (struct btrfs_shared_data_ref *)(iref + 1);
1232 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1233 }
1234 } else if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1235 ref1 = btrfs_item_ptr(leaf, path->slots[0],
1236 struct btrfs_extent_data_ref);
1237 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1238 } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1239 ref2 = btrfs_item_ptr(leaf, path->slots[0],
1240 struct btrfs_shared_data_ref);
1241 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1242#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1243 } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1244 struct btrfs_extent_ref_v0 *ref0;
1245 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1246 struct btrfs_extent_ref_v0);
1247 num_refs = btrfs_ref_count_v0(leaf, ref0);
1248#endif
1249 } else {
1250 WARN_ON(1);
1251 }
1252 return num_refs;
1253}
1254
1255static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans,
1256 struct btrfs_root *root,
1257 struct btrfs_path *path,
1258 u64 bytenr, u64 parent,
1259 u64 root_objectid)
1260{
1261 struct btrfs_key key;
1262 int ret;
1263
1264 key.objectid = bytenr;
1265 if (parent) {
1266 key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1267 key.offset = parent;
1268 } else {
1269 key.type = BTRFS_TREE_BLOCK_REF_KEY;
1270 key.offset = root_objectid;
1271 }
1272
1273 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1274 if (ret > 0)
1275 ret = -ENOENT;
1276#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1277 if (ret == -ENOENT && parent) {
1278 btrfs_release_path(root, path);
1279 key.type = BTRFS_EXTENT_REF_V0_KEY;
1280 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1281 if (ret > 0)
1282 ret = -ENOENT;
1283 }
1284#endif
1285 return ret;
1286}
1287
1288static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,
1289 struct btrfs_root *root,
1290 struct btrfs_path *path,
1291 u64 bytenr, u64 parent,
1292 u64 root_objectid)
1293{
1294 struct btrfs_key key;
1295 int ret;
1296
1297 key.objectid = bytenr;
1298 if (parent) {
1299 key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1300 key.offset = parent;
1301 } else {
1302 key.type = BTRFS_TREE_BLOCK_REF_KEY;
1303 key.offset = root_objectid;
1304 }
1305
1306 ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
Zheng Yan31840ae2008-09-23 13:14:14 -04001307 btrfs_release_path(root, path);
1308 return ret;
1309}
1310
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001311static inline int extent_ref_type(u64 parent, u64 owner)
1312{
1313 int type;
1314 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1315 if (parent > 0)
1316 type = BTRFS_SHARED_BLOCK_REF_KEY;
1317 else
1318 type = BTRFS_TREE_BLOCK_REF_KEY;
1319 } else {
1320 if (parent > 0)
1321 type = BTRFS_SHARED_DATA_REF_KEY;
1322 else
1323 type = BTRFS_EXTENT_DATA_REF_KEY;
1324 }
1325 return type;
1326}
1327
Yan Zheng2c47e6052009-06-27 21:07:35 -04001328static int find_next_key(struct btrfs_path *path, int level,
1329 struct btrfs_key *key)
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001330
1331{
Yan Zheng2c47e6052009-06-27 21:07:35 -04001332 for (; level < BTRFS_MAX_LEVEL; level++) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001333 if (!path->nodes[level])
1334 break;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001335 if (path->slots[level] + 1 >=
1336 btrfs_header_nritems(path->nodes[level]))
1337 continue;
1338 if (level == 0)
1339 btrfs_item_key_to_cpu(path->nodes[level], key,
1340 path->slots[level] + 1);
1341 else
1342 btrfs_node_key_to_cpu(path->nodes[level], key,
1343 path->slots[level] + 1);
1344 return 0;
1345 }
1346 return 1;
1347}
1348
1349/*
1350 * look for inline back ref. if back ref is found, *ref_ret is set
1351 * to the address of inline back ref, and 0 is returned.
1352 *
1353 * if back ref isn't found, *ref_ret is set to the address where it
1354 * should be inserted, and -ENOENT is returned.
1355 *
1356 * if insert is true and there are too many inline back refs, the path
1357 * points to the extent item, and -EAGAIN is returned.
1358 *
1359 * NOTE: inline back refs are ordered in the same way that back ref
1360 * items in the tree are ordered.
1361 */
1362static noinline_for_stack
1363int lookup_inline_extent_backref(struct btrfs_trans_handle *trans,
1364 struct btrfs_root *root,
1365 struct btrfs_path *path,
1366 struct btrfs_extent_inline_ref **ref_ret,
1367 u64 bytenr, u64 num_bytes,
1368 u64 parent, u64 root_objectid,
1369 u64 owner, u64 offset, int insert)
1370{
1371 struct btrfs_key key;
1372 struct extent_buffer *leaf;
1373 struct btrfs_extent_item *ei;
1374 struct btrfs_extent_inline_ref *iref;
1375 u64 flags;
1376 u64 item_size;
1377 unsigned long ptr;
1378 unsigned long end;
1379 int extra_size;
1380 int type;
1381 int want;
1382 int ret;
1383 int err = 0;
1384
1385 key.objectid = bytenr;
1386 key.type = BTRFS_EXTENT_ITEM_KEY;
1387 key.offset = num_bytes;
1388
1389 want = extent_ref_type(parent, owner);
1390 if (insert) {
1391 extra_size = btrfs_extent_inline_ref_size(want);
Yan Zheng85d41982009-06-11 08:51:10 -04001392 path->keep_locks = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001393 } else
1394 extra_size = -1;
1395 ret = btrfs_search_slot(trans, root, &key, path, extra_size, 1);
1396 if (ret < 0) {
1397 err = ret;
1398 goto out;
1399 }
1400 BUG_ON(ret);
1401
1402 leaf = path->nodes[0];
1403 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1404#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1405 if (item_size < sizeof(*ei)) {
1406 if (!insert) {
1407 err = -ENOENT;
1408 goto out;
1409 }
1410 ret = convert_extent_item_v0(trans, root, path, owner,
1411 extra_size);
1412 if (ret < 0) {
1413 err = ret;
1414 goto out;
1415 }
1416 leaf = path->nodes[0];
1417 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1418 }
1419#endif
1420 BUG_ON(item_size < sizeof(*ei));
1421
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001422 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1423 flags = btrfs_extent_flags(leaf, ei);
1424
1425 ptr = (unsigned long)(ei + 1);
1426 end = (unsigned long)ei + item_size;
1427
1428 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
1429 ptr += sizeof(struct btrfs_tree_block_info);
1430 BUG_ON(ptr > end);
1431 } else {
1432 BUG_ON(!(flags & BTRFS_EXTENT_FLAG_DATA));
1433 }
1434
1435 err = -ENOENT;
1436 while (1) {
1437 if (ptr >= end) {
1438 WARN_ON(ptr > end);
1439 break;
1440 }
1441 iref = (struct btrfs_extent_inline_ref *)ptr;
1442 type = btrfs_extent_inline_ref_type(leaf, iref);
1443 if (want < type)
1444 break;
1445 if (want > type) {
1446 ptr += btrfs_extent_inline_ref_size(type);
1447 continue;
1448 }
1449
1450 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1451 struct btrfs_extent_data_ref *dref;
1452 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1453 if (match_extent_data_ref(leaf, dref, root_objectid,
1454 owner, offset)) {
1455 err = 0;
1456 break;
1457 }
1458 if (hash_extent_data_ref_item(leaf, dref) <
1459 hash_extent_data_ref(root_objectid, owner, offset))
1460 break;
1461 } else {
1462 u64 ref_offset;
1463 ref_offset = btrfs_extent_inline_ref_offset(leaf, iref);
1464 if (parent > 0) {
1465 if (parent == ref_offset) {
1466 err = 0;
1467 break;
1468 }
1469 if (ref_offset < parent)
1470 break;
1471 } else {
1472 if (root_objectid == ref_offset) {
1473 err = 0;
1474 break;
1475 }
1476 if (ref_offset < root_objectid)
1477 break;
1478 }
1479 }
1480 ptr += btrfs_extent_inline_ref_size(type);
1481 }
1482 if (err == -ENOENT && insert) {
1483 if (item_size + extra_size >=
1484 BTRFS_MAX_EXTENT_ITEM_SIZE(root)) {
1485 err = -EAGAIN;
1486 goto out;
1487 }
1488 /*
1489 * To add new inline back ref, we have to make sure
1490 * there is no corresponding back ref item.
1491 * For simplicity, we just do not add new inline back
1492 * ref if there is any kind of item for this block
1493 */
Yan Zheng2c47e6052009-06-27 21:07:35 -04001494 if (find_next_key(path, 0, &key) == 0 &&
1495 key.objectid == bytenr &&
Yan Zheng85d41982009-06-11 08:51:10 -04001496 key.type < BTRFS_BLOCK_GROUP_ITEM_KEY) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001497 err = -EAGAIN;
1498 goto out;
1499 }
1500 }
1501 *ref_ret = (struct btrfs_extent_inline_ref *)ptr;
1502out:
Yan Zheng85d41982009-06-11 08:51:10 -04001503 if (insert) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001504 path->keep_locks = 0;
1505 btrfs_unlock_up_safe(path, 1);
1506 }
1507 return err;
1508}
1509
1510/*
1511 * helper to add new inline back ref
1512 */
1513static noinline_for_stack
1514int setup_inline_extent_backref(struct btrfs_trans_handle *trans,
1515 struct btrfs_root *root,
1516 struct btrfs_path *path,
1517 struct btrfs_extent_inline_ref *iref,
1518 u64 parent, u64 root_objectid,
1519 u64 owner, u64 offset, int refs_to_add,
1520 struct btrfs_delayed_extent_op *extent_op)
1521{
1522 struct extent_buffer *leaf;
1523 struct btrfs_extent_item *ei;
1524 unsigned long ptr;
1525 unsigned long end;
1526 unsigned long item_offset;
1527 u64 refs;
1528 int size;
1529 int type;
1530 int ret;
1531
1532 leaf = path->nodes[0];
1533 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1534 item_offset = (unsigned long)iref - (unsigned long)ei;
1535
1536 type = extent_ref_type(parent, owner);
1537 size = btrfs_extent_inline_ref_size(type);
1538
1539 ret = btrfs_extend_item(trans, root, path, size);
1540 BUG_ON(ret);
1541
1542 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1543 refs = btrfs_extent_refs(leaf, ei);
1544 refs += refs_to_add;
1545 btrfs_set_extent_refs(leaf, ei, refs);
1546 if (extent_op)
1547 __run_delayed_extent_op(extent_op, leaf, ei);
1548
1549 ptr = (unsigned long)ei + item_offset;
1550 end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);
1551 if (ptr < end - size)
1552 memmove_extent_buffer(leaf, ptr + size, ptr,
1553 end - size - ptr);
1554
1555 iref = (struct btrfs_extent_inline_ref *)ptr;
1556 btrfs_set_extent_inline_ref_type(leaf, iref, type);
1557 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1558 struct btrfs_extent_data_ref *dref;
1559 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1560 btrfs_set_extent_data_ref_root(leaf, dref, root_objectid);
1561 btrfs_set_extent_data_ref_objectid(leaf, dref, owner);
1562 btrfs_set_extent_data_ref_offset(leaf, dref, offset);
1563 btrfs_set_extent_data_ref_count(leaf, dref, refs_to_add);
1564 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1565 struct btrfs_shared_data_ref *sref;
1566 sref = (struct btrfs_shared_data_ref *)(iref + 1);
1567 btrfs_set_shared_data_ref_count(leaf, sref, refs_to_add);
1568 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1569 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
1570 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1571 } else {
1572 btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
1573 }
1574 btrfs_mark_buffer_dirty(leaf);
1575 return 0;
1576}
1577
1578static int lookup_extent_backref(struct btrfs_trans_handle *trans,
1579 struct btrfs_root *root,
1580 struct btrfs_path *path,
1581 struct btrfs_extent_inline_ref **ref_ret,
1582 u64 bytenr, u64 num_bytes, u64 parent,
1583 u64 root_objectid, u64 owner, u64 offset)
1584{
1585 int ret;
1586
1587 ret = lookup_inline_extent_backref(trans, root, path, ref_ret,
1588 bytenr, num_bytes, parent,
1589 root_objectid, owner, offset, 0);
1590 if (ret != -ENOENT)
1591 return ret;
1592
1593 btrfs_release_path(root, path);
1594 *ref_ret = NULL;
1595
1596 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1597 ret = lookup_tree_block_ref(trans, root, path, bytenr, parent,
1598 root_objectid);
1599 } else {
1600 ret = lookup_extent_data_ref(trans, root, path, bytenr, parent,
1601 root_objectid, owner, offset);
1602 }
1603 return ret;
1604}
1605
1606/*
1607 * helper to update/remove inline back ref
1608 */
1609static noinline_for_stack
1610int update_inline_extent_backref(struct btrfs_trans_handle *trans,
1611 struct btrfs_root *root,
1612 struct btrfs_path *path,
1613 struct btrfs_extent_inline_ref *iref,
1614 int refs_to_mod,
1615 struct btrfs_delayed_extent_op *extent_op)
1616{
1617 struct extent_buffer *leaf;
1618 struct btrfs_extent_item *ei;
1619 struct btrfs_extent_data_ref *dref = NULL;
1620 struct btrfs_shared_data_ref *sref = NULL;
1621 unsigned long ptr;
1622 unsigned long end;
1623 u32 item_size;
1624 int size;
1625 int type;
1626 int ret;
1627 u64 refs;
1628
1629 leaf = path->nodes[0];
1630 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1631 refs = btrfs_extent_refs(leaf, ei);
1632 WARN_ON(refs_to_mod < 0 && refs + refs_to_mod <= 0);
1633 refs += refs_to_mod;
1634 btrfs_set_extent_refs(leaf, ei, refs);
1635 if (extent_op)
1636 __run_delayed_extent_op(extent_op, leaf, ei);
1637
1638 type = btrfs_extent_inline_ref_type(leaf, iref);
1639
1640 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1641 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1642 refs = btrfs_extent_data_ref_count(leaf, dref);
1643 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1644 sref = (struct btrfs_shared_data_ref *)(iref + 1);
1645 refs = btrfs_shared_data_ref_count(leaf, sref);
1646 } else {
1647 refs = 1;
1648 BUG_ON(refs_to_mod != -1);
1649 }
1650
1651 BUG_ON(refs_to_mod < 0 && refs < -refs_to_mod);
1652 refs += refs_to_mod;
1653
1654 if (refs > 0) {
1655 if (type == BTRFS_EXTENT_DATA_REF_KEY)
1656 btrfs_set_extent_data_ref_count(leaf, dref, refs);
1657 else
1658 btrfs_set_shared_data_ref_count(leaf, sref, refs);
1659 } else {
1660 size = btrfs_extent_inline_ref_size(type);
1661 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1662 ptr = (unsigned long)iref;
1663 end = (unsigned long)ei + item_size;
1664 if (ptr + size < end)
1665 memmove_extent_buffer(leaf, ptr, ptr + size,
1666 end - ptr - size);
1667 item_size -= size;
1668 ret = btrfs_truncate_item(trans, root, path, item_size, 1);
1669 BUG_ON(ret);
1670 }
1671 btrfs_mark_buffer_dirty(leaf);
1672 return 0;
1673}
1674
1675static noinline_for_stack
1676int insert_inline_extent_backref(struct btrfs_trans_handle *trans,
1677 struct btrfs_root *root,
1678 struct btrfs_path *path,
1679 u64 bytenr, u64 num_bytes, u64 parent,
1680 u64 root_objectid, u64 owner,
1681 u64 offset, int refs_to_add,
1682 struct btrfs_delayed_extent_op *extent_op)
1683{
1684 struct btrfs_extent_inline_ref *iref;
1685 int ret;
1686
1687 ret = lookup_inline_extent_backref(trans, root, path, &iref,
1688 bytenr, num_bytes, parent,
1689 root_objectid, owner, offset, 1);
1690 if (ret == 0) {
1691 BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID);
1692 ret = update_inline_extent_backref(trans, root, path, iref,
1693 refs_to_add, extent_op);
1694 } else if (ret == -ENOENT) {
1695 ret = setup_inline_extent_backref(trans, root, path, iref,
1696 parent, root_objectid,
1697 owner, offset, refs_to_add,
1698 extent_op);
1699 }
1700 return ret;
1701}
1702
1703static int insert_extent_backref(struct btrfs_trans_handle *trans,
1704 struct btrfs_root *root,
1705 struct btrfs_path *path,
1706 u64 bytenr, u64 parent, u64 root_objectid,
1707 u64 owner, u64 offset, int refs_to_add)
1708{
1709 int ret;
1710 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1711 BUG_ON(refs_to_add != 1);
1712 ret = insert_tree_block_ref(trans, root, path, bytenr,
1713 parent, root_objectid);
1714 } else {
1715 ret = insert_extent_data_ref(trans, root, path, bytenr,
1716 parent, root_objectid,
1717 owner, offset, refs_to_add);
1718 }
1719 return ret;
1720}
1721
1722static int remove_extent_backref(struct btrfs_trans_handle *trans,
1723 struct btrfs_root *root,
1724 struct btrfs_path *path,
1725 struct btrfs_extent_inline_ref *iref,
1726 int refs_to_drop, int is_data)
1727{
1728 int ret;
1729
1730 BUG_ON(!is_data && refs_to_drop != 1);
1731 if (iref) {
1732 ret = update_inline_extent_backref(trans, root, path, iref,
1733 -refs_to_drop, NULL);
1734 } else if (is_data) {
1735 ret = remove_extent_data_ref(trans, root, path, refs_to_drop);
1736 } else {
1737 ret = btrfs_del_item(trans, root, path);
1738 }
1739 return ret;
1740}
1741
Chris Mason15916de2008-11-19 21:17:22 -05001742static void btrfs_issue_discard(struct block_device *bdev,
1743 u64 start, u64 len)
1744{
Christoph Hellwig746cd1e2009-09-12 07:35:43 +02001745 blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_KERNEL,
Dmitry Monakhovfbd9b092010-04-28 17:55:06 +04001746 BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
Chris Mason15916de2008-11-19 21:17:22 -05001747}
Chris Mason15916de2008-11-19 21:17:22 -05001748
Liu Hui1f3c79a2009-01-05 15:57:51 -05001749static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
1750 u64 num_bytes)
1751{
Liu Hui1f3c79a2009-01-05 15:57:51 -05001752 int ret;
1753 u64 map_length = num_bytes;
1754 struct btrfs_multi_bio *multi = NULL;
1755
Christoph Hellwige244a0a2009-10-14 09:24:59 -04001756 if (!btrfs_test_opt(root, DISCARD))
1757 return 0;
1758
Liu Hui1f3c79a2009-01-05 15:57:51 -05001759 /* Tell the block device(s) that the sectors can be discarded */
1760 ret = btrfs_map_block(&root->fs_info->mapping_tree, READ,
1761 bytenr, &map_length, &multi, 0);
1762 if (!ret) {
1763 struct btrfs_bio_stripe *stripe = multi->stripes;
1764 int i;
1765
1766 if (map_length > num_bytes)
1767 map_length = num_bytes;
1768
1769 for (i = 0; i < multi->num_stripes; i++, stripe++) {
1770 btrfs_issue_discard(stripe->dev->bdev,
1771 stripe->physical,
1772 map_length);
1773 }
1774 kfree(multi);
1775 }
1776
1777 return ret;
Liu Hui1f3c79a2009-01-05 15:57:51 -05001778}
1779
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001780int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1781 struct btrfs_root *root,
1782 u64 bytenr, u64 num_bytes, u64 parent,
1783 u64 root_objectid, u64 owner, u64 offset)
Zheng Yan31840ae2008-09-23 13:14:14 -04001784{
1785 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001786 BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID &&
1787 root_objectid == BTRFS_TREE_LOG_OBJECTID);
Zheng Yan31840ae2008-09-23 13:14:14 -04001788
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001789 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1790 ret = btrfs_add_delayed_tree_ref(trans, bytenr, num_bytes,
1791 parent, root_objectid, (int)owner,
1792 BTRFS_ADD_DELAYED_REF, NULL);
1793 } else {
1794 ret = btrfs_add_delayed_data_ref(trans, bytenr, num_bytes,
1795 parent, root_objectid, owner, offset,
1796 BTRFS_ADD_DELAYED_REF, NULL);
1797 }
Zheng Yan31840ae2008-09-23 13:14:14 -04001798 return ret;
1799}
1800
Chris Mason925baed2008-06-25 16:01:30 -04001801static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001802 struct btrfs_root *root,
1803 u64 bytenr, u64 num_bytes,
1804 u64 parent, u64 root_objectid,
1805 u64 owner, u64 offset, int refs_to_add,
1806 struct btrfs_delayed_extent_op *extent_op)
Chris Mason56bec292009-03-13 10:10:06 -04001807{
Chris Mason5caf2a02007-04-02 11:20:42 -04001808 struct btrfs_path *path;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001809 struct extent_buffer *leaf;
Chris Mason234b63a2007-03-13 10:46:10 -04001810 struct btrfs_extent_item *item;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001811 u64 refs;
1812 int ret;
1813 int err = 0;
Chris Mason037e6392007-03-07 11:50:24 -05001814
Chris Mason5caf2a02007-04-02 11:20:42 -04001815 path = btrfs_alloc_path();
Chris Mason54aa1f42007-06-22 14:16:25 -04001816 if (!path)
1817 return -ENOMEM;
Chris Mason26b80032007-08-08 20:17:12 -04001818
Chris Mason3c12ac72008-04-21 12:01:38 -04001819 path->reada = 1;
Chris Masonb9473432009-03-13 11:00:37 -04001820 path->leave_spinning = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001821 /* this will setup the path even if it fails to insert the back ref */
1822 ret = insert_inline_extent_backref(trans, root->fs_info->extent_root,
1823 path, bytenr, num_bytes, parent,
1824 root_objectid, owner, offset,
1825 refs_to_add, extent_op);
1826 if (ret == 0)
1827 goto out;
Zheng Yan31840ae2008-09-23 13:14:14 -04001828
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001829 if (ret != -EAGAIN) {
1830 err = ret;
1831 goto out;
Chris Masonb9473432009-03-13 11:00:37 -04001832 }
Zheng Yan31840ae2008-09-23 13:14:14 -04001833
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001834 leaf = path->nodes[0];
1835 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1836 refs = btrfs_extent_refs(leaf, item);
1837 btrfs_set_extent_refs(leaf, item, refs + refs_to_add);
1838 if (extent_op)
1839 __run_delayed_extent_op(extent_op, leaf, item);
Zheng Yan31840ae2008-09-23 13:14:14 -04001840
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001841 btrfs_mark_buffer_dirty(leaf);
Chris Mason5caf2a02007-04-02 11:20:42 -04001842 btrfs_release_path(root->fs_info->extent_root, path);
Chris Mason7bb86312007-12-11 09:25:06 -05001843
Chris Mason3c12ac72008-04-21 12:01:38 -04001844 path->reada = 1;
Chris Masonb9473432009-03-13 11:00:37 -04001845 path->leave_spinning = 1;
1846
Chris Mason56bec292009-03-13 10:10:06 -04001847 /* now insert the actual backref */
Zheng Yan31840ae2008-09-23 13:14:14 -04001848 ret = insert_extent_backref(trans, root->fs_info->extent_root,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001849 path, bytenr, parent, root_objectid,
1850 owner, offset, refs_to_add);
Chris Mason7bb86312007-12-11 09:25:06 -05001851 BUG_ON(ret);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001852out:
Chris Mason74493f72007-12-11 09:25:06 -05001853 btrfs_free_path(path);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001854 return err;
Chris Mason02217ed2007-03-02 16:08:05 -05001855}
1856
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001857static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
1858 struct btrfs_root *root,
1859 struct btrfs_delayed_ref_node *node,
1860 struct btrfs_delayed_extent_op *extent_op,
1861 int insert_reserved)
Chris Masone9d0b132007-08-10 14:06:19 -04001862{
Chris Mason56bec292009-03-13 10:10:06 -04001863 int ret = 0;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001864 struct btrfs_delayed_data_ref *ref;
1865 struct btrfs_key ins;
1866 u64 parent = 0;
1867 u64 ref_root = 0;
1868 u64 flags = 0;
Chris Mason56bec292009-03-13 10:10:06 -04001869
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001870 ins.objectid = node->bytenr;
1871 ins.offset = node->num_bytes;
1872 ins.type = BTRFS_EXTENT_ITEM_KEY;
Chris Mason56bec292009-03-13 10:10:06 -04001873
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001874 ref = btrfs_delayed_node_to_data_ref(node);
1875 if (node->type == BTRFS_SHARED_DATA_REF_KEY)
1876 parent = ref->parent;
1877 else
1878 ref_root = ref->root;
1879
1880 if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
1881 if (extent_op) {
1882 BUG_ON(extent_op->update_key);
1883 flags |= extent_op->flags_to_set;
1884 }
1885 ret = alloc_reserved_file_extent(trans, root,
1886 parent, ref_root, flags,
1887 ref->objectid, ref->offset,
1888 &ins, node->ref_mod);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001889 } else if (node->action == BTRFS_ADD_DELAYED_REF) {
1890 ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
1891 node->num_bytes, parent,
1892 ref_root, ref->objectid,
1893 ref->offset, node->ref_mod,
1894 extent_op);
1895 } else if (node->action == BTRFS_DROP_DELAYED_REF) {
1896 ret = __btrfs_free_extent(trans, root, node->bytenr,
1897 node->num_bytes, parent,
1898 ref_root, ref->objectid,
1899 ref->offset, node->ref_mod,
1900 extent_op);
1901 } else {
1902 BUG();
1903 }
Chris Mason56bec292009-03-13 10:10:06 -04001904 return ret;
1905}
1906
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001907static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
1908 struct extent_buffer *leaf,
1909 struct btrfs_extent_item *ei)
1910{
1911 u64 flags = btrfs_extent_flags(leaf, ei);
1912 if (extent_op->update_flags) {
1913 flags |= extent_op->flags_to_set;
1914 btrfs_set_extent_flags(leaf, ei, flags);
1915 }
1916
1917 if (extent_op->update_key) {
1918 struct btrfs_tree_block_info *bi;
1919 BUG_ON(!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK));
1920 bi = (struct btrfs_tree_block_info *)(ei + 1);
1921 btrfs_set_tree_block_key(leaf, bi, &extent_op->key);
1922 }
1923}
1924
1925static int run_delayed_extent_op(struct btrfs_trans_handle *trans,
1926 struct btrfs_root *root,
1927 struct btrfs_delayed_ref_node *node,
1928 struct btrfs_delayed_extent_op *extent_op)
1929{
1930 struct btrfs_key key;
1931 struct btrfs_path *path;
1932 struct btrfs_extent_item *ei;
1933 struct extent_buffer *leaf;
1934 u32 item_size;
1935 int ret;
1936 int err = 0;
1937
1938 path = btrfs_alloc_path();
1939 if (!path)
1940 return -ENOMEM;
1941
1942 key.objectid = node->bytenr;
1943 key.type = BTRFS_EXTENT_ITEM_KEY;
1944 key.offset = node->num_bytes;
1945
1946 path->reada = 1;
1947 path->leave_spinning = 1;
1948 ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key,
1949 path, 0, 1);
1950 if (ret < 0) {
1951 err = ret;
1952 goto out;
1953 }
1954 if (ret > 0) {
1955 err = -EIO;
1956 goto out;
1957 }
1958
1959 leaf = path->nodes[0];
1960 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1961#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1962 if (item_size < sizeof(*ei)) {
1963 ret = convert_extent_item_v0(trans, root->fs_info->extent_root,
1964 path, (u64)-1, 0);
1965 if (ret < 0) {
1966 err = ret;
1967 goto out;
1968 }
1969 leaf = path->nodes[0];
1970 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1971 }
1972#endif
1973 BUG_ON(item_size < sizeof(*ei));
1974 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1975 __run_delayed_extent_op(extent_op, leaf, ei);
1976
1977 btrfs_mark_buffer_dirty(leaf);
1978out:
1979 btrfs_free_path(path);
1980 return err;
1981}
1982
1983static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
1984 struct btrfs_root *root,
1985 struct btrfs_delayed_ref_node *node,
1986 struct btrfs_delayed_extent_op *extent_op,
1987 int insert_reserved)
1988{
1989 int ret = 0;
1990 struct btrfs_delayed_tree_ref *ref;
1991 struct btrfs_key ins;
1992 u64 parent = 0;
1993 u64 ref_root = 0;
1994
1995 ins.objectid = node->bytenr;
1996 ins.offset = node->num_bytes;
1997 ins.type = BTRFS_EXTENT_ITEM_KEY;
1998
1999 ref = btrfs_delayed_node_to_tree_ref(node);
2000 if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)
2001 parent = ref->parent;
2002 else
2003 ref_root = ref->root;
2004
2005 BUG_ON(node->ref_mod != 1);
2006 if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
2007 BUG_ON(!extent_op || !extent_op->update_flags ||
2008 !extent_op->update_key);
2009 ret = alloc_reserved_tree_block(trans, root,
2010 parent, ref_root,
2011 extent_op->flags_to_set,
2012 &extent_op->key,
2013 ref->level, &ins);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002014 } else if (node->action == BTRFS_ADD_DELAYED_REF) {
2015 ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
2016 node->num_bytes, parent, ref_root,
2017 ref->level, 0, 1, extent_op);
2018 } else if (node->action == BTRFS_DROP_DELAYED_REF) {
2019 ret = __btrfs_free_extent(trans, root, node->bytenr,
2020 node->num_bytes, parent, ref_root,
2021 ref->level, 0, 1, extent_op);
2022 } else {
2023 BUG();
2024 }
2025 return ret;
2026}
2027
Chris Mason56bec292009-03-13 10:10:06 -04002028/* helper function to actually process a single delayed ref entry */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002029static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
2030 struct btrfs_root *root,
2031 struct btrfs_delayed_ref_node *node,
2032 struct btrfs_delayed_extent_op *extent_op,
2033 int insert_reserved)
Chris Mason56bec292009-03-13 10:10:06 -04002034{
Josef Bacikeb099672009-02-12 09:27:38 -05002035 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002036 if (btrfs_delayed_ref_is_head(node)) {
Chris Mason56bec292009-03-13 10:10:06 -04002037 struct btrfs_delayed_ref_head *head;
2038 /*
2039 * we've hit the end of the chain and we were supposed
2040 * to insert this extent into the tree. But, it got
2041 * deleted before we ever needed to insert it, so all
2042 * we have to do is clean up the accounting
2043 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002044 BUG_ON(extent_op);
2045 head = btrfs_delayed_node_to_head(node);
Chris Mason56bec292009-03-13 10:10:06 -04002046 if (insert_reserved) {
Yan, Zhengf0486c62010-05-16 10:46:25 -04002047 btrfs_pin_extent(root, node->bytenr,
2048 node->num_bytes, 1);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002049 if (head->is_data) {
2050 ret = btrfs_del_csums(trans, root,
2051 node->bytenr,
2052 node->num_bytes);
2053 BUG_ON(ret);
2054 }
Chris Mason56bec292009-03-13 10:10:06 -04002055 }
Chris Mason56bec292009-03-13 10:10:06 -04002056 mutex_unlock(&head->mutex);
2057 return 0;
2058 }
Josef Bacikeb099672009-02-12 09:27:38 -05002059
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002060 if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
2061 node->type == BTRFS_SHARED_BLOCK_REF_KEY)
2062 ret = run_delayed_tree_ref(trans, root, node, extent_op,
2063 insert_reserved);
2064 else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
2065 node->type == BTRFS_SHARED_DATA_REF_KEY)
2066 ret = run_delayed_data_ref(trans, root, node, extent_op,
2067 insert_reserved);
2068 else
2069 BUG();
2070 return ret;
Chris Masone9d0b132007-08-10 14:06:19 -04002071}
2072
Chris Mason56bec292009-03-13 10:10:06 -04002073static noinline struct btrfs_delayed_ref_node *
2074select_delayed_ref(struct btrfs_delayed_ref_head *head)
Chris Masona28ec192007-03-06 20:08:01 -05002075{
Chris Mason56bec292009-03-13 10:10:06 -04002076 struct rb_node *node;
2077 struct btrfs_delayed_ref_node *ref;
2078 int action = BTRFS_ADD_DELAYED_REF;
2079again:
2080 /*
2081 * select delayed ref of type BTRFS_ADD_DELAYED_REF first.
2082 * this prevents ref count from going down to zero when
2083 * there still are pending delayed ref.
2084 */
2085 node = rb_prev(&head->node.rb_node);
2086 while (1) {
2087 if (!node)
2088 break;
2089 ref = rb_entry(node, struct btrfs_delayed_ref_node,
2090 rb_node);
2091 if (ref->bytenr != head->node.bytenr)
2092 break;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002093 if (ref->action == action)
Chris Mason56bec292009-03-13 10:10:06 -04002094 return ref;
2095 node = rb_prev(node);
Chris Mason5f39d392007-10-15 16:14:19 -04002096 }
Chris Mason56bec292009-03-13 10:10:06 -04002097 if (action == BTRFS_ADD_DELAYED_REF) {
2098 action = BTRFS_DROP_DELAYED_REF;
2099 goto again;
2100 }
2101 return NULL;
2102}
2103
Chris Masonc3e69d52009-03-13 10:17:05 -04002104static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
2105 struct btrfs_root *root,
2106 struct list_head *cluster)
Chris Mason56bec292009-03-13 10:10:06 -04002107{
Chris Mason56bec292009-03-13 10:10:06 -04002108 struct btrfs_delayed_ref_root *delayed_refs;
2109 struct btrfs_delayed_ref_node *ref;
2110 struct btrfs_delayed_ref_head *locked_ref = NULL;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002111 struct btrfs_delayed_extent_op *extent_op;
Chris Mason56bec292009-03-13 10:10:06 -04002112 int ret;
Chris Masonc3e69d52009-03-13 10:17:05 -04002113 int count = 0;
Chris Mason56bec292009-03-13 10:10:06 -04002114 int must_insert_reserved = 0;
Chris Mason56bec292009-03-13 10:10:06 -04002115
2116 delayed_refs = &trans->transaction->delayed_refs;
Chris Mason56bec292009-03-13 10:10:06 -04002117 while (1) {
2118 if (!locked_ref) {
Chris Masonc3e69d52009-03-13 10:17:05 -04002119 /* pick a new head ref from the cluster list */
2120 if (list_empty(cluster))
Chris Mason56bec292009-03-13 10:10:06 -04002121 break;
Chris Mason56bec292009-03-13 10:10:06 -04002122
Chris Masonc3e69d52009-03-13 10:17:05 -04002123 locked_ref = list_entry(cluster->next,
2124 struct btrfs_delayed_ref_head, cluster);
2125
2126 /* grab the lock that says we are going to process
2127 * all the refs for this head */
2128 ret = btrfs_delayed_ref_lock(trans, locked_ref);
2129
2130 /*
2131 * we may have dropped the spin lock to get the head
2132 * mutex lock, and that might have given someone else
2133 * time to free the head. If that's true, it has been
2134 * removed from our list and we can move on.
2135 */
2136 if (ret == -EAGAIN) {
2137 locked_ref = NULL;
2138 count++;
2139 continue;
Chris Mason56bec292009-03-13 10:10:06 -04002140 }
2141 }
2142
2143 /*
2144 * record the must insert reserved flag before we
2145 * drop the spin lock.
2146 */
2147 must_insert_reserved = locked_ref->must_insert_reserved;
2148 locked_ref->must_insert_reserved = 0;
2149
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002150 extent_op = locked_ref->extent_op;
2151 locked_ref->extent_op = NULL;
2152
Chris Mason56bec292009-03-13 10:10:06 -04002153 /*
2154 * locked_ref is the head node, so we have to go one
2155 * node back for any delayed ref updates
2156 */
Chris Mason56bec292009-03-13 10:10:06 -04002157 ref = select_delayed_ref(locked_ref);
2158 if (!ref) {
2159 /* All delayed refs have been processed, Go ahead
2160 * and send the head node to run_one_delayed_ref,
2161 * so that any accounting fixes can happen
2162 */
2163 ref = &locked_ref->node;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002164
2165 if (extent_op && must_insert_reserved) {
2166 kfree(extent_op);
2167 extent_op = NULL;
2168 }
2169
2170 if (extent_op) {
2171 spin_unlock(&delayed_refs->lock);
2172
2173 ret = run_delayed_extent_op(trans, root,
2174 ref, extent_op);
2175 BUG_ON(ret);
2176 kfree(extent_op);
2177
2178 cond_resched();
2179 spin_lock(&delayed_refs->lock);
2180 continue;
2181 }
2182
Chris Masonc3e69d52009-03-13 10:17:05 -04002183 list_del_init(&locked_ref->cluster);
Chris Mason56bec292009-03-13 10:10:06 -04002184 locked_ref = NULL;
2185 }
2186
2187 ref->in_tree = 0;
2188 rb_erase(&ref->rb_node, &delayed_refs->root);
2189 delayed_refs->num_entries--;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002190
Chris Mason56bec292009-03-13 10:10:06 -04002191 spin_unlock(&delayed_refs->lock);
2192
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002193 ret = run_one_delayed_ref(trans, root, ref, extent_op,
Chris Mason56bec292009-03-13 10:10:06 -04002194 must_insert_reserved);
2195 BUG_ON(ret);
Chris Mason56bec292009-03-13 10:10:06 -04002196
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002197 btrfs_put_delayed_ref(ref);
2198 kfree(extent_op);
Chris Masonc3e69d52009-03-13 10:17:05 -04002199 count++;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002200
Chris Mason1887be62009-03-13 10:11:24 -04002201 cond_resched();
Chris Mason56bec292009-03-13 10:10:06 -04002202 spin_lock(&delayed_refs->lock);
2203 }
Chris Masonc3e69d52009-03-13 10:17:05 -04002204 return count;
2205}
2206
2207/*
2208 * this starts processing the delayed reference count updates and
2209 * extent insertions we have queued up so far. count can be
2210 * 0, which means to process everything in the tree at the start
2211 * of the run (but not newly added entries), or it can be some target
2212 * number you'd like to process.
2213 */
2214int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2215 struct btrfs_root *root, unsigned long count)
2216{
2217 struct rb_node *node;
2218 struct btrfs_delayed_ref_root *delayed_refs;
2219 struct btrfs_delayed_ref_node *ref;
2220 struct list_head cluster;
2221 int ret;
2222 int run_all = count == (unsigned long)-1;
2223 int run_most = 0;
2224
2225 if (root == root->fs_info->extent_root)
2226 root = root->fs_info->tree_root;
2227
2228 delayed_refs = &trans->transaction->delayed_refs;
2229 INIT_LIST_HEAD(&cluster);
2230again:
2231 spin_lock(&delayed_refs->lock);
2232 if (count == 0) {
2233 count = delayed_refs->num_entries * 2;
2234 run_most = 1;
2235 }
2236 while (1) {
2237 if (!(run_all || run_most) &&
2238 delayed_refs->num_heads_ready < 64)
2239 break;
2240
2241 /*
2242 * go find something we can process in the rbtree. We start at
2243 * the beginning of the tree, and then build a cluster
2244 * of refs to process starting at the first one we are able to
2245 * lock
2246 */
2247 ret = btrfs_find_ref_cluster(trans, &cluster,
2248 delayed_refs->run_delayed_start);
2249 if (ret)
2250 break;
2251
2252 ret = run_clustered_refs(trans, root, &cluster);
2253 BUG_ON(ret < 0);
2254
2255 count -= min_t(unsigned long, ret, count);
2256
2257 if (count == 0)
2258 break;
2259 }
2260
Chris Mason56bec292009-03-13 10:10:06 -04002261 if (run_all) {
Chris Mason56bec292009-03-13 10:10:06 -04002262 node = rb_first(&delayed_refs->root);
Chris Masonc3e69d52009-03-13 10:17:05 -04002263 if (!node)
Chris Mason56bec292009-03-13 10:10:06 -04002264 goto out;
Chris Masonc3e69d52009-03-13 10:17:05 -04002265 count = (unsigned long)-1;
Chris Mason56bec292009-03-13 10:10:06 -04002266
2267 while (node) {
2268 ref = rb_entry(node, struct btrfs_delayed_ref_node,
2269 rb_node);
2270 if (btrfs_delayed_ref_is_head(ref)) {
2271 struct btrfs_delayed_ref_head *head;
2272
2273 head = btrfs_delayed_node_to_head(ref);
2274 atomic_inc(&ref->refs);
2275
2276 spin_unlock(&delayed_refs->lock);
2277 mutex_lock(&head->mutex);
2278 mutex_unlock(&head->mutex);
2279
2280 btrfs_put_delayed_ref(ref);
Chris Mason1887be62009-03-13 10:11:24 -04002281 cond_resched();
Chris Mason56bec292009-03-13 10:10:06 -04002282 goto again;
2283 }
2284 node = rb_next(node);
2285 }
2286 spin_unlock(&delayed_refs->lock);
Chris Mason56bec292009-03-13 10:10:06 -04002287 schedule_timeout(1);
2288 goto again;
2289 }
Chris Mason54aa1f42007-06-22 14:16:25 -04002290out:
Chris Masonc3e69d52009-03-13 10:17:05 -04002291 spin_unlock(&delayed_refs->lock);
Chris Masona28ec192007-03-06 20:08:01 -05002292 return 0;
2293}
2294
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002295int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2296 struct btrfs_root *root,
2297 u64 bytenr, u64 num_bytes, u64 flags,
2298 int is_data)
2299{
2300 struct btrfs_delayed_extent_op *extent_op;
2301 int ret;
2302
2303 extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
2304 if (!extent_op)
2305 return -ENOMEM;
2306
2307 extent_op->flags_to_set = flags;
2308 extent_op->update_flags = 1;
2309 extent_op->update_key = 0;
2310 extent_op->is_data = is_data ? 1 : 0;
2311
2312 ret = btrfs_add_delayed_extent_op(trans, bytenr, num_bytes, extent_op);
2313 if (ret)
2314 kfree(extent_op);
2315 return ret;
2316}
2317
2318static noinline int check_delayed_ref(struct btrfs_trans_handle *trans,
2319 struct btrfs_root *root,
2320 struct btrfs_path *path,
2321 u64 objectid, u64 offset, u64 bytenr)
2322{
2323 struct btrfs_delayed_ref_head *head;
2324 struct btrfs_delayed_ref_node *ref;
2325 struct btrfs_delayed_data_ref *data_ref;
2326 struct btrfs_delayed_ref_root *delayed_refs;
2327 struct rb_node *node;
2328 int ret = 0;
2329
2330 ret = -ENOENT;
2331 delayed_refs = &trans->transaction->delayed_refs;
2332 spin_lock(&delayed_refs->lock);
2333 head = btrfs_find_delayed_ref_head(trans, bytenr);
2334 if (!head)
2335 goto out;
2336
2337 if (!mutex_trylock(&head->mutex)) {
2338 atomic_inc(&head->node.refs);
2339 spin_unlock(&delayed_refs->lock);
2340
2341 btrfs_release_path(root->fs_info->extent_root, path);
2342
2343 mutex_lock(&head->mutex);
2344 mutex_unlock(&head->mutex);
2345 btrfs_put_delayed_ref(&head->node);
2346 return -EAGAIN;
2347 }
2348
2349 node = rb_prev(&head->node.rb_node);
2350 if (!node)
2351 goto out_unlock;
2352
2353 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2354
2355 if (ref->bytenr != bytenr)
2356 goto out_unlock;
2357
2358 ret = 1;
2359 if (ref->type != BTRFS_EXTENT_DATA_REF_KEY)
2360 goto out_unlock;
2361
2362 data_ref = btrfs_delayed_node_to_data_ref(ref);
2363
2364 node = rb_prev(node);
2365 if (node) {
2366 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2367 if (ref->bytenr == bytenr)
2368 goto out_unlock;
2369 }
2370
2371 if (data_ref->root != root->root_key.objectid ||
2372 data_ref->objectid != objectid || data_ref->offset != offset)
2373 goto out_unlock;
2374
2375 ret = 0;
2376out_unlock:
2377 mutex_unlock(&head->mutex);
2378out:
2379 spin_unlock(&delayed_refs->lock);
2380 return ret;
2381}
2382
2383static noinline int check_committed_ref(struct btrfs_trans_handle *trans,
2384 struct btrfs_root *root,
2385 struct btrfs_path *path,
2386 u64 objectid, u64 offset, u64 bytenr)
Chris Masonbe20aa92007-12-17 20:14:01 -05002387{
2388 struct btrfs_root *extent_root = root->fs_info->extent_root;
Yan Zhengf321e492008-07-30 09:26:11 -04002389 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002390 struct btrfs_extent_data_ref *ref;
2391 struct btrfs_extent_inline_ref *iref;
2392 struct btrfs_extent_item *ei;
Chris Masonbe20aa92007-12-17 20:14:01 -05002393 struct btrfs_key key;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002394 u32 item_size;
Yan Zhengf321e492008-07-30 09:26:11 -04002395 int ret;
Chris Masonbe20aa92007-12-17 20:14:01 -05002396
Chris Masonbe20aa92007-12-17 20:14:01 -05002397 key.objectid = bytenr;
Zheng Yan31840ae2008-09-23 13:14:14 -04002398 key.offset = (u64)-1;
Yan Zhengf321e492008-07-30 09:26:11 -04002399 key.type = BTRFS_EXTENT_ITEM_KEY;
Chris Masonbe20aa92007-12-17 20:14:01 -05002400
Chris Masonbe20aa92007-12-17 20:14:01 -05002401 ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
2402 if (ret < 0)
2403 goto out;
2404 BUG_ON(ret == 0);
Yan Zheng80ff3852008-10-30 14:20:02 -04002405
2406 ret = -ENOENT;
2407 if (path->slots[0] == 0)
Zheng Yan31840ae2008-09-23 13:14:14 -04002408 goto out;
Chris Masonbe20aa92007-12-17 20:14:01 -05002409
Zheng Yan31840ae2008-09-23 13:14:14 -04002410 path->slots[0]--;
Yan Zhengf321e492008-07-30 09:26:11 -04002411 leaf = path->nodes[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002412 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
Chris Masonbe20aa92007-12-17 20:14:01 -05002413
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002414 if (key.objectid != bytenr || key.type != BTRFS_EXTENT_ITEM_KEY)
Chris Masonbe20aa92007-12-17 20:14:01 -05002415 goto out;
Chris Masonbe20aa92007-12-17 20:14:01 -05002416
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002417 ret = 1;
2418 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2419#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
2420 if (item_size < sizeof(*ei)) {
2421 WARN_ON(item_size != sizeof(struct btrfs_extent_item_v0));
2422 goto out;
Chris Masonbe20aa92007-12-17 20:14:01 -05002423 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002424#endif
2425 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
2426
2427 if (item_size != sizeof(*ei) +
2428 btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY))
2429 goto out;
2430
2431 if (btrfs_extent_generation(leaf, ei) <=
2432 btrfs_root_last_snapshot(&root->root_item))
2433 goto out;
2434
2435 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
2436 if (btrfs_extent_inline_ref_type(leaf, iref) !=
2437 BTRFS_EXTENT_DATA_REF_KEY)
2438 goto out;
2439
2440 ref = (struct btrfs_extent_data_ref *)(&iref->offset);
2441 if (btrfs_extent_refs(leaf, ei) !=
2442 btrfs_extent_data_ref_count(leaf, ref) ||
2443 btrfs_extent_data_ref_root(leaf, ref) !=
2444 root->root_key.objectid ||
2445 btrfs_extent_data_ref_objectid(leaf, ref) != objectid ||
2446 btrfs_extent_data_ref_offset(leaf, ref) != offset)
2447 goto out;
2448
Yan Zhengf321e492008-07-30 09:26:11 -04002449 ret = 0;
Chris Masonbe20aa92007-12-17 20:14:01 -05002450out:
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002451 return ret;
2452}
2453
2454int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
2455 struct btrfs_root *root,
2456 u64 objectid, u64 offset, u64 bytenr)
2457{
2458 struct btrfs_path *path;
2459 int ret;
2460 int ret2;
2461
2462 path = btrfs_alloc_path();
2463 if (!path)
2464 return -ENOENT;
2465
2466 do {
2467 ret = check_committed_ref(trans, root, path, objectid,
2468 offset, bytenr);
2469 if (ret && ret != -ENOENT)
2470 goto out;
2471
2472 ret2 = check_delayed_ref(trans, root, path, objectid,
2473 offset, bytenr);
2474 } while (ret2 == -EAGAIN);
2475
2476 if (ret2 && ret2 != -ENOENT) {
2477 ret = ret2;
2478 goto out;
2479 }
2480
2481 if (ret != -ENOENT || ret2 != -ENOENT)
2482 ret = 0;
2483out:
Yan Zhengf321e492008-07-30 09:26:11 -04002484 btrfs_free_path(path);
Yan, Zhengf0486c62010-05-16 10:46:25 -04002485 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
2486 WARN_ON(ret > 0);
Yan Zhengf321e492008-07-30 09:26:11 -04002487 return ret;
2488}
2489
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002490#if 0
Zheng Yan31840ae2008-09-23 13:14:14 -04002491int btrfs_cache_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2492 struct extent_buffer *buf, u32 nr_extents)
Chris Mason02217ed2007-03-02 16:08:05 -05002493{
Chris Mason5f39d392007-10-15 16:14:19 -04002494 struct btrfs_key key;
Chris Mason6407bf62007-03-27 06:33:00 -04002495 struct btrfs_file_extent_item *fi;
Zheng Yane4657682008-09-26 10:04:53 -04002496 u64 root_gen;
2497 u32 nritems;
Chris Mason02217ed2007-03-02 16:08:05 -05002498 int i;
Chris Masondb945352007-10-15 16:15:53 -04002499 int level;
Zheng Yan31840ae2008-09-23 13:14:14 -04002500 int ret = 0;
Zheng Yane4657682008-09-26 10:04:53 -04002501 int shared = 0;
Chris Masona28ec192007-03-06 20:08:01 -05002502
Chris Mason3768f362007-03-13 16:47:54 -04002503 if (!root->ref_cows)
Chris Masona28ec192007-03-06 20:08:01 -05002504 return 0;
Chris Mason5f39d392007-10-15 16:14:19 -04002505
Zheng Yane4657682008-09-26 10:04:53 -04002506 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
2507 shared = 0;
2508 root_gen = root->root_key.offset;
2509 } else {
2510 shared = 1;
2511 root_gen = trans->transid - 1;
2512 }
2513
Chris Masondb945352007-10-15 16:15:53 -04002514 level = btrfs_header_level(buf);
Chris Mason5f39d392007-10-15 16:14:19 -04002515 nritems = btrfs_header_nritems(buf);
Chris Mason4a096752008-07-21 10:29:44 -04002516
Zheng Yan31840ae2008-09-23 13:14:14 -04002517 if (level == 0) {
Yan Zheng31153d82008-07-28 15:32:19 -04002518 struct btrfs_leaf_ref *ref;
2519 struct btrfs_extent_info *info;
2520
Zheng Yan31840ae2008-09-23 13:14:14 -04002521 ref = btrfs_alloc_leaf_ref(root, nr_extents);
Yan Zheng31153d82008-07-28 15:32:19 -04002522 if (!ref) {
Zheng Yan31840ae2008-09-23 13:14:14 -04002523 ret = -ENOMEM;
Yan Zheng31153d82008-07-28 15:32:19 -04002524 goto out;
2525 }
2526
Zheng Yane4657682008-09-26 10:04:53 -04002527 ref->root_gen = root_gen;
Yan Zheng31153d82008-07-28 15:32:19 -04002528 ref->bytenr = buf->start;
2529 ref->owner = btrfs_header_owner(buf);
2530 ref->generation = btrfs_header_generation(buf);
Zheng Yan31840ae2008-09-23 13:14:14 -04002531 ref->nritems = nr_extents;
Yan Zheng31153d82008-07-28 15:32:19 -04002532 info = ref->extents;
Yanbcc63ab2008-07-30 16:29:20 -04002533
Zheng Yan31840ae2008-09-23 13:14:14 -04002534 for (i = 0; nr_extents > 0 && i < nritems; i++) {
Yan Zheng31153d82008-07-28 15:32:19 -04002535 u64 disk_bytenr;
2536 btrfs_item_key_to_cpu(buf, &key, i);
2537 if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
2538 continue;
2539 fi = btrfs_item_ptr(buf, i,
2540 struct btrfs_file_extent_item);
2541 if (btrfs_file_extent_type(buf, fi) ==
2542 BTRFS_FILE_EXTENT_INLINE)
2543 continue;
2544 disk_bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
2545 if (disk_bytenr == 0)
2546 continue;
2547
2548 info->bytenr = disk_bytenr;
2549 info->num_bytes =
2550 btrfs_file_extent_disk_num_bytes(buf, fi);
2551 info->objectid = key.objectid;
2552 info->offset = key.offset;
2553 info++;
2554 }
2555
Zheng Yane4657682008-09-26 10:04:53 -04002556 ret = btrfs_add_leaf_ref(root, ref, shared);
Yan Zheng5b84e8d2008-10-09 11:46:19 -04002557 if (ret == -EEXIST && shared) {
2558 struct btrfs_leaf_ref *old;
2559 old = btrfs_lookup_leaf_ref(root, ref->bytenr);
2560 BUG_ON(!old);
2561 btrfs_remove_leaf_ref(root, old);
2562 btrfs_free_leaf_ref(root, old);
2563 ret = btrfs_add_leaf_ref(root, ref, shared);
2564 }
Yan Zheng31153d82008-07-28 15:32:19 -04002565 WARN_ON(ret);
Yanbcc63ab2008-07-30 16:29:20 -04002566 btrfs_free_leaf_ref(root, ref);
Yan Zheng31153d82008-07-28 15:32:19 -04002567 }
2568out:
Zheng Yan31840ae2008-09-23 13:14:14 -04002569 return ret;
2570}
2571
Chris Masonb7a9f292009-02-04 09:23:45 -05002572/* when a block goes through cow, we update the reference counts of
2573 * everything that block points to. The internal pointers of the block
2574 * can be in just about any order, and it is likely to have clusters of
2575 * things that are close together and clusters of things that are not.
2576 *
2577 * To help reduce the seeks that come with updating all of these reference
2578 * counts, sort them by byte number before actual updates are done.
2579 *
2580 * struct refsort is used to match byte number to slot in the btree block.
2581 * we sort based on the byte number and then use the slot to actually
2582 * find the item.
Chris Masonbd56b302009-02-04 09:27:02 -05002583 *
2584 * struct refsort is smaller than strcut btrfs_item and smaller than
2585 * struct btrfs_key_ptr. Since we're currently limited to the page size
2586 * for a btree block, there's no way for a kmalloc of refsorts for a
2587 * single node to be bigger than a page.
Chris Masonb7a9f292009-02-04 09:23:45 -05002588 */
2589struct refsort {
2590 u64 bytenr;
2591 u32 slot;
2592};
2593
2594/*
2595 * for passing into sort()
2596 */
2597static int refsort_cmp(const void *a_void, const void *b_void)
2598{
2599 const struct refsort *a = a_void;
2600 const struct refsort *b = b_void;
2601
2602 if (a->bytenr < b->bytenr)
2603 return -1;
2604 if (a->bytenr > b->bytenr)
2605 return 1;
2606 return 0;
2607}
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002608#endif
Chris Masonb7a9f292009-02-04 09:23:45 -05002609
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002610static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,
Chris Masonb7a9f292009-02-04 09:23:45 -05002611 struct btrfs_root *root,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002612 struct extent_buffer *buf,
2613 int full_backref, int inc)
Zheng Yan31840ae2008-09-23 13:14:14 -04002614{
2615 u64 bytenr;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002616 u64 num_bytes;
2617 u64 parent;
Zheng Yan31840ae2008-09-23 13:14:14 -04002618 u64 ref_root;
Zheng Yan31840ae2008-09-23 13:14:14 -04002619 u32 nritems;
Zheng Yan31840ae2008-09-23 13:14:14 -04002620 struct btrfs_key key;
2621 struct btrfs_file_extent_item *fi;
2622 int i;
2623 int level;
2624 int ret = 0;
Zheng Yan31840ae2008-09-23 13:14:14 -04002625 int (*process_func)(struct btrfs_trans_handle *, struct btrfs_root *,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002626 u64, u64, u64, u64, u64, u64);
Zheng Yan31840ae2008-09-23 13:14:14 -04002627
2628 ref_root = btrfs_header_owner(buf);
Zheng Yan31840ae2008-09-23 13:14:14 -04002629 nritems = btrfs_header_nritems(buf);
2630 level = btrfs_header_level(buf);
2631
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002632 if (!root->ref_cows && level == 0)
2633 return 0;
Chris Masonb7a9f292009-02-04 09:23:45 -05002634
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002635 if (inc)
2636 process_func = btrfs_inc_extent_ref;
2637 else
2638 process_func = btrfs_free_extent;
Zheng Yan31840ae2008-09-23 13:14:14 -04002639
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002640 if (full_backref)
2641 parent = buf->start;
2642 else
2643 parent = 0;
2644
Zheng Yan31840ae2008-09-23 13:14:14 -04002645 for (i = 0; i < nritems; i++) {
Chris Masondb945352007-10-15 16:15:53 -04002646 if (level == 0) {
Chris Mason5f39d392007-10-15 16:14:19 -04002647 btrfs_item_key_to_cpu(buf, &key, i);
2648 if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
Chris Mason54aa1f42007-06-22 14:16:25 -04002649 continue;
Chris Mason5f39d392007-10-15 16:14:19 -04002650 fi = btrfs_item_ptr(buf, i,
Chris Mason54aa1f42007-06-22 14:16:25 -04002651 struct btrfs_file_extent_item);
Chris Mason5f39d392007-10-15 16:14:19 -04002652 if (btrfs_file_extent_type(buf, fi) ==
Chris Mason54aa1f42007-06-22 14:16:25 -04002653 BTRFS_FILE_EXTENT_INLINE)
2654 continue;
Zheng Yan31840ae2008-09-23 13:14:14 -04002655 bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
2656 if (bytenr == 0)
Chris Mason54aa1f42007-06-22 14:16:25 -04002657 continue;
Zheng Yan31840ae2008-09-23 13:14:14 -04002658
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002659 num_bytes = btrfs_file_extent_disk_num_bytes(buf, fi);
2660 key.offset -= btrfs_file_extent_offset(buf, fi);
2661 ret = process_func(trans, root, bytenr, num_bytes,
2662 parent, ref_root, key.objectid,
2663 key.offset);
2664 if (ret)
2665 goto fail;
Chris Masonb7a9f292009-02-04 09:23:45 -05002666 } else {
2667 bytenr = btrfs_node_blockptr(buf, i);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002668 num_bytes = btrfs_level_size(root, level - 1);
2669 ret = process_func(trans, root, bytenr, num_bytes,
2670 parent, ref_root, level - 1, 0);
2671 if (ret)
Zheng Yan31840ae2008-09-23 13:14:14 -04002672 goto fail;
Chris Mason54aa1f42007-06-22 14:16:25 -04002673 }
2674 }
Zheng Yan31840ae2008-09-23 13:14:14 -04002675 return 0;
2676fail:
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002677 BUG();
Chris Mason54aa1f42007-06-22 14:16:25 -04002678 return ret;
Chris Mason02217ed2007-03-02 16:08:05 -05002679}
2680
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002681int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2682 struct extent_buffer *buf, int full_backref)
Zheng Yan31840ae2008-09-23 13:14:14 -04002683{
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002684 return __btrfs_mod_ref(trans, root, buf, full_backref, 1);
2685}
Zheng Yan31840ae2008-09-23 13:14:14 -04002686
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002687int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2688 struct extent_buffer *buf, int full_backref)
2689{
2690 return __btrfs_mod_ref(trans, root, buf, full_backref, 0);
Zheng Yan31840ae2008-09-23 13:14:14 -04002691}
2692
Chris Mason9078a3e2007-04-26 16:46:15 -04002693static int write_one_cache_group(struct btrfs_trans_handle *trans,
2694 struct btrfs_root *root,
2695 struct btrfs_path *path,
2696 struct btrfs_block_group_cache *cache)
2697{
2698 int ret;
Chris Mason9078a3e2007-04-26 16:46:15 -04002699 struct btrfs_root *extent_root = root->fs_info->extent_root;
Chris Mason5f39d392007-10-15 16:14:19 -04002700 unsigned long bi;
2701 struct extent_buffer *leaf;
Chris Mason9078a3e2007-04-26 16:46:15 -04002702
Chris Mason9078a3e2007-04-26 16:46:15 -04002703 ret = btrfs_search_slot(trans, extent_root, &cache->key, path, 0, 1);
Chris Mason54aa1f42007-06-22 14:16:25 -04002704 if (ret < 0)
2705 goto fail;
Chris Mason9078a3e2007-04-26 16:46:15 -04002706 BUG_ON(ret);
Chris Mason5f39d392007-10-15 16:14:19 -04002707
2708 leaf = path->nodes[0];
2709 bi = btrfs_item_ptr_offset(leaf, path->slots[0]);
2710 write_extent_buffer(leaf, &cache->item, bi, sizeof(cache->item));
2711 btrfs_mark_buffer_dirty(leaf);
Chris Mason9078a3e2007-04-26 16:46:15 -04002712 btrfs_release_path(extent_root, path);
Chris Mason54aa1f42007-06-22 14:16:25 -04002713fail:
Chris Mason9078a3e2007-04-26 16:46:15 -04002714 if (ret)
2715 return ret;
Chris Mason9078a3e2007-04-26 16:46:15 -04002716 return 0;
2717
2718}
2719
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002720static struct btrfs_block_group_cache *
2721next_block_group(struct btrfs_root *root,
2722 struct btrfs_block_group_cache *cache)
2723{
2724 struct rb_node *node;
2725 spin_lock(&root->fs_info->block_group_cache_lock);
2726 node = rb_next(&cache->cache_node);
2727 btrfs_put_block_group(cache);
2728 if (node) {
2729 cache = rb_entry(node, struct btrfs_block_group_cache,
2730 cache_node);
Josef Bacik11dfe352009-11-13 20:12:59 +00002731 btrfs_get_block_group(cache);
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002732 } else
2733 cache = NULL;
2734 spin_unlock(&root->fs_info->block_group_cache_lock);
2735 return cache;
2736}
2737
Josef Bacik0af3d002010-06-21 14:48:16 -04002738static int cache_save_setup(struct btrfs_block_group_cache *block_group,
2739 struct btrfs_trans_handle *trans,
2740 struct btrfs_path *path)
2741{
2742 struct btrfs_root *root = block_group->fs_info->tree_root;
2743 struct inode *inode = NULL;
2744 u64 alloc_hint = 0;
2745 int num_pages = 0;
2746 int retries = 0;
2747 int ret = 0;
2748
2749 /*
2750 * If this block group is smaller than 100 megs don't bother caching the
2751 * block group.
2752 */
2753 if (block_group->key.offset < (100 * 1024 * 1024)) {
2754 spin_lock(&block_group->lock);
2755 block_group->disk_cache_state = BTRFS_DC_WRITTEN;
2756 spin_unlock(&block_group->lock);
2757 return 0;
2758 }
2759
2760again:
2761 inode = lookup_free_space_inode(root, block_group, path);
2762 if (IS_ERR(inode) && PTR_ERR(inode) != -ENOENT) {
2763 ret = PTR_ERR(inode);
2764 btrfs_release_path(root, path);
2765 goto out;
2766 }
2767
2768 if (IS_ERR(inode)) {
2769 BUG_ON(retries);
2770 retries++;
2771
2772 if (block_group->ro)
2773 goto out_free;
2774
2775 ret = create_free_space_inode(root, trans, block_group, path);
2776 if (ret)
2777 goto out_free;
2778 goto again;
2779 }
2780
2781 /*
2782 * We want to set the generation to 0, that way if anything goes wrong
2783 * from here on out we know not to trust this cache when we load up next
2784 * time.
2785 */
2786 BTRFS_I(inode)->generation = 0;
2787 ret = btrfs_update_inode(trans, root, inode);
2788 WARN_ON(ret);
2789
2790 if (i_size_read(inode) > 0) {
2791 ret = btrfs_truncate_free_space_cache(root, trans, path,
2792 inode);
2793 if (ret)
2794 goto out_put;
2795 }
2796
2797 spin_lock(&block_group->lock);
2798 if (block_group->cached != BTRFS_CACHE_FINISHED) {
2799 spin_unlock(&block_group->lock);
2800 goto out_put;
2801 }
2802 spin_unlock(&block_group->lock);
2803
2804 num_pages = (int)div64_u64(block_group->key.offset, 1024 * 1024 * 1024);
2805 if (!num_pages)
2806 num_pages = 1;
2807
2808 /*
2809 * Just to make absolutely sure we have enough space, we're going to
2810 * preallocate 12 pages worth of space for each block group. In
2811 * practice we ought to use at most 8, but we need extra space so we can
2812 * add our header and have a terminator between the extents and the
2813 * bitmaps.
2814 */
2815 num_pages *= 16;
2816 num_pages *= PAGE_CACHE_SIZE;
2817
2818 ret = btrfs_check_data_free_space(inode, num_pages);
2819 if (ret)
2820 goto out_put;
2821
2822 ret = btrfs_prealloc_file_range_trans(inode, trans, 0, 0, num_pages,
2823 num_pages, num_pages,
2824 &alloc_hint);
2825 btrfs_free_reserved_data_space(inode, num_pages);
2826out_put:
2827 iput(inode);
2828out_free:
2829 btrfs_release_path(root, path);
2830out:
2831 spin_lock(&block_group->lock);
2832 if (ret)
2833 block_group->disk_cache_state = BTRFS_DC_ERROR;
2834 else
2835 block_group->disk_cache_state = BTRFS_DC_SETUP;
2836 spin_unlock(&block_group->lock);
2837
2838 return ret;
2839}
2840
Chris Mason96b51792007-10-15 16:15:19 -04002841int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2842 struct btrfs_root *root)
Chris Mason9078a3e2007-04-26 16:46:15 -04002843{
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002844 struct btrfs_block_group_cache *cache;
Chris Mason9078a3e2007-04-26 16:46:15 -04002845 int err = 0;
Chris Mason9078a3e2007-04-26 16:46:15 -04002846 struct btrfs_path *path;
Chris Mason96b51792007-10-15 16:15:19 -04002847 u64 last = 0;
Chris Mason9078a3e2007-04-26 16:46:15 -04002848
2849 path = btrfs_alloc_path();
2850 if (!path)
2851 return -ENOMEM;
2852
Josef Bacik0af3d002010-06-21 14:48:16 -04002853again:
2854 while (1) {
2855 cache = btrfs_lookup_first_block_group(root->fs_info, last);
2856 while (cache) {
2857 if (cache->disk_cache_state == BTRFS_DC_CLEAR)
2858 break;
2859 cache = next_block_group(root, cache);
2860 }
2861 if (!cache) {
2862 if (last == 0)
2863 break;
2864 last = 0;
2865 continue;
2866 }
2867 err = cache_save_setup(cache, trans, path);
2868 last = cache->key.objectid + cache->key.offset;
2869 btrfs_put_block_group(cache);
2870 }
2871
Chris Masond3977122009-01-05 21:25:51 -05002872 while (1) {
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002873 if (last == 0) {
2874 err = btrfs_run_delayed_refs(trans, root,
2875 (unsigned long)-1);
2876 BUG_ON(err);
Josef Bacik0f9dd462008-09-23 13:14:11 -04002877 }
Josef Bacik0f9dd462008-09-23 13:14:11 -04002878
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002879 cache = btrfs_lookup_first_block_group(root->fs_info, last);
2880 while (cache) {
Josef Bacik0af3d002010-06-21 14:48:16 -04002881 if (cache->disk_cache_state == BTRFS_DC_CLEAR) {
2882 btrfs_put_block_group(cache);
2883 goto again;
2884 }
2885
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002886 if (cache->dirty)
2887 break;
2888 cache = next_block_group(root, cache);
2889 }
2890 if (!cache) {
2891 if (last == 0)
2892 break;
2893 last = 0;
Chris Mason96b51792007-10-15 16:15:19 -04002894 continue;
Chris Mason9078a3e2007-04-26 16:46:15 -04002895 }
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002896
Josef Bacik0cb59c92010-07-02 12:14:14 -04002897 if (cache->disk_cache_state == BTRFS_DC_SETUP)
2898 cache->disk_cache_state = BTRFS_DC_NEED_WRITE;
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002899 cache->dirty = 0;
2900 last = cache->key.objectid + cache->key.offset;
2901
2902 err = write_one_cache_group(trans, root, path, cache);
2903 BUG_ON(err);
2904 btrfs_put_block_group(cache);
Chris Mason9078a3e2007-04-26 16:46:15 -04002905 }
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002906
Josef Bacik0cb59c92010-07-02 12:14:14 -04002907 while (1) {
2908 /*
2909 * I don't think this is needed since we're just marking our
2910 * preallocated extent as written, but just in case it can't
2911 * hurt.
2912 */
2913 if (last == 0) {
2914 err = btrfs_run_delayed_refs(trans, root,
2915 (unsigned long)-1);
2916 BUG_ON(err);
2917 }
2918
2919 cache = btrfs_lookup_first_block_group(root->fs_info, last);
2920 while (cache) {
2921 /*
2922 * Really this shouldn't happen, but it could if we
2923 * couldn't write the entire preallocated extent and
2924 * splitting the extent resulted in a new block.
2925 */
2926 if (cache->dirty) {
2927 btrfs_put_block_group(cache);
2928 goto again;
2929 }
2930 if (cache->disk_cache_state == BTRFS_DC_NEED_WRITE)
2931 break;
2932 cache = next_block_group(root, cache);
2933 }
2934 if (!cache) {
2935 if (last == 0)
2936 break;
2937 last = 0;
2938 continue;
2939 }
2940
2941 btrfs_write_out_cache(root, trans, cache, path);
2942
2943 /*
2944 * If we didn't have an error then the cache state is still
2945 * NEED_WRITE, so we can set it to WRITTEN.
2946 */
2947 if (cache->disk_cache_state == BTRFS_DC_NEED_WRITE)
2948 cache->disk_cache_state = BTRFS_DC_WRITTEN;
2949 last = cache->key.objectid + cache->key.offset;
2950 btrfs_put_block_group(cache);
2951 }
2952
Chris Mason9078a3e2007-04-26 16:46:15 -04002953 btrfs_free_path(path);
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002954 return 0;
Chris Mason9078a3e2007-04-26 16:46:15 -04002955}
2956
Yan Zhengd2fb3432008-12-11 16:30:39 -05002957int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr)
2958{
2959 struct btrfs_block_group_cache *block_group;
2960 int readonly = 0;
2961
2962 block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
2963 if (!block_group || block_group->ro)
2964 readonly = 1;
2965 if (block_group)
Chris Masonfa9c0d72009-04-03 09:47:43 -04002966 btrfs_put_block_group(block_group);
Yan Zhengd2fb3432008-12-11 16:30:39 -05002967 return readonly;
2968}
2969
Chris Mason593060d2008-03-25 16:50:33 -04002970static int update_space_info(struct btrfs_fs_info *info, u64 flags,
2971 u64 total_bytes, u64 bytes_used,
2972 struct btrfs_space_info **space_info)
2973{
2974 struct btrfs_space_info *found;
Yan, Zhengb742bb82010-05-16 10:46:24 -04002975 int i;
2976 int factor;
2977
2978 if (flags & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
2979 BTRFS_BLOCK_GROUP_RAID10))
2980 factor = 2;
2981 else
2982 factor = 1;
Chris Mason593060d2008-03-25 16:50:33 -04002983
2984 found = __find_space_info(info, flags);
2985 if (found) {
Josef Bacik25179202008-10-29 14:49:05 -04002986 spin_lock(&found->lock);
Chris Mason593060d2008-03-25 16:50:33 -04002987 found->total_bytes += total_bytes;
Josef Bacik89a55892010-10-14 14:52:27 -04002988 found->disk_total += total_bytes * factor;
Chris Mason593060d2008-03-25 16:50:33 -04002989 found->bytes_used += bytes_used;
Yan, Zhengb742bb82010-05-16 10:46:24 -04002990 found->disk_used += bytes_used * factor;
Chris Mason8f18cf12008-04-25 16:53:30 -04002991 found->full = 0;
Josef Bacik25179202008-10-29 14:49:05 -04002992 spin_unlock(&found->lock);
Chris Mason593060d2008-03-25 16:50:33 -04002993 *space_info = found;
2994 return 0;
2995 }
Yan Zhengc146afa2008-11-12 14:34:12 -05002996 found = kzalloc(sizeof(*found), GFP_NOFS);
Chris Mason593060d2008-03-25 16:50:33 -04002997 if (!found)
2998 return -ENOMEM;
2999
Yan, Zhengb742bb82010-05-16 10:46:24 -04003000 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++)
3001 INIT_LIST_HEAD(&found->block_groups[i]);
Josef Bacik80eb2342008-10-29 14:49:05 -04003002 init_rwsem(&found->groups_sem);
Josef Bacik0f9dd462008-09-23 13:14:11 -04003003 spin_lock_init(&found->lock);
Yan, Zhengb742bb82010-05-16 10:46:24 -04003004 found->flags = flags & (BTRFS_BLOCK_GROUP_DATA |
3005 BTRFS_BLOCK_GROUP_SYSTEM |
3006 BTRFS_BLOCK_GROUP_METADATA);
Chris Mason593060d2008-03-25 16:50:33 -04003007 found->total_bytes = total_bytes;
Josef Bacik89a55892010-10-14 14:52:27 -04003008 found->disk_total = total_bytes * factor;
Chris Mason593060d2008-03-25 16:50:33 -04003009 found->bytes_used = bytes_used;
Yan, Zhengb742bb82010-05-16 10:46:24 -04003010 found->disk_used = bytes_used * factor;
Chris Mason593060d2008-03-25 16:50:33 -04003011 found->bytes_pinned = 0;
Zheng Yane8569812008-09-26 10:05:48 -04003012 found->bytes_reserved = 0;
Yan Zhengc146afa2008-11-12 14:34:12 -05003013 found->bytes_readonly = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003014 found->bytes_may_use = 0;
Chris Mason593060d2008-03-25 16:50:33 -04003015 found->full = 0;
Chris Mason0ef3e662008-05-24 14:04:53 -04003016 found->force_alloc = 0;
Chris Mason593060d2008-03-25 16:50:33 -04003017 *space_info = found;
Chris Mason4184ea72009-03-10 12:39:20 -04003018 list_add_rcu(&found->list, &info->space_info);
Josef Bacik817d52f2009-07-13 21:29:25 -04003019 atomic_set(&found->caching_threads, 0);
Chris Mason593060d2008-03-25 16:50:33 -04003020 return 0;
3021}
3022
Chris Mason8790d502008-04-03 16:29:03 -04003023static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
3024{
3025 u64 extra_flags = flags & (BTRFS_BLOCK_GROUP_RAID0 |
Chris Mason611f0e02008-04-03 16:29:03 -04003026 BTRFS_BLOCK_GROUP_RAID1 |
Chris Mason321aecc2008-04-16 10:49:51 -04003027 BTRFS_BLOCK_GROUP_RAID10 |
Chris Mason611f0e02008-04-03 16:29:03 -04003028 BTRFS_BLOCK_GROUP_DUP);
Chris Mason8790d502008-04-03 16:29:03 -04003029 if (extra_flags) {
3030 if (flags & BTRFS_BLOCK_GROUP_DATA)
3031 fs_info->avail_data_alloc_bits |= extra_flags;
3032 if (flags & BTRFS_BLOCK_GROUP_METADATA)
3033 fs_info->avail_metadata_alloc_bits |= extra_flags;
3034 if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
3035 fs_info->avail_system_alloc_bits |= extra_flags;
3036 }
3037}
Chris Mason593060d2008-03-25 16:50:33 -04003038
Yan Zheng2b820322008-11-17 21:11:30 -05003039u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags)
Chris Masonec44a352008-04-28 15:29:52 -04003040{
Yan Zheng2b820322008-11-17 21:11:30 -05003041 u64 num_devices = root->fs_info->fs_devices->rw_devices;
Chris Masona061fc82008-05-07 11:43:44 -04003042
3043 if (num_devices == 1)
3044 flags &= ~(BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID0);
3045 if (num_devices < 4)
3046 flags &= ~BTRFS_BLOCK_GROUP_RAID10;
3047
Chris Masonec44a352008-04-28 15:29:52 -04003048 if ((flags & BTRFS_BLOCK_GROUP_DUP) &&
3049 (flags & (BTRFS_BLOCK_GROUP_RAID1 |
Chris Masona061fc82008-05-07 11:43:44 -04003050 BTRFS_BLOCK_GROUP_RAID10))) {
Chris Masonec44a352008-04-28 15:29:52 -04003051 flags &= ~BTRFS_BLOCK_GROUP_DUP;
Chris Masona061fc82008-05-07 11:43:44 -04003052 }
Chris Masonec44a352008-04-28 15:29:52 -04003053
3054 if ((flags & BTRFS_BLOCK_GROUP_RAID1) &&
Chris Masona061fc82008-05-07 11:43:44 -04003055 (flags & BTRFS_BLOCK_GROUP_RAID10)) {
Chris Masonec44a352008-04-28 15:29:52 -04003056 flags &= ~BTRFS_BLOCK_GROUP_RAID1;
Chris Masona061fc82008-05-07 11:43:44 -04003057 }
Chris Masonec44a352008-04-28 15:29:52 -04003058
3059 if ((flags & BTRFS_BLOCK_GROUP_RAID0) &&
3060 ((flags & BTRFS_BLOCK_GROUP_RAID1) |
3061 (flags & BTRFS_BLOCK_GROUP_RAID10) |
3062 (flags & BTRFS_BLOCK_GROUP_DUP)))
3063 flags &= ~BTRFS_BLOCK_GROUP_RAID0;
3064 return flags;
3065}
3066
Yan, Zhengb742bb82010-05-16 10:46:24 -04003067static u64 get_alloc_profile(struct btrfs_root *root, u64 flags)
Josef Bacik6a632092009-02-20 11:00:09 -05003068{
Yan, Zhengb742bb82010-05-16 10:46:24 -04003069 if (flags & BTRFS_BLOCK_GROUP_DATA)
3070 flags |= root->fs_info->avail_data_alloc_bits &
3071 root->fs_info->data_alloc_profile;
3072 else if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
3073 flags |= root->fs_info->avail_system_alloc_bits &
3074 root->fs_info->system_alloc_profile;
3075 else if (flags & BTRFS_BLOCK_GROUP_METADATA)
3076 flags |= root->fs_info->avail_metadata_alloc_bits &
3077 root->fs_info->metadata_alloc_profile;
3078 return btrfs_reduce_alloc_profile(root, flags);
3079}
Josef Bacik6a632092009-02-20 11:00:09 -05003080
Yan, Zhengb742bb82010-05-16 10:46:24 -04003081static u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data)
3082{
3083 u64 flags;
Josef Bacik6a632092009-02-20 11:00:09 -05003084
Yan, Zhengb742bb82010-05-16 10:46:24 -04003085 if (data)
3086 flags = BTRFS_BLOCK_GROUP_DATA;
3087 else if (root == root->fs_info->chunk_root)
3088 flags = BTRFS_BLOCK_GROUP_SYSTEM;
3089 else
3090 flags = BTRFS_BLOCK_GROUP_METADATA;
3091
3092 return get_alloc_profile(root, flags);
Josef Bacik6a632092009-02-20 11:00:09 -05003093}
3094
3095void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *inode)
3096{
Josef Bacik6a632092009-02-20 11:00:09 -05003097 BTRFS_I(inode)->space_info = __find_space_info(root->fs_info,
Yan, Zhengf0486c62010-05-16 10:46:25 -04003098 BTRFS_BLOCK_GROUP_DATA);
Josef Bacik6a632092009-02-20 11:00:09 -05003099}
3100
3101/*
3102 * This will check the space that the inode allocates from to make sure we have
3103 * enough space for bytes.
3104 */
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003105int btrfs_check_data_free_space(struct inode *inode, u64 bytes)
Josef Bacik6a632092009-02-20 11:00:09 -05003106{
3107 struct btrfs_space_info *data_sinfo;
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003108 struct btrfs_root *root = BTRFS_I(inode)->root;
Josef Bacikab6e2412010-03-19 14:38:13 +00003109 u64 used;
Josef Bacik0af3d002010-06-21 14:48:16 -04003110 int ret = 0, committed = 0, alloc_chunk = 1;
Josef Bacik6a632092009-02-20 11:00:09 -05003111
3112 /* make sure bytes are sectorsize aligned */
3113 bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
3114
Josef Bacik0af3d002010-06-21 14:48:16 -04003115 if (root == root->fs_info->tree_root) {
3116 alloc_chunk = 0;
3117 committed = 1;
3118 }
3119
Josef Bacik6a632092009-02-20 11:00:09 -05003120 data_sinfo = BTRFS_I(inode)->space_info;
Chris Mason33b4d472009-09-22 14:45:50 -04003121 if (!data_sinfo)
3122 goto alloc;
3123
Josef Bacik6a632092009-02-20 11:00:09 -05003124again:
3125 /* make sure we have enough space to handle the data first */
3126 spin_lock(&data_sinfo->lock);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003127 used = data_sinfo->bytes_used + data_sinfo->bytes_reserved +
3128 data_sinfo->bytes_pinned + data_sinfo->bytes_readonly +
3129 data_sinfo->bytes_may_use;
Josef Bacikab6e2412010-03-19 14:38:13 +00003130
3131 if (used + bytes > data_sinfo->total_bytes) {
Josef Bacik4e06bdd2009-02-20 10:59:53 -05003132 struct btrfs_trans_handle *trans;
3133
Josef Bacik6a632092009-02-20 11:00:09 -05003134 /*
3135 * if we don't have enough free bytes in this space then we need
3136 * to alloc a new chunk.
3137 */
Josef Bacik0af3d002010-06-21 14:48:16 -04003138 if (!data_sinfo->full && alloc_chunk) {
Josef Bacik6a632092009-02-20 11:00:09 -05003139 u64 alloc_target;
Josef Bacik6a632092009-02-20 11:00:09 -05003140
3141 data_sinfo->force_alloc = 1;
3142 spin_unlock(&data_sinfo->lock);
Chris Mason33b4d472009-09-22 14:45:50 -04003143alloc:
Josef Bacik6a632092009-02-20 11:00:09 -05003144 alloc_target = btrfs_get_alloc_profile(root, 1);
Yan, Zhenga22285a2010-05-16 10:48:46 -04003145 trans = btrfs_join_transaction(root, 1);
3146 if (IS_ERR(trans))
3147 return PTR_ERR(trans);
Josef Bacik6a632092009-02-20 11:00:09 -05003148
3149 ret = do_chunk_alloc(trans, root->fs_info->extent_root,
3150 bytes + 2 * 1024 * 1024,
3151 alloc_target, 0);
3152 btrfs_end_transaction(trans, root);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003153 if (ret < 0)
Josef Bacik6a632092009-02-20 11:00:09 -05003154 return ret;
Chris Mason33b4d472009-09-22 14:45:50 -04003155
3156 if (!data_sinfo) {
3157 btrfs_set_inode_space_info(root, inode);
3158 data_sinfo = BTRFS_I(inode)->space_info;
3159 }
Josef Bacik6a632092009-02-20 11:00:09 -05003160 goto again;
3161 }
3162 spin_unlock(&data_sinfo->lock);
Josef Bacik4e06bdd2009-02-20 10:59:53 -05003163
3164 /* commit the current transaction and try again */
Sage Weildd7e0b72009-09-29 18:38:44 -04003165 if (!committed && !root->fs_info->open_ioctl_trans) {
Josef Bacik4e06bdd2009-02-20 10:59:53 -05003166 committed = 1;
3167 trans = btrfs_join_transaction(root, 1);
Yan, Zhenga22285a2010-05-16 10:48:46 -04003168 if (IS_ERR(trans))
3169 return PTR_ERR(trans);
Josef Bacik4e06bdd2009-02-20 10:59:53 -05003170 ret = btrfs_commit_transaction(trans, root);
3171 if (ret)
3172 return ret;
3173 goto again;
3174 }
3175
Chris Mason933b5852010-05-26 11:31:00 -04003176#if 0 /* I hope we never need this code again, just in case */
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003177 printk(KERN_ERR "no space left, need %llu, %llu bytes_used, "
3178 "%llu bytes_reserved, " "%llu bytes_pinned, "
3179 "%llu bytes_readonly, %llu may use %llu total\n",
3180 (unsigned long long)bytes,
Joel Becker21380932009-04-21 12:38:29 -07003181 (unsigned long long)data_sinfo->bytes_used,
3182 (unsigned long long)data_sinfo->bytes_reserved,
3183 (unsigned long long)data_sinfo->bytes_pinned,
3184 (unsigned long long)data_sinfo->bytes_readonly,
3185 (unsigned long long)data_sinfo->bytes_may_use,
3186 (unsigned long long)data_sinfo->total_bytes);
Chris Mason933b5852010-05-26 11:31:00 -04003187#endif
Josef Bacik6a632092009-02-20 11:00:09 -05003188 return -ENOSPC;
3189 }
3190 data_sinfo->bytes_may_use += bytes;
3191 BTRFS_I(inode)->reserved_bytes += bytes;
3192 spin_unlock(&data_sinfo->lock);
3193
Josef Bacik9ed74f22009-09-11 16:12:44 -04003194 return 0;
Josef Bacik6a632092009-02-20 11:00:09 -05003195}
3196
3197/*
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003198 * called when we are clearing an delalloc extent from the
3199 * inode's io_tree or there was an error for whatever reason
3200 * after calling btrfs_check_data_free_space
Josef Bacik6a632092009-02-20 11:00:09 -05003201 */
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003202void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes)
Josef Bacik6a632092009-02-20 11:00:09 -05003203{
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003204 struct btrfs_root *root = BTRFS_I(inode)->root;
Josef Bacik6a632092009-02-20 11:00:09 -05003205 struct btrfs_space_info *data_sinfo;
3206
3207 /* make sure bytes are sectorsize aligned */
3208 bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
3209
3210 data_sinfo = BTRFS_I(inode)->space_info;
3211 spin_lock(&data_sinfo->lock);
3212 data_sinfo->bytes_may_use -= bytes;
3213 BTRFS_I(inode)->reserved_bytes -= bytes;
3214 spin_unlock(&data_sinfo->lock);
3215}
3216
Josef Bacik97e728d2009-04-21 17:40:57 -04003217static void force_metadata_allocation(struct btrfs_fs_info *info)
3218{
3219 struct list_head *head = &info->space_info;
3220 struct btrfs_space_info *found;
3221
3222 rcu_read_lock();
3223 list_for_each_entry_rcu(found, head, list) {
3224 if (found->flags & BTRFS_BLOCK_GROUP_METADATA)
3225 found->force_alloc = 1;
3226 }
3227 rcu_read_unlock();
3228}
3229
Chris Masone5bc2452010-10-26 13:37:56 -04003230static int should_alloc_chunk(struct btrfs_root *root,
3231 struct btrfs_space_info *sinfo, u64 alloc_bytes)
Yan, Zheng424499d2010-05-16 10:46:25 -04003232{
3233 u64 num_bytes = sinfo->total_bytes - sinfo->bytes_readonly;
Chris Masone5bc2452010-10-26 13:37:56 -04003234 u64 thresh;
Yan, Zheng424499d2010-05-16 10:46:25 -04003235
3236 if (sinfo->bytes_used + sinfo->bytes_reserved +
3237 alloc_bytes + 256 * 1024 * 1024 < num_bytes)
3238 return 0;
3239
3240 if (sinfo->bytes_used + sinfo->bytes_reserved +
3241 alloc_bytes < div_factor(num_bytes, 8))
3242 return 0;
3243
Chris Masone5bc2452010-10-26 13:37:56 -04003244 thresh = btrfs_super_total_bytes(&root->fs_info->super_copy);
3245 thresh = max_t(u64, 256 * 1024 * 1024, div_factor_fine(thresh, 5));
3246
3247 if (num_bytes > thresh && sinfo->bytes_used < div_factor(num_bytes, 3))
Josef Bacik14ed0ca2010-10-15 15:23:48 -04003248 return 0;
3249
Yan, Zheng424499d2010-05-16 10:46:25 -04003250 return 1;
3251}
3252
Chris Mason6324fbf2008-03-24 15:01:59 -04003253static int do_chunk_alloc(struct btrfs_trans_handle *trans,
3254 struct btrfs_root *extent_root, u64 alloc_bytes,
Chris Mason0ef3e662008-05-24 14:04:53 -04003255 u64 flags, int force)
Chris Mason6324fbf2008-03-24 15:01:59 -04003256{
3257 struct btrfs_space_info *space_info;
Josef Bacik97e728d2009-04-21 17:40:57 -04003258 struct btrfs_fs_info *fs_info = extent_root->fs_info;
Yan Zhengc146afa2008-11-12 14:34:12 -05003259 int ret = 0;
3260
Josef Bacik97e728d2009-04-21 17:40:57 -04003261 mutex_lock(&fs_info->chunk_mutex);
Chris Mason6324fbf2008-03-24 15:01:59 -04003262
Yan Zheng2b820322008-11-17 21:11:30 -05003263 flags = btrfs_reduce_alloc_profile(extent_root, flags);
Chris Masonec44a352008-04-28 15:29:52 -04003264
Chris Mason6324fbf2008-03-24 15:01:59 -04003265 space_info = __find_space_info(extent_root->fs_info, flags);
Chris Mason593060d2008-03-25 16:50:33 -04003266 if (!space_info) {
3267 ret = update_space_info(extent_root->fs_info, flags,
3268 0, 0, &space_info);
3269 BUG_ON(ret);
3270 }
Chris Mason6324fbf2008-03-24 15:01:59 -04003271 BUG_ON(!space_info);
3272
Josef Bacik25179202008-10-29 14:49:05 -04003273 spin_lock(&space_info->lock);
Josef Bacik9ed74f22009-09-11 16:12:44 -04003274 if (space_info->force_alloc)
Chris Mason0ef3e662008-05-24 14:04:53 -04003275 force = 1;
Josef Bacik25179202008-10-29 14:49:05 -04003276 if (space_info->full) {
3277 spin_unlock(&space_info->lock);
Chris Mason925baed2008-06-25 16:01:30 -04003278 goto out;
Josef Bacik25179202008-10-29 14:49:05 -04003279 }
Chris Mason6324fbf2008-03-24 15:01:59 -04003280
Chris Masone5bc2452010-10-26 13:37:56 -04003281 if (!force && !should_alloc_chunk(extent_root, space_info,
3282 alloc_bytes)) {
Josef Bacik25179202008-10-29 14:49:05 -04003283 spin_unlock(&space_info->lock);
Chris Mason925baed2008-06-25 16:01:30 -04003284 goto out;
Josef Bacik25179202008-10-29 14:49:05 -04003285 }
Josef Bacik25179202008-10-29 14:49:05 -04003286 spin_unlock(&space_info->lock);
3287
Josef Bacik97e728d2009-04-21 17:40:57 -04003288 /*
Josef Bacik67377732010-09-16 16:19:09 -04003289 * If we have mixed data/metadata chunks we want to make sure we keep
3290 * allocating mixed chunks instead of individual chunks.
3291 */
3292 if (btrfs_mixed_space_info(space_info))
3293 flags |= (BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA);
3294
3295 /*
Josef Bacik97e728d2009-04-21 17:40:57 -04003296 * if we're doing a data chunk, go ahead and make sure that
3297 * we keep a reasonable number of metadata chunks allocated in the
3298 * FS as well.
3299 */
Josef Bacik9ed74f22009-09-11 16:12:44 -04003300 if (flags & BTRFS_BLOCK_GROUP_DATA && fs_info->metadata_ratio) {
Josef Bacik97e728d2009-04-21 17:40:57 -04003301 fs_info->data_chunk_allocations++;
3302 if (!(fs_info->data_chunk_allocations %
3303 fs_info->metadata_ratio))
3304 force_metadata_allocation(fs_info);
3305 }
3306
Yan Zheng2b820322008-11-17 21:11:30 -05003307 ret = btrfs_alloc_chunk(trans, extent_root, flags);
Josef Bacik9ed74f22009-09-11 16:12:44 -04003308 spin_lock(&space_info->lock);
Chris Masond3977122009-01-05 21:25:51 -05003309 if (ret)
Chris Mason6324fbf2008-03-24 15:01:59 -04003310 space_info->full = 1;
Yan, Zheng424499d2010-05-16 10:46:25 -04003311 else
3312 ret = 1;
Josef Bacik9ed74f22009-09-11 16:12:44 -04003313 space_info->force_alloc = 0;
3314 spin_unlock(&space_info->lock);
Chris Masona74a4b92008-06-25 16:01:31 -04003315out:
Yan Zhengc146afa2008-11-12 14:34:12 -05003316 mutex_unlock(&extent_root->fs_info->chunk_mutex);
Josef Bacik0f9dd462008-09-23 13:14:11 -04003317 return ret;
Chris Mason6324fbf2008-03-24 15:01:59 -04003318}
3319
Yan, Zheng5da9d012010-05-16 10:46:25 -04003320/*
3321 * shrink metadata reservation for delalloc
3322 */
3323static int shrink_delalloc(struct btrfs_trans_handle *trans,
Josef Bacik0019f102010-10-15 15:18:40 -04003324 struct btrfs_root *root, u64 to_reclaim, int sync)
Yan, Zheng5da9d012010-05-16 10:46:25 -04003325{
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003326 struct btrfs_block_rsv *block_rsv;
Josef Bacik0019f102010-10-15 15:18:40 -04003327 struct btrfs_space_info *space_info;
Yan, Zheng5da9d012010-05-16 10:46:25 -04003328 u64 reserved;
3329 u64 max_reclaim;
3330 u64 reclaimed = 0;
Josef Bacika1f76502010-09-16 14:29:55 -04003331 int no_reclaim = 0;
Yan, Zheng5da9d012010-05-16 10:46:25 -04003332 int pause = 1;
3333 int ret;
3334
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003335 block_rsv = &root->fs_info->delalloc_block_rsv;
Josef Bacik0019f102010-10-15 15:18:40 -04003336 space_info = block_rsv->space_info;
3337 spin_lock(&space_info->lock);
3338 reserved = space_info->bytes_reserved;
3339 spin_unlock(&space_info->lock);
Yan, Zheng5da9d012010-05-16 10:46:25 -04003340
3341 if (reserved == 0)
3342 return 0;
3343
3344 max_reclaim = min(reserved, to_reclaim);
3345
3346 while (1) {
Josef Bacik0019f102010-10-15 15:18:40 -04003347 ret = btrfs_start_one_delalloc_inode(root, trans ? 1 : 0, sync);
Yan, Zheng5da9d012010-05-16 10:46:25 -04003348 if (!ret) {
Josef Bacika1f76502010-09-16 14:29:55 -04003349 if (no_reclaim > 2)
3350 break;
3351 no_reclaim++;
Yan, Zheng5da9d012010-05-16 10:46:25 -04003352 __set_current_state(TASK_INTERRUPTIBLE);
3353 schedule_timeout(pause);
3354 pause <<= 1;
3355 if (pause > HZ / 10)
3356 pause = HZ / 10;
3357 } else {
Josef Bacika1f76502010-09-16 14:29:55 -04003358 no_reclaim = 0;
Yan, Zheng5da9d012010-05-16 10:46:25 -04003359 pause = 1;
3360 }
3361
Josef Bacik0019f102010-10-15 15:18:40 -04003362 spin_lock(&space_info->lock);
3363 if (reserved > space_info->bytes_reserved)
3364 reclaimed += reserved - space_info->bytes_reserved;
3365 reserved = space_info->bytes_reserved;
3366 spin_unlock(&space_info->lock);
Yan, Zheng5da9d012010-05-16 10:46:25 -04003367
3368 if (reserved == 0 || reclaimed >= max_reclaim)
3369 break;
3370
3371 if (trans && trans->transaction->blocked)
3372 return -EAGAIN;
3373 }
3374 return reclaimed >= to_reclaim;
3375}
3376
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003377/*
3378 * Retries tells us how many times we've called reserve_metadata_bytes. The
3379 * idea is if this is the first call (retries == 0) then we will add to our
3380 * reserved count if we can't make the allocation in order to hold our place
3381 * while we go and try and free up space. That way for retries > 1 we don't try
3382 * and add space, we just check to see if the amount of unused space is >= the
3383 * total space, meaning that our reservation is valid.
3384 *
3385 * However if we don't intend to retry this reservation, pass -1 as retries so
3386 * that it short circuits this logic.
3387 */
3388static int reserve_metadata_bytes(struct btrfs_trans_handle *trans,
3389 struct btrfs_root *root,
3390 struct btrfs_block_rsv *block_rsv,
3391 u64 orig_bytes, int flush)
Yan, Zhengf0486c62010-05-16 10:46:25 -04003392{
3393 struct btrfs_space_info *space_info = block_rsv->space_info;
3394 u64 unused;
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003395 u64 num_bytes = orig_bytes;
3396 int retries = 0;
3397 int ret = 0;
3398 bool reserved = false;
Josef Bacik38227932010-10-26 12:52:53 -04003399 bool committed = false;
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003400
3401again:
3402 ret = -ENOSPC;
3403 if (reserved)
3404 num_bytes = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003405
3406 spin_lock(&space_info->lock);
3407 unused = space_info->bytes_used + space_info->bytes_reserved +
Josef Bacik6d487552010-10-15 15:13:32 -04003408 space_info->bytes_pinned + space_info->bytes_readonly +
3409 space_info->bytes_may_use;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003410
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003411 /*
3412 * The idea here is that we've not already over-reserved the block group
3413 * then we can go ahead and save our reservation first and then start
3414 * flushing if we need to. Otherwise if we've already overcommitted
3415 * lets start flushing stuff first and then come back and try to make
3416 * our reservation.
3417 */
3418 if (unused <= space_info->total_bytes) {
3419 unused -= space_info->total_bytes;
3420 if (unused >= num_bytes) {
3421 if (!reserved)
3422 space_info->bytes_reserved += orig_bytes;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003423 ret = 0;
3424 } else {
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003425 /*
3426 * Ok set num_bytes to orig_bytes since we aren't
3427 * overocmmitted, this way we only try and reclaim what
3428 * we need.
3429 */
3430 num_bytes = orig_bytes;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003431 }
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003432 } else {
3433 /*
3434 * Ok we're over committed, set num_bytes to the overcommitted
3435 * amount plus the amount of bytes that we need for this
3436 * reservation.
3437 */
3438 num_bytes = unused - space_info->total_bytes +
3439 (orig_bytes * (retries + 1));
Yan, Zhengf0486c62010-05-16 10:46:25 -04003440 }
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003441
3442 /*
3443 * Couldn't make our reservation, save our place so while we're trying
3444 * to reclaim space we can actually use it instead of somebody else
3445 * stealing it from us.
3446 */
3447 if (ret && !reserved) {
3448 space_info->bytes_reserved += orig_bytes;
3449 reserved = true;
3450 }
3451
Yan, Zhengf0486c62010-05-16 10:46:25 -04003452 spin_unlock(&space_info->lock);
3453
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003454 if (!ret)
3455 return 0;
3456
3457 if (!flush)
3458 goto out;
3459
3460 /*
3461 * We do synchronous shrinking since we don't actually unreserve
3462 * metadata until after the IO is completed.
3463 */
3464 ret = shrink_delalloc(trans, root, num_bytes, 1);
3465 if (ret > 0)
3466 return 0;
3467 else if (ret < 0)
3468 goto out;
3469
3470 /*
3471 * So if we were overcommitted it's possible that somebody else flushed
3472 * out enough space and we simply didn't have enough space to reclaim,
3473 * so go back around and try again.
3474 */
3475 if (retries < 2) {
3476 retries++;
3477 goto again;
3478 }
3479
3480 spin_lock(&space_info->lock);
3481 /*
3482 * Not enough space to be reclaimed, don't bother committing the
3483 * transaction.
3484 */
3485 if (space_info->bytes_pinned < orig_bytes)
3486 ret = -ENOSPC;
3487 spin_unlock(&space_info->lock);
3488 if (ret)
3489 goto out;
3490
3491 ret = -EAGAIN;
Josef Bacik38227932010-10-26 12:52:53 -04003492 if (trans || committed)
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003493 goto out;
3494
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003495 ret = -ENOSPC;
3496 trans = btrfs_join_transaction(root, 1);
3497 if (IS_ERR(trans))
3498 goto out;
3499 ret = btrfs_commit_transaction(trans, root);
Josef Bacik38227932010-10-26 12:52:53 -04003500 if (!ret) {
3501 trans = NULL;
3502 committed = true;
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003503 goto again;
Josef Bacik38227932010-10-26 12:52:53 -04003504 }
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003505
3506out:
3507 if (reserved) {
3508 spin_lock(&space_info->lock);
3509 space_info->bytes_reserved -= orig_bytes;
3510 spin_unlock(&space_info->lock);
3511 }
3512
Yan, Zhengf0486c62010-05-16 10:46:25 -04003513 return ret;
3514}
3515
3516static struct btrfs_block_rsv *get_block_rsv(struct btrfs_trans_handle *trans,
3517 struct btrfs_root *root)
3518{
3519 struct btrfs_block_rsv *block_rsv;
3520 if (root->ref_cows)
3521 block_rsv = trans->block_rsv;
3522 else
3523 block_rsv = root->block_rsv;
3524
3525 if (!block_rsv)
3526 block_rsv = &root->fs_info->empty_block_rsv;
3527
3528 return block_rsv;
3529}
3530
3531static int block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv,
3532 u64 num_bytes)
3533{
3534 int ret = -ENOSPC;
3535 spin_lock(&block_rsv->lock);
3536 if (block_rsv->reserved >= num_bytes) {
3537 block_rsv->reserved -= num_bytes;
3538 if (block_rsv->reserved < block_rsv->size)
3539 block_rsv->full = 0;
3540 ret = 0;
3541 }
3542 spin_unlock(&block_rsv->lock);
3543 return ret;
3544}
3545
3546static void block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
3547 u64 num_bytes, int update_size)
3548{
3549 spin_lock(&block_rsv->lock);
3550 block_rsv->reserved += num_bytes;
3551 if (update_size)
3552 block_rsv->size += num_bytes;
3553 else if (block_rsv->reserved >= block_rsv->size)
3554 block_rsv->full = 1;
3555 spin_unlock(&block_rsv->lock);
3556}
3557
3558void block_rsv_release_bytes(struct btrfs_block_rsv *block_rsv,
3559 struct btrfs_block_rsv *dest, u64 num_bytes)
3560{
3561 struct btrfs_space_info *space_info = block_rsv->space_info;
3562
3563 spin_lock(&block_rsv->lock);
3564 if (num_bytes == (u64)-1)
3565 num_bytes = block_rsv->size;
3566 block_rsv->size -= num_bytes;
3567 if (block_rsv->reserved >= block_rsv->size) {
3568 num_bytes = block_rsv->reserved - block_rsv->size;
3569 block_rsv->reserved = block_rsv->size;
3570 block_rsv->full = 1;
3571 } else {
3572 num_bytes = 0;
3573 }
3574 spin_unlock(&block_rsv->lock);
3575
3576 if (num_bytes > 0) {
3577 if (dest) {
3578 block_rsv_add_bytes(dest, num_bytes, 0);
3579 } else {
3580 spin_lock(&space_info->lock);
3581 space_info->bytes_reserved -= num_bytes;
3582 spin_unlock(&space_info->lock);
3583 }
3584 }
3585}
3586
3587static int block_rsv_migrate_bytes(struct btrfs_block_rsv *src,
3588 struct btrfs_block_rsv *dst, u64 num_bytes)
3589{
3590 int ret;
3591
3592 ret = block_rsv_use_bytes(src, num_bytes);
3593 if (ret)
3594 return ret;
3595
3596 block_rsv_add_bytes(dst, num_bytes, 1);
3597 return 0;
3598}
3599
3600void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv)
3601{
3602 memset(rsv, 0, sizeof(*rsv));
3603 spin_lock_init(&rsv->lock);
3604 atomic_set(&rsv->usage, 1);
3605 rsv->priority = 6;
3606 INIT_LIST_HEAD(&rsv->list);
3607}
3608
3609struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
3610{
3611 struct btrfs_block_rsv *block_rsv;
3612 struct btrfs_fs_info *fs_info = root->fs_info;
3613 u64 alloc_target;
3614
3615 block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
3616 if (!block_rsv)
3617 return NULL;
3618
3619 btrfs_init_block_rsv(block_rsv);
3620
3621 alloc_target = btrfs_get_alloc_profile(root, 0);
3622 block_rsv->space_info = __find_space_info(fs_info,
3623 BTRFS_BLOCK_GROUP_METADATA);
3624
3625 return block_rsv;
3626}
3627
3628void btrfs_free_block_rsv(struct btrfs_root *root,
3629 struct btrfs_block_rsv *rsv)
3630{
3631 if (rsv && atomic_dec_and_test(&rsv->usage)) {
3632 btrfs_block_rsv_release(root, rsv, (u64)-1);
3633 if (!rsv->durable)
3634 kfree(rsv);
3635 }
3636}
3637
3638/*
3639 * make the block_rsv struct be able to capture freed space.
3640 * the captured space will re-add to the the block_rsv struct
3641 * after transaction commit
3642 */
3643void btrfs_add_durable_block_rsv(struct btrfs_fs_info *fs_info,
3644 struct btrfs_block_rsv *block_rsv)
3645{
3646 block_rsv->durable = 1;
3647 mutex_lock(&fs_info->durable_block_rsv_mutex);
3648 list_add_tail(&block_rsv->list, &fs_info->durable_block_rsv_list);
3649 mutex_unlock(&fs_info->durable_block_rsv_mutex);
3650}
3651
3652int btrfs_block_rsv_add(struct btrfs_trans_handle *trans,
3653 struct btrfs_root *root,
3654 struct btrfs_block_rsv *block_rsv,
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003655 u64 num_bytes)
Yan, Zhengf0486c62010-05-16 10:46:25 -04003656{
3657 int ret;
3658
3659 if (num_bytes == 0)
3660 return 0;
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003661
3662 ret = reserve_metadata_bytes(trans, root, block_rsv, num_bytes, 1);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003663 if (!ret) {
3664 block_rsv_add_bytes(block_rsv, num_bytes, 1);
3665 return 0;
3666 }
3667
Yan, Zhengf0486c62010-05-16 10:46:25 -04003668 return ret;
3669}
3670
3671int btrfs_block_rsv_check(struct btrfs_trans_handle *trans,
3672 struct btrfs_root *root,
3673 struct btrfs_block_rsv *block_rsv,
3674 u64 min_reserved, int min_factor)
3675{
3676 u64 num_bytes = 0;
3677 int commit_trans = 0;
3678 int ret = -ENOSPC;
3679
3680 if (!block_rsv)
3681 return 0;
3682
3683 spin_lock(&block_rsv->lock);
3684 if (min_factor > 0)
3685 num_bytes = div_factor(block_rsv->size, min_factor);
3686 if (min_reserved > num_bytes)
3687 num_bytes = min_reserved;
3688
3689 if (block_rsv->reserved >= num_bytes) {
3690 ret = 0;
3691 } else {
3692 num_bytes -= block_rsv->reserved;
3693 if (block_rsv->durable &&
3694 block_rsv->freed[0] + block_rsv->freed[1] >= num_bytes)
3695 commit_trans = 1;
3696 }
3697 spin_unlock(&block_rsv->lock);
3698 if (!ret)
3699 return 0;
3700
3701 if (block_rsv->refill_used) {
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003702 ret = reserve_metadata_bytes(trans, root, block_rsv,
3703 num_bytes, 0);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003704 if (!ret) {
3705 block_rsv_add_bytes(block_rsv, num_bytes, 0);
3706 return 0;
3707 }
3708 }
3709
3710 if (commit_trans) {
3711 if (trans)
3712 return -EAGAIN;
3713
3714 trans = btrfs_join_transaction(root, 1);
3715 BUG_ON(IS_ERR(trans));
3716 ret = btrfs_commit_transaction(trans, root);
3717 return 0;
3718 }
3719
3720 WARN_ON(1);
3721 printk(KERN_INFO"block_rsv size %llu reserved %llu freed %llu %llu\n",
3722 block_rsv->size, block_rsv->reserved,
3723 block_rsv->freed[0], block_rsv->freed[1]);
3724
3725 return -ENOSPC;
3726}
3727
3728int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
3729 struct btrfs_block_rsv *dst_rsv,
3730 u64 num_bytes)
3731{
3732 return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
3733}
3734
3735void btrfs_block_rsv_release(struct btrfs_root *root,
3736 struct btrfs_block_rsv *block_rsv,
3737 u64 num_bytes)
3738{
3739 struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
3740 if (global_rsv->full || global_rsv == block_rsv ||
3741 block_rsv->space_info != global_rsv->space_info)
3742 global_rsv = NULL;
3743 block_rsv_release_bytes(block_rsv, global_rsv, num_bytes);
3744}
3745
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003746/*
3747 * helper to calculate size of global block reservation.
3748 * the desired value is sum of space used by extent tree,
3749 * checksum tree and root tree
3750 */
3751static u64 calc_global_metadata_size(struct btrfs_fs_info *fs_info)
3752{
3753 struct btrfs_space_info *sinfo;
3754 u64 num_bytes;
3755 u64 meta_used;
3756 u64 data_used;
3757 int csum_size = btrfs_super_csum_size(&fs_info->super_copy);
3758#if 0
3759 /*
3760 * per tree used space accounting can be inaccuracy, so we
3761 * can't rely on it.
3762 */
3763 spin_lock(&fs_info->extent_root->accounting_lock);
3764 num_bytes = btrfs_root_used(&fs_info->extent_root->root_item);
3765 spin_unlock(&fs_info->extent_root->accounting_lock);
3766
3767 spin_lock(&fs_info->csum_root->accounting_lock);
3768 num_bytes += btrfs_root_used(&fs_info->csum_root->root_item);
3769 spin_unlock(&fs_info->csum_root->accounting_lock);
3770
3771 spin_lock(&fs_info->tree_root->accounting_lock);
3772 num_bytes += btrfs_root_used(&fs_info->tree_root->root_item);
3773 spin_unlock(&fs_info->tree_root->accounting_lock);
3774#endif
3775 sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_DATA);
3776 spin_lock(&sinfo->lock);
3777 data_used = sinfo->bytes_used;
3778 spin_unlock(&sinfo->lock);
3779
3780 sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
3781 spin_lock(&sinfo->lock);
Josef Bacik6d487552010-10-15 15:13:32 -04003782 if (sinfo->flags & BTRFS_BLOCK_GROUP_DATA)
3783 data_used = 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003784 meta_used = sinfo->bytes_used;
3785 spin_unlock(&sinfo->lock);
3786
3787 num_bytes = (data_used >> fs_info->sb->s_blocksize_bits) *
3788 csum_size * 2;
3789 num_bytes += div64_u64(data_used + meta_used, 50);
3790
3791 if (num_bytes * 3 > meta_used)
3792 num_bytes = div64_u64(meta_used, 3);
3793
3794 return ALIGN(num_bytes, fs_info->extent_root->leafsize << 10);
3795}
3796
3797static void update_global_block_rsv(struct btrfs_fs_info *fs_info)
3798{
3799 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
3800 struct btrfs_space_info *sinfo = block_rsv->space_info;
3801 u64 num_bytes;
3802
3803 num_bytes = calc_global_metadata_size(fs_info);
3804
3805 spin_lock(&block_rsv->lock);
3806 spin_lock(&sinfo->lock);
3807
3808 block_rsv->size = num_bytes;
3809
3810 num_bytes = sinfo->bytes_used + sinfo->bytes_pinned +
Josef Bacik6d487552010-10-15 15:13:32 -04003811 sinfo->bytes_reserved + sinfo->bytes_readonly +
3812 sinfo->bytes_may_use;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003813
3814 if (sinfo->total_bytes > num_bytes) {
3815 num_bytes = sinfo->total_bytes - num_bytes;
3816 block_rsv->reserved += num_bytes;
3817 sinfo->bytes_reserved += num_bytes;
3818 }
3819
3820 if (block_rsv->reserved >= block_rsv->size) {
3821 num_bytes = block_rsv->reserved - block_rsv->size;
3822 sinfo->bytes_reserved -= num_bytes;
3823 block_rsv->reserved = block_rsv->size;
3824 block_rsv->full = 1;
3825 }
3826#if 0
3827 printk(KERN_INFO"global block rsv size %llu reserved %llu\n",
3828 block_rsv->size, block_rsv->reserved);
3829#endif
3830 spin_unlock(&sinfo->lock);
3831 spin_unlock(&block_rsv->lock);
3832}
3833
Yan, Zhengf0486c62010-05-16 10:46:25 -04003834static void init_global_block_rsv(struct btrfs_fs_info *fs_info)
3835{
3836 struct btrfs_space_info *space_info;
3837
3838 space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
3839 fs_info->chunk_block_rsv.space_info = space_info;
3840 fs_info->chunk_block_rsv.priority = 10;
3841
3842 space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003843 fs_info->global_block_rsv.space_info = space_info;
3844 fs_info->global_block_rsv.priority = 10;
3845 fs_info->global_block_rsv.refill_used = 1;
3846 fs_info->delalloc_block_rsv.space_info = space_info;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003847 fs_info->trans_block_rsv.space_info = space_info;
3848 fs_info->empty_block_rsv.space_info = space_info;
3849 fs_info->empty_block_rsv.priority = 10;
3850
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003851 fs_info->extent_root->block_rsv = &fs_info->global_block_rsv;
3852 fs_info->csum_root->block_rsv = &fs_info->global_block_rsv;
3853 fs_info->dev_root->block_rsv = &fs_info->global_block_rsv;
3854 fs_info->tree_root->block_rsv = &fs_info->global_block_rsv;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003855 fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003856
3857 btrfs_add_durable_block_rsv(fs_info, &fs_info->global_block_rsv);
3858
3859 btrfs_add_durable_block_rsv(fs_info, &fs_info->delalloc_block_rsv);
3860
3861 update_global_block_rsv(fs_info);
3862}
3863
3864static void release_global_block_rsv(struct btrfs_fs_info *fs_info)
3865{
3866 block_rsv_release_bytes(&fs_info->global_block_rsv, NULL, (u64)-1);
3867 WARN_ON(fs_info->delalloc_block_rsv.size > 0);
3868 WARN_ON(fs_info->delalloc_block_rsv.reserved > 0);
3869 WARN_ON(fs_info->trans_block_rsv.size > 0);
3870 WARN_ON(fs_info->trans_block_rsv.reserved > 0);
3871 WARN_ON(fs_info->chunk_block_rsv.size > 0);
3872 WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003873}
3874
Yan, Zhenga22285a2010-05-16 10:48:46 -04003875static u64 calc_trans_metadata_size(struct btrfs_root *root, int num_items)
3876{
3877 return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
3878 3 * num_items;
3879}
3880
3881int btrfs_trans_reserve_metadata(struct btrfs_trans_handle *trans,
3882 struct btrfs_root *root,
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003883 int num_items)
Yan, Zhenga22285a2010-05-16 10:48:46 -04003884{
3885 u64 num_bytes;
3886 int ret;
3887
3888 if (num_items == 0 || root->fs_info->chunk_root == root)
3889 return 0;
3890
3891 num_bytes = calc_trans_metadata_size(root, num_items);
3892 ret = btrfs_block_rsv_add(trans, root, &root->fs_info->trans_block_rsv,
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003893 num_bytes);
Yan, Zhenga22285a2010-05-16 10:48:46 -04003894 if (!ret) {
3895 trans->bytes_reserved += num_bytes;
3896 trans->block_rsv = &root->fs_info->trans_block_rsv;
3897 }
3898 return ret;
3899}
3900
3901void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
3902 struct btrfs_root *root)
3903{
3904 if (!trans->bytes_reserved)
3905 return;
3906
3907 BUG_ON(trans->block_rsv != &root->fs_info->trans_block_rsv);
3908 btrfs_block_rsv_release(root, trans->block_rsv,
3909 trans->bytes_reserved);
3910 trans->bytes_reserved = 0;
3911}
3912
Yan, Zhengd68fc572010-05-16 10:49:58 -04003913int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
3914 struct inode *inode)
3915{
3916 struct btrfs_root *root = BTRFS_I(inode)->root;
3917 struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
3918 struct btrfs_block_rsv *dst_rsv = root->orphan_block_rsv;
3919
3920 /*
3921 * one for deleting orphan item, one for updating inode and
3922 * two for calling btrfs_truncate_inode_items.
3923 *
3924 * btrfs_truncate_inode_items is a delete operation, it frees
3925 * more space than it uses in most cases. So two units of
3926 * metadata space should be enough for calling it many times.
3927 * If all of the metadata space is used, we can commit
3928 * transaction and use space it freed.
3929 */
3930 u64 num_bytes = calc_trans_metadata_size(root, 4);
3931 return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
3932}
3933
3934void btrfs_orphan_release_metadata(struct inode *inode)
3935{
3936 struct btrfs_root *root = BTRFS_I(inode)->root;
3937 u64 num_bytes = calc_trans_metadata_size(root, 4);
3938 btrfs_block_rsv_release(root, root->orphan_block_rsv, num_bytes);
3939}
3940
Yan, Zhenga22285a2010-05-16 10:48:46 -04003941int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,
3942 struct btrfs_pending_snapshot *pending)
3943{
3944 struct btrfs_root *root = pending->root;
3945 struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
3946 struct btrfs_block_rsv *dst_rsv = &pending->block_rsv;
3947 /*
3948 * two for root back/forward refs, two for directory entries
3949 * and one for root of the snapshot.
3950 */
3951 u64 num_bytes = calc_trans_metadata_size(root, 5);
3952 dst_rsv->space_info = src_rsv->space_info;
3953 return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
3954}
3955
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003956static u64 calc_csum_metadata_size(struct inode *inode, u64 num_bytes)
3957{
3958 return num_bytes >>= 3;
3959}
3960
3961int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
3962{
3963 struct btrfs_root *root = BTRFS_I(inode)->root;
3964 struct btrfs_block_rsv *block_rsv = &root->fs_info->delalloc_block_rsv;
3965 u64 to_reserve;
3966 int nr_extents;
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003967 int ret;
3968
3969 if (btrfs_transaction_in_commit(root->fs_info))
3970 schedule_timeout(1);
3971
3972 num_bytes = ALIGN(num_bytes, root->sectorsize);
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003973
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003974 spin_lock(&BTRFS_I(inode)->accounting_lock);
3975 nr_extents = atomic_read(&BTRFS_I(inode)->outstanding_extents) + 1;
3976 if (nr_extents > BTRFS_I(inode)->reserved_extents) {
3977 nr_extents -= BTRFS_I(inode)->reserved_extents;
3978 to_reserve = calc_trans_metadata_size(root, nr_extents);
3979 } else {
3980 nr_extents = 0;
3981 to_reserve = 0;
3982 }
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003983 spin_unlock(&BTRFS_I(inode)->accounting_lock);
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003984
3985 to_reserve += calc_csum_metadata_size(inode, num_bytes);
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003986 ret = reserve_metadata_bytes(NULL, root, block_rsv, to_reserve, 1);
3987 if (ret)
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003988 return ret;
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003989
Josef Bacik8bb8ab22010-10-15 16:52:49 -04003990 spin_lock(&BTRFS_I(inode)->accounting_lock);
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003991 BTRFS_I(inode)->reserved_extents += nr_extents;
3992 atomic_inc(&BTRFS_I(inode)->outstanding_extents);
3993 spin_unlock(&BTRFS_I(inode)->accounting_lock);
3994
3995 block_rsv_add_bytes(block_rsv, to_reserve, 1);
3996
3997 if (block_rsv->size > 512 * 1024 * 1024)
Josef Bacik0019f102010-10-15 15:18:40 -04003998 shrink_delalloc(NULL, root, to_reserve, 0);
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003999
4000 return 0;
4001}
4002
4003void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes)
4004{
4005 struct btrfs_root *root = BTRFS_I(inode)->root;
4006 u64 to_free;
4007 int nr_extents;
4008
4009 num_bytes = ALIGN(num_bytes, root->sectorsize);
4010 atomic_dec(&BTRFS_I(inode)->outstanding_extents);
4011
4012 spin_lock(&BTRFS_I(inode)->accounting_lock);
4013 nr_extents = atomic_read(&BTRFS_I(inode)->outstanding_extents);
4014 if (nr_extents < BTRFS_I(inode)->reserved_extents) {
4015 nr_extents = BTRFS_I(inode)->reserved_extents - nr_extents;
4016 BTRFS_I(inode)->reserved_extents -= nr_extents;
4017 } else {
4018 nr_extents = 0;
4019 }
4020 spin_unlock(&BTRFS_I(inode)->accounting_lock);
4021
4022 to_free = calc_csum_metadata_size(inode, num_bytes);
4023 if (nr_extents > 0)
4024 to_free += calc_trans_metadata_size(root, nr_extents);
4025
4026 btrfs_block_rsv_release(root, &root->fs_info->delalloc_block_rsv,
4027 to_free);
4028}
4029
4030int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes)
4031{
4032 int ret;
4033
4034 ret = btrfs_check_data_free_space(inode, num_bytes);
4035 if (ret)
4036 return ret;
4037
4038 ret = btrfs_delalloc_reserve_metadata(inode, num_bytes);
4039 if (ret) {
4040 btrfs_free_reserved_data_space(inode, num_bytes);
4041 return ret;
4042 }
4043
4044 return 0;
4045}
4046
4047void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes)
4048{
4049 btrfs_delalloc_release_metadata(inode, num_bytes);
4050 btrfs_free_reserved_data_space(inode, num_bytes);
4051}
4052
Chris Mason9078a3e2007-04-26 16:46:15 -04004053static int update_block_group(struct btrfs_trans_handle *trans,
4054 struct btrfs_root *root,
Yan, Zhengf0486c62010-05-16 10:46:25 -04004055 u64 bytenr, u64 num_bytes, int alloc)
Chris Mason9078a3e2007-04-26 16:46:15 -04004056{
Josef Bacik0af3d002010-06-21 14:48:16 -04004057 struct btrfs_block_group_cache *cache = NULL;
Chris Mason9078a3e2007-04-26 16:46:15 -04004058 struct btrfs_fs_info *info = root->fs_info;
Chris Masondb945352007-10-15 16:15:53 -04004059 u64 total = num_bytes;
Chris Mason9078a3e2007-04-26 16:46:15 -04004060 u64 old_val;
Chris Masondb945352007-10-15 16:15:53 -04004061 u64 byte_in_group;
Josef Bacik0af3d002010-06-21 14:48:16 -04004062 int factor;
Chris Mason3e1ad542007-05-07 20:03:49 -04004063
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004064 /* block accounting for super block */
4065 spin_lock(&info->delalloc_lock);
4066 old_val = btrfs_super_bytes_used(&info->super_copy);
4067 if (alloc)
4068 old_val += num_bytes;
4069 else
4070 old_val -= num_bytes;
4071 btrfs_set_super_bytes_used(&info->super_copy, old_val);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004072 spin_unlock(&info->delalloc_lock);
4073
Chris Masond3977122009-01-05 21:25:51 -05004074 while (total) {
Chris Masondb945352007-10-15 16:15:53 -04004075 cache = btrfs_lookup_block_group(info, bytenr);
Josef Bacikf3465ca2008-11-12 14:19:50 -05004076 if (!cache)
Chris Mason9078a3e2007-04-26 16:46:15 -04004077 return -1;
Yan, Zhengb742bb82010-05-16 10:46:24 -04004078 if (cache->flags & (BTRFS_BLOCK_GROUP_DUP |
4079 BTRFS_BLOCK_GROUP_RAID1 |
4080 BTRFS_BLOCK_GROUP_RAID10))
4081 factor = 2;
4082 else
4083 factor = 1;
Josef Bacik9d66e232010-08-25 16:54:15 -04004084 /*
4085 * If this block group has free space cache written out, we
4086 * need to make sure to load it if we are removing space. This
4087 * is because we need the unpinning stage to actually add the
4088 * space back to the block group, otherwise we will leak space.
4089 */
4090 if (!alloc && cache->cached == BTRFS_CACHE_NO)
4091 cache_block_group(cache, trans, 1);
Josef Bacik0af3d002010-06-21 14:48:16 -04004092
Chris Masondb945352007-10-15 16:15:53 -04004093 byte_in_group = bytenr - cache->key.objectid;
4094 WARN_ON(byte_in_group > cache->key.offset);
Chris Mason9078a3e2007-04-26 16:46:15 -04004095
Josef Bacik25179202008-10-29 14:49:05 -04004096 spin_lock(&cache->space_info->lock);
Chris Masonc286ac42008-07-22 23:06:41 -04004097 spin_lock(&cache->lock);
Josef Bacik0af3d002010-06-21 14:48:16 -04004098
4099 if (btrfs_super_cache_generation(&info->super_copy) != 0 &&
4100 cache->disk_cache_state < BTRFS_DC_CLEAR)
4101 cache->disk_cache_state = BTRFS_DC_CLEAR;
4102
Josef Bacik0f9dd462008-09-23 13:14:11 -04004103 cache->dirty = 1;
Chris Mason9078a3e2007-04-26 16:46:15 -04004104 old_val = btrfs_block_group_used(&cache->item);
Chris Masondb945352007-10-15 16:15:53 -04004105 num_bytes = min(total, cache->key.offset - byte_in_group);
Chris Masoncd1bc462007-04-27 10:08:34 -04004106 if (alloc) {
Chris Masondb945352007-10-15 16:15:53 -04004107 old_val += num_bytes;
Yan Zheng11833d62009-09-11 16:11:19 -04004108 btrfs_set_block_group_used(&cache->item, old_val);
4109 cache->reserved -= num_bytes;
Yan Zheng11833d62009-09-11 16:11:19 -04004110 cache->space_info->bytes_reserved -= num_bytes;
Yan, Zhengb742bb82010-05-16 10:46:24 -04004111 cache->space_info->bytes_used += num_bytes;
4112 cache->space_info->disk_used += num_bytes * factor;
Chris Masonc286ac42008-07-22 23:06:41 -04004113 spin_unlock(&cache->lock);
Josef Bacik25179202008-10-29 14:49:05 -04004114 spin_unlock(&cache->space_info->lock);
Chris Masoncd1bc462007-04-27 10:08:34 -04004115 } else {
Chris Masondb945352007-10-15 16:15:53 -04004116 old_val -= num_bytes;
Chris Masonc286ac42008-07-22 23:06:41 -04004117 btrfs_set_block_group_used(&cache->item, old_val);
Yan, Zhengf0486c62010-05-16 10:46:25 -04004118 cache->pinned += num_bytes;
4119 cache->space_info->bytes_pinned += num_bytes;
Chris Mason9078a3e2007-04-26 16:46:15 -04004120 cache->space_info->bytes_used -= num_bytes;
Yan, Zhengb742bb82010-05-16 10:46:24 -04004121 cache->space_info->disk_used -= num_bytes * factor;
Chris Masonc286ac42008-07-22 23:06:41 -04004122 spin_unlock(&cache->lock);
Josef Bacik25179202008-10-29 14:49:05 -04004123 spin_unlock(&cache->space_info->lock);
Liu Hui1f3c79a2009-01-05 15:57:51 -05004124
Yan, Zhengf0486c62010-05-16 10:46:25 -04004125 set_extent_dirty(info->pinned_extents,
4126 bytenr, bytenr + num_bytes - 1,
4127 GFP_NOFS | __GFP_NOFAIL);
Chris Masoncd1bc462007-04-27 10:08:34 -04004128 }
Chris Masonfa9c0d72009-04-03 09:47:43 -04004129 btrfs_put_block_group(cache);
Chris Masondb945352007-10-15 16:15:53 -04004130 total -= num_bytes;
4131 bytenr += num_bytes;
Chris Mason9078a3e2007-04-26 16:46:15 -04004132 }
4133 return 0;
4134}
Chris Mason6324fbf2008-03-24 15:01:59 -04004135
Chris Masona061fc82008-05-07 11:43:44 -04004136static u64 first_logical_byte(struct btrfs_root *root, u64 search_start)
4137{
Josef Bacik0f9dd462008-09-23 13:14:11 -04004138 struct btrfs_block_group_cache *cache;
Yan Zhengd2fb3432008-12-11 16:30:39 -05004139 u64 bytenr;
Josef Bacik0f9dd462008-09-23 13:14:11 -04004140
4141 cache = btrfs_lookup_first_block_group(root->fs_info, search_start);
4142 if (!cache)
Chris Masona061fc82008-05-07 11:43:44 -04004143 return 0;
Josef Bacik0f9dd462008-09-23 13:14:11 -04004144
Yan Zhengd2fb3432008-12-11 16:30:39 -05004145 bytenr = cache->key.objectid;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004146 btrfs_put_block_group(cache);
Yan Zhengd2fb3432008-12-11 16:30:39 -05004147
4148 return bytenr;
Chris Masona061fc82008-05-07 11:43:44 -04004149}
4150
Yan, Zhengf0486c62010-05-16 10:46:25 -04004151static int pin_down_extent(struct btrfs_root *root,
4152 struct btrfs_block_group_cache *cache,
4153 u64 bytenr, u64 num_bytes, int reserved)
Yan324ae4d2007-11-16 14:57:08 -05004154{
Yan Zheng11833d62009-09-11 16:11:19 -04004155 spin_lock(&cache->space_info->lock);
4156 spin_lock(&cache->lock);
4157 cache->pinned += num_bytes;
4158 cache->space_info->bytes_pinned += num_bytes;
4159 if (reserved) {
4160 cache->reserved -= num_bytes;
4161 cache->space_info->bytes_reserved -= num_bytes;
Yan324ae4d2007-11-16 14:57:08 -05004162 }
Yan Zheng11833d62009-09-11 16:11:19 -04004163 spin_unlock(&cache->lock);
4164 spin_unlock(&cache->space_info->lock);
4165
Yan, Zhengf0486c62010-05-16 10:46:25 -04004166 set_extent_dirty(root->fs_info->pinned_extents, bytenr,
4167 bytenr + num_bytes - 1, GFP_NOFS | __GFP_NOFAIL);
Yan324ae4d2007-11-16 14:57:08 -05004168 return 0;
4169}
Chris Mason9078a3e2007-04-26 16:46:15 -04004170
Yan, Zhengf0486c62010-05-16 10:46:25 -04004171/*
4172 * this function must be called within transaction
4173 */
4174int btrfs_pin_extent(struct btrfs_root *root,
4175 u64 bytenr, u64 num_bytes, int reserved)
Zheng Yane8569812008-09-26 10:05:48 -04004176{
Yan, Zhengf0486c62010-05-16 10:46:25 -04004177 struct btrfs_block_group_cache *cache;
4178
4179 cache = btrfs_lookup_block_group(root->fs_info, bytenr);
4180 BUG_ON(!cache);
4181
4182 pin_down_extent(root, cache, bytenr, num_bytes, reserved);
4183
4184 btrfs_put_block_group(cache);
Yan Zheng11833d62009-09-11 16:11:19 -04004185 return 0;
4186}
Zheng Yane8569812008-09-26 10:05:48 -04004187
Yan, Zhengf0486c62010-05-16 10:46:25 -04004188/*
4189 * update size of reserved extents. this function may return -EAGAIN
4190 * if 'reserve' is true or 'sinfo' is false.
4191 */
4192static int update_reserved_bytes(struct btrfs_block_group_cache *cache,
4193 u64 num_bytes, int reserve, int sinfo)
4194{
4195 int ret = 0;
4196 if (sinfo) {
4197 struct btrfs_space_info *space_info = cache->space_info;
4198 spin_lock(&space_info->lock);
4199 spin_lock(&cache->lock);
4200 if (reserve) {
4201 if (cache->ro) {
4202 ret = -EAGAIN;
4203 } else {
4204 cache->reserved += num_bytes;
4205 space_info->bytes_reserved += num_bytes;
4206 }
4207 } else {
4208 if (cache->ro)
4209 space_info->bytes_readonly += num_bytes;
4210 cache->reserved -= num_bytes;
4211 space_info->bytes_reserved -= num_bytes;
4212 }
4213 spin_unlock(&cache->lock);
4214 spin_unlock(&space_info->lock);
4215 } else {
4216 spin_lock(&cache->lock);
4217 if (cache->ro) {
4218 ret = -EAGAIN;
4219 } else {
4220 if (reserve)
4221 cache->reserved += num_bytes;
4222 else
4223 cache->reserved -= num_bytes;
4224 }
4225 spin_unlock(&cache->lock);
4226 }
4227 return ret;
4228}
4229
Yan Zheng11833d62009-09-11 16:11:19 -04004230int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
4231 struct btrfs_root *root)
4232{
4233 struct btrfs_fs_info *fs_info = root->fs_info;
4234 struct btrfs_caching_control *next;
4235 struct btrfs_caching_control *caching_ctl;
4236 struct btrfs_block_group_cache *cache;
4237
4238 down_write(&fs_info->extent_commit_sem);
4239
4240 list_for_each_entry_safe(caching_ctl, next,
4241 &fs_info->caching_block_groups, list) {
4242 cache = caching_ctl->block_group;
4243 if (block_group_cache_done(cache)) {
4244 cache->last_byte_to_unpin = (u64)-1;
4245 list_del_init(&caching_ctl->list);
4246 put_caching_control(caching_ctl);
4247 } else {
4248 cache->last_byte_to_unpin = caching_ctl->progress;
4249 }
4250 }
4251
4252 if (fs_info->pinned_extents == &fs_info->freed_extents[0])
4253 fs_info->pinned_extents = &fs_info->freed_extents[1];
4254 else
4255 fs_info->pinned_extents = &fs_info->freed_extents[0];
4256
4257 up_write(&fs_info->extent_commit_sem);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04004258
4259 update_global_block_rsv(fs_info);
Yan Zheng11833d62009-09-11 16:11:19 -04004260 return 0;
4261}
4262
4263static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
4264{
4265 struct btrfs_fs_info *fs_info = root->fs_info;
4266 struct btrfs_block_group_cache *cache = NULL;
4267 u64 len;
4268
4269 while (start <= end) {
4270 if (!cache ||
4271 start >= cache->key.objectid + cache->key.offset) {
4272 if (cache)
4273 btrfs_put_block_group(cache);
4274 cache = btrfs_lookup_block_group(fs_info, start);
4275 BUG_ON(!cache);
4276 }
4277
4278 len = cache->key.objectid + cache->key.offset - start;
4279 len = min(len, end + 1 - start);
4280
4281 if (start < cache->last_byte_to_unpin) {
4282 len = min(len, cache->last_byte_to_unpin - start);
4283 btrfs_add_free_space(cache, start, len);
4284 }
Josef Bacik25179202008-10-29 14:49:05 -04004285
Yan, Zhengf0486c62010-05-16 10:46:25 -04004286 start += len;
4287
Josef Bacik25179202008-10-29 14:49:05 -04004288 spin_lock(&cache->space_info->lock);
4289 spin_lock(&cache->lock);
Yan Zheng11833d62009-09-11 16:11:19 -04004290 cache->pinned -= len;
4291 cache->space_info->bytes_pinned -= len;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004292 if (cache->ro) {
4293 cache->space_info->bytes_readonly += len;
4294 } else if (cache->reserved_pinned > 0) {
4295 len = min(len, cache->reserved_pinned);
4296 cache->reserved_pinned -= len;
4297 cache->space_info->bytes_reserved += len;
4298 }
Josef Bacik25179202008-10-29 14:49:05 -04004299 spin_unlock(&cache->lock);
4300 spin_unlock(&cache->space_info->lock);
Yan Zheng11833d62009-09-11 16:11:19 -04004301 }
4302
4303 if (cache)
Chris Masonfa9c0d72009-04-03 09:47:43 -04004304 btrfs_put_block_group(cache);
Chris Masonccd467d2007-06-28 15:57:36 -04004305 return 0;
4306}
4307
4308int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
Yan Zheng11833d62009-09-11 16:11:19 -04004309 struct btrfs_root *root)
Chris Masona28ec192007-03-06 20:08:01 -05004310{
Yan Zheng11833d62009-09-11 16:11:19 -04004311 struct btrfs_fs_info *fs_info = root->fs_info;
4312 struct extent_io_tree *unpin;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004313 struct btrfs_block_rsv *block_rsv;
4314 struct btrfs_block_rsv *next_rsv;
Chris Mason1a5bc162007-10-15 16:15:26 -04004315 u64 start;
4316 u64 end;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004317 int idx;
Chris Masona28ec192007-03-06 20:08:01 -05004318 int ret;
Chris Masona28ec192007-03-06 20:08:01 -05004319
Yan Zheng11833d62009-09-11 16:11:19 -04004320 if (fs_info->pinned_extents == &fs_info->freed_extents[0])
4321 unpin = &fs_info->freed_extents[1];
4322 else
4323 unpin = &fs_info->freed_extents[0];
4324
Chris Masond3977122009-01-05 21:25:51 -05004325 while (1) {
Chris Mason1a5bc162007-10-15 16:15:26 -04004326 ret = find_first_extent_bit(unpin, 0, &start, &end,
4327 EXTENT_DIRTY);
4328 if (ret)
Chris Masona28ec192007-03-06 20:08:01 -05004329 break;
Liu Hui1f3c79a2009-01-05 15:57:51 -05004330
4331 ret = btrfs_discard_extent(root, start, end + 1 - start);
4332
Chris Mason1a5bc162007-10-15 16:15:26 -04004333 clear_extent_dirty(unpin, start, end, GFP_NOFS);
Yan Zheng11833d62009-09-11 16:11:19 -04004334 unpin_extent_range(root, start, end);
Chris Masonb9473432009-03-13 11:00:37 -04004335 cond_resched();
Chris Masona28ec192007-03-06 20:08:01 -05004336 }
Josef Bacik817d52f2009-07-13 21:29:25 -04004337
Yan, Zhengf0486c62010-05-16 10:46:25 -04004338 mutex_lock(&fs_info->durable_block_rsv_mutex);
4339 list_for_each_entry_safe(block_rsv, next_rsv,
4340 &fs_info->durable_block_rsv_list, list) {
Chris Masona28ec192007-03-06 20:08:01 -05004341
Yan, Zhengf0486c62010-05-16 10:46:25 -04004342 idx = trans->transid & 0x1;
4343 if (block_rsv->freed[idx] > 0) {
4344 block_rsv_add_bytes(block_rsv,
4345 block_rsv->freed[idx], 0);
4346 block_rsv->freed[idx] = 0;
Chris Mason8ef97622007-03-26 10:15:30 -04004347 }
Yan, Zhengf0486c62010-05-16 10:46:25 -04004348 if (atomic_read(&block_rsv->usage) == 0) {
4349 btrfs_block_rsv_release(root, block_rsv, (u64)-1);
Zheng Yan31840ae2008-09-23 13:14:14 -04004350
Yan, Zhengf0486c62010-05-16 10:46:25 -04004351 if (block_rsv->freed[0] == 0 &&
4352 block_rsv->freed[1] == 0) {
4353 list_del_init(&block_rsv->list);
4354 kfree(block_rsv);
4355 }
4356 } else {
4357 btrfs_block_rsv_release(root, block_rsv, 0);
4358 }
4359 }
4360 mutex_unlock(&fs_info->durable_block_rsv_mutex);
4361
Chris Masone20d96d2007-03-22 12:13:20 -04004362 return 0;
4363}
4364
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004365static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
4366 struct btrfs_root *root,
4367 u64 bytenr, u64 num_bytes, u64 parent,
4368 u64 root_objectid, u64 owner_objectid,
4369 u64 owner_offset, int refs_to_drop,
4370 struct btrfs_delayed_extent_op *extent_op)
Chris Masona28ec192007-03-06 20:08:01 -05004371{
Chris Masone2fa7222007-03-12 16:22:34 -04004372 struct btrfs_key key;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004373 struct btrfs_path *path;
Chris Mason1261ec42007-03-20 20:35:03 -04004374 struct btrfs_fs_info *info = root->fs_info;
4375 struct btrfs_root *extent_root = info->extent_root;
Chris Mason5f39d392007-10-15 16:14:19 -04004376 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004377 struct btrfs_extent_item *ei;
4378 struct btrfs_extent_inline_ref *iref;
Chris Masona28ec192007-03-06 20:08:01 -05004379 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004380 int is_data;
Chris Mason952fcca2008-02-18 16:33:44 -05004381 int extent_slot = 0;
4382 int found_extent = 0;
4383 int num_to_del = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004384 u32 item_size;
4385 u64 refs;
Chris Mason037e6392007-03-07 11:50:24 -05004386
Chris Mason5caf2a02007-04-02 11:20:42 -04004387 path = btrfs_alloc_path();
Chris Mason54aa1f42007-06-22 14:16:25 -04004388 if (!path)
4389 return -ENOMEM;
4390
Chris Mason3c12ac72008-04-21 12:01:38 -04004391 path->reada = 1;
Chris Masonb9473432009-03-13 11:00:37 -04004392 path->leave_spinning = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004393
4394 is_data = owner_objectid >= BTRFS_FIRST_FREE_OBJECTID;
4395 BUG_ON(!is_data && refs_to_drop != 1);
4396
4397 ret = lookup_extent_backref(trans, extent_root, path, &iref,
4398 bytenr, num_bytes, parent,
4399 root_objectid, owner_objectid,
4400 owner_offset);
Chris Mason7bb86312007-12-11 09:25:06 -05004401 if (ret == 0) {
Chris Mason952fcca2008-02-18 16:33:44 -05004402 extent_slot = path->slots[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004403 while (extent_slot >= 0) {
4404 btrfs_item_key_to_cpu(path->nodes[0], &key,
Chris Mason952fcca2008-02-18 16:33:44 -05004405 extent_slot);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004406 if (key.objectid != bytenr)
Chris Mason952fcca2008-02-18 16:33:44 -05004407 break;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004408 if (key.type == BTRFS_EXTENT_ITEM_KEY &&
4409 key.offset == num_bytes) {
Chris Mason952fcca2008-02-18 16:33:44 -05004410 found_extent = 1;
4411 break;
4412 }
4413 if (path->slots[0] - extent_slot > 5)
4414 break;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004415 extent_slot--;
Chris Mason952fcca2008-02-18 16:33:44 -05004416 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004417#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
4418 item_size = btrfs_item_size_nr(path->nodes[0], extent_slot);
4419 if (found_extent && item_size < sizeof(*ei))
4420 found_extent = 0;
4421#endif
Zheng Yan31840ae2008-09-23 13:14:14 -04004422 if (!found_extent) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004423 BUG_ON(iref);
Chris Mason56bec292009-03-13 10:10:06 -04004424 ret = remove_extent_backref(trans, extent_root, path,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004425 NULL, refs_to_drop,
4426 is_data);
Zheng Yan31840ae2008-09-23 13:14:14 -04004427 BUG_ON(ret);
4428 btrfs_release_path(extent_root, path);
Chris Masonb9473432009-03-13 11:00:37 -04004429 path->leave_spinning = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004430
4431 key.objectid = bytenr;
4432 key.type = BTRFS_EXTENT_ITEM_KEY;
4433 key.offset = num_bytes;
4434
Zheng Yan31840ae2008-09-23 13:14:14 -04004435 ret = btrfs_search_slot(trans, extent_root,
4436 &key, path, -1, 1);
Josef Bacikf3465ca2008-11-12 14:19:50 -05004437 if (ret) {
4438 printk(KERN_ERR "umm, got %d back from search"
Chris Masond3977122009-01-05 21:25:51 -05004439 ", was looking for %llu\n", ret,
4440 (unsigned long long)bytenr);
Josef Bacikf3465ca2008-11-12 14:19:50 -05004441 btrfs_print_leaf(extent_root, path->nodes[0]);
4442 }
Zheng Yan31840ae2008-09-23 13:14:14 -04004443 BUG_ON(ret);
4444 extent_slot = path->slots[0];
4445 }
Chris Mason7bb86312007-12-11 09:25:06 -05004446 } else {
4447 btrfs_print_leaf(extent_root, path->nodes[0]);
4448 WARN_ON(1);
Chris Masond3977122009-01-05 21:25:51 -05004449 printk(KERN_ERR "btrfs unable to find ref byte nr %llu "
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004450 "parent %llu root %llu owner %llu offset %llu\n",
Chris Masond3977122009-01-05 21:25:51 -05004451 (unsigned long long)bytenr,
Chris Mason56bec292009-03-13 10:10:06 -04004452 (unsigned long long)parent,
Chris Masond3977122009-01-05 21:25:51 -05004453 (unsigned long long)root_objectid,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004454 (unsigned long long)owner_objectid,
4455 (unsigned long long)owner_offset);
Chris Mason7bb86312007-12-11 09:25:06 -05004456 }
Chris Mason5f39d392007-10-15 16:14:19 -04004457
4458 leaf = path->nodes[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004459 item_size = btrfs_item_size_nr(leaf, extent_slot);
4460#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
4461 if (item_size < sizeof(*ei)) {
4462 BUG_ON(found_extent || extent_slot != path->slots[0]);
4463 ret = convert_extent_item_v0(trans, extent_root, path,
4464 owner_objectid, 0);
4465 BUG_ON(ret < 0);
4466
4467 btrfs_release_path(extent_root, path);
4468 path->leave_spinning = 1;
4469
4470 key.objectid = bytenr;
4471 key.type = BTRFS_EXTENT_ITEM_KEY;
4472 key.offset = num_bytes;
4473
4474 ret = btrfs_search_slot(trans, extent_root, &key, path,
4475 -1, 1);
4476 if (ret) {
4477 printk(KERN_ERR "umm, got %d back from search"
4478 ", was looking for %llu\n", ret,
4479 (unsigned long long)bytenr);
4480 btrfs_print_leaf(extent_root, path->nodes[0]);
4481 }
4482 BUG_ON(ret);
4483 extent_slot = path->slots[0];
4484 leaf = path->nodes[0];
4485 item_size = btrfs_item_size_nr(leaf, extent_slot);
4486 }
4487#endif
4488 BUG_ON(item_size < sizeof(*ei));
Chris Mason952fcca2008-02-18 16:33:44 -05004489 ei = btrfs_item_ptr(leaf, extent_slot,
Chris Mason123abc82007-03-14 14:14:43 -04004490 struct btrfs_extent_item);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004491 if (owner_objectid < BTRFS_FIRST_FREE_OBJECTID) {
4492 struct btrfs_tree_block_info *bi;
4493 BUG_ON(item_size < sizeof(*ei) + sizeof(*bi));
4494 bi = (struct btrfs_tree_block_info *)(ei + 1);
4495 WARN_ON(owner_objectid != btrfs_tree_block_level(leaf, bi));
Chris Mason952fcca2008-02-18 16:33:44 -05004496 }
4497
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004498 refs = btrfs_extent_refs(leaf, ei);
4499 BUG_ON(refs < refs_to_drop);
4500 refs -= refs_to_drop;
4501
4502 if (refs > 0) {
4503 if (extent_op)
4504 __run_delayed_extent_op(extent_op, leaf, ei);
4505 /*
4506 * In the case of inline back ref, reference count will
4507 * be updated by remove_extent_backref
4508 */
4509 if (iref) {
4510 BUG_ON(!found_extent);
4511 } else {
4512 btrfs_set_extent_refs(leaf, ei, refs);
4513 btrfs_mark_buffer_dirty(leaf);
4514 }
4515 if (found_extent) {
4516 ret = remove_extent_backref(trans, extent_root, path,
4517 iref, refs_to_drop,
4518 is_data);
4519 BUG_ON(ret);
4520 }
4521 } else {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004522 if (found_extent) {
4523 BUG_ON(is_data && refs_to_drop !=
4524 extent_data_ref_count(root, path, iref));
4525 if (iref) {
4526 BUG_ON(path->slots[0] != extent_slot);
4527 } else {
4528 BUG_ON(path->slots[0] != extent_slot + 1);
4529 path->slots[0] = extent_slot;
4530 num_to_del = 2;
4531 }
Chris Mason78fae272007-03-25 11:35:08 -04004532 }
Chris Masonb9473432009-03-13 11:00:37 -04004533
Chris Mason952fcca2008-02-18 16:33:44 -05004534 ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
4535 num_to_del);
Zheng Yan31840ae2008-09-23 13:14:14 -04004536 BUG_ON(ret);
Josef Bacik25179202008-10-29 14:49:05 -04004537 btrfs_release_path(extent_root, path);
David Woodhouse21af8042008-08-12 14:13:26 +01004538
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004539 if (is_data) {
Chris Mason459931e2008-12-10 09:10:46 -05004540 ret = btrfs_del_csums(trans, root, bytenr, num_bytes);
4541 BUG_ON(ret);
Chris Masond57e62b2009-03-31 13:47:50 -04004542 } else {
4543 invalidate_mapping_pages(info->btree_inode->i_mapping,
4544 bytenr >> PAGE_CACHE_SHIFT,
4545 (bytenr + num_bytes - 1) >> PAGE_CACHE_SHIFT);
Chris Mason459931e2008-12-10 09:10:46 -05004546 }
4547
Yan, Zhengf0486c62010-05-16 10:46:25 -04004548 ret = update_block_group(trans, root, bytenr, num_bytes, 0);
Chris Masondcbdd4d2008-12-16 13:51:01 -05004549 BUG_ON(ret);
Chris Masona28ec192007-03-06 20:08:01 -05004550 }
Chris Mason5caf2a02007-04-02 11:20:42 -04004551 btrfs_free_path(path);
Chris Masona28ec192007-03-06 20:08:01 -05004552 return ret;
4553}
4554
4555/*
Yan, Zhengf0486c62010-05-16 10:46:25 -04004556 * when we free an block, it is possible (and likely) that we free the last
Chris Mason1887be62009-03-13 10:11:24 -04004557 * delayed ref for that extent as well. This searches the delayed ref tree for
4558 * a given extent, and if there are no other delayed refs to be processed, it
4559 * removes it from the tree.
4560 */
4561static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans,
4562 struct btrfs_root *root, u64 bytenr)
4563{
4564 struct btrfs_delayed_ref_head *head;
4565 struct btrfs_delayed_ref_root *delayed_refs;
4566 struct btrfs_delayed_ref_node *ref;
4567 struct rb_node *node;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004568 int ret = 0;
Chris Mason1887be62009-03-13 10:11:24 -04004569
4570 delayed_refs = &trans->transaction->delayed_refs;
4571 spin_lock(&delayed_refs->lock);
4572 head = btrfs_find_delayed_ref_head(trans, bytenr);
4573 if (!head)
4574 goto out;
4575
4576 node = rb_prev(&head->node.rb_node);
4577 if (!node)
4578 goto out;
4579
4580 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
4581
4582 /* there are still entries for this ref, we can't drop it */
4583 if (ref->bytenr == bytenr)
4584 goto out;
4585
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004586 if (head->extent_op) {
4587 if (!head->must_insert_reserved)
4588 goto out;
4589 kfree(head->extent_op);
4590 head->extent_op = NULL;
4591 }
4592
Chris Mason1887be62009-03-13 10:11:24 -04004593 /*
4594 * waiting for the lock here would deadlock. If someone else has it
4595 * locked they are already in the process of dropping it anyway
4596 */
4597 if (!mutex_trylock(&head->mutex))
4598 goto out;
4599
4600 /*
4601 * at this point we have a head with no other entries. Go
4602 * ahead and process it.
4603 */
4604 head->node.in_tree = 0;
4605 rb_erase(&head->node.rb_node, &delayed_refs->root);
Chris Masonc3e69d52009-03-13 10:17:05 -04004606
Chris Mason1887be62009-03-13 10:11:24 -04004607 delayed_refs->num_entries--;
4608
4609 /*
4610 * we don't take a ref on the node because we're removing it from the
4611 * tree, so we just steal the ref the tree was holding.
4612 */
Chris Masonc3e69d52009-03-13 10:17:05 -04004613 delayed_refs->num_heads--;
4614 if (list_empty(&head->cluster))
4615 delayed_refs->num_heads_ready--;
4616
4617 list_del_init(&head->cluster);
Chris Mason1887be62009-03-13 10:11:24 -04004618 spin_unlock(&delayed_refs->lock);
4619
Yan, Zhengf0486c62010-05-16 10:46:25 -04004620 BUG_ON(head->extent_op);
4621 if (head->must_insert_reserved)
4622 ret = 1;
4623
4624 mutex_unlock(&head->mutex);
Chris Mason1887be62009-03-13 10:11:24 -04004625 btrfs_put_delayed_ref(&head->node);
Yan, Zhengf0486c62010-05-16 10:46:25 -04004626 return ret;
Chris Mason1887be62009-03-13 10:11:24 -04004627out:
4628 spin_unlock(&delayed_refs->lock);
4629 return 0;
4630}
4631
Yan, Zhengf0486c62010-05-16 10:46:25 -04004632void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
4633 struct btrfs_root *root,
4634 struct extent_buffer *buf,
4635 u64 parent, int last_ref)
4636{
4637 struct btrfs_block_rsv *block_rsv;
4638 struct btrfs_block_group_cache *cache = NULL;
4639 int ret;
4640
4641 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
4642 ret = btrfs_add_delayed_tree_ref(trans, buf->start, buf->len,
4643 parent, root->root_key.objectid,
4644 btrfs_header_level(buf),
4645 BTRFS_DROP_DELAYED_REF, NULL);
4646 BUG_ON(ret);
4647 }
4648
4649 if (!last_ref)
4650 return;
4651
4652 block_rsv = get_block_rsv(trans, root);
4653 cache = btrfs_lookup_block_group(root->fs_info, buf->start);
Yan, Zheng3bf84a52010-05-31 09:04:46 +00004654 if (block_rsv->space_info != cache->space_info)
4655 goto out;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004656
4657 if (btrfs_header_generation(buf) == trans->transid) {
4658 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
4659 ret = check_ref_cleanup(trans, root, buf->start);
4660 if (!ret)
4661 goto pin;
4662 }
4663
4664 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN)) {
4665 pin_down_extent(root, cache, buf->start, buf->len, 1);
4666 goto pin;
4667 }
4668
4669 WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));
4670
4671 btrfs_add_free_space(cache, buf->start, buf->len);
4672 ret = update_reserved_bytes(cache, buf->len, 0, 0);
4673 if (ret == -EAGAIN) {
4674 /* block group became read-only */
4675 update_reserved_bytes(cache, buf->len, 0, 1);
4676 goto out;
4677 }
4678
4679 ret = 1;
4680 spin_lock(&block_rsv->lock);
4681 if (block_rsv->reserved < block_rsv->size) {
4682 block_rsv->reserved += buf->len;
4683 ret = 0;
4684 }
4685 spin_unlock(&block_rsv->lock);
4686
4687 if (ret) {
4688 spin_lock(&cache->space_info->lock);
4689 cache->space_info->bytes_reserved -= buf->len;
4690 spin_unlock(&cache->space_info->lock);
4691 }
4692 goto out;
4693 }
4694pin:
4695 if (block_rsv->durable && !cache->ro) {
4696 ret = 0;
4697 spin_lock(&cache->lock);
4698 if (!cache->ro) {
4699 cache->reserved_pinned += buf->len;
4700 ret = 1;
4701 }
4702 spin_unlock(&cache->lock);
4703
4704 if (ret) {
4705 spin_lock(&block_rsv->lock);
4706 block_rsv->freed[trans->transid & 0x1] += buf->len;
4707 spin_unlock(&block_rsv->lock);
4708 }
4709 }
4710out:
4711 btrfs_put_block_group(cache);
4712}
4713
Chris Mason925baed2008-06-25 16:01:30 -04004714int btrfs_free_extent(struct btrfs_trans_handle *trans,
Zheng Yan31840ae2008-09-23 13:14:14 -04004715 struct btrfs_root *root,
4716 u64 bytenr, u64 num_bytes, u64 parent,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004717 u64 root_objectid, u64 owner, u64 offset)
Chris Mason925baed2008-06-25 16:01:30 -04004718{
4719 int ret;
4720
Chris Mason56bec292009-03-13 10:10:06 -04004721 /*
4722 * tree log blocks never actually go into the extent allocation
4723 * tree, just update pinning info and exit early.
Chris Mason56bec292009-03-13 10:10:06 -04004724 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004725 if (root_objectid == BTRFS_TREE_LOG_OBJECTID) {
4726 WARN_ON(owner >= BTRFS_FIRST_FREE_OBJECTID);
Chris Masonb9473432009-03-13 11:00:37 -04004727 /* unlocks the pinned mutex */
Yan Zheng11833d62009-09-11 16:11:19 -04004728 btrfs_pin_extent(root, bytenr, num_bytes, 1);
Chris Mason56bec292009-03-13 10:10:06 -04004729 ret = 0;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004730 } else if (owner < BTRFS_FIRST_FREE_OBJECTID) {
4731 ret = btrfs_add_delayed_tree_ref(trans, bytenr, num_bytes,
4732 parent, root_objectid, (int)owner,
4733 BTRFS_DROP_DELAYED_REF, NULL);
Chris Mason1887be62009-03-13 10:11:24 -04004734 BUG_ON(ret);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004735 } else {
4736 ret = btrfs_add_delayed_data_ref(trans, bytenr, num_bytes,
4737 parent, root_objectid, owner,
4738 offset, BTRFS_DROP_DELAYED_REF, NULL);
4739 BUG_ON(ret);
Chris Mason56bec292009-03-13 10:10:06 -04004740 }
Chris Mason925baed2008-06-25 16:01:30 -04004741 return ret;
4742}
4743
Chris Mason87ee04e2007-11-30 11:30:34 -05004744static u64 stripe_align(struct btrfs_root *root, u64 val)
4745{
4746 u64 mask = ((u64)root->stripesize - 1);
4747 u64 ret = (val + mask) & ~mask;
4748 return ret;
4749}
4750
Chris Masonfec577f2007-02-26 10:40:21 -05004751/*
Josef Bacik817d52f2009-07-13 21:29:25 -04004752 * when we wait for progress in the block group caching, its because
4753 * our allocation attempt failed at least once. So, we must sleep
4754 * and let some progress happen before we try again.
4755 *
4756 * This function will sleep at least once waiting for new free space to
4757 * show up, and then it will check the block group free space numbers
4758 * for our min num_bytes. Another option is to have it go ahead
4759 * and look in the rbtree for a free extent of a given size, but this
4760 * is a good start.
4761 */
4762static noinline int
4763wait_block_group_cache_progress(struct btrfs_block_group_cache *cache,
4764 u64 num_bytes)
4765{
Yan Zheng11833d62009-09-11 16:11:19 -04004766 struct btrfs_caching_control *caching_ctl;
Josef Bacik817d52f2009-07-13 21:29:25 -04004767 DEFINE_WAIT(wait);
4768
Yan Zheng11833d62009-09-11 16:11:19 -04004769 caching_ctl = get_caching_control(cache);
4770 if (!caching_ctl)
Josef Bacik817d52f2009-07-13 21:29:25 -04004771 return 0;
Josef Bacik817d52f2009-07-13 21:29:25 -04004772
Yan Zheng11833d62009-09-11 16:11:19 -04004773 wait_event(caching_ctl->wait, block_group_cache_done(cache) ||
Josef Bacik817d52f2009-07-13 21:29:25 -04004774 (cache->free_space >= num_bytes));
Yan Zheng11833d62009-09-11 16:11:19 -04004775
4776 put_caching_control(caching_ctl);
4777 return 0;
4778}
4779
4780static noinline int
4781wait_block_group_cache_done(struct btrfs_block_group_cache *cache)
4782{
4783 struct btrfs_caching_control *caching_ctl;
4784 DEFINE_WAIT(wait);
4785
4786 caching_ctl = get_caching_control(cache);
4787 if (!caching_ctl)
4788 return 0;
4789
4790 wait_event(caching_ctl->wait, block_group_cache_done(cache));
4791
4792 put_caching_control(caching_ctl);
Josef Bacik817d52f2009-07-13 21:29:25 -04004793 return 0;
4794}
4795
Yan, Zhengb742bb82010-05-16 10:46:24 -04004796static int get_block_group_index(struct btrfs_block_group_cache *cache)
4797{
4798 int index;
4799 if (cache->flags & BTRFS_BLOCK_GROUP_RAID10)
4800 index = 0;
4801 else if (cache->flags & BTRFS_BLOCK_GROUP_RAID1)
4802 index = 1;
4803 else if (cache->flags & BTRFS_BLOCK_GROUP_DUP)
4804 index = 2;
4805 else if (cache->flags & BTRFS_BLOCK_GROUP_RAID0)
4806 index = 3;
4807 else
4808 index = 4;
4809 return index;
4810}
4811
Josef Bacik817d52f2009-07-13 21:29:25 -04004812enum btrfs_loop_type {
Josef Bacikccf0e722009-11-10 21:23:48 -05004813 LOOP_FIND_IDEAL = 0,
Josef Bacik817d52f2009-07-13 21:29:25 -04004814 LOOP_CACHING_NOWAIT = 1,
4815 LOOP_CACHING_WAIT = 2,
4816 LOOP_ALLOC_CHUNK = 3,
4817 LOOP_NO_EMPTY_SIZE = 4,
4818};
4819
4820/*
Chris Masonfec577f2007-02-26 10:40:21 -05004821 * walks the btree of allocated extents and find a hole of a given size.
4822 * The key ins is changed to record the hole:
4823 * ins->objectid == block start
Chris Mason62e27492007-03-15 12:56:47 -04004824 * ins->flags = BTRFS_EXTENT_ITEM_KEY
Chris Masonfec577f2007-02-26 10:40:21 -05004825 * ins->offset == number of blocks
4826 * Any available blocks before search_start are skipped.
4827 */
Chris Masond3977122009-01-05 21:25:51 -05004828static noinline int find_free_extent(struct btrfs_trans_handle *trans,
Chris Mason98ed5172008-01-03 10:01:48 -05004829 struct btrfs_root *orig_root,
4830 u64 num_bytes, u64 empty_size,
4831 u64 search_start, u64 search_end,
4832 u64 hint_byte, struct btrfs_key *ins,
Chris Mason98ed5172008-01-03 10:01:48 -05004833 int data)
Chris Masonfec577f2007-02-26 10:40:21 -05004834{
Josef Bacik80eb2342008-10-29 14:49:05 -04004835 int ret = 0;
Chris Masond3977122009-01-05 21:25:51 -05004836 struct btrfs_root *root = orig_root->fs_info->extent_root;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004837 struct btrfs_free_cluster *last_ptr = NULL;
Josef Bacik80eb2342008-10-29 14:49:05 -04004838 struct btrfs_block_group_cache *block_group = NULL;
Chris Mason239b14b2008-03-24 15:02:07 -04004839 int empty_cluster = 2 * 1024 * 1024;
Chris Mason0ef3e662008-05-24 14:04:53 -04004840 int allowed_chunk_alloc = 0;
Josef Bacikccf0e722009-11-10 21:23:48 -05004841 int done_chunk_alloc = 0;
Josef Bacik80eb2342008-10-29 14:49:05 -04004842 struct btrfs_space_info *space_info;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004843 int last_ptr_loop = 0;
4844 int loop = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004845 int index = 0;
Josef Bacik817d52f2009-07-13 21:29:25 -04004846 bool found_uncached_bg = false;
Josef Bacik0a243252009-09-11 16:11:20 -04004847 bool failed_cluster_refill = false;
Josef Bacik1cdda9b2009-10-06 10:04:28 -04004848 bool failed_alloc = false;
Josef Bacik67377732010-09-16 16:19:09 -04004849 bool use_cluster = true;
Josef Bacikccf0e722009-11-10 21:23:48 -05004850 u64 ideal_cache_percent = 0;
4851 u64 ideal_cache_offset = 0;
Chris Masonfec577f2007-02-26 10:40:21 -05004852
Chris Masondb945352007-10-15 16:15:53 -04004853 WARN_ON(num_bytes < root->sectorsize);
Chris Masonb1a4d962007-04-04 15:27:52 -04004854 btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
Josef Bacik80eb2342008-10-29 14:49:05 -04004855 ins->objectid = 0;
4856 ins->offset = 0;
Chris Masonb1a4d962007-04-04 15:27:52 -04004857
Josef Bacik2552d172009-04-03 10:14:19 -04004858 space_info = __find_space_info(root->fs_info, data);
Josef Bacik1b1d1f62010-03-19 20:49:55 +00004859 if (!space_info) {
4860 printk(KERN_ERR "No space info for %d\n", data);
4861 return -ENOSPC;
4862 }
Josef Bacik2552d172009-04-03 10:14:19 -04004863
Josef Bacik67377732010-09-16 16:19:09 -04004864 /*
4865 * If the space info is for both data and metadata it means we have a
4866 * small filesystem and we can't use the clustering stuff.
4867 */
4868 if (btrfs_mixed_space_info(space_info))
4869 use_cluster = false;
4870
Chris Mason0ef3e662008-05-24 14:04:53 -04004871 if (orig_root->ref_cows || empty_size)
4872 allowed_chunk_alloc = 1;
4873
Josef Bacik67377732010-09-16 16:19:09 -04004874 if (data & BTRFS_BLOCK_GROUP_METADATA && use_cluster) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004875 last_ptr = &root->fs_info->meta_alloc_cluster;
Chris Mason536ac8a2009-02-12 09:41:38 -05004876 if (!btrfs_test_opt(root, SSD))
4877 empty_cluster = 64 * 1024;
Chris Mason239b14b2008-03-24 15:02:07 -04004878 }
4879
Josef Bacik67377732010-09-16 16:19:09 -04004880 if ((data & BTRFS_BLOCK_GROUP_DATA) && use_cluster &&
4881 btrfs_test_opt(root, SSD)) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004882 last_ptr = &root->fs_info->data_alloc_cluster;
4883 }
Josef Bacik0f9dd462008-09-23 13:14:11 -04004884
Chris Mason239b14b2008-03-24 15:02:07 -04004885 if (last_ptr) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004886 spin_lock(&last_ptr->lock);
4887 if (last_ptr->block_group)
4888 hint_byte = last_ptr->window_start;
4889 spin_unlock(&last_ptr->lock);
Chris Mason239b14b2008-03-24 15:02:07 -04004890 }
Chris Masonfa9c0d72009-04-03 09:47:43 -04004891
Chris Masona061fc82008-05-07 11:43:44 -04004892 search_start = max(search_start, first_logical_byte(root, 0));
Chris Mason239b14b2008-03-24 15:02:07 -04004893 search_start = max(search_start, hint_byte);
Chris Mason0b86a832008-03-24 15:01:56 -04004894
Josef Bacik817d52f2009-07-13 21:29:25 -04004895 if (!last_ptr)
Chris Masonfa9c0d72009-04-03 09:47:43 -04004896 empty_cluster = 0;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004897
Josef Bacik2552d172009-04-03 10:14:19 -04004898 if (search_start == hint_byte) {
Josef Bacikccf0e722009-11-10 21:23:48 -05004899ideal_cache:
Josef Bacik2552d172009-04-03 10:14:19 -04004900 block_group = btrfs_lookup_block_group(root->fs_info,
4901 search_start);
Josef Bacik817d52f2009-07-13 21:29:25 -04004902 /*
4903 * we don't want to use the block group if it doesn't match our
4904 * allocation bits, or if its not cached.
Josef Bacikccf0e722009-11-10 21:23:48 -05004905 *
4906 * However if we are re-searching with an ideal block group
4907 * picked out then we don't care that the block group is cached.
Josef Bacik817d52f2009-07-13 21:29:25 -04004908 */
4909 if (block_group && block_group_bits(block_group, data) &&
Josef Bacikccf0e722009-11-10 21:23:48 -05004910 (block_group->cached != BTRFS_CACHE_NO ||
4911 search_start == ideal_cache_offset)) {
Josef Bacik2552d172009-04-03 10:14:19 -04004912 down_read(&space_info->groups_sem);
Chris Mason44fb5512009-06-04 15:34:51 -04004913 if (list_empty(&block_group->list) ||
4914 block_group->ro) {
4915 /*
4916 * someone is removing this block group,
4917 * we can't jump into the have_block_group
4918 * target because our list pointers are not
4919 * valid
4920 */
4921 btrfs_put_block_group(block_group);
4922 up_read(&space_info->groups_sem);
Josef Bacikccf0e722009-11-10 21:23:48 -05004923 } else {
Yan, Zhengb742bb82010-05-16 10:46:24 -04004924 index = get_block_group_index(block_group);
Chris Mason44fb5512009-06-04 15:34:51 -04004925 goto have_block_group;
Josef Bacikccf0e722009-11-10 21:23:48 -05004926 }
Josef Bacik2552d172009-04-03 10:14:19 -04004927 } else if (block_group) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004928 btrfs_put_block_group(block_group);
Josef Bacik2552d172009-04-03 10:14:19 -04004929 }
Chris Mason42e70e72008-11-07 18:17:11 -05004930 }
Josef Bacik2552d172009-04-03 10:14:19 -04004931search:
Josef Bacik80eb2342008-10-29 14:49:05 -04004932 down_read(&space_info->groups_sem);
Yan, Zhengb742bb82010-05-16 10:46:24 -04004933 list_for_each_entry(block_group, &space_info->block_groups[index],
4934 list) {
Josef Bacik6226cb02009-04-03 10:14:18 -04004935 u64 offset;
Josef Bacik817d52f2009-07-13 21:29:25 -04004936 int cached;
Chris Mason8a1413a2008-11-10 16:13:54 -05004937
Josef Bacik11dfe352009-11-13 20:12:59 +00004938 btrfs_get_block_group(block_group);
Josef Bacik2552d172009-04-03 10:14:19 -04004939 search_start = block_group->key.objectid;
Chris Mason42e70e72008-11-07 18:17:11 -05004940
Josef Bacik2552d172009-04-03 10:14:19 -04004941have_block_group:
Josef Bacik817d52f2009-07-13 21:29:25 -04004942 if (unlikely(block_group->cached == BTRFS_CACHE_NO)) {
Josef Bacikccf0e722009-11-10 21:23:48 -05004943 u64 free_percent;
4944
Josef Bacik9d66e232010-08-25 16:54:15 -04004945 ret = cache_block_group(block_group, trans, 1);
4946 if (block_group->cached == BTRFS_CACHE_FINISHED)
4947 goto have_block_group;
4948
Josef Bacikccf0e722009-11-10 21:23:48 -05004949 free_percent = btrfs_block_group_used(&block_group->item);
4950 free_percent *= 100;
4951 free_percent = div64_u64(free_percent,
4952 block_group->key.offset);
4953 free_percent = 100 - free_percent;
4954 if (free_percent > ideal_cache_percent &&
4955 likely(!block_group->ro)) {
4956 ideal_cache_offset = block_group->key.objectid;
4957 ideal_cache_percent = free_percent;
4958 }
4959
Josef Bacik817d52f2009-07-13 21:29:25 -04004960 /*
Josef Bacikccf0e722009-11-10 21:23:48 -05004961 * We only want to start kthread caching if we are at
4962 * the point where we will wait for caching to make
4963 * progress, or if our ideal search is over and we've
4964 * found somebody to start caching.
Josef Bacik817d52f2009-07-13 21:29:25 -04004965 */
4966 if (loop > LOOP_CACHING_NOWAIT ||
Josef Bacikccf0e722009-11-10 21:23:48 -05004967 (loop > LOOP_FIND_IDEAL &&
4968 atomic_read(&space_info->caching_threads) < 2)) {
Josef Bacik9d66e232010-08-25 16:54:15 -04004969 ret = cache_block_group(block_group, trans, 0);
Josef Bacik817d52f2009-07-13 21:29:25 -04004970 BUG_ON(ret);
Josef Bacik2552d172009-04-03 10:14:19 -04004971 }
Josef Bacikccf0e722009-11-10 21:23:48 -05004972 found_uncached_bg = true;
4973
4974 /*
4975 * If loop is set for cached only, try the next block
4976 * group.
4977 */
4978 if (loop == LOOP_FIND_IDEAL)
4979 goto loop;
Josef Bacikea6a4782008-11-20 12:16:16 -05004980 }
4981
Josef Bacik817d52f2009-07-13 21:29:25 -04004982 cached = block_group_cache_done(block_group);
Josef Bacikccf0e722009-11-10 21:23:48 -05004983 if (unlikely(!cached))
Josef Bacik817d52f2009-07-13 21:29:25 -04004984 found_uncached_bg = true;
4985
Josef Bacikea6a4782008-11-20 12:16:16 -05004986 if (unlikely(block_group->ro))
Josef Bacik2552d172009-04-03 10:14:19 -04004987 goto loop;
Josef Bacik0f9dd462008-09-23 13:14:11 -04004988
Josef Bacik0a243252009-09-11 16:11:20 -04004989 /*
4990 * Ok we want to try and use the cluster allocator, so lets look
4991 * there, unless we are on LOOP_NO_EMPTY_SIZE, since we will
4992 * have tried the cluster allocator plenty of times at this
4993 * point and not have found anything, so we are likely way too
4994 * fragmented for the clustering stuff to find anything, so lets
4995 * just skip it and let the allocator find whatever block it can
4996 * find
4997 */
4998 if (last_ptr && loop < LOOP_NO_EMPTY_SIZE) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004999 /*
5000 * the refill lock keeps out other
5001 * people trying to start a new cluster
5002 */
5003 spin_lock(&last_ptr->refill_lock);
Chris Mason44fb5512009-06-04 15:34:51 -04005004 if (last_ptr->block_group &&
5005 (last_ptr->block_group->ro ||
5006 !block_group_bits(last_ptr->block_group, data))) {
5007 offset = 0;
5008 goto refill_cluster;
5009 }
5010
Chris Masonfa9c0d72009-04-03 09:47:43 -04005011 offset = btrfs_alloc_from_cluster(block_group, last_ptr,
5012 num_bytes, search_start);
5013 if (offset) {
5014 /* we have a block, we're done */
5015 spin_unlock(&last_ptr->refill_lock);
5016 goto checks;
5017 }
5018
5019 spin_lock(&last_ptr->lock);
5020 /*
5021 * whoops, this cluster doesn't actually point to
5022 * this block group. Get a ref on the block
5023 * group is does point to and try again
5024 */
5025 if (!last_ptr_loop && last_ptr->block_group &&
5026 last_ptr->block_group != block_group) {
5027
5028 btrfs_put_block_group(block_group);
5029 block_group = last_ptr->block_group;
Josef Bacik11dfe352009-11-13 20:12:59 +00005030 btrfs_get_block_group(block_group);
Chris Masonfa9c0d72009-04-03 09:47:43 -04005031 spin_unlock(&last_ptr->lock);
5032 spin_unlock(&last_ptr->refill_lock);
5033
5034 last_ptr_loop = 1;
5035 search_start = block_group->key.objectid;
Chris Mason44fb5512009-06-04 15:34:51 -04005036 /*
5037 * we know this block group is properly
5038 * in the list because
5039 * btrfs_remove_block_group, drops the
5040 * cluster before it removes the block
5041 * group from the list
5042 */
Chris Masonfa9c0d72009-04-03 09:47:43 -04005043 goto have_block_group;
5044 }
5045 spin_unlock(&last_ptr->lock);
Chris Mason44fb5512009-06-04 15:34:51 -04005046refill_cluster:
Chris Masonfa9c0d72009-04-03 09:47:43 -04005047 /*
5048 * this cluster didn't work out, free it and
5049 * start over
5050 */
5051 btrfs_return_cluster_to_free_space(NULL, last_ptr);
5052
5053 last_ptr_loop = 0;
5054
5055 /* allocate a cluster in this block group */
Chris Mason451d7582009-06-09 20:28:34 -04005056 ret = btrfs_find_space_cluster(trans, root,
Chris Masonfa9c0d72009-04-03 09:47:43 -04005057 block_group, last_ptr,
5058 offset, num_bytes,
5059 empty_cluster + empty_size);
5060 if (ret == 0) {
5061 /*
5062 * now pull our allocation out of this
5063 * cluster
5064 */
5065 offset = btrfs_alloc_from_cluster(block_group,
5066 last_ptr, num_bytes,
5067 search_start);
5068 if (offset) {
5069 /* we found one, proceed */
5070 spin_unlock(&last_ptr->refill_lock);
5071 goto checks;
5072 }
Josef Bacik0a243252009-09-11 16:11:20 -04005073 } else if (!cached && loop > LOOP_CACHING_NOWAIT
5074 && !failed_cluster_refill) {
Josef Bacik817d52f2009-07-13 21:29:25 -04005075 spin_unlock(&last_ptr->refill_lock);
5076
Josef Bacik0a243252009-09-11 16:11:20 -04005077 failed_cluster_refill = true;
Josef Bacik817d52f2009-07-13 21:29:25 -04005078 wait_block_group_cache_progress(block_group,
5079 num_bytes + empty_cluster + empty_size);
5080 goto have_block_group;
Chris Masonfa9c0d72009-04-03 09:47:43 -04005081 }
Josef Bacik817d52f2009-07-13 21:29:25 -04005082
Chris Masonfa9c0d72009-04-03 09:47:43 -04005083 /*
5084 * at this point we either didn't find a cluster
5085 * or we weren't able to allocate a block from our
5086 * cluster. Free the cluster we've been trying
5087 * to use, and go to the next block group
5088 */
Josef Bacik0a243252009-09-11 16:11:20 -04005089 btrfs_return_cluster_to_free_space(NULL, last_ptr);
Chris Masonfa9c0d72009-04-03 09:47:43 -04005090 spin_unlock(&last_ptr->refill_lock);
Josef Bacik0a243252009-09-11 16:11:20 -04005091 goto loop;
Chris Masonfa9c0d72009-04-03 09:47:43 -04005092 }
5093
Josef Bacik6226cb02009-04-03 10:14:18 -04005094 offset = btrfs_find_space_for_alloc(block_group, search_start,
5095 num_bytes, empty_size);
Josef Bacik1cdda9b2009-10-06 10:04:28 -04005096 /*
5097 * If we didn't find a chunk, and we haven't failed on this
5098 * block group before, and this block group is in the middle of
5099 * caching and we are ok with waiting, then go ahead and wait
5100 * for progress to be made, and set failed_alloc to true.
5101 *
5102 * If failed_alloc is true then we've already waited on this
5103 * block group once and should move on to the next block group.
5104 */
5105 if (!offset && !failed_alloc && !cached &&
5106 loop > LOOP_CACHING_NOWAIT) {
Josef Bacik817d52f2009-07-13 21:29:25 -04005107 wait_block_group_cache_progress(block_group,
Josef Bacik1cdda9b2009-10-06 10:04:28 -04005108 num_bytes + empty_size);
5109 failed_alloc = true;
Josef Bacik817d52f2009-07-13 21:29:25 -04005110 goto have_block_group;
Josef Bacik1cdda9b2009-10-06 10:04:28 -04005111 } else if (!offset) {
5112 goto loop;
Josef Bacik817d52f2009-07-13 21:29:25 -04005113 }
Chris Masonfa9c0d72009-04-03 09:47:43 -04005114checks:
Josef Bacik6226cb02009-04-03 10:14:18 -04005115 search_start = stripe_align(root, offset);
Josef Bacik2552d172009-04-03 10:14:19 -04005116 /* move on to the next group */
Josef Bacik6226cb02009-04-03 10:14:18 -04005117 if (search_start + num_bytes >= search_end) {
5118 btrfs_add_free_space(block_group, offset, num_bytes);
Josef Bacik2552d172009-04-03 10:14:19 -04005119 goto loop;
Josef Bacik6226cb02009-04-03 10:14:18 -04005120 }
Chris Masone37c9e62007-05-09 20:13:14 -04005121
Josef Bacik2552d172009-04-03 10:14:19 -04005122 /* move on to the next group */
5123 if (search_start + num_bytes >
Josef Bacik6226cb02009-04-03 10:14:18 -04005124 block_group->key.objectid + block_group->key.offset) {
5125 btrfs_add_free_space(block_group, offset, num_bytes);
Josef Bacik2552d172009-04-03 10:14:19 -04005126 goto loop;
Josef Bacik6226cb02009-04-03 10:14:18 -04005127 }
Josef Bacik80eb2342008-10-29 14:49:05 -04005128
Josef Bacik2552d172009-04-03 10:14:19 -04005129 ins->objectid = search_start;
5130 ins->offset = num_bytes;
5131
Josef Bacik6226cb02009-04-03 10:14:18 -04005132 if (offset < search_start)
5133 btrfs_add_free_space(block_group, offset,
5134 search_start - offset);
5135 BUG_ON(offset > search_start);
5136
Yan, Zhengf0486c62010-05-16 10:46:25 -04005137 ret = update_reserved_bytes(block_group, num_bytes, 1,
5138 (data & BTRFS_BLOCK_GROUP_DATA));
5139 if (ret == -EAGAIN) {
5140 btrfs_add_free_space(block_group, offset, num_bytes);
5141 goto loop;
5142 }
Yan Zheng11833d62009-09-11 16:11:19 -04005143
Josef Bacik2552d172009-04-03 10:14:19 -04005144 /* we are all good, lets return */
Yan, Zhengf0486c62010-05-16 10:46:25 -04005145 ins->objectid = search_start;
5146 ins->offset = num_bytes;
5147
5148 if (offset < search_start)
5149 btrfs_add_free_space(block_group, offset,
5150 search_start - offset);
5151 BUG_ON(offset > search_start);
Josef Bacik2552d172009-04-03 10:14:19 -04005152 break;
5153loop:
Josef Bacik0a243252009-09-11 16:11:20 -04005154 failed_cluster_refill = false;
Josef Bacik1cdda9b2009-10-06 10:04:28 -04005155 failed_alloc = false;
Yan, Zhengb742bb82010-05-16 10:46:24 -04005156 BUG_ON(index != get_block_group_index(block_group));
Chris Masonfa9c0d72009-04-03 09:47:43 -04005157 btrfs_put_block_group(block_group);
Josef Bacik2552d172009-04-03 10:14:19 -04005158 }
5159 up_read(&space_info->groups_sem);
Chris Masonf5a31e12008-11-10 11:47:09 -05005160
Yan, Zhengb742bb82010-05-16 10:46:24 -04005161 if (!ins->objectid && ++index < BTRFS_NR_RAID_TYPES)
5162 goto search;
5163
Josef Bacikccf0e722009-11-10 21:23:48 -05005164 /* LOOP_FIND_IDEAL, only search caching/cached bg's, and don't wait for
5165 * for them to make caching progress. Also
5166 * determine the best possible bg to cache
5167 * LOOP_CACHING_NOWAIT, search partially cached block groups, kicking
5168 * caching kthreads as we move along
Josef Bacik817d52f2009-07-13 21:29:25 -04005169 * LOOP_CACHING_WAIT, search everything, and wait if our bg is caching
5170 * LOOP_ALLOC_CHUNK, force a chunk allocation and try again
5171 * LOOP_NO_EMPTY_SIZE, set empty_size and empty_cluster to 0 and try
5172 * again
Chris Masonfa9c0d72009-04-03 09:47:43 -04005173 */
Josef Bacik817d52f2009-07-13 21:29:25 -04005174 if (!ins->objectid && loop < LOOP_NO_EMPTY_SIZE &&
5175 (found_uncached_bg || empty_size || empty_cluster ||
5176 allowed_chunk_alloc)) {
Yan, Zhengb742bb82010-05-16 10:46:24 -04005177 index = 0;
Josef Bacikccf0e722009-11-10 21:23:48 -05005178 if (loop == LOOP_FIND_IDEAL && found_uncached_bg) {
Josef Bacik817d52f2009-07-13 21:29:25 -04005179 found_uncached_bg = false;
Josef Bacikccf0e722009-11-10 21:23:48 -05005180 loop++;
5181 if (!ideal_cache_percent &&
5182 atomic_read(&space_info->caching_threads))
Josef Bacik817d52f2009-07-13 21:29:25 -04005183 goto search;
Josef Bacikccf0e722009-11-10 21:23:48 -05005184
5185 /*
5186 * 1 of the following 2 things have happened so far
5187 *
5188 * 1) We found an ideal block group for caching that
5189 * is mostly full and will cache quickly, so we might
5190 * as well wait for it.
5191 *
5192 * 2) We searched for cached only and we didn't find
5193 * anything, and we didn't start any caching kthreads
5194 * either, so chances are we will loop through and
5195 * start a couple caching kthreads, and then come back
5196 * around and just wait for them. This will be slower
5197 * because we will have 2 caching kthreads reading at
5198 * the same time when we could have just started one
5199 * and waited for it to get far enough to give us an
5200 * allocation, so go ahead and go to the wait caching
5201 * loop.
5202 */
5203 loop = LOOP_CACHING_WAIT;
5204 search_start = ideal_cache_offset;
5205 ideal_cache_percent = 0;
5206 goto ideal_cache;
5207 } else if (loop == LOOP_FIND_IDEAL) {
5208 /*
5209 * Didn't find a uncached bg, wait on anything we find
5210 * next.
5211 */
5212 loop = LOOP_CACHING_WAIT;
5213 goto search;
5214 }
5215
5216 if (loop < LOOP_CACHING_WAIT) {
5217 loop++;
5218 goto search;
Josef Bacik817d52f2009-07-13 21:29:25 -04005219 }
5220
5221 if (loop == LOOP_ALLOC_CHUNK) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04005222 empty_size = 0;
5223 empty_cluster = 0;
5224 }
Chris Mason42e70e72008-11-07 18:17:11 -05005225
Josef Bacik2552d172009-04-03 10:14:19 -04005226 if (allowed_chunk_alloc) {
5227 ret = do_chunk_alloc(trans, root, num_bytes +
5228 2 * 1024 * 1024, data, 1);
Josef Bacik2552d172009-04-03 10:14:19 -04005229 allowed_chunk_alloc = 0;
Josef Bacikccf0e722009-11-10 21:23:48 -05005230 done_chunk_alloc = 1;
5231 } else if (!done_chunk_alloc) {
Josef Bacik2552d172009-04-03 10:14:19 -04005232 space_info->force_alloc = 1;
Josef Bacik0f9dd462008-09-23 13:14:11 -04005233 }
Josef Bacik80eb2342008-10-29 14:49:05 -04005234
Josef Bacik817d52f2009-07-13 21:29:25 -04005235 if (loop < LOOP_NO_EMPTY_SIZE) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04005236 loop++;
Josef Bacik2552d172009-04-03 10:14:19 -04005237 goto search;
Chris Masonfa9c0d72009-04-03 09:47:43 -04005238 }
Josef Bacik2552d172009-04-03 10:14:19 -04005239 ret = -ENOSPC;
5240 } else if (!ins->objectid) {
5241 ret = -ENOSPC;
Chris Masone19caa52007-10-15 16:17:44 -04005242 }
Chris Mason0b86a832008-03-24 15:01:56 -04005243
Josef Bacik80eb2342008-10-29 14:49:05 -04005244 /* we found what we needed */
5245 if (ins->objectid) {
5246 if (!(data & BTRFS_BLOCK_GROUP_DATA))
Yan Zhengd2fb3432008-12-11 16:30:39 -05005247 trans->block_group = block_group->key.objectid;
Josef Bacik80eb2342008-10-29 14:49:05 -04005248
Chris Masonfa9c0d72009-04-03 09:47:43 -04005249 btrfs_put_block_group(block_group);
Josef Bacik2552d172009-04-03 10:14:19 -04005250 ret = 0;
5251 }
Chris Mason0b86a832008-03-24 15:01:56 -04005252
Chris Mason0f70abe2007-02-28 16:46:22 -05005253 return ret;
Chris Masonfec577f2007-02-26 10:40:21 -05005254}
Chris Masonec44a352008-04-28 15:29:52 -04005255
Josef Bacik9ed74f22009-09-11 16:12:44 -04005256static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
5257 int dump_block_groups)
Josef Bacik0f9dd462008-09-23 13:14:11 -04005258{
5259 struct btrfs_block_group_cache *cache;
Yan, Zhengb742bb82010-05-16 10:46:24 -04005260 int index = 0;
Josef Bacik0f9dd462008-09-23 13:14:11 -04005261
Josef Bacik9ed74f22009-09-11 16:12:44 -04005262 spin_lock(&info->lock);
Chris Masond3977122009-01-05 21:25:51 -05005263 printk(KERN_INFO "space_info has %llu free, is %sfull\n",
5264 (unsigned long long)(info->total_bytes - info->bytes_used -
Josef Bacik9ed74f22009-09-11 16:12:44 -04005265 info->bytes_pinned - info->bytes_reserved -
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04005266 info->bytes_readonly),
Chris Masond3977122009-01-05 21:25:51 -05005267 (info->full) ? "" : "not ");
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04005268 printk(KERN_INFO "space_info total=%llu, used=%llu, pinned=%llu, "
5269 "reserved=%llu, may_use=%llu, readonly=%llu\n",
Joel Becker21380932009-04-21 12:38:29 -07005270 (unsigned long long)info->total_bytes,
Josef Bacik9ed74f22009-09-11 16:12:44 -04005271 (unsigned long long)info->bytes_used,
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04005272 (unsigned long long)info->bytes_pinned,
5273 (unsigned long long)info->bytes_reserved,
5274 (unsigned long long)info->bytes_may_use,
5275 (unsigned long long)info->bytes_readonly);
Josef Bacik9ed74f22009-09-11 16:12:44 -04005276 spin_unlock(&info->lock);
5277
5278 if (!dump_block_groups)
5279 return;
Josef Bacik0f9dd462008-09-23 13:14:11 -04005280
Josef Bacik80eb2342008-10-29 14:49:05 -04005281 down_read(&info->groups_sem);
Yan, Zhengb742bb82010-05-16 10:46:24 -04005282again:
5283 list_for_each_entry(cache, &info->block_groups[index], list) {
Josef Bacik0f9dd462008-09-23 13:14:11 -04005284 spin_lock(&cache->lock);
Chris Masond3977122009-01-05 21:25:51 -05005285 printk(KERN_INFO "block group %llu has %llu bytes, %llu used "
5286 "%llu pinned %llu reserved\n",
5287 (unsigned long long)cache->key.objectid,
5288 (unsigned long long)cache->key.offset,
5289 (unsigned long long)btrfs_block_group_used(&cache->item),
5290 (unsigned long long)cache->pinned,
5291 (unsigned long long)cache->reserved);
Josef Bacik0f9dd462008-09-23 13:14:11 -04005292 btrfs_dump_free_space(cache, bytes);
5293 spin_unlock(&cache->lock);
5294 }
Yan, Zhengb742bb82010-05-16 10:46:24 -04005295 if (++index < BTRFS_NR_RAID_TYPES)
5296 goto again;
Josef Bacik80eb2342008-10-29 14:49:05 -04005297 up_read(&info->groups_sem);
Josef Bacik0f9dd462008-09-23 13:14:11 -04005298}
Zheng Yane8569812008-09-26 10:05:48 -04005299
Yan Zheng11833d62009-09-11 16:11:19 -04005300int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
5301 struct btrfs_root *root,
5302 u64 num_bytes, u64 min_alloc_size,
5303 u64 empty_size, u64 hint_byte,
5304 u64 search_end, struct btrfs_key *ins,
5305 u64 data)
Chris Masonfec577f2007-02-26 10:40:21 -05005306{
5307 int ret;
Chris Masonfbdc7622007-05-30 10:22:12 -04005308 u64 search_start = 0;
Chris Mason925baed2008-06-25 16:01:30 -04005309
Josef Bacik6a632092009-02-20 11:00:09 -05005310 data = btrfs_get_alloc_profile(root, data);
Chris Mason98d20f62008-04-14 09:46:10 -04005311again:
Chris Mason0ef3e662008-05-24 14:04:53 -04005312 /*
5313 * the only place that sets empty_size is btrfs_realloc_node, which
5314 * is not called recursively on allocations
5315 */
Josef Bacik83d3c962009-12-07 21:45:59 +00005316 if (empty_size || root->ref_cows)
Chris Mason6324fbf2008-03-24 15:01:59 -04005317 ret = do_chunk_alloc(trans, root->fs_info->extent_root,
Chris Mason0ef3e662008-05-24 14:04:53 -04005318 num_bytes + 2 * 1024 * 1024, data, 0);
Chris Mason0b86a832008-03-24 15:01:56 -04005319
Chris Masondb945352007-10-15 16:15:53 -04005320 WARN_ON(num_bytes < root->sectorsize);
5321 ret = find_free_extent(trans, root, num_bytes, empty_size,
Yan, Zhengf0486c62010-05-16 10:46:25 -04005322 search_start, search_end, hint_byte,
5323 ins, data);
Chris Mason3b951512008-04-17 11:29:12 -04005324
Chris Mason98d20f62008-04-14 09:46:10 -04005325 if (ret == -ENOSPC && num_bytes > min_alloc_size) {
5326 num_bytes = num_bytes >> 1;
Josef Bacik0f9dd462008-09-23 13:14:11 -04005327 num_bytes = num_bytes & ~(root->sectorsize - 1);
Chris Mason98d20f62008-04-14 09:46:10 -04005328 num_bytes = max(num_bytes, min_alloc_size);
Chris Mason0ef3e662008-05-24 14:04:53 -04005329 do_chunk_alloc(trans, root->fs_info->extent_root,
5330 num_bytes, data, 1);
Chris Mason98d20f62008-04-14 09:46:10 -04005331 goto again;
5332 }
Josef Bacik817d52f2009-07-13 21:29:25 -04005333 if (ret == -ENOSPC) {
Josef Bacik0f9dd462008-09-23 13:14:11 -04005334 struct btrfs_space_info *sinfo;
5335
5336 sinfo = __find_space_info(root->fs_info, data);
Chris Masond3977122009-01-05 21:25:51 -05005337 printk(KERN_ERR "btrfs allocation failed flags %llu, "
5338 "wanted %llu\n", (unsigned long long)data,
5339 (unsigned long long)num_bytes);
Josef Bacik9ed74f22009-09-11 16:12:44 -04005340 dump_space_info(sinfo, num_bytes, 1);
Chris Mason925baed2008-06-25 16:01:30 -04005341 }
Josef Bacik0f9dd462008-09-23 13:14:11 -04005342
5343 return ret;
Chris Masone6dcd2d2008-07-17 12:53:50 -04005344}
5345
Chris Mason65b51a02008-08-01 15:11:20 -04005346int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len)
5347{
Josef Bacik0f9dd462008-09-23 13:14:11 -04005348 struct btrfs_block_group_cache *cache;
Liu Hui1f3c79a2009-01-05 15:57:51 -05005349 int ret = 0;
Josef Bacik0f9dd462008-09-23 13:14:11 -04005350
Josef Bacik0f9dd462008-09-23 13:14:11 -04005351 cache = btrfs_lookup_block_group(root->fs_info, start);
5352 if (!cache) {
Chris Masond3977122009-01-05 21:25:51 -05005353 printk(KERN_ERR "Unable to find block group for %llu\n",
5354 (unsigned long long)start);
Josef Bacik0f9dd462008-09-23 13:14:11 -04005355 return -ENOSPC;
5356 }
Liu Hui1f3c79a2009-01-05 15:57:51 -05005357
5358 ret = btrfs_discard_extent(root, start, len);
5359
Josef Bacik0f9dd462008-09-23 13:14:11 -04005360 btrfs_add_free_space(cache, start, len);
Yan, Zhengf0486c62010-05-16 10:46:25 -04005361 update_reserved_bytes(cache, len, 0, 1);
Chris Masonfa9c0d72009-04-03 09:47:43 -04005362 btrfs_put_block_group(cache);
Josef Bacik817d52f2009-07-13 21:29:25 -04005363
Chris Masone6dcd2d2008-07-17 12:53:50 -04005364 return ret;
5365}
5366
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005367static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
5368 struct btrfs_root *root,
5369 u64 parent, u64 root_objectid,
5370 u64 flags, u64 owner, u64 offset,
5371 struct btrfs_key *ins, int ref_mod)
Chris Masone6dcd2d2008-07-17 12:53:50 -04005372{
5373 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005374 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Masone6dcd2d2008-07-17 12:53:50 -04005375 struct btrfs_extent_item *extent_item;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005376 struct btrfs_extent_inline_ref *iref;
Chris Masone6dcd2d2008-07-17 12:53:50 -04005377 struct btrfs_path *path;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005378 struct extent_buffer *leaf;
5379 int type;
5380 u32 size;
Chris Masonf2654de2007-06-26 12:20:46 -04005381
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005382 if (parent > 0)
5383 type = BTRFS_SHARED_DATA_REF_KEY;
5384 else
5385 type = BTRFS_EXTENT_DATA_REF_KEY;
Zheng Yan31840ae2008-09-23 13:14:14 -04005386
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005387 size = sizeof(*extent_item) + btrfs_extent_inline_ref_size(type);
Chris Mason7bb86312007-12-11 09:25:06 -05005388
5389 path = btrfs_alloc_path();
5390 BUG_ON(!path);
Chris Mason47e4bb92008-02-01 14:51:59 -05005391
Chris Masonb9473432009-03-13 11:00:37 -04005392 path->leave_spinning = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005393 ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
5394 ins, size);
Chris Masonccd467d2007-06-28 15:57:36 -04005395 BUG_ON(ret);
Josef Bacik0f9dd462008-09-23 13:14:11 -04005396
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005397 leaf = path->nodes[0];
5398 extent_item = btrfs_item_ptr(leaf, path->slots[0],
Chris Mason47e4bb92008-02-01 14:51:59 -05005399 struct btrfs_extent_item);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005400 btrfs_set_extent_refs(leaf, extent_item, ref_mod);
5401 btrfs_set_extent_generation(leaf, extent_item, trans->transid);
5402 btrfs_set_extent_flags(leaf, extent_item,
5403 flags | BTRFS_EXTENT_FLAG_DATA);
Chris Mason47e4bb92008-02-01 14:51:59 -05005404
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005405 iref = (struct btrfs_extent_inline_ref *)(extent_item + 1);
5406 btrfs_set_extent_inline_ref_type(leaf, iref, type);
5407 if (parent > 0) {
5408 struct btrfs_shared_data_ref *ref;
5409 ref = (struct btrfs_shared_data_ref *)(iref + 1);
5410 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
5411 btrfs_set_shared_data_ref_count(leaf, ref, ref_mod);
5412 } else {
5413 struct btrfs_extent_data_ref *ref;
5414 ref = (struct btrfs_extent_data_ref *)(&iref->offset);
5415 btrfs_set_extent_data_ref_root(leaf, ref, root_objectid);
5416 btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
5417 btrfs_set_extent_data_ref_offset(leaf, ref, offset);
5418 btrfs_set_extent_data_ref_count(leaf, ref, ref_mod);
5419 }
Chris Mason47e4bb92008-02-01 14:51:59 -05005420
5421 btrfs_mark_buffer_dirty(path->nodes[0]);
Chris Mason7bb86312007-12-11 09:25:06 -05005422 btrfs_free_path(path);
Chris Masonf510cfe2007-10-15 16:14:48 -04005423
Yan, Zhengf0486c62010-05-16 10:46:25 -04005424 ret = update_block_group(trans, root, ins->objectid, ins->offset, 1);
Chris Masonf5947062008-02-04 10:10:13 -05005425 if (ret) {
Chris Masond3977122009-01-05 21:25:51 -05005426 printk(KERN_ERR "btrfs update block group failed for %llu "
5427 "%llu\n", (unsigned long long)ins->objectid,
5428 (unsigned long long)ins->offset);
Chris Masonf5947062008-02-04 10:10:13 -05005429 BUG();
5430 }
Chris Masone6dcd2d2008-07-17 12:53:50 -04005431 return ret;
5432}
5433
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005434static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
5435 struct btrfs_root *root,
5436 u64 parent, u64 root_objectid,
5437 u64 flags, struct btrfs_disk_key *key,
5438 int level, struct btrfs_key *ins)
5439{
5440 int ret;
5441 struct btrfs_fs_info *fs_info = root->fs_info;
5442 struct btrfs_extent_item *extent_item;
5443 struct btrfs_tree_block_info *block_info;
5444 struct btrfs_extent_inline_ref *iref;
5445 struct btrfs_path *path;
5446 struct extent_buffer *leaf;
5447 u32 size = sizeof(*extent_item) + sizeof(*block_info) + sizeof(*iref);
5448
5449 path = btrfs_alloc_path();
5450 BUG_ON(!path);
5451
5452 path->leave_spinning = 1;
5453 ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
5454 ins, size);
5455 BUG_ON(ret);
5456
5457 leaf = path->nodes[0];
5458 extent_item = btrfs_item_ptr(leaf, path->slots[0],
5459 struct btrfs_extent_item);
5460 btrfs_set_extent_refs(leaf, extent_item, 1);
5461 btrfs_set_extent_generation(leaf, extent_item, trans->transid);
5462 btrfs_set_extent_flags(leaf, extent_item,
5463 flags | BTRFS_EXTENT_FLAG_TREE_BLOCK);
5464 block_info = (struct btrfs_tree_block_info *)(extent_item + 1);
5465
5466 btrfs_set_tree_block_key(leaf, block_info, key);
5467 btrfs_set_tree_block_level(leaf, block_info, level);
5468
5469 iref = (struct btrfs_extent_inline_ref *)(block_info + 1);
5470 if (parent > 0) {
5471 BUG_ON(!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));
5472 btrfs_set_extent_inline_ref_type(leaf, iref,
5473 BTRFS_SHARED_BLOCK_REF_KEY);
5474 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
5475 } else {
5476 btrfs_set_extent_inline_ref_type(leaf, iref,
5477 BTRFS_TREE_BLOCK_REF_KEY);
5478 btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
5479 }
5480
5481 btrfs_mark_buffer_dirty(leaf);
5482 btrfs_free_path(path);
5483
Yan, Zhengf0486c62010-05-16 10:46:25 -04005484 ret = update_block_group(trans, root, ins->objectid, ins->offset, 1);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005485 if (ret) {
5486 printk(KERN_ERR "btrfs update block group failed for %llu "
5487 "%llu\n", (unsigned long long)ins->objectid,
5488 (unsigned long long)ins->offset);
5489 BUG();
5490 }
5491 return ret;
5492}
5493
5494int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
5495 struct btrfs_root *root,
5496 u64 root_objectid, u64 owner,
5497 u64 offset, struct btrfs_key *ins)
Chris Masone6dcd2d2008-07-17 12:53:50 -04005498{
5499 int ret;
Chris Mason1c2308f2008-09-23 13:14:13 -04005500
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005501 BUG_ON(root_objectid == BTRFS_TREE_LOG_OBJECTID);
Chris Mason56bec292009-03-13 10:10:06 -04005502
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005503 ret = btrfs_add_delayed_data_ref(trans, ins->objectid, ins->offset,
5504 0, root_objectid, owner, offset,
5505 BTRFS_ADD_DELAYED_EXTENT, NULL);
Chris Masone6dcd2d2008-07-17 12:53:50 -04005506 return ret;
5507}
Chris Masone02119d2008-09-05 16:13:11 -04005508
5509/*
5510 * this is used by the tree logging recovery code. It records that
5511 * an extent has been allocated and makes sure to clear the free
5512 * space cache bits as well
5513 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005514int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
5515 struct btrfs_root *root,
5516 u64 root_objectid, u64 owner, u64 offset,
5517 struct btrfs_key *ins)
Chris Masone02119d2008-09-05 16:13:11 -04005518{
5519 int ret;
5520 struct btrfs_block_group_cache *block_group;
Yan Zheng11833d62009-09-11 16:11:19 -04005521 struct btrfs_caching_control *caching_ctl;
5522 u64 start = ins->objectid;
5523 u64 num_bytes = ins->offset;
Chris Masone02119d2008-09-05 16:13:11 -04005524
Chris Masone02119d2008-09-05 16:13:11 -04005525 block_group = btrfs_lookup_block_group(root->fs_info, ins->objectid);
Josef Bacik9d66e232010-08-25 16:54:15 -04005526 cache_block_group(block_group, trans, 0);
Yan Zheng11833d62009-09-11 16:11:19 -04005527 caching_ctl = get_caching_control(block_group);
Chris Masone02119d2008-09-05 16:13:11 -04005528
Yan Zheng11833d62009-09-11 16:11:19 -04005529 if (!caching_ctl) {
5530 BUG_ON(!block_group_cache_done(block_group));
5531 ret = btrfs_remove_free_space(block_group, start, num_bytes);
5532 BUG_ON(ret);
5533 } else {
5534 mutex_lock(&caching_ctl->mutex);
5535
5536 if (start >= caching_ctl->progress) {
5537 ret = add_excluded_extent(root, start, num_bytes);
5538 BUG_ON(ret);
5539 } else if (start + num_bytes <= caching_ctl->progress) {
5540 ret = btrfs_remove_free_space(block_group,
5541 start, num_bytes);
5542 BUG_ON(ret);
5543 } else {
5544 num_bytes = caching_ctl->progress - start;
5545 ret = btrfs_remove_free_space(block_group,
5546 start, num_bytes);
5547 BUG_ON(ret);
5548
5549 start = caching_ctl->progress;
5550 num_bytes = ins->objectid + ins->offset -
5551 caching_ctl->progress;
5552 ret = add_excluded_extent(root, start, num_bytes);
5553 BUG_ON(ret);
5554 }
5555
5556 mutex_unlock(&caching_ctl->mutex);
5557 put_caching_control(caching_ctl);
5558 }
5559
Yan, Zhengf0486c62010-05-16 10:46:25 -04005560 ret = update_reserved_bytes(block_group, ins->offset, 1, 1);
5561 BUG_ON(ret);
Chris Masonfa9c0d72009-04-03 09:47:43 -04005562 btrfs_put_block_group(block_group);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005563 ret = alloc_reserved_file_extent(trans, root, 0, root_objectid,
5564 0, owner, offset, ins, 1);
Chris Masone02119d2008-09-05 16:13:11 -04005565 return ret;
5566}
5567
Chris Mason65b51a02008-08-01 15:11:20 -04005568struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
5569 struct btrfs_root *root,
Chris Mason4008c042009-02-12 14:09:45 -05005570 u64 bytenr, u32 blocksize,
5571 int level)
Chris Mason65b51a02008-08-01 15:11:20 -04005572{
5573 struct extent_buffer *buf;
5574
5575 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
5576 if (!buf)
5577 return ERR_PTR(-ENOMEM);
5578 btrfs_set_header_generation(buf, trans->transid);
Chris Mason4008c042009-02-12 14:09:45 -05005579 btrfs_set_buffer_lockdep_class(buf, level);
Chris Mason65b51a02008-08-01 15:11:20 -04005580 btrfs_tree_lock(buf);
5581 clean_tree_block(trans, root, buf);
Chris Masonb4ce94d2009-02-04 09:25:08 -05005582
5583 btrfs_set_lock_blocking(buf);
Chris Mason65b51a02008-08-01 15:11:20 -04005584 btrfs_set_buffer_uptodate(buf);
Chris Masonb4ce94d2009-02-04 09:25:08 -05005585
Chris Masond0c803c2008-09-11 16:17:57 -04005586 if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
Yan, Zheng8cef4e12009-11-12 09:33:26 +00005587 /*
5588 * we allow two log transactions at a time, use different
5589 * EXENT bit to differentiate dirty pages.
5590 */
5591 if (root->log_transid % 2 == 0)
5592 set_extent_dirty(&root->dirty_log_pages, buf->start,
5593 buf->start + buf->len - 1, GFP_NOFS);
5594 else
5595 set_extent_new(&root->dirty_log_pages, buf->start,
5596 buf->start + buf->len - 1, GFP_NOFS);
Chris Masond0c803c2008-09-11 16:17:57 -04005597 } else {
5598 set_extent_dirty(&trans->transaction->dirty_pages, buf->start,
5599 buf->start + buf->len - 1, GFP_NOFS);
5600 }
Chris Mason65b51a02008-08-01 15:11:20 -04005601 trans->blocks_used++;
Chris Masonb4ce94d2009-02-04 09:25:08 -05005602 /* this returns a buffer locked for blocking */
Chris Mason65b51a02008-08-01 15:11:20 -04005603 return buf;
5604}
5605
Yan, Zhengf0486c62010-05-16 10:46:25 -04005606static struct btrfs_block_rsv *
5607use_block_rsv(struct btrfs_trans_handle *trans,
5608 struct btrfs_root *root, u32 blocksize)
5609{
5610 struct btrfs_block_rsv *block_rsv;
5611 int ret;
5612
5613 block_rsv = get_block_rsv(trans, root);
5614
5615 if (block_rsv->size == 0) {
Josef Bacik8bb8ab22010-10-15 16:52:49 -04005616 ret = reserve_metadata_bytes(trans, root, block_rsv,
5617 blocksize, 0);
Yan, Zhengf0486c62010-05-16 10:46:25 -04005618 if (ret)
5619 return ERR_PTR(ret);
5620 return block_rsv;
5621 }
5622
5623 ret = block_rsv_use_bytes(block_rsv, blocksize);
5624 if (!ret)
5625 return block_rsv;
5626
Yan, Zhengf0486c62010-05-16 10:46:25 -04005627 return ERR_PTR(-ENOSPC);
5628}
5629
5630static void unuse_block_rsv(struct btrfs_block_rsv *block_rsv, u32 blocksize)
5631{
5632 block_rsv_add_bytes(block_rsv, blocksize, 0);
5633 block_rsv_release_bytes(block_rsv, NULL, 0);
5634}
5635
Chris Masonfec577f2007-02-26 10:40:21 -05005636/*
Yan, Zhengf0486c62010-05-16 10:46:25 -04005637 * finds a free extent and does all the dirty work required for allocation
5638 * returns the key for the extent through ins, and a tree buffer for
5639 * the first block of the extent through buf.
5640 *
Chris Masonfec577f2007-02-26 10:40:21 -05005641 * returns the tree buffer or NULL.
5642 */
Chris Mason5f39d392007-10-15 16:14:19 -04005643struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005644 struct btrfs_root *root, u32 blocksize,
5645 u64 parent, u64 root_objectid,
5646 struct btrfs_disk_key *key, int level,
5647 u64 hint, u64 empty_size)
Chris Masonfec577f2007-02-26 10:40:21 -05005648{
Chris Masone2fa7222007-03-12 16:22:34 -04005649 struct btrfs_key ins;
Yan, Zhengf0486c62010-05-16 10:46:25 -04005650 struct btrfs_block_rsv *block_rsv;
Chris Mason5f39d392007-10-15 16:14:19 -04005651 struct extent_buffer *buf;
Yan, Zhengf0486c62010-05-16 10:46:25 -04005652 u64 flags = 0;
5653 int ret;
Chris Masonfec577f2007-02-26 10:40:21 -05005654
Yan, Zhengf0486c62010-05-16 10:46:25 -04005655
5656 block_rsv = use_block_rsv(trans, root, blocksize);
5657 if (IS_ERR(block_rsv))
5658 return ERR_CAST(block_rsv);
5659
5660 ret = btrfs_reserve_extent(trans, root, blocksize, blocksize,
5661 empty_size, hint, (u64)-1, &ins, 0);
Chris Masonfec577f2007-02-26 10:40:21 -05005662 if (ret) {
Yan, Zhengf0486c62010-05-16 10:46:25 -04005663 unuse_block_rsv(block_rsv, blocksize);
Chris Mason54aa1f42007-06-22 14:16:25 -04005664 return ERR_PTR(ret);
Chris Masonfec577f2007-02-26 10:40:21 -05005665 }
Chris Mason55c69072008-01-09 15:55:33 -05005666
Chris Mason4008c042009-02-12 14:09:45 -05005667 buf = btrfs_init_new_buffer(trans, root, ins.objectid,
5668 blocksize, level);
Yan, Zhengf0486c62010-05-16 10:46:25 -04005669 BUG_ON(IS_ERR(buf));
5670
5671 if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
5672 if (parent == 0)
5673 parent = ins.objectid;
5674 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
5675 } else
5676 BUG_ON(parent > 0);
5677
5678 if (root_objectid != BTRFS_TREE_LOG_OBJECTID) {
5679 struct btrfs_delayed_extent_op *extent_op;
5680 extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
5681 BUG_ON(!extent_op);
5682 if (key)
5683 memcpy(&extent_op->key, key, sizeof(extent_op->key));
5684 else
5685 memset(&extent_op->key, 0, sizeof(extent_op->key));
5686 extent_op->flags_to_set = flags;
5687 extent_op->update_key = 1;
5688 extent_op->update_flags = 1;
5689 extent_op->is_data = 0;
5690
5691 ret = btrfs_add_delayed_tree_ref(trans, ins.objectid,
5692 ins.offset, parent, root_objectid,
5693 level, BTRFS_ADD_DELAYED_EXTENT,
5694 extent_op);
5695 BUG_ON(ret);
5696 }
Chris Masonfec577f2007-02-26 10:40:21 -05005697 return buf;
5698}
Chris Masona28ec192007-03-06 20:08:01 -05005699
Yan Zheng2c47e6052009-06-27 21:07:35 -04005700struct walk_control {
5701 u64 refs[BTRFS_MAX_LEVEL];
5702 u64 flags[BTRFS_MAX_LEVEL];
5703 struct btrfs_key update_progress;
5704 int stage;
5705 int level;
5706 int shared_level;
5707 int update_ref;
5708 int keep_locks;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005709 int reada_slot;
5710 int reada_count;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005711};
5712
5713#define DROP_REFERENCE 1
5714#define UPDATE_BACKREF 2
5715
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005716static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
5717 struct btrfs_root *root,
5718 struct walk_control *wc,
5719 struct btrfs_path *path)
5720{
5721 u64 bytenr;
5722 u64 generation;
5723 u64 refs;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005724 u64 flags;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005725 u64 last = 0;
5726 u32 nritems;
5727 u32 blocksize;
5728 struct btrfs_key key;
5729 struct extent_buffer *eb;
5730 int ret;
5731 int slot;
5732 int nread = 0;
5733
5734 if (path->slots[wc->level] < wc->reada_slot) {
5735 wc->reada_count = wc->reada_count * 2 / 3;
5736 wc->reada_count = max(wc->reada_count, 2);
5737 } else {
5738 wc->reada_count = wc->reada_count * 3 / 2;
5739 wc->reada_count = min_t(int, wc->reada_count,
5740 BTRFS_NODEPTRS_PER_BLOCK(root));
5741 }
5742
5743 eb = path->nodes[wc->level];
5744 nritems = btrfs_header_nritems(eb);
5745 blocksize = btrfs_level_size(root, wc->level - 1);
5746
5747 for (slot = path->slots[wc->level]; slot < nritems; slot++) {
5748 if (nread >= wc->reada_count)
5749 break;
5750
5751 cond_resched();
5752 bytenr = btrfs_node_blockptr(eb, slot);
5753 generation = btrfs_node_ptr_generation(eb, slot);
5754
5755 if (slot == path->slots[wc->level])
5756 goto reada;
5757
5758 if (wc->stage == UPDATE_BACKREF &&
5759 generation <= root->root_key.offset)
5760 continue;
5761
Yan, Zheng94fcca92009-10-09 09:25:16 -04005762 /* We don't lock the tree block, it's OK to be racy here */
5763 ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
5764 &refs, &flags);
5765 BUG_ON(ret);
5766 BUG_ON(refs == 0);
5767
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005768 if (wc->stage == DROP_REFERENCE) {
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005769 if (refs == 1)
5770 goto reada;
5771
Yan, Zheng94fcca92009-10-09 09:25:16 -04005772 if (wc->level == 1 &&
5773 (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5774 continue;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005775 if (!wc->update_ref ||
5776 generation <= root->root_key.offset)
5777 continue;
5778 btrfs_node_key_to_cpu(eb, &key, slot);
5779 ret = btrfs_comp_cpu_keys(&key,
5780 &wc->update_progress);
5781 if (ret < 0)
5782 continue;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005783 } else {
5784 if (wc->level == 1 &&
5785 (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5786 continue;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005787 }
5788reada:
5789 ret = readahead_tree_block(root, bytenr, blocksize,
5790 generation);
5791 if (ret)
5792 break;
5793 last = bytenr + blocksize;
5794 nread++;
5795 }
5796 wc->reada_slot = slot;
5797}
5798
Chris Mason9aca1d52007-03-13 11:09:37 -04005799/*
Yan Zheng2c47e6052009-06-27 21:07:35 -04005800 * hepler to process tree block while walking down the tree.
5801 *
Yan Zheng2c47e6052009-06-27 21:07:35 -04005802 * when wc->stage == UPDATE_BACKREF, this function updates
5803 * back refs for pointers in the block.
5804 *
5805 * NOTE: return value 1 means we should stop walking down.
Yan Zhengf82d02d2008-10-29 14:49:05 -04005806 */
Yan Zheng2c47e6052009-06-27 21:07:35 -04005807static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
5808 struct btrfs_root *root,
5809 struct btrfs_path *path,
Yan, Zheng94fcca92009-10-09 09:25:16 -04005810 struct walk_control *wc, int lookup_info)
Yan Zheng2c47e6052009-06-27 21:07:35 -04005811{
5812 int level = wc->level;
5813 struct extent_buffer *eb = path->nodes[level];
Yan Zheng2c47e6052009-06-27 21:07:35 -04005814 u64 flag = BTRFS_BLOCK_FLAG_FULL_BACKREF;
5815 int ret;
5816
5817 if (wc->stage == UPDATE_BACKREF &&
5818 btrfs_header_owner(eb) != root->root_key.objectid)
5819 return 1;
5820
5821 /*
5822 * when reference count of tree block is 1, it won't increase
5823 * again. once full backref flag is set, we never clear it.
5824 */
Yan, Zheng94fcca92009-10-09 09:25:16 -04005825 if (lookup_info &&
5826 ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||
5827 (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {
Yan Zheng2c47e6052009-06-27 21:07:35 -04005828 BUG_ON(!path->locks[level]);
5829 ret = btrfs_lookup_extent_info(trans, root,
5830 eb->start, eb->len,
5831 &wc->refs[level],
5832 &wc->flags[level]);
5833 BUG_ON(ret);
5834 BUG_ON(wc->refs[level] == 0);
5835 }
5836
Yan Zheng2c47e6052009-06-27 21:07:35 -04005837 if (wc->stage == DROP_REFERENCE) {
5838 if (wc->refs[level] > 1)
5839 return 1;
5840
5841 if (path->locks[level] && !wc->keep_locks) {
5842 btrfs_tree_unlock(eb);
5843 path->locks[level] = 0;
5844 }
5845 return 0;
5846 }
5847
5848 /* wc->stage == UPDATE_BACKREF */
5849 if (!(wc->flags[level] & flag)) {
5850 BUG_ON(!path->locks[level]);
5851 ret = btrfs_inc_ref(trans, root, eb, 1);
5852 BUG_ON(ret);
5853 ret = btrfs_dec_ref(trans, root, eb, 0);
5854 BUG_ON(ret);
5855 ret = btrfs_set_disk_extent_flags(trans, root, eb->start,
5856 eb->len, flag, 0);
5857 BUG_ON(ret);
5858 wc->flags[level] |= flag;
5859 }
5860
5861 /*
5862 * the block is shared by multiple trees, so it's not good to
5863 * keep the tree lock
5864 */
5865 if (path->locks[level] && level > 0) {
5866 btrfs_tree_unlock(eb);
5867 path->locks[level] = 0;
5868 }
5869 return 0;
5870}
5871
5872/*
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005873 * hepler to process tree block pointer.
5874 *
5875 * when wc->stage == DROP_REFERENCE, this function checks
5876 * reference count of the block pointed to. if the block
5877 * is shared and we need update back refs for the subtree
5878 * rooted at the block, this function changes wc->stage to
5879 * UPDATE_BACKREF. if the block is shared and there is no
5880 * need to update back, this function drops the reference
5881 * to the block.
5882 *
5883 * NOTE: return value 1 means we should stop walking down.
5884 */
5885static noinline int do_walk_down(struct btrfs_trans_handle *trans,
5886 struct btrfs_root *root,
5887 struct btrfs_path *path,
Yan, Zheng94fcca92009-10-09 09:25:16 -04005888 struct walk_control *wc, int *lookup_info)
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005889{
5890 u64 bytenr;
5891 u64 generation;
5892 u64 parent;
5893 u32 blocksize;
5894 struct btrfs_key key;
5895 struct extent_buffer *next;
5896 int level = wc->level;
5897 int reada = 0;
5898 int ret = 0;
5899
5900 generation = btrfs_node_ptr_generation(path->nodes[level],
5901 path->slots[level]);
5902 /*
5903 * if the lower level block was created before the snapshot
5904 * was created, we know there is no need to update back refs
5905 * for the subtree
5906 */
5907 if (wc->stage == UPDATE_BACKREF &&
Yan, Zheng94fcca92009-10-09 09:25:16 -04005908 generation <= root->root_key.offset) {
5909 *lookup_info = 1;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005910 return 1;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005911 }
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005912
5913 bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
5914 blocksize = btrfs_level_size(root, level - 1);
5915
5916 next = btrfs_find_tree_block(root, bytenr, blocksize);
5917 if (!next) {
5918 next = btrfs_find_create_tree_block(root, bytenr, blocksize);
Miao Xie90d2c512010-03-25 12:37:12 +00005919 if (!next)
5920 return -ENOMEM;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005921 reada = 1;
5922 }
5923 btrfs_tree_lock(next);
5924 btrfs_set_lock_blocking(next);
5925
Yan, Zheng94fcca92009-10-09 09:25:16 -04005926 ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
5927 &wc->refs[level - 1],
5928 &wc->flags[level - 1]);
5929 BUG_ON(ret);
5930 BUG_ON(wc->refs[level - 1] == 0);
5931 *lookup_info = 0;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005932
Yan, Zheng94fcca92009-10-09 09:25:16 -04005933 if (wc->stage == DROP_REFERENCE) {
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005934 if (wc->refs[level - 1] > 1) {
Yan, Zheng94fcca92009-10-09 09:25:16 -04005935 if (level == 1 &&
5936 (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5937 goto skip;
5938
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005939 if (!wc->update_ref ||
5940 generation <= root->root_key.offset)
5941 goto skip;
5942
5943 btrfs_node_key_to_cpu(path->nodes[level], &key,
5944 path->slots[level]);
5945 ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);
5946 if (ret < 0)
5947 goto skip;
5948
5949 wc->stage = UPDATE_BACKREF;
5950 wc->shared_level = level - 1;
5951 }
Yan, Zheng94fcca92009-10-09 09:25:16 -04005952 } else {
5953 if (level == 1 &&
5954 (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5955 goto skip;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005956 }
5957
5958 if (!btrfs_buffer_uptodate(next, generation)) {
5959 btrfs_tree_unlock(next);
5960 free_extent_buffer(next);
5961 next = NULL;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005962 *lookup_info = 1;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005963 }
5964
5965 if (!next) {
5966 if (reada && level == 1)
5967 reada_walk_down(trans, root, wc, path);
5968 next = read_tree_block(root, bytenr, blocksize, generation);
5969 btrfs_tree_lock(next);
5970 btrfs_set_lock_blocking(next);
5971 }
5972
5973 level--;
5974 BUG_ON(level != btrfs_header_level(next));
5975 path->nodes[level] = next;
5976 path->slots[level] = 0;
5977 path->locks[level] = 1;
5978 wc->level = level;
5979 if (wc->level == 1)
5980 wc->reada_slot = 0;
5981 return 0;
5982skip:
5983 wc->refs[level - 1] = 0;
5984 wc->flags[level - 1] = 0;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005985 if (wc->stage == DROP_REFERENCE) {
5986 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
5987 parent = path->nodes[level]->start;
5988 } else {
5989 BUG_ON(root->root_key.objectid !=
5990 btrfs_header_owner(path->nodes[level]));
5991 parent = 0;
5992 }
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005993
Yan, Zheng94fcca92009-10-09 09:25:16 -04005994 ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent,
5995 root->root_key.objectid, level - 1, 0);
5996 BUG_ON(ret);
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005997 }
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005998 btrfs_tree_unlock(next);
5999 free_extent_buffer(next);
Yan, Zheng94fcca92009-10-09 09:25:16 -04006000 *lookup_info = 1;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04006001 return 1;
6002}
6003
6004/*
Yan Zheng2c47e6052009-06-27 21:07:35 -04006005 * hepler to process tree block while walking up the tree.
6006 *
6007 * when wc->stage == DROP_REFERENCE, this function drops
6008 * reference count on the block.
6009 *
6010 * when wc->stage == UPDATE_BACKREF, this function changes
6011 * wc->stage back to DROP_REFERENCE if we changed wc->stage
6012 * to UPDATE_BACKREF previously while processing the block.
6013 *
6014 * NOTE: return value 1 means we should stop walking up.
6015 */
6016static noinline int walk_up_proc(struct btrfs_trans_handle *trans,
6017 struct btrfs_root *root,
6018 struct btrfs_path *path,
6019 struct walk_control *wc)
6020{
Yan, Zhengf0486c62010-05-16 10:46:25 -04006021 int ret;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006022 int level = wc->level;
6023 struct extent_buffer *eb = path->nodes[level];
6024 u64 parent = 0;
6025
6026 if (wc->stage == UPDATE_BACKREF) {
6027 BUG_ON(wc->shared_level < level);
6028 if (level < wc->shared_level)
6029 goto out;
6030
Yan Zheng2c47e6052009-06-27 21:07:35 -04006031 ret = find_next_key(path, level + 1, &wc->update_progress);
6032 if (ret > 0)
6033 wc->update_ref = 0;
6034
6035 wc->stage = DROP_REFERENCE;
6036 wc->shared_level = -1;
6037 path->slots[level] = 0;
6038
6039 /*
6040 * check reference count again if the block isn't locked.
6041 * we should start walking down the tree again if reference
6042 * count is one.
6043 */
6044 if (!path->locks[level]) {
6045 BUG_ON(level == 0);
6046 btrfs_tree_lock(eb);
6047 btrfs_set_lock_blocking(eb);
6048 path->locks[level] = 1;
6049
6050 ret = btrfs_lookup_extent_info(trans, root,
6051 eb->start, eb->len,
6052 &wc->refs[level],
6053 &wc->flags[level]);
6054 BUG_ON(ret);
6055 BUG_ON(wc->refs[level] == 0);
6056 if (wc->refs[level] == 1) {
6057 btrfs_tree_unlock(eb);
6058 path->locks[level] = 0;
6059 return 1;
6060 }
Yan Zheng2c47e6052009-06-27 21:07:35 -04006061 }
6062 }
6063
6064 /* wc->stage == DROP_REFERENCE */
6065 BUG_ON(wc->refs[level] > 1 && !path->locks[level]);
6066
6067 if (wc->refs[level] == 1) {
6068 if (level == 0) {
6069 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
6070 ret = btrfs_dec_ref(trans, root, eb, 1);
6071 else
6072 ret = btrfs_dec_ref(trans, root, eb, 0);
6073 BUG_ON(ret);
6074 }
6075 /* make block locked assertion in clean_tree_block happy */
6076 if (!path->locks[level] &&
6077 btrfs_header_generation(eb) == trans->transid) {
6078 btrfs_tree_lock(eb);
6079 btrfs_set_lock_blocking(eb);
6080 path->locks[level] = 1;
6081 }
6082 clean_tree_block(trans, root, eb);
6083 }
6084
6085 if (eb == root->node) {
6086 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
6087 parent = eb->start;
6088 else
6089 BUG_ON(root->root_key.objectid !=
6090 btrfs_header_owner(eb));
6091 } else {
6092 if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
6093 parent = path->nodes[level + 1]->start;
6094 else
6095 BUG_ON(root->root_key.objectid !=
6096 btrfs_header_owner(path->nodes[level + 1]));
6097 }
6098
Yan, Zhengf0486c62010-05-16 10:46:25 -04006099 btrfs_free_tree_block(trans, root, eb, parent, wc->refs[level] == 1);
Yan Zheng2c47e6052009-06-27 21:07:35 -04006100out:
6101 wc->refs[level] = 0;
6102 wc->flags[level] = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -04006103 return 0;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006104}
6105
Yan Zheng5d4f98a2009-06-10 10:45:14 -04006106static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
6107 struct btrfs_root *root,
Yan Zheng2c47e6052009-06-27 21:07:35 -04006108 struct btrfs_path *path,
6109 struct walk_control *wc)
Yan Zhengf82d02d2008-10-29 14:49:05 -04006110{
Yan Zheng2c47e6052009-06-27 21:07:35 -04006111 int level = wc->level;
Yan, Zheng94fcca92009-10-09 09:25:16 -04006112 int lookup_info = 1;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006113 int ret;
6114
Yan Zheng2c47e6052009-06-27 21:07:35 -04006115 while (level >= 0) {
Yan, Zheng94fcca92009-10-09 09:25:16 -04006116 ret = walk_down_proc(trans, root, path, wc, lookup_info);
Yan Zheng2c47e6052009-06-27 21:07:35 -04006117 if (ret > 0)
Yan Zhengf82d02d2008-10-29 14:49:05 -04006118 break;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006119
Yan Zheng2c47e6052009-06-27 21:07:35 -04006120 if (level == 0)
6121 break;
6122
Yan, Zheng7a7965f2010-02-01 02:41:17 +00006123 if (path->slots[level] >=
6124 btrfs_header_nritems(path->nodes[level]))
6125 break;
6126
Yan, Zheng94fcca92009-10-09 09:25:16 -04006127 ret = do_walk_down(trans, root, path, wc, &lookup_info);
Yan, Zheng1c4850e2009-09-21 15:55:59 -04006128 if (ret > 0) {
6129 path->slots[level]++;
6130 continue;
Miao Xie90d2c512010-03-25 12:37:12 +00006131 } else if (ret < 0)
6132 return ret;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04006133 level = wc->level;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006134 }
Yan Zhengf82d02d2008-10-29 14:49:05 -04006135 return 0;
6136}
6137
Chris Masond3977122009-01-05 21:25:51 -05006138static noinline int walk_up_tree(struct btrfs_trans_handle *trans,
Chris Mason98ed5172008-01-03 10:01:48 -05006139 struct btrfs_root *root,
Yan Zhengf82d02d2008-10-29 14:49:05 -04006140 struct btrfs_path *path,
Yan Zheng2c47e6052009-06-27 21:07:35 -04006141 struct walk_control *wc, int max_level)
Chris Mason20524f02007-03-10 06:35:47 -05006142{
Yan Zheng2c47e6052009-06-27 21:07:35 -04006143 int level = wc->level;
Chris Mason20524f02007-03-10 06:35:47 -05006144 int ret;
Chris Mason9f3a7422007-08-07 15:52:19 -04006145
Yan Zheng2c47e6052009-06-27 21:07:35 -04006146 path->slots[level] = btrfs_header_nritems(path->nodes[level]);
6147 while (level < max_level && path->nodes[level]) {
6148 wc->level = level;
6149 if (path->slots[level] + 1 <
6150 btrfs_header_nritems(path->nodes[level])) {
6151 path->slots[level]++;
Chris Mason20524f02007-03-10 06:35:47 -05006152 return 0;
6153 } else {
Yan Zheng2c47e6052009-06-27 21:07:35 -04006154 ret = walk_up_proc(trans, root, path, wc);
6155 if (ret > 0)
6156 return 0;
Chris Masonbd56b302009-02-04 09:27:02 -05006157
Yan Zheng2c47e6052009-06-27 21:07:35 -04006158 if (path->locks[level]) {
6159 btrfs_tree_unlock(path->nodes[level]);
6160 path->locks[level] = 0;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006161 }
Yan Zheng2c47e6052009-06-27 21:07:35 -04006162 free_extent_buffer(path->nodes[level]);
6163 path->nodes[level] = NULL;
6164 level++;
Chris Mason20524f02007-03-10 06:35:47 -05006165 }
6166 }
6167 return 1;
6168}
6169
Chris Mason9aca1d52007-03-13 11:09:37 -04006170/*
Yan Zheng2c47e6052009-06-27 21:07:35 -04006171 * drop a subvolume tree.
6172 *
6173 * this function traverses the tree freeing any blocks that only
6174 * referenced by the tree.
6175 *
6176 * when a shared tree block is found. this function decreases its
6177 * reference count by one. if update_ref is true, this function
6178 * also make sure backrefs for the shared block and all lower level
6179 * blocks are properly updated.
Chris Mason9aca1d52007-03-13 11:09:37 -04006180 */
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006181int btrfs_drop_snapshot(struct btrfs_root *root,
6182 struct btrfs_block_rsv *block_rsv, int update_ref)
Chris Mason20524f02007-03-10 06:35:47 -05006183{
Chris Mason5caf2a02007-04-02 11:20:42 -04006184 struct btrfs_path *path;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006185 struct btrfs_trans_handle *trans;
6186 struct btrfs_root *tree_root = root->fs_info->tree_root;
Chris Mason9f3a7422007-08-07 15:52:19 -04006187 struct btrfs_root_item *root_item = &root->root_item;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006188 struct walk_control *wc;
6189 struct btrfs_key key;
6190 int err = 0;
6191 int ret;
6192 int level;
Chris Mason20524f02007-03-10 06:35:47 -05006193
Chris Mason5caf2a02007-04-02 11:20:42 -04006194 path = btrfs_alloc_path();
6195 BUG_ON(!path);
Chris Mason20524f02007-03-10 06:35:47 -05006196
Yan Zheng2c47e6052009-06-27 21:07:35 -04006197 wc = kzalloc(sizeof(*wc), GFP_NOFS);
6198 BUG_ON(!wc);
6199
Yan, Zhenga22285a2010-05-16 10:48:46 -04006200 trans = btrfs_start_transaction(tree_root, 0);
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006201 if (block_rsv)
6202 trans->block_rsv = block_rsv;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006203
Chris Mason9f3a7422007-08-07 15:52:19 -04006204 if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
Yan Zheng2c47e6052009-06-27 21:07:35 -04006205 level = btrfs_header_level(root->node);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04006206 path->nodes[level] = btrfs_lock_root_node(root);
6207 btrfs_set_lock_blocking(path->nodes[level]);
Chris Mason9f3a7422007-08-07 15:52:19 -04006208 path->slots[level] = 0;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04006209 path->locks[level] = 1;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006210 memset(&wc->update_progress, 0,
6211 sizeof(wc->update_progress));
Chris Mason9f3a7422007-08-07 15:52:19 -04006212 } else {
Chris Mason9f3a7422007-08-07 15:52:19 -04006213 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
Yan Zheng2c47e6052009-06-27 21:07:35 -04006214 memcpy(&wc->update_progress, &key,
6215 sizeof(wc->update_progress));
6216
Chris Mason6702ed42007-08-07 16:15:09 -04006217 level = root_item->drop_level;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006218 BUG_ON(level == 0);
Chris Mason6702ed42007-08-07 16:15:09 -04006219 path->lowest_level = level;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006220 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
6221 path->lowest_level = 0;
6222 if (ret < 0) {
6223 err = ret;
Chris Mason9f3a7422007-08-07 15:52:19 -04006224 goto out;
6225 }
Yan, Zheng1c4850e2009-09-21 15:55:59 -04006226 WARN_ON(ret > 0);
Yan Zheng2c47e6052009-06-27 21:07:35 -04006227
Chris Mason7d9eb122008-07-08 14:19:17 -04006228 /*
6229 * unlock our path, this is safe because only this
6230 * function is allowed to delete this snapshot
6231 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04006232 btrfs_unlock_up_safe(path, 0);
Chris Mason9aca1d52007-03-13 11:09:37 -04006233
Yan Zheng2c47e6052009-06-27 21:07:35 -04006234 level = btrfs_header_level(root->node);
6235 while (1) {
6236 btrfs_tree_lock(path->nodes[level]);
6237 btrfs_set_lock_blocking(path->nodes[level]);
6238
6239 ret = btrfs_lookup_extent_info(trans, root,
6240 path->nodes[level]->start,
6241 path->nodes[level]->len,
6242 &wc->refs[level],
6243 &wc->flags[level]);
6244 BUG_ON(ret);
6245 BUG_ON(wc->refs[level] == 0);
6246
6247 if (level == root_item->drop_level)
6248 break;
6249
6250 btrfs_tree_unlock(path->nodes[level]);
6251 WARN_ON(wc->refs[level] != 1);
6252 level--;
6253 }
6254 }
6255
6256 wc->level = level;
6257 wc->shared_level = -1;
6258 wc->stage = DROP_REFERENCE;
6259 wc->update_ref = update_ref;
6260 wc->keep_locks = 0;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04006261 wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
Yan Zheng2c47e6052009-06-27 21:07:35 -04006262
6263 while (1) {
6264 ret = walk_down_tree(trans, root, path, wc);
6265 if (ret < 0) {
6266 err = ret;
Chris Masone7a84562008-06-25 16:01:31 -04006267 break;
6268 }
Yan Zheng2c47e6052009-06-27 21:07:35 -04006269
6270 ret = walk_up_tree(trans, root, path, wc, BTRFS_MAX_LEVEL);
6271 if (ret < 0) {
6272 err = ret;
6273 break;
6274 }
6275
6276 if (ret > 0) {
6277 BUG_ON(wc->stage != DROP_REFERENCE);
6278 break;
6279 }
6280
6281 if (wc->stage == DROP_REFERENCE) {
6282 level = wc->level;
6283 btrfs_node_key(path->nodes[level],
6284 &root_item->drop_progress,
6285 path->slots[level]);
6286 root_item->drop_level = level;
6287 }
6288
6289 BUG_ON(wc->level == 0);
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006290 if (btrfs_should_end_transaction(trans, tree_root)) {
Yan Zheng2c47e6052009-06-27 21:07:35 -04006291 ret = btrfs_update_root(trans, tree_root,
6292 &root->root_key,
6293 root_item);
6294 BUG_ON(ret);
6295
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006296 btrfs_end_transaction_throttle(trans, tree_root);
Yan, Zhenga22285a2010-05-16 10:48:46 -04006297 trans = btrfs_start_transaction(tree_root, 0);
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006298 if (block_rsv)
6299 trans->block_rsv = block_rsv;
Chris Masonc3e69d52009-03-13 10:17:05 -04006300 }
Chris Mason20524f02007-03-10 06:35:47 -05006301 }
Yan Zheng2c47e6052009-06-27 21:07:35 -04006302 btrfs_release_path(root, path);
6303 BUG_ON(err);
6304
6305 ret = btrfs_del_root(trans, tree_root, &root->root_key);
6306 BUG_ON(ret);
6307
Yan, Zheng76dda932009-09-21 16:00:26 -04006308 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
6309 ret = btrfs_find_last_root(tree_root, root->root_key.objectid,
6310 NULL, NULL);
6311 BUG_ON(ret < 0);
6312 if (ret > 0) {
6313 ret = btrfs_del_orphan_item(trans, tree_root,
6314 root->root_key.objectid);
6315 BUG_ON(ret);
6316 }
6317 }
6318
6319 if (root->in_radix) {
6320 btrfs_free_fs_root(tree_root->fs_info, root);
6321 } else {
6322 free_extent_buffer(root->node);
6323 free_extent_buffer(root->commit_root);
6324 kfree(root);
6325 }
Chris Mason9f3a7422007-08-07 15:52:19 -04006326out:
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006327 btrfs_end_transaction_throttle(trans, tree_root);
Yan Zheng2c47e6052009-06-27 21:07:35 -04006328 kfree(wc);
Chris Mason5caf2a02007-04-02 11:20:42 -04006329 btrfs_free_path(path);
Yan Zheng2c47e6052009-06-27 21:07:35 -04006330 return err;
Chris Mason20524f02007-03-10 06:35:47 -05006331}
Chris Mason9078a3e2007-04-26 16:46:15 -04006332
Yan Zheng2c47e6052009-06-27 21:07:35 -04006333/*
6334 * drop subtree rooted at tree block 'node'.
6335 *
6336 * NOTE: this function will unlock and release tree block 'node'
6337 */
Yan Zhengf82d02d2008-10-29 14:49:05 -04006338int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
6339 struct btrfs_root *root,
6340 struct extent_buffer *node,
6341 struct extent_buffer *parent)
6342{
6343 struct btrfs_path *path;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006344 struct walk_control *wc;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006345 int level;
6346 int parent_level;
6347 int ret = 0;
6348 int wret;
6349
Yan Zheng2c47e6052009-06-27 21:07:35 -04006350 BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);
6351
Yan Zhengf82d02d2008-10-29 14:49:05 -04006352 path = btrfs_alloc_path();
6353 BUG_ON(!path);
6354
Yan Zheng2c47e6052009-06-27 21:07:35 -04006355 wc = kzalloc(sizeof(*wc), GFP_NOFS);
6356 BUG_ON(!wc);
6357
Chris Masonb9447ef2009-03-09 11:45:38 -04006358 btrfs_assert_tree_locked(parent);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006359 parent_level = btrfs_header_level(parent);
6360 extent_buffer_get(parent);
6361 path->nodes[parent_level] = parent;
6362 path->slots[parent_level] = btrfs_header_nritems(parent);
6363
Chris Masonb9447ef2009-03-09 11:45:38 -04006364 btrfs_assert_tree_locked(node);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006365 level = btrfs_header_level(node);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006366 path->nodes[level] = node;
6367 path->slots[level] = 0;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006368 path->locks[level] = 1;
6369
6370 wc->refs[parent_level] = 1;
6371 wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;
6372 wc->level = level;
6373 wc->shared_level = -1;
6374 wc->stage = DROP_REFERENCE;
6375 wc->update_ref = 0;
6376 wc->keep_locks = 1;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04006377 wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006378
6379 while (1) {
Yan Zheng2c47e6052009-06-27 21:07:35 -04006380 wret = walk_down_tree(trans, root, path, wc);
6381 if (wret < 0) {
Yan Zhengf82d02d2008-10-29 14:49:05 -04006382 ret = wret;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006383 break;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006384 }
Yan Zhengf82d02d2008-10-29 14:49:05 -04006385
Yan Zheng2c47e6052009-06-27 21:07:35 -04006386 wret = walk_up_tree(trans, root, path, wc, parent_level);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006387 if (wret < 0)
6388 ret = wret;
6389 if (wret != 0)
6390 break;
6391 }
6392
Yan Zheng2c47e6052009-06-27 21:07:35 -04006393 kfree(wc);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006394 btrfs_free_path(path);
6395 return ret;
6396}
6397
Yan Zheng5d4f98a2009-06-10 10:45:14 -04006398#if 0
Chris Mason8e7bf942008-04-28 09:02:36 -04006399static unsigned long calc_ra(unsigned long start, unsigned long last,
6400 unsigned long nr)
6401{
6402 return min(last, start + nr - 1);
6403}
6404
Chris Masond3977122009-01-05 21:25:51 -05006405static noinline int relocate_inode_pages(struct inode *inode, u64 start,
Chris Mason98ed5172008-01-03 10:01:48 -05006406 u64 len)
Chris Masonedbd8d42007-12-21 16:27:24 -05006407{
6408 u64 page_start;
6409 u64 page_end;
Zheng Yan1a40e232008-09-26 10:09:34 -04006410 unsigned long first_index;
Chris Masonedbd8d42007-12-21 16:27:24 -05006411 unsigned long last_index;
Chris Masonedbd8d42007-12-21 16:27:24 -05006412 unsigned long i;
6413 struct page *page;
Chris Masond1310b22008-01-24 16:13:08 -05006414 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
Chris Mason4313b392008-01-03 09:08:48 -05006415 struct file_ra_state *ra;
Chris Mason3eaa2882008-07-24 11:57:52 -04006416 struct btrfs_ordered_extent *ordered;
Zheng Yan1a40e232008-09-26 10:09:34 -04006417 unsigned int total_read = 0;
6418 unsigned int total_dirty = 0;
6419 int ret = 0;
Chris Mason4313b392008-01-03 09:08:48 -05006420
6421 ra = kzalloc(sizeof(*ra), GFP_NOFS);
Chris Masonedbd8d42007-12-21 16:27:24 -05006422
6423 mutex_lock(&inode->i_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04006424 first_index = start >> PAGE_CACHE_SHIFT;
Chris Masonedbd8d42007-12-21 16:27:24 -05006425 last_index = (start + len - 1) >> PAGE_CACHE_SHIFT;
6426
Zheng Yan1a40e232008-09-26 10:09:34 -04006427 /* make sure the dirty trick played by the caller work */
6428 ret = invalidate_inode_pages2_range(inode->i_mapping,
6429 first_index, last_index);
6430 if (ret)
6431 goto out_unlock;
Chris Mason8e7bf942008-04-28 09:02:36 -04006432
Chris Mason4313b392008-01-03 09:08:48 -05006433 file_ra_state_init(ra, inode->i_mapping);
Chris Masonedbd8d42007-12-21 16:27:24 -05006434
Zheng Yan1a40e232008-09-26 10:09:34 -04006435 for (i = first_index ; i <= last_index; i++) {
6436 if (total_read % ra->ra_pages == 0) {
Chris Mason8e7bf942008-04-28 09:02:36 -04006437 btrfs_force_ra(inode->i_mapping, ra, NULL, i,
Zheng Yan1a40e232008-09-26 10:09:34 -04006438 calc_ra(i, last_index, ra->ra_pages));
Chris Mason8e7bf942008-04-28 09:02:36 -04006439 }
6440 total_read++;
Chris Mason3eaa2882008-07-24 11:57:52 -04006441again:
6442 if (((u64)i << PAGE_CACHE_SHIFT) > i_size_read(inode))
Zheng Yan1a40e232008-09-26 10:09:34 -04006443 BUG_ON(1);
Chris Masonedbd8d42007-12-21 16:27:24 -05006444 page = grab_cache_page(inode->i_mapping, i);
Chris Masona061fc82008-05-07 11:43:44 -04006445 if (!page) {
Zheng Yan1a40e232008-09-26 10:09:34 -04006446 ret = -ENOMEM;
Chris Masonedbd8d42007-12-21 16:27:24 -05006447 goto out_unlock;
Chris Masona061fc82008-05-07 11:43:44 -04006448 }
Chris Masonedbd8d42007-12-21 16:27:24 -05006449 if (!PageUptodate(page)) {
6450 btrfs_readpage(NULL, page);
6451 lock_page(page);
6452 if (!PageUptodate(page)) {
6453 unlock_page(page);
6454 page_cache_release(page);
Zheng Yan1a40e232008-09-26 10:09:34 -04006455 ret = -EIO;
Chris Masonedbd8d42007-12-21 16:27:24 -05006456 goto out_unlock;
6457 }
6458 }
Chris Masonec44a352008-04-28 15:29:52 -04006459 wait_on_page_writeback(page);
Chris Mason3eaa2882008-07-24 11:57:52 -04006460
Chris Masonedbd8d42007-12-21 16:27:24 -05006461 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
6462 page_end = page_start + PAGE_CACHE_SIZE - 1;
Chris Masond1310b22008-01-24 16:13:08 -05006463 lock_extent(io_tree, page_start, page_end, GFP_NOFS);
Chris Masonedbd8d42007-12-21 16:27:24 -05006464
Chris Mason3eaa2882008-07-24 11:57:52 -04006465 ordered = btrfs_lookup_ordered_extent(inode, page_start);
6466 if (ordered) {
6467 unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
6468 unlock_page(page);
6469 page_cache_release(page);
6470 btrfs_start_ordered_extent(inode, ordered, 1);
6471 btrfs_put_ordered_extent(ordered);
6472 goto again;
6473 }
6474 set_page_extent_mapped(page);
6475
Zheng Yan1a40e232008-09-26 10:09:34 -04006476 if (i == first_index)
6477 set_extent_bits(io_tree, page_start, page_end,
6478 EXTENT_BOUNDARY, GFP_NOFS);
Yan Zheng1f80e4d2008-12-19 10:59:04 -05006479 btrfs_set_extent_delalloc(inode, page_start, page_end);
Zheng Yan1a40e232008-09-26 10:09:34 -04006480
Chris Masona061fc82008-05-07 11:43:44 -04006481 set_page_dirty(page);
Zheng Yan1a40e232008-09-26 10:09:34 -04006482 total_dirty++;
Chris Masonedbd8d42007-12-21 16:27:24 -05006483
Chris Masond1310b22008-01-24 16:13:08 -05006484 unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
Chris Masonedbd8d42007-12-21 16:27:24 -05006485 unlock_page(page);
6486 page_cache_release(page);
6487 }
6488
6489out_unlock:
Chris Masonec44a352008-04-28 15:29:52 -04006490 kfree(ra);
Chris Masonedbd8d42007-12-21 16:27:24 -05006491 mutex_unlock(&inode->i_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04006492 balance_dirty_pages_ratelimited_nr(inode->i_mapping, total_dirty);
Chris Masonbf4ef672008-05-08 13:26:18 -04006493 return ret;
6494}
6495
Chris Masond3977122009-01-05 21:25:51 -05006496static noinline int relocate_data_extent(struct inode *reloc_inode,
Zheng Yan1a40e232008-09-26 10:09:34 -04006497 struct btrfs_key *extent_key,
6498 u64 offset)
Chris Masonedbd8d42007-12-21 16:27:24 -05006499{
Zheng Yan1a40e232008-09-26 10:09:34 -04006500 struct btrfs_root *root = BTRFS_I(reloc_inode)->root;
6501 struct extent_map_tree *em_tree = &BTRFS_I(reloc_inode)->extent_tree;
6502 struct extent_map *em;
Yan Zheng66435582008-10-30 14:19:50 -04006503 u64 start = extent_key->objectid - offset;
6504 u64 end = start + extent_key->offset - 1;
Zheng Yan1a40e232008-09-26 10:09:34 -04006505
6506 em = alloc_extent_map(GFP_NOFS);
6507 BUG_ON(!em || IS_ERR(em));
6508
Yan Zheng66435582008-10-30 14:19:50 -04006509 em->start = start;
Zheng Yan1a40e232008-09-26 10:09:34 -04006510 em->len = extent_key->offset;
Chris Masonc8b97812008-10-29 14:49:59 -04006511 em->block_len = extent_key->offset;
Zheng Yan1a40e232008-09-26 10:09:34 -04006512 em->block_start = extent_key->objectid;
6513 em->bdev = root->fs_info->fs_devices->latest_bdev;
6514 set_bit(EXTENT_FLAG_PINNED, &em->flags);
6515
6516 /* setup extent map to cheat btrfs_readpage */
Yan Zheng66435582008-10-30 14:19:50 -04006517 lock_extent(&BTRFS_I(reloc_inode)->io_tree, start, end, GFP_NOFS);
Zheng Yan1a40e232008-09-26 10:09:34 -04006518 while (1) {
6519 int ret;
Chris Mason890871b2009-09-02 16:24:52 -04006520 write_lock(&em_tree->lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04006521 ret = add_extent_mapping(em_tree, em);
Chris Mason890871b2009-09-02 16:24:52 -04006522 write_unlock(&em_tree->lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04006523 if (ret != -EEXIST) {
6524 free_extent_map(em);
6525 break;
6526 }
Yan Zheng66435582008-10-30 14:19:50 -04006527 btrfs_drop_extent_cache(reloc_inode, start, end, 0);
Zheng Yan1a40e232008-09-26 10:09:34 -04006528 }
Yan Zheng66435582008-10-30 14:19:50 -04006529 unlock_extent(&BTRFS_I(reloc_inode)->io_tree, start, end, GFP_NOFS);
Zheng Yan1a40e232008-09-26 10:09:34 -04006530
Yan Zheng66435582008-10-30 14:19:50 -04006531 return relocate_inode_pages(reloc_inode, start, extent_key->offset);
Zheng Yan1a40e232008-09-26 10:09:34 -04006532}
6533
6534struct btrfs_ref_path {
6535 u64 extent_start;
6536 u64 nodes[BTRFS_MAX_LEVEL];
6537 u64 root_objectid;
6538 u64 root_generation;
6539 u64 owner_objectid;
Zheng Yan1a40e232008-09-26 10:09:34 -04006540 u32 num_refs;
6541 int lowest_level;
6542 int current_level;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006543 int shared_level;
6544
6545 struct btrfs_key node_keys[BTRFS_MAX_LEVEL];
6546 u64 new_nodes[BTRFS_MAX_LEVEL];
Zheng Yan1a40e232008-09-26 10:09:34 -04006547};
6548
6549struct disk_extent {
Chris Masonc8b97812008-10-29 14:49:59 -04006550 u64 ram_bytes;
Zheng Yan1a40e232008-09-26 10:09:34 -04006551 u64 disk_bytenr;
6552 u64 disk_num_bytes;
6553 u64 offset;
6554 u64 num_bytes;
Chris Masonc8b97812008-10-29 14:49:59 -04006555 u8 compression;
6556 u8 encryption;
6557 u16 other_encoding;
Zheng Yan1a40e232008-09-26 10:09:34 -04006558};
6559
6560static int is_cowonly_root(u64 root_objectid)
6561{
6562 if (root_objectid == BTRFS_ROOT_TREE_OBJECTID ||
6563 root_objectid == BTRFS_EXTENT_TREE_OBJECTID ||
6564 root_objectid == BTRFS_CHUNK_TREE_OBJECTID ||
6565 root_objectid == BTRFS_DEV_TREE_OBJECTID ||
Yan Zheng0403e472008-12-10 20:32:51 -05006566 root_objectid == BTRFS_TREE_LOG_OBJECTID ||
6567 root_objectid == BTRFS_CSUM_TREE_OBJECTID)
Zheng Yan1a40e232008-09-26 10:09:34 -04006568 return 1;
6569 return 0;
6570}
6571
Chris Masond3977122009-01-05 21:25:51 -05006572static noinline int __next_ref_path(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04006573 struct btrfs_root *extent_root,
6574 struct btrfs_ref_path *ref_path,
6575 int first_time)
6576{
6577 struct extent_buffer *leaf;
6578 struct btrfs_path *path;
Chris Mason4313b392008-01-03 09:08:48 -05006579 struct btrfs_extent_ref *ref;
Chris Masonedbd8d42007-12-21 16:27:24 -05006580 struct btrfs_key key;
6581 struct btrfs_key found_key;
Zheng Yan1a40e232008-09-26 10:09:34 -04006582 u64 bytenr;
Chris Masonedbd8d42007-12-21 16:27:24 -05006583 u32 nritems;
Zheng Yan1a40e232008-09-26 10:09:34 -04006584 int level;
6585 int ret = 1;
Chris Masonedbd8d42007-12-21 16:27:24 -05006586
Zheng Yan1a40e232008-09-26 10:09:34 -04006587 path = btrfs_alloc_path();
6588 if (!path)
6589 return -ENOMEM;
6590
Zheng Yan1a40e232008-09-26 10:09:34 -04006591 if (first_time) {
6592 ref_path->lowest_level = -1;
6593 ref_path->current_level = -1;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006594 ref_path->shared_level = -1;
Zheng Yan1a40e232008-09-26 10:09:34 -04006595 goto walk_up;
Chris Masona061fc82008-05-07 11:43:44 -04006596 }
Zheng Yan1a40e232008-09-26 10:09:34 -04006597walk_down:
6598 level = ref_path->current_level - 1;
6599 while (level >= -1) {
6600 u64 parent;
6601 if (level < ref_path->lowest_level)
6602 break;
Chris Masonedbd8d42007-12-21 16:27:24 -05006603
Chris Masond3977122009-01-05 21:25:51 -05006604 if (level >= 0)
Zheng Yan1a40e232008-09-26 10:09:34 -04006605 bytenr = ref_path->nodes[level];
Chris Masond3977122009-01-05 21:25:51 -05006606 else
Zheng Yan1a40e232008-09-26 10:09:34 -04006607 bytenr = ref_path->extent_start;
Zheng Yan1a40e232008-09-26 10:09:34 -04006608 BUG_ON(bytenr == 0);
Chris Masonedbd8d42007-12-21 16:27:24 -05006609
Zheng Yan1a40e232008-09-26 10:09:34 -04006610 parent = ref_path->nodes[level + 1];
6611 ref_path->nodes[level + 1] = 0;
6612 ref_path->current_level = level;
6613 BUG_ON(parent == 0);
6614
6615 key.objectid = bytenr;
6616 key.offset = parent + 1;
6617 key.type = BTRFS_EXTENT_REF_KEY;
6618
6619 ret = btrfs_search_slot(trans, extent_root, &key, path, 0, 0);
Chris Masonedbd8d42007-12-21 16:27:24 -05006620 if (ret < 0)
6621 goto out;
Zheng Yan1a40e232008-09-26 10:09:34 -04006622 BUG_ON(ret == 0);
Chris Masonedbd8d42007-12-21 16:27:24 -05006623
Chris Masonedbd8d42007-12-21 16:27:24 -05006624 leaf = path->nodes[0];
6625 nritems = btrfs_header_nritems(leaf);
Zheng Yan1a40e232008-09-26 10:09:34 -04006626 if (path->slots[0] >= nritems) {
Chris Masona061fc82008-05-07 11:43:44 -04006627 ret = btrfs_next_leaf(extent_root, path);
Chris Masona061fc82008-05-07 11:43:44 -04006628 if (ret < 0)
6629 goto out;
Zheng Yan1a40e232008-09-26 10:09:34 -04006630 if (ret > 0)
6631 goto next;
Chris Masonbf4ef672008-05-08 13:26:18 -04006632 leaf = path->nodes[0];
Chris Masona061fc82008-05-07 11:43:44 -04006633 }
Chris Masonedbd8d42007-12-21 16:27:24 -05006634
6635 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
Zheng Yan1a40e232008-09-26 10:09:34 -04006636 if (found_key.objectid == bytenr &&
Yan Zhengf82d02d2008-10-29 14:49:05 -04006637 found_key.type == BTRFS_EXTENT_REF_KEY) {
6638 if (level < ref_path->shared_level)
6639 ref_path->shared_level = level;
Zheng Yan1a40e232008-09-26 10:09:34 -04006640 goto found;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006641 }
Zheng Yan1a40e232008-09-26 10:09:34 -04006642next:
6643 level--;
6644 btrfs_release_path(extent_root, path);
Yan Zhengd899e052008-10-30 14:25:28 -04006645 cond_resched();
Zheng Yan1a40e232008-09-26 10:09:34 -04006646 }
6647 /* reached lowest level */
6648 ret = 1;
6649 goto out;
6650walk_up:
6651 level = ref_path->current_level;
6652 while (level < BTRFS_MAX_LEVEL - 1) {
6653 u64 ref_objectid;
Chris Masond3977122009-01-05 21:25:51 -05006654
6655 if (level >= 0)
Zheng Yan1a40e232008-09-26 10:09:34 -04006656 bytenr = ref_path->nodes[level];
Chris Masond3977122009-01-05 21:25:51 -05006657 else
Zheng Yan1a40e232008-09-26 10:09:34 -04006658 bytenr = ref_path->extent_start;
Chris Masond3977122009-01-05 21:25:51 -05006659
Zheng Yan1a40e232008-09-26 10:09:34 -04006660 BUG_ON(bytenr == 0);
Chris Masonedbd8d42007-12-21 16:27:24 -05006661
Zheng Yan1a40e232008-09-26 10:09:34 -04006662 key.objectid = bytenr;
6663 key.offset = 0;
6664 key.type = BTRFS_EXTENT_REF_KEY;
Chris Masonedbd8d42007-12-21 16:27:24 -05006665
Zheng Yan1a40e232008-09-26 10:09:34 -04006666 ret = btrfs_search_slot(trans, extent_root, &key, path, 0, 0);
6667 if (ret < 0)
Chris Masonedbd8d42007-12-21 16:27:24 -05006668 goto out;
Zheng Yan1a40e232008-09-26 10:09:34 -04006669
6670 leaf = path->nodes[0];
6671 nritems = btrfs_header_nritems(leaf);
6672 if (path->slots[0] >= nritems) {
6673 ret = btrfs_next_leaf(extent_root, path);
6674 if (ret < 0)
6675 goto out;
6676 if (ret > 0) {
6677 /* the extent was freed by someone */
6678 if (ref_path->lowest_level == level)
6679 goto out;
6680 btrfs_release_path(extent_root, path);
6681 goto walk_down;
6682 }
6683 leaf = path->nodes[0];
6684 }
6685
6686 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6687 if (found_key.objectid != bytenr ||
6688 found_key.type != BTRFS_EXTENT_REF_KEY) {
6689 /* the extent was freed by someone */
6690 if (ref_path->lowest_level == level) {
6691 ret = 1;
6692 goto out;
6693 }
6694 btrfs_release_path(extent_root, path);
6695 goto walk_down;
6696 }
6697found:
6698 ref = btrfs_item_ptr(leaf, path->slots[0],
6699 struct btrfs_extent_ref);
6700 ref_objectid = btrfs_ref_objectid(leaf, ref);
6701 if (ref_objectid < BTRFS_FIRST_FREE_OBJECTID) {
6702 if (first_time) {
6703 level = (int)ref_objectid;
6704 BUG_ON(level >= BTRFS_MAX_LEVEL);
6705 ref_path->lowest_level = level;
6706 ref_path->current_level = level;
6707 ref_path->nodes[level] = bytenr;
6708 } else {
6709 WARN_ON(ref_objectid != level);
6710 }
6711 } else {
6712 WARN_ON(level != -1);
6713 }
6714 first_time = 0;
6715
6716 if (ref_path->lowest_level == level) {
6717 ref_path->owner_objectid = ref_objectid;
Zheng Yan1a40e232008-09-26 10:09:34 -04006718 ref_path->num_refs = btrfs_ref_num_refs(leaf, ref);
6719 }
6720
6721 /*
6722 * the block is tree root or the block isn't in reference
6723 * counted tree.
6724 */
6725 if (found_key.objectid == found_key.offset ||
6726 is_cowonly_root(btrfs_ref_root(leaf, ref))) {
6727 ref_path->root_objectid = btrfs_ref_root(leaf, ref);
6728 ref_path->root_generation =
6729 btrfs_ref_generation(leaf, ref);
6730 if (level < 0) {
6731 /* special reference from the tree log */
6732 ref_path->nodes[0] = found_key.offset;
6733 ref_path->current_level = 0;
6734 }
6735 ret = 0;
6736 goto out;
6737 }
6738
6739 level++;
6740 BUG_ON(ref_path->nodes[level] != 0);
6741 ref_path->nodes[level] = found_key.offset;
6742 ref_path->current_level = level;
6743
6744 /*
6745 * the reference was created in the running transaction,
6746 * no need to continue walking up.
6747 */
6748 if (btrfs_ref_generation(leaf, ref) == trans->transid) {
6749 ref_path->root_objectid = btrfs_ref_root(leaf, ref);
6750 ref_path->root_generation =
6751 btrfs_ref_generation(leaf, ref);
6752 ret = 0;
6753 goto out;
6754 }
6755
6756 btrfs_release_path(extent_root, path);
Yan Zhengd899e052008-10-30 14:25:28 -04006757 cond_resched();
Zheng Yan1a40e232008-09-26 10:09:34 -04006758 }
6759 /* reached max tree level, but no tree root found. */
6760 BUG();
6761out:
Zheng Yan1a40e232008-09-26 10:09:34 -04006762 btrfs_free_path(path);
6763 return ret;
6764}
6765
6766static int btrfs_first_ref_path(struct btrfs_trans_handle *trans,
6767 struct btrfs_root *extent_root,
6768 struct btrfs_ref_path *ref_path,
6769 u64 extent_start)
6770{
6771 memset(ref_path, 0, sizeof(*ref_path));
6772 ref_path->extent_start = extent_start;
6773
6774 return __next_ref_path(trans, extent_root, ref_path, 1);
6775}
6776
6777static int btrfs_next_ref_path(struct btrfs_trans_handle *trans,
6778 struct btrfs_root *extent_root,
6779 struct btrfs_ref_path *ref_path)
6780{
6781 return __next_ref_path(trans, extent_root, ref_path, 0);
6782}
6783
Chris Masond3977122009-01-05 21:25:51 -05006784static noinline int get_new_locations(struct inode *reloc_inode,
Zheng Yan1a40e232008-09-26 10:09:34 -04006785 struct btrfs_key *extent_key,
6786 u64 offset, int no_fragment,
6787 struct disk_extent **extents,
6788 int *nr_extents)
6789{
6790 struct btrfs_root *root = BTRFS_I(reloc_inode)->root;
6791 struct btrfs_path *path;
6792 struct btrfs_file_extent_item *fi;
6793 struct extent_buffer *leaf;
6794 struct disk_extent *exts = *extents;
6795 struct btrfs_key found_key;
6796 u64 cur_pos;
6797 u64 last_byte;
6798 u32 nritems;
6799 int nr = 0;
6800 int max = *nr_extents;
6801 int ret;
6802
6803 WARN_ON(!no_fragment && *extents);
6804 if (!exts) {
6805 max = 1;
6806 exts = kmalloc(sizeof(*exts) * max, GFP_NOFS);
6807 if (!exts)
6808 return -ENOMEM;
6809 }
6810
6811 path = btrfs_alloc_path();
6812 BUG_ON(!path);
6813
6814 cur_pos = extent_key->objectid - offset;
6815 last_byte = extent_key->objectid + extent_key->offset;
6816 ret = btrfs_lookup_file_extent(NULL, root, path, reloc_inode->i_ino,
6817 cur_pos, 0);
6818 if (ret < 0)
6819 goto out;
6820 if (ret > 0) {
6821 ret = -ENOENT;
6822 goto out;
6823 }
6824
6825 while (1) {
6826 leaf = path->nodes[0];
6827 nritems = btrfs_header_nritems(leaf);
6828 if (path->slots[0] >= nritems) {
6829 ret = btrfs_next_leaf(root, path);
6830 if (ret < 0)
6831 goto out;
6832 if (ret > 0)
6833 break;
6834 leaf = path->nodes[0];
6835 }
6836
6837 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6838 if (found_key.offset != cur_pos ||
6839 found_key.type != BTRFS_EXTENT_DATA_KEY ||
6840 found_key.objectid != reloc_inode->i_ino)
6841 break;
6842
6843 fi = btrfs_item_ptr(leaf, path->slots[0],
6844 struct btrfs_file_extent_item);
6845 if (btrfs_file_extent_type(leaf, fi) !=
6846 BTRFS_FILE_EXTENT_REG ||
6847 btrfs_file_extent_disk_bytenr(leaf, fi) == 0)
6848 break;
6849
6850 if (nr == max) {
6851 struct disk_extent *old = exts;
6852 max *= 2;
6853 exts = kzalloc(sizeof(*exts) * max, GFP_NOFS);
6854 memcpy(exts, old, sizeof(*exts) * nr);
6855 if (old != *extents)
6856 kfree(old);
6857 }
6858
6859 exts[nr].disk_bytenr =
6860 btrfs_file_extent_disk_bytenr(leaf, fi);
6861 exts[nr].disk_num_bytes =
6862 btrfs_file_extent_disk_num_bytes(leaf, fi);
6863 exts[nr].offset = btrfs_file_extent_offset(leaf, fi);
6864 exts[nr].num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
Chris Masonc8b97812008-10-29 14:49:59 -04006865 exts[nr].ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
6866 exts[nr].compression = btrfs_file_extent_compression(leaf, fi);
6867 exts[nr].encryption = btrfs_file_extent_encryption(leaf, fi);
6868 exts[nr].other_encoding = btrfs_file_extent_other_encoding(leaf,
6869 fi);
Yan Zhengd899e052008-10-30 14:25:28 -04006870 BUG_ON(exts[nr].offset > 0);
6871 BUG_ON(exts[nr].compression || exts[nr].encryption);
6872 BUG_ON(exts[nr].num_bytes != exts[nr].disk_num_bytes);
Zheng Yan1a40e232008-09-26 10:09:34 -04006873
6874 cur_pos += exts[nr].num_bytes;
6875 nr++;
6876
6877 if (cur_pos + offset >= last_byte)
6878 break;
6879
6880 if (no_fragment) {
6881 ret = 1;
6882 goto out;
6883 }
6884 path->slots[0]++;
6885 }
6886
Yan Zheng1f80e4d2008-12-19 10:59:04 -05006887 BUG_ON(cur_pos + offset > last_byte);
Zheng Yan1a40e232008-09-26 10:09:34 -04006888 if (cur_pos + offset < last_byte) {
6889 ret = -ENOENT;
6890 goto out;
Chris Masonedbd8d42007-12-21 16:27:24 -05006891 }
6892 ret = 0;
6893out:
Zheng Yan1a40e232008-09-26 10:09:34 -04006894 btrfs_free_path(path);
6895 if (ret) {
6896 if (exts != *extents)
6897 kfree(exts);
6898 } else {
6899 *extents = exts;
6900 *nr_extents = nr;
6901 }
6902 return ret;
6903}
6904
Chris Masond3977122009-01-05 21:25:51 -05006905static noinline int replace_one_extent(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04006906 struct btrfs_root *root,
6907 struct btrfs_path *path,
6908 struct btrfs_key *extent_key,
6909 struct btrfs_key *leaf_key,
6910 struct btrfs_ref_path *ref_path,
6911 struct disk_extent *new_extents,
6912 int nr_extents)
6913{
6914 struct extent_buffer *leaf;
6915 struct btrfs_file_extent_item *fi;
6916 struct inode *inode = NULL;
6917 struct btrfs_key key;
6918 u64 lock_start = 0;
6919 u64 lock_end = 0;
6920 u64 num_bytes;
6921 u64 ext_offset;
Yan Zheng86288a12009-01-21 10:49:16 -05006922 u64 search_end = (u64)-1;
Zheng Yan1a40e232008-09-26 10:09:34 -04006923 u32 nritems;
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006924 int nr_scaned = 0;
Zheng Yan1a40e232008-09-26 10:09:34 -04006925 int extent_locked = 0;
Yan Zhengd899e052008-10-30 14:25:28 -04006926 int extent_type;
Zheng Yan1a40e232008-09-26 10:09:34 -04006927 int ret;
6928
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006929 memcpy(&key, leaf_key, sizeof(key));
Zheng Yan1a40e232008-09-26 10:09:34 -04006930 if (ref_path->owner_objectid != BTRFS_MULTIPLE_OBJECTIDS) {
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006931 if (key.objectid < ref_path->owner_objectid ||
6932 (key.objectid == ref_path->owner_objectid &&
6933 key.type < BTRFS_EXTENT_DATA_KEY)) {
6934 key.objectid = ref_path->owner_objectid;
6935 key.type = BTRFS_EXTENT_DATA_KEY;
6936 key.offset = 0;
6937 }
Zheng Yan1a40e232008-09-26 10:09:34 -04006938 }
6939
6940 while (1) {
6941 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
6942 if (ret < 0)
6943 goto out;
6944
6945 leaf = path->nodes[0];
6946 nritems = btrfs_header_nritems(leaf);
6947next:
6948 if (extent_locked && ret > 0) {
6949 /*
6950 * the file extent item was modified by someone
6951 * before the extent got locked.
6952 */
Zheng Yan1a40e232008-09-26 10:09:34 -04006953 unlock_extent(&BTRFS_I(inode)->io_tree, lock_start,
6954 lock_end, GFP_NOFS);
6955 extent_locked = 0;
6956 }
6957
6958 if (path->slots[0] >= nritems) {
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006959 if (++nr_scaned > 2)
Zheng Yan1a40e232008-09-26 10:09:34 -04006960 break;
6961
6962 BUG_ON(extent_locked);
6963 ret = btrfs_next_leaf(root, path);
6964 if (ret < 0)
6965 goto out;
6966 if (ret > 0)
6967 break;
6968 leaf = path->nodes[0];
6969 nritems = btrfs_header_nritems(leaf);
6970 }
6971
6972 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
6973
6974 if (ref_path->owner_objectid != BTRFS_MULTIPLE_OBJECTIDS) {
6975 if ((key.objectid > ref_path->owner_objectid) ||
6976 (key.objectid == ref_path->owner_objectid &&
6977 key.type > BTRFS_EXTENT_DATA_KEY) ||
Yan Zheng86288a12009-01-21 10:49:16 -05006978 key.offset >= search_end)
Zheng Yan1a40e232008-09-26 10:09:34 -04006979 break;
6980 }
6981
6982 if (inode && key.objectid != inode->i_ino) {
6983 BUG_ON(extent_locked);
6984 btrfs_release_path(root, path);
6985 mutex_unlock(&inode->i_mutex);
6986 iput(inode);
6987 inode = NULL;
6988 continue;
6989 }
6990
6991 if (key.type != BTRFS_EXTENT_DATA_KEY) {
6992 path->slots[0]++;
6993 ret = 1;
6994 goto next;
6995 }
6996 fi = btrfs_item_ptr(leaf, path->slots[0],
6997 struct btrfs_file_extent_item);
Yan Zhengd899e052008-10-30 14:25:28 -04006998 extent_type = btrfs_file_extent_type(leaf, fi);
6999 if ((extent_type != BTRFS_FILE_EXTENT_REG &&
7000 extent_type != BTRFS_FILE_EXTENT_PREALLOC) ||
Zheng Yan1a40e232008-09-26 10:09:34 -04007001 (btrfs_file_extent_disk_bytenr(leaf, fi) !=
7002 extent_key->objectid)) {
7003 path->slots[0]++;
7004 ret = 1;
7005 goto next;
7006 }
7007
7008 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
7009 ext_offset = btrfs_file_extent_offset(leaf, fi);
7010
Yan Zheng86288a12009-01-21 10:49:16 -05007011 if (search_end == (u64)-1) {
7012 search_end = key.offset - ext_offset +
7013 btrfs_file_extent_ram_bytes(leaf, fi);
7014 }
Zheng Yan1a40e232008-09-26 10:09:34 -04007015
7016 if (!extent_locked) {
7017 lock_start = key.offset;
7018 lock_end = lock_start + num_bytes - 1;
7019 } else {
Yan Zheng66435582008-10-30 14:19:50 -04007020 if (lock_start > key.offset ||
7021 lock_end + 1 < key.offset + num_bytes) {
7022 unlock_extent(&BTRFS_I(inode)->io_tree,
7023 lock_start, lock_end, GFP_NOFS);
7024 extent_locked = 0;
7025 }
Zheng Yan1a40e232008-09-26 10:09:34 -04007026 }
7027
7028 if (!inode) {
7029 btrfs_release_path(root, path);
7030
7031 inode = btrfs_iget_locked(root->fs_info->sb,
7032 key.objectid, root);
7033 if (inode->i_state & I_NEW) {
7034 BTRFS_I(inode)->root = root;
7035 BTRFS_I(inode)->location.objectid =
7036 key.objectid;
7037 BTRFS_I(inode)->location.type =
7038 BTRFS_INODE_ITEM_KEY;
7039 BTRFS_I(inode)->location.offset = 0;
7040 btrfs_read_locked_inode(inode);
7041 unlock_new_inode(inode);
7042 }
7043 /*
7044 * some code call btrfs_commit_transaction while
7045 * holding the i_mutex, so we can't use mutex_lock
7046 * here.
7047 */
7048 if (is_bad_inode(inode) ||
7049 !mutex_trylock(&inode->i_mutex)) {
7050 iput(inode);
7051 inode = NULL;
7052 key.offset = (u64)-1;
7053 goto skip;
7054 }
7055 }
7056
7057 if (!extent_locked) {
7058 struct btrfs_ordered_extent *ordered;
7059
7060 btrfs_release_path(root, path);
7061
7062 lock_extent(&BTRFS_I(inode)->io_tree, lock_start,
7063 lock_end, GFP_NOFS);
7064 ordered = btrfs_lookup_first_ordered_extent(inode,
7065 lock_end);
7066 if (ordered &&
7067 ordered->file_offset <= lock_end &&
7068 ordered->file_offset + ordered->len > lock_start) {
7069 unlock_extent(&BTRFS_I(inode)->io_tree,
7070 lock_start, lock_end, GFP_NOFS);
7071 btrfs_start_ordered_extent(inode, ordered, 1);
7072 btrfs_put_ordered_extent(ordered);
7073 key.offset += num_bytes;
7074 goto skip;
7075 }
7076 if (ordered)
7077 btrfs_put_ordered_extent(ordered);
7078
Zheng Yan1a40e232008-09-26 10:09:34 -04007079 extent_locked = 1;
7080 continue;
7081 }
7082
7083 if (nr_extents == 1) {
7084 /* update extent pointer in place */
Zheng Yan1a40e232008-09-26 10:09:34 -04007085 btrfs_set_file_extent_disk_bytenr(leaf, fi,
7086 new_extents[0].disk_bytenr);
7087 btrfs_set_file_extent_disk_num_bytes(leaf, fi,
7088 new_extents[0].disk_num_bytes);
Zheng Yan1a40e232008-09-26 10:09:34 -04007089 btrfs_mark_buffer_dirty(leaf);
7090
7091 btrfs_drop_extent_cache(inode, key.offset,
7092 key.offset + num_bytes - 1, 0);
7093
7094 ret = btrfs_inc_extent_ref(trans, root,
7095 new_extents[0].disk_bytenr,
7096 new_extents[0].disk_num_bytes,
7097 leaf->start,
7098 root->root_key.objectid,
7099 trans->transid,
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04007100 key.objectid);
Zheng Yan1a40e232008-09-26 10:09:34 -04007101 BUG_ON(ret);
7102
7103 ret = btrfs_free_extent(trans, root,
7104 extent_key->objectid,
7105 extent_key->offset,
7106 leaf->start,
7107 btrfs_header_owner(leaf),
7108 btrfs_header_generation(leaf),
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04007109 key.objectid, 0);
Zheng Yan1a40e232008-09-26 10:09:34 -04007110 BUG_ON(ret);
7111
7112 btrfs_release_path(root, path);
7113 key.offset += num_bytes;
7114 } else {
Yan Zhengd899e052008-10-30 14:25:28 -04007115 BUG_ON(1);
7116#if 0
Zheng Yan1a40e232008-09-26 10:09:34 -04007117 u64 alloc_hint;
7118 u64 extent_len;
7119 int i;
7120 /*
7121 * drop old extent pointer at first, then insert the
7122 * new pointers one bye one
7123 */
7124 btrfs_release_path(root, path);
7125 ret = btrfs_drop_extents(trans, root, inode, key.offset,
7126 key.offset + num_bytes,
7127 key.offset, &alloc_hint);
7128 BUG_ON(ret);
7129
7130 for (i = 0; i < nr_extents; i++) {
7131 if (ext_offset >= new_extents[i].num_bytes) {
7132 ext_offset -= new_extents[i].num_bytes;
7133 continue;
7134 }
7135 extent_len = min(new_extents[i].num_bytes -
7136 ext_offset, num_bytes);
7137
7138 ret = btrfs_insert_empty_item(trans, root,
7139 path, &key,
7140 sizeof(*fi));
7141 BUG_ON(ret);
7142
7143 leaf = path->nodes[0];
7144 fi = btrfs_item_ptr(leaf, path->slots[0],
7145 struct btrfs_file_extent_item);
7146 btrfs_set_file_extent_generation(leaf, fi,
7147 trans->transid);
7148 btrfs_set_file_extent_type(leaf, fi,
7149 BTRFS_FILE_EXTENT_REG);
7150 btrfs_set_file_extent_disk_bytenr(leaf, fi,
7151 new_extents[i].disk_bytenr);
7152 btrfs_set_file_extent_disk_num_bytes(leaf, fi,
7153 new_extents[i].disk_num_bytes);
Chris Masonc8b97812008-10-29 14:49:59 -04007154 btrfs_set_file_extent_ram_bytes(leaf, fi,
7155 new_extents[i].ram_bytes);
7156
7157 btrfs_set_file_extent_compression(leaf, fi,
7158 new_extents[i].compression);
7159 btrfs_set_file_extent_encryption(leaf, fi,
7160 new_extents[i].encryption);
7161 btrfs_set_file_extent_other_encoding(leaf, fi,
7162 new_extents[i].other_encoding);
7163
Zheng Yan1a40e232008-09-26 10:09:34 -04007164 btrfs_set_file_extent_num_bytes(leaf, fi,
7165 extent_len);
7166 ext_offset += new_extents[i].offset;
7167 btrfs_set_file_extent_offset(leaf, fi,
7168 ext_offset);
7169 btrfs_mark_buffer_dirty(leaf);
7170
7171 btrfs_drop_extent_cache(inode, key.offset,
7172 key.offset + extent_len - 1, 0);
7173
7174 ret = btrfs_inc_extent_ref(trans, root,
7175 new_extents[i].disk_bytenr,
7176 new_extents[i].disk_num_bytes,
7177 leaf->start,
7178 root->root_key.objectid,
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04007179 trans->transid, key.objectid);
Zheng Yan1a40e232008-09-26 10:09:34 -04007180 BUG_ON(ret);
7181 btrfs_release_path(root, path);
7182
Yan Zhenga76a3cd2008-10-09 11:46:29 -04007183 inode_add_bytes(inode, extent_len);
Zheng Yan1a40e232008-09-26 10:09:34 -04007184
7185 ext_offset = 0;
7186 num_bytes -= extent_len;
7187 key.offset += extent_len;
7188
7189 if (num_bytes == 0)
7190 break;
7191 }
7192 BUG_ON(i >= nr_extents);
Yan Zhengd899e052008-10-30 14:25:28 -04007193#endif
Zheng Yan1a40e232008-09-26 10:09:34 -04007194 }
7195
7196 if (extent_locked) {
Zheng Yan1a40e232008-09-26 10:09:34 -04007197 unlock_extent(&BTRFS_I(inode)->io_tree, lock_start,
7198 lock_end, GFP_NOFS);
7199 extent_locked = 0;
7200 }
7201skip:
7202 if (ref_path->owner_objectid != BTRFS_MULTIPLE_OBJECTIDS &&
Yan Zheng86288a12009-01-21 10:49:16 -05007203 key.offset >= search_end)
Zheng Yan1a40e232008-09-26 10:09:34 -04007204 break;
7205
7206 cond_resched();
7207 }
7208 ret = 0;
7209out:
7210 btrfs_release_path(root, path);
7211 if (inode) {
7212 mutex_unlock(&inode->i_mutex);
7213 if (extent_locked) {
Zheng Yan1a40e232008-09-26 10:09:34 -04007214 unlock_extent(&BTRFS_I(inode)->io_tree, lock_start,
7215 lock_end, GFP_NOFS);
7216 }
7217 iput(inode);
7218 }
7219 return ret;
7220}
7221
Zheng Yan1a40e232008-09-26 10:09:34 -04007222int btrfs_reloc_tree_cache_ref(struct btrfs_trans_handle *trans,
7223 struct btrfs_root *root,
7224 struct extent_buffer *buf, u64 orig_start)
7225{
7226 int level;
7227 int ret;
7228
7229 BUG_ON(btrfs_header_generation(buf) != trans->transid);
7230 BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);
7231
7232 level = btrfs_header_level(buf);
7233 if (level == 0) {
7234 struct btrfs_leaf_ref *ref;
7235 struct btrfs_leaf_ref *orig_ref;
7236
7237 orig_ref = btrfs_lookup_leaf_ref(root, orig_start);
7238 if (!orig_ref)
7239 return -ENOENT;
7240
7241 ref = btrfs_alloc_leaf_ref(root, orig_ref->nritems);
7242 if (!ref) {
7243 btrfs_free_leaf_ref(root, orig_ref);
7244 return -ENOMEM;
7245 }
7246
7247 ref->nritems = orig_ref->nritems;
7248 memcpy(ref->extents, orig_ref->extents,
7249 sizeof(ref->extents[0]) * ref->nritems);
7250
7251 btrfs_free_leaf_ref(root, orig_ref);
7252
7253 ref->root_gen = trans->transid;
7254 ref->bytenr = buf->start;
7255 ref->owner = btrfs_header_owner(buf);
7256 ref->generation = btrfs_header_generation(buf);
Chris Masonbd56b302009-02-04 09:27:02 -05007257
Zheng Yan1a40e232008-09-26 10:09:34 -04007258 ret = btrfs_add_leaf_ref(root, ref, 0);
7259 WARN_ON(ret);
7260 btrfs_free_leaf_ref(root, ref);
7261 }
7262 return 0;
7263}
7264
Chris Masond3977122009-01-05 21:25:51 -05007265static noinline int invalidate_extent_cache(struct btrfs_root *root,
Zheng Yan1a40e232008-09-26 10:09:34 -04007266 struct extent_buffer *leaf,
7267 struct btrfs_block_group_cache *group,
7268 struct btrfs_root *target_root)
7269{
7270 struct btrfs_key key;
7271 struct inode *inode = NULL;
7272 struct btrfs_file_extent_item *fi;
Josef Bacik2ac55d42010-02-03 19:33:23 +00007273 struct extent_state *cached_state = NULL;
Zheng Yan1a40e232008-09-26 10:09:34 -04007274 u64 num_bytes;
7275 u64 skip_objectid = 0;
7276 u32 nritems;
7277 u32 i;
7278
7279 nritems = btrfs_header_nritems(leaf);
7280 for (i = 0; i < nritems; i++) {
7281 btrfs_item_key_to_cpu(leaf, &key, i);
7282 if (key.objectid == skip_objectid ||
7283 key.type != BTRFS_EXTENT_DATA_KEY)
7284 continue;
7285 fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
7286 if (btrfs_file_extent_type(leaf, fi) ==
7287 BTRFS_FILE_EXTENT_INLINE)
7288 continue;
7289 if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0)
7290 continue;
7291 if (!inode || inode->i_ino != key.objectid) {
7292 iput(inode);
7293 inode = btrfs_ilookup(target_root->fs_info->sb,
7294 key.objectid, target_root, 1);
7295 }
7296 if (!inode) {
7297 skip_objectid = key.objectid;
7298 continue;
7299 }
7300 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
7301
Josef Bacik2ac55d42010-02-03 19:33:23 +00007302 lock_extent_bits(&BTRFS_I(inode)->io_tree, key.offset,
7303 key.offset + num_bytes - 1, 0, &cached_state,
7304 GFP_NOFS);
Zheng Yan1a40e232008-09-26 10:09:34 -04007305 btrfs_drop_extent_cache(inode, key.offset,
7306 key.offset + num_bytes - 1, 1);
Josef Bacik2ac55d42010-02-03 19:33:23 +00007307 unlock_extent_cached(&BTRFS_I(inode)->io_tree, key.offset,
7308 key.offset + num_bytes - 1, &cached_state,
7309 GFP_NOFS);
Zheng Yan1a40e232008-09-26 10:09:34 -04007310 cond_resched();
7311 }
7312 iput(inode);
7313 return 0;
7314}
7315
Chris Masond3977122009-01-05 21:25:51 -05007316static noinline int replace_extents_in_leaf(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007317 struct btrfs_root *root,
7318 struct extent_buffer *leaf,
7319 struct btrfs_block_group_cache *group,
7320 struct inode *reloc_inode)
7321{
7322 struct btrfs_key key;
7323 struct btrfs_key extent_key;
7324 struct btrfs_file_extent_item *fi;
7325 struct btrfs_leaf_ref *ref;
7326 struct disk_extent *new_extent;
7327 u64 bytenr;
7328 u64 num_bytes;
7329 u32 nritems;
7330 u32 i;
7331 int ext_index;
7332 int nr_extent;
7333 int ret;
7334
7335 new_extent = kmalloc(sizeof(*new_extent), GFP_NOFS);
7336 BUG_ON(!new_extent);
7337
7338 ref = btrfs_lookup_leaf_ref(root, leaf->start);
7339 BUG_ON(!ref);
7340
7341 ext_index = -1;
7342 nritems = btrfs_header_nritems(leaf);
7343 for (i = 0; i < nritems; i++) {
7344 btrfs_item_key_to_cpu(leaf, &key, i);
7345 if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
7346 continue;
7347 fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
7348 if (btrfs_file_extent_type(leaf, fi) ==
7349 BTRFS_FILE_EXTENT_INLINE)
7350 continue;
7351 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
7352 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
7353 if (bytenr == 0)
7354 continue;
7355
7356 ext_index++;
7357 if (bytenr >= group->key.objectid + group->key.offset ||
7358 bytenr + num_bytes <= group->key.objectid)
7359 continue;
7360
7361 extent_key.objectid = bytenr;
7362 extent_key.offset = num_bytes;
7363 extent_key.type = BTRFS_EXTENT_ITEM_KEY;
7364 nr_extent = 1;
7365 ret = get_new_locations(reloc_inode, &extent_key,
7366 group->key.objectid, 1,
7367 &new_extent, &nr_extent);
7368 if (ret > 0)
7369 continue;
7370 BUG_ON(ret < 0);
7371
7372 BUG_ON(ref->extents[ext_index].bytenr != bytenr);
7373 BUG_ON(ref->extents[ext_index].num_bytes != num_bytes);
7374 ref->extents[ext_index].bytenr = new_extent->disk_bytenr;
7375 ref->extents[ext_index].num_bytes = new_extent->disk_num_bytes;
7376
Zheng Yan1a40e232008-09-26 10:09:34 -04007377 btrfs_set_file_extent_disk_bytenr(leaf, fi,
7378 new_extent->disk_bytenr);
7379 btrfs_set_file_extent_disk_num_bytes(leaf, fi,
7380 new_extent->disk_num_bytes);
Zheng Yan1a40e232008-09-26 10:09:34 -04007381 btrfs_mark_buffer_dirty(leaf);
7382
7383 ret = btrfs_inc_extent_ref(trans, root,
7384 new_extent->disk_bytenr,
7385 new_extent->disk_num_bytes,
7386 leaf->start,
7387 root->root_key.objectid,
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04007388 trans->transid, key.objectid);
Zheng Yan1a40e232008-09-26 10:09:34 -04007389 BUG_ON(ret);
Chris Mason56bec292009-03-13 10:10:06 -04007390
Zheng Yan1a40e232008-09-26 10:09:34 -04007391 ret = btrfs_free_extent(trans, root,
7392 bytenr, num_bytes, leaf->start,
7393 btrfs_header_owner(leaf),
7394 btrfs_header_generation(leaf),
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04007395 key.objectid, 0);
Zheng Yan1a40e232008-09-26 10:09:34 -04007396 BUG_ON(ret);
7397 cond_resched();
7398 }
7399 kfree(new_extent);
7400 BUG_ON(ext_index + 1 != ref->nritems);
7401 btrfs_free_leaf_ref(root, ref);
7402 return 0;
7403}
7404
Yan Zhengf82d02d2008-10-29 14:49:05 -04007405int btrfs_free_reloc_root(struct btrfs_trans_handle *trans,
7406 struct btrfs_root *root)
Zheng Yan1a40e232008-09-26 10:09:34 -04007407{
7408 struct btrfs_root *reloc_root;
Yan Zhengf82d02d2008-10-29 14:49:05 -04007409 int ret;
Zheng Yan1a40e232008-09-26 10:09:34 -04007410
7411 if (root->reloc_root) {
7412 reloc_root = root->reloc_root;
7413 root->reloc_root = NULL;
7414 list_add(&reloc_root->dead_list,
7415 &root->fs_info->dead_reloc_roots);
Yan Zhengf82d02d2008-10-29 14:49:05 -04007416
7417 btrfs_set_root_bytenr(&reloc_root->root_item,
7418 reloc_root->node->start);
7419 btrfs_set_root_level(&root->root_item,
7420 btrfs_header_level(reloc_root->node));
7421 memset(&reloc_root->root_item.drop_progress, 0,
7422 sizeof(struct btrfs_disk_key));
7423 reloc_root->root_item.drop_level = 0;
7424
7425 ret = btrfs_update_root(trans, root->fs_info->tree_root,
7426 &reloc_root->root_key,
7427 &reloc_root->root_item);
7428 BUG_ON(ret);
Zheng Yan1a40e232008-09-26 10:09:34 -04007429 }
7430 return 0;
7431}
7432
7433int btrfs_drop_dead_reloc_roots(struct btrfs_root *root)
7434{
7435 struct btrfs_trans_handle *trans;
7436 struct btrfs_root *reloc_root;
7437 struct btrfs_root *prev_root = NULL;
7438 struct list_head dead_roots;
7439 int ret;
7440 unsigned long nr;
7441
7442 INIT_LIST_HEAD(&dead_roots);
7443 list_splice_init(&root->fs_info->dead_reloc_roots, &dead_roots);
7444
7445 while (!list_empty(&dead_roots)) {
7446 reloc_root = list_entry(dead_roots.prev,
7447 struct btrfs_root, dead_list);
7448 list_del_init(&reloc_root->dead_list);
7449
7450 BUG_ON(reloc_root->commit_root != NULL);
7451 while (1) {
7452 trans = btrfs_join_transaction(root, 1);
7453 BUG_ON(!trans);
7454
7455 mutex_lock(&root->fs_info->drop_mutex);
7456 ret = btrfs_drop_snapshot(trans, reloc_root);
7457 if (ret != -EAGAIN)
7458 break;
7459 mutex_unlock(&root->fs_info->drop_mutex);
7460
7461 nr = trans->blocks_used;
7462 ret = btrfs_end_transaction(trans, root);
7463 BUG_ON(ret);
7464 btrfs_btree_balance_dirty(root, nr);
7465 }
7466
7467 free_extent_buffer(reloc_root->node);
7468
7469 ret = btrfs_del_root(trans, root->fs_info->tree_root,
7470 &reloc_root->root_key);
7471 BUG_ON(ret);
7472 mutex_unlock(&root->fs_info->drop_mutex);
7473
7474 nr = trans->blocks_used;
7475 ret = btrfs_end_transaction(trans, root);
7476 BUG_ON(ret);
7477 btrfs_btree_balance_dirty(root, nr);
7478
7479 kfree(prev_root);
7480 prev_root = reloc_root;
7481 }
7482 if (prev_root) {
7483 btrfs_remove_leaf_refs(prev_root, (u64)-1, 0);
7484 kfree(prev_root);
7485 }
7486 return 0;
7487}
7488
7489int btrfs_add_dead_reloc_root(struct btrfs_root *root)
7490{
7491 list_add(&root->dead_list, &root->fs_info->dead_reloc_roots);
7492 return 0;
7493}
7494
7495int btrfs_cleanup_reloc_trees(struct btrfs_root *root)
7496{
7497 struct btrfs_root *reloc_root;
7498 struct btrfs_trans_handle *trans;
7499 struct btrfs_key location;
7500 int found;
7501 int ret;
7502
7503 mutex_lock(&root->fs_info->tree_reloc_mutex);
7504 ret = btrfs_find_dead_roots(root, BTRFS_TREE_RELOC_OBJECTID, NULL);
7505 BUG_ON(ret);
7506 found = !list_empty(&root->fs_info->dead_reloc_roots);
7507 mutex_unlock(&root->fs_info->tree_reloc_mutex);
7508
7509 if (found) {
7510 trans = btrfs_start_transaction(root, 1);
7511 BUG_ON(!trans);
7512 ret = btrfs_commit_transaction(trans, root);
7513 BUG_ON(ret);
7514 }
7515
7516 location.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
7517 location.offset = (u64)-1;
7518 location.type = BTRFS_ROOT_ITEM_KEY;
7519
7520 reloc_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
7521 BUG_ON(!reloc_root);
7522 btrfs_orphan_cleanup(reloc_root);
7523 return 0;
7524}
7525
Chris Masond3977122009-01-05 21:25:51 -05007526static noinline int init_reloc_tree(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007527 struct btrfs_root *root)
7528{
7529 struct btrfs_root *reloc_root;
7530 struct extent_buffer *eb;
7531 struct btrfs_root_item *root_item;
7532 struct btrfs_key root_key;
7533 int ret;
7534
7535 BUG_ON(!root->ref_cows);
7536 if (root->reloc_root)
7537 return 0;
7538
7539 root_item = kmalloc(sizeof(*root_item), GFP_NOFS);
7540 BUG_ON(!root_item);
7541
7542 ret = btrfs_copy_root(trans, root, root->commit_root,
7543 &eb, BTRFS_TREE_RELOC_OBJECTID);
7544 BUG_ON(ret);
7545
7546 root_key.objectid = BTRFS_TREE_RELOC_OBJECTID;
7547 root_key.offset = root->root_key.objectid;
7548 root_key.type = BTRFS_ROOT_ITEM_KEY;
7549
7550 memcpy(root_item, &root->root_item, sizeof(root_item));
7551 btrfs_set_root_refs(root_item, 0);
7552 btrfs_set_root_bytenr(root_item, eb->start);
7553 btrfs_set_root_level(root_item, btrfs_header_level(eb));
Yan Zheng84234f32008-10-29 14:49:05 -04007554 btrfs_set_root_generation(root_item, trans->transid);
Zheng Yan1a40e232008-09-26 10:09:34 -04007555
7556 btrfs_tree_unlock(eb);
7557 free_extent_buffer(eb);
7558
7559 ret = btrfs_insert_root(trans, root->fs_info->tree_root,
7560 &root_key, root_item);
7561 BUG_ON(ret);
7562 kfree(root_item);
7563
7564 reloc_root = btrfs_read_fs_root_no_radix(root->fs_info->tree_root,
7565 &root_key);
7566 BUG_ON(!reloc_root);
7567 reloc_root->last_trans = trans->transid;
7568 reloc_root->commit_root = NULL;
7569 reloc_root->ref_tree = &root->fs_info->reloc_ref_tree;
7570
7571 root->reloc_root = reloc_root;
7572 return 0;
7573}
7574
7575/*
7576 * Core function of space balance.
7577 *
7578 * The idea is using reloc trees to relocate tree blocks in reference
Yan Zhengf82d02d2008-10-29 14:49:05 -04007579 * counted roots. There is one reloc tree for each subvol, and all
7580 * reloc trees share same root key objectid. Reloc trees are snapshots
7581 * of the latest committed roots of subvols (root->commit_root).
7582 *
7583 * To relocate a tree block referenced by a subvol, there are two steps.
7584 * COW the block through subvol's reloc tree, then update block pointer
7585 * in the subvol to point to the new block. Since all reloc trees share
7586 * same root key objectid, doing special handing for tree blocks owned
7587 * by them is easy. Once a tree block has been COWed in one reloc tree,
7588 * we can use the resulting new block directly when the same block is
7589 * required to COW again through other reloc trees. By this way, relocated
7590 * tree blocks are shared between reloc trees, so they are also shared
7591 * between subvols.
Zheng Yan1a40e232008-09-26 10:09:34 -04007592 */
Chris Masond3977122009-01-05 21:25:51 -05007593static noinline int relocate_one_path(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007594 struct btrfs_root *root,
7595 struct btrfs_path *path,
7596 struct btrfs_key *first_key,
7597 struct btrfs_ref_path *ref_path,
7598 struct btrfs_block_group_cache *group,
7599 struct inode *reloc_inode)
7600{
7601 struct btrfs_root *reloc_root;
7602 struct extent_buffer *eb = NULL;
7603 struct btrfs_key *keys;
7604 u64 *nodes;
7605 int level;
Yan Zhengf82d02d2008-10-29 14:49:05 -04007606 int shared_level;
Zheng Yan1a40e232008-09-26 10:09:34 -04007607 int lowest_level = 0;
Zheng Yan1a40e232008-09-26 10:09:34 -04007608 int ret;
7609
7610 if (ref_path->owner_objectid < BTRFS_FIRST_FREE_OBJECTID)
7611 lowest_level = ref_path->owner_objectid;
7612
Yan Zhengf82d02d2008-10-29 14:49:05 -04007613 if (!root->ref_cows) {
Zheng Yan1a40e232008-09-26 10:09:34 -04007614 path->lowest_level = lowest_level;
7615 ret = btrfs_search_slot(trans, root, first_key, path, 0, 1);
7616 BUG_ON(ret < 0);
7617 path->lowest_level = 0;
7618 btrfs_release_path(root, path);
7619 return 0;
7620 }
7621
Zheng Yan1a40e232008-09-26 10:09:34 -04007622 mutex_lock(&root->fs_info->tree_reloc_mutex);
7623 ret = init_reloc_tree(trans, root);
7624 BUG_ON(ret);
7625 reloc_root = root->reloc_root;
7626
Yan Zhengf82d02d2008-10-29 14:49:05 -04007627 shared_level = ref_path->shared_level;
7628 ref_path->shared_level = BTRFS_MAX_LEVEL - 1;
Zheng Yan1a40e232008-09-26 10:09:34 -04007629
Yan Zhengf82d02d2008-10-29 14:49:05 -04007630 keys = ref_path->node_keys;
7631 nodes = ref_path->new_nodes;
7632 memset(&keys[shared_level + 1], 0,
7633 sizeof(*keys) * (BTRFS_MAX_LEVEL - shared_level - 1));
7634 memset(&nodes[shared_level + 1], 0,
7635 sizeof(*nodes) * (BTRFS_MAX_LEVEL - shared_level - 1));
Zheng Yan1a40e232008-09-26 10:09:34 -04007636
Yan Zhengf82d02d2008-10-29 14:49:05 -04007637 if (nodes[lowest_level] == 0) {
7638 path->lowest_level = lowest_level;
7639 ret = btrfs_search_slot(trans, reloc_root, first_key, path,
7640 0, 1);
7641 BUG_ON(ret);
7642 for (level = lowest_level; level < BTRFS_MAX_LEVEL; level++) {
7643 eb = path->nodes[level];
7644 if (!eb || eb == reloc_root->node)
7645 break;
7646 nodes[level] = eb->start;
7647 if (level == 0)
7648 btrfs_item_key_to_cpu(eb, &keys[level], 0);
7649 else
7650 btrfs_node_key_to_cpu(eb, &keys[level], 0);
7651 }
Yan Zheng2b820322008-11-17 21:11:30 -05007652 if (nodes[0] &&
7653 ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
Yan Zhengf82d02d2008-10-29 14:49:05 -04007654 eb = path->nodes[0];
7655 ret = replace_extents_in_leaf(trans, reloc_root, eb,
7656 group, reloc_inode);
7657 BUG_ON(ret);
7658 }
7659 btrfs_release_path(reloc_root, path);
7660 } else {
Zheng Yan1a40e232008-09-26 10:09:34 -04007661 ret = btrfs_merge_path(trans, reloc_root, keys, nodes,
Yan Zhengf82d02d2008-10-29 14:49:05 -04007662 lowest_level);
Zheng Yan1a40e232008-09-26 10:09:34 -04007663 BUG_ON(ret);
7664 }
7665
Zheng Yan1a40e232008-09-26 10:09:34 -04007666 /*
7667 * replace tree blocks in the fs tree with tree blocks in
7668 * the reloc tree.
7669 */
7670 ret = btrfs_merge_path(trans, root, keys, nodes, lowest_level);
7671 BUG_ON(ret < 0);
7672
7673 if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
Yan Zhengf82d02d2008-10-29 14:49:05 -04007674 ret = btrfs_search_slot(trans, reloc_root, first_key, path,
7675 0, 0);
7676 BUG_ON(ret);
7677 extent_buffer_get(path->nodes[0]);
7678 eb = path->nodes[0];
7679 btrfs_release_path(reloc_root, path);
Zheng Yan1a40e232008-09-26 10:09:34 -04007680 ret = invalidate_extent_cache(reloc_root, eb, group, root);
7681 BUG_ON(ret);
7682 free_extent_buffer(eb);
7683 }
Zheng Yan1a40e232008-09-26 10:09:34 -04007684
Yan Zhengf82d02d2008-10-29 14:49:05 -04007685 mutex_unlock(&root->fs_info->tree_reloc_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04007686 path->lowest_level = 0;
Zheng Yan1a40e232008-09-26 10:09:34 -04007687 return 0;
7688}
7689
Chris Masond3977122009-01-05 21:25:51 -05007690static noinline int relocate_tree_block(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007691 struct btrfs_root *root,
7692 struct btrfs_path *path,
7693 struct btrfs_key *first_key,
7694 struct btrfs_ref_path *ref_path)
7695{
7696 int ret;
Zheng Yan1a40e232008-09-26 10:09:34 -04007697
7698 ret = relocate_one_path(trans, root, path, first_key,
7699 ref_path, NULL, NULL);
7700 BUG_ON(ret);
7701
Zheng Yan1a40e232008-09-26 10:09:34 -04007702 return 0;
7703}
7704
Chris Masond3977122009-01-05 21:25:51 -05007705static noinline int del_extent_zero(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007706 struct btrfs_root *extent_root,
7707 struct btrfs_path *path,
7708 struct btrfs_key *extent_key)
7709{
7710 int ret;
7711
Zheng Yan1a40e232008-09-26 10:09:34 -04007712 ret = btrfs_search_slot(trans, extent_root, extent_key, path, -1, 1);
7713 if (ret)
7714 goto out;
7715 ret = btrfs_del_item(trans, extent_root, path);
7716out:
Chris Masonedbd8d42007-12-21 16:27:24 -05007717 btrfs_release_path(extent_root, path);
Zheng Yan1a40e232008-09-26 10:09:34 -04007718 return ret;
7719}
7720
Chris Masond3977122009-01-05 21:25:51 -05007721static noinline struct btrfs_root *read_ref_root(struct btrfs_fs_info *fs_info,
Zheng Yan1a40e232008-09-26 10:09:34 -04007722 struct btrfs_ref_path *ref_path)
7723{
7724 struct btrfs_key root_key;
7725
7726 root_key.objectid = ref_path->root_objectid;
7727 root_key.type = BTRFS_ROOT_ITEM_KEY;
7728 if (is_cowonly_root(ref_path->root_objectid))
7729 root_key.offset = 0;
7730 else
7731 root_key.offset = (u64)-1;
7732
7733 return btrfs_read_fs_root_no_name(fs_info, &root_key);
7734}
7735
Chris Masond3977122009-01-05 21:25:51 -05007736static noinline int relocate_one_extent(struct btrfs_root *extent_root,
Zheng Yan1a40e232008-09-26 10:09:34 -04007737 struct btrfs_path *path,
7738 struct btrfs_key *extent_key,
7739 struct btrfs_block_group_cache *group,
7740 struct inode *reloc_inode, int pass)
7741{
7742 struct btrfs_trans_handle *trans;
7743 struct btrfs_root *found_root;
7744 struct btrfs_ref_path *ref_path = NULL;
7745 struct disk_extent *new_extents = NULL;
7746 int nr_extents = 0;
7747 int loops;
7748 int ret;
7749 int level;
7750 struct btrfs_key first_key;
7751 u64 prev_block = 0;
7752
Zheng Yan1a40e232008-09-26 10:09:34 -04007753
7754 trans = btrfs_start_transaction(extent_root, 1);
7755 BUG_ON(!trans);
7756
7757 if (extent_key->objectid == 0) {
7758 ret = del_extent_zero(trans, extent_root, path, extent_key);
7759 goto out;
7760 }
7761
7762 ref_path = kmalloc(sizeof(*ref_path), GFP_NOFS);
7763 if (!ref_path) {
Chris Masond3977122009-01-05 21:25:51 -05007764 ret = -ENOMEM;
7765 goto out;
Zheng Yan1a40e232008-09-26 10:09:34 -04007766 }
7767
7768 for (loops = 0; ; loops++) {
7769 if (loops == 0) {
7770 ret = btrfs_first_ref_path(trans, extent_root, ref_path,
7771 extent_key->objectid);
7772 } else {
7773 ret = btrfs_next_ref_path(trans, extent_root, ref_path);
7774 }
7775 if (ret < 0)
7776 goto out;
7777 if (ret > 0)
7778 break;
7779
7780 if (ref_path->root_objectid == BTRFS_TREE_LOG_OBJECTID ||
7781 ref_path->root_objectid == BTRFS_TREE_RELOC_OBJECTID)
7782 continue;
7783
7784 found_root = read_ref_root(extent_root->fs_info, ref_path);
7785 BUG_ON(!found_root);
7786 /*
7787 * for reference counted tree, only process reference paths
7788 * rooted at the latest committed root.
7789 */
7790 if (found_root->ref_cows &&
7791 ref_path->root_generation != found_root->root_key.offset)
7792 continue;
7793
7794 if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
7795 if (pass == 0) {
7796 /*
7797 * copy data extents to new locations
7798 */
7799 u64 group_start = group->key.objectid;
7800 ret = relocate_data_extent(reloc_inode,
7801 extent_key,
7802 group_start);
7803 if (ret < 0)
7804 goto out;
7805 break;
7806 }
7807 level = 0;
7808 } else {
7809 level = ref_path->owner_objectid;
7810 }
7811
7812 if (prev_block != ref_path->nodes[level]) {
7813 struct extent_buffer *eb;
7814 u64 block_start = ref_path->nodes[level];
7815 u64 block_size = btrfs_level_size(found_root, level);
7816
7817 eb = read_tree_block(found_root, block_start,
7818 block_size, 0);
7819 btrfs_tree_lock(eb);
7820 BUG_ON(level != btrfs_header_level(eb));
7821
7822 if (level == 0)
7823 btrfs_item_key_to_cpu(eb, &first_key, 0);
7824 else
7825 btrfs_node_key_to_cpu(eb, &first_key, 0);
7826
7827 btrfs_tree_unlock(eb);
7828 free_extent_buffer(eb);
7829 prev_block = block_start;
7830 }
7831
Yan Zheng24562422009-02-12 14:14:53 -05007832 mutex_lock(&extent_root->fs_info->trans_mutex);
Yan Zhenge4404d62008-12-12 10:03:26 -05007833 btrfs_record_root_in_trans(found_root);
Yan Zheng24562422009-02-12 14:14:53 -05007834 mutex_unlock(&extent_root->fs_info->trans_mutex);
Yan Zhenge4404d62008-12-12 10:03:26 -05007835 if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
7836 /*
7837 * try to update data extent references while
7838 * keeping metadata shared between snapshots.
7839 */
7840 if (pass == 1) {
7841 ret = relocate_one_path(trans, found_root,
7842 path, &first_key, ref_path,
7843 group, reloc_inode);
7844 if (ret < 0)
7845 goto out;
7846 continue;
7847 }
Zheng Yan1a40e232008-09-26 10:09:34 -04007848 /*
7849 * use fallback method to process the remaining
7850 * references.
7851 */
7852 if (!new_extents) {
7853 u64 group_start = group->key.objectid;
Yan Zhengd899e052008-10-30 14:25:28 -04007854 new_extents = kmalloc(sizeof(*new_extents),
7855 GFP_NOFS);
7856 nr_extents = 1;
Zheng Yan1a40e232008-09-26 10:09:34 -04007857 ret = get_new_locations(reloc_inode,
7858 extent_key,
Yan Zhengd899e052008-10-30 14:25:28 -04007859 group_start, 1,
Zheng Yan1a40e232008-09-26 10:09:34 -04007860 &new_extents,
7861 &nr_extents);
Yan Zhengd899e052008-10-30 14:25:28 -04007862 if (ret)
Zheng Yan1a40e232008-09-26 10:09:34 -04007863 goto out;
7864 }
Zheng Yan1a40e232008-09-26 10:09:34 -04007865 ret = replace_one_extent(trans, found_root,
7866 path, extent_key,
7867 &first_key, ref_path,
7868 new_extents, nr_extents);
Yan Zhenge4404d62008-12-12 10:03:26 -05007869 } else {
Zheng Yan1a40e232008-09-26 10:09:34 -04007870 ret = relocate_tree_block(trans, found_root, path,
7871 &first_key, ref_path);
Zheng Yan1a40e232008-09-26 10:09:34 -04007872 }
7873 if (ret < 0)
7874 goto out;
7875 }
7876 ret = 0;
7877out:
7878 btrfs_end_transaction(trans, extent_root);
7879 kfree(new_extents);
7880 kfree(ref_path);
Chris Masonedbd8d42007-12-21 16:27:24 -05007881 return ret;
7882}
Yan Zheng5d4f98a2009-06-10 10:45:14 -04007883#endif
Chris Masonedbd8d42007-12-21 16:27:24 -05007884
Chris Masonec44a352008-04-28 15:29:52 -04007885static u64 update_block_group_flags(struct btrfs_root *root, u64 flags)
7886{
7887 u64 num_devices;
7888 u64 stripped = BTRFS_BLOCK_GROUP_RAID0 |
7889 BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10;
7890
Yan Zheng2b820322008-11-17 21:11:30 -05007891 num_devices = root->fs_info->fs_devices->rw_devices;
Chris Masonec44a352008-04-28 15:29:52 -04007892 if (num_devices == 1) {
7893 stripped |= BTRFS_BLOCK_GROUP_DUP;
7894 stripped = flags & ~stripped;
7895
7896 /* turn raid0 into single device chunks */
7897 if (flags & BTRFS_BLOCK_GROUP_RAID0)
7898 return stripped;
7899
7900 /* turn mirroring into duplication */
7901 if (flags & (BTRFS_BLOCK_GROUP_RAID1 |
7902 BTRFS_BLOCK_GROUP_RAID10))
7903 return stripped | BTRFS_BLOCK_GROUP_DUP;
7904 return flags;
7905 } else {
7906 /* they already had raid on here, just return */
Chris Masonec44a352008-04-28 15:29:52 -04007907 if (flags & stripped)
7908 return flags;
7909
7910 stripped |= BTRFS_BLOCK_GROUP_DUP;
7911 stripped = flags & ~stripped;
7912
7913 /* switch duplicated blocks with raid1 */
7914 if (flags & BTRFS_BLOCK_GROUP_DUP)
7915 return stripped | BTRFS_BLOCK_GROUP_RAID1;
7916
7917 /* turn single device chunks into raid0 */
7918 return stripped | BTRFS_BLOCK_GROUP_RAID0;
7919 }
7920 return flags;
7921}
7922
Yan, Zhengf0486c62010-05-16 10:46:25 -04007923static int set_block_group_ro(struct btrfs_block_group_cache *cache)
Chris Mason0ef3e662008-05-24 14:04:53 -04007924{
Yan, Zhengf0486c62010-05-16 10:46:25 -04007925 struct btrfs_space_info *sinfo = cache->space_info;
7926 u64 num_bytes;
7927 int ret = -ENOSPC;
Chris Mason0ef3e662008-05-24 14:04:53 -04007928
Yan, Zhengf0486c62010-05-16 10:46:25 -04007929 if (cache->ro)
7930 return 0;
Chris Masonc286ac42008-07-22 23:06:41 -04007931
Yan, Zhengf0486c62010-05-16 10:46:25 -04007932 spin_lock(&sinfo->lock);
7933 spin_lock(&cache->lock);
7934 num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7935 cache->bytes_super - btrfs_block_group_used(&cache->item);
Chris Mason7d9eb122008-07-08 14:19:17 -04007936
Yan, Zhengf0486c62010-05-16 10:46:25 -04007937 if (sinfo->bytes_used + sinfo->bytes_reserved + sinfo->bytes_pinned +
7938 sinfo->bytes_may_use + sinfo->bytes_readonly +
7939 cache->reserved_pinned + num_bytes < sinfo->total_bytes) {
7940 sinfo->bytes_readonly += num_bytes;
7941 sinfo->bytes_reserved += cache->reserved_pinned;
7942 cache->reserved_pinned = 0;
7943 cache->ro = 1;
7944 ret = 0;
7945 }
7946 spin_unlock(&cache->lock);
7947 spin_unlock(&sinfo->lock);
7948 return ret;
Chris Mason0ef3e662008-05-24 14:04:53 -04007949}
7950
Yan, Zhengf0486c62010-05-16 10:46:25 -04007951int btrfs_set_block_group_ro(struct btrfs_root *root,
7952 struct btrfs_block_group_cache *cache)
Yan Zheng5d4f98a2009-06-10 10:45:14 -04007953
7954{
Yan, Zhengf0486c62010-05-16 10:46:25 -04007955 struct btrfs_trans_handle *trans;
7956 u64 alloc_flags;
7957 int ret;
7958
7959 BUG_ON(cache->ro);
7960
7961 trans = btrfs_join_transaction(root, 1);
7962 BUG_ON(IS_ERR(trans));
7963
7964 alloc_flags = update_block_group_flags(root, cache->flags);
7965 if (alloc_flags != cache->flags)
7966 do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags, 1);
7967
7968 ret = set_block_group_ro(cache);
7969 if (!ret)
7970 goto out;
7971 alloc_flags = get_alloc_profile(root, cache->space_info->flags);
7972 ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags, 1);
7973 if (ret < 0)
7974 goto out;
7975 ret = set_block_group_ro(cache);
7976out:
7977 btrfs_end_transaction(trans, root);
7978 return ret;
7979}
7980
7981int btrfs_set_block_group_rw(struct btrfs_root *root,
7982 struct btrfs_block_group_cache *cache)
7983{
7984 struct btrfs_space_info *sinfo = cache->space_info;
7985 u64 num_bytes;
7986
7987 BUG_ON(!cache->ro);
7988
7989 spin_lock(&sinfo->lock);
7990 spin_lock(&cache->lock);
7991 num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7992 cache->bytes_super - btrfs_block_group_used(&cache->item);
7993 sinfo->bytes_readonly -= num_bytes;
7994 cache->ro = 0;
7995 spin_unlock(&cache->lock);
7996 spin_unlock(&sinfo->lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04007997 return 0;
7998}
7999
Josef Bacikba1bf482009-09-11 16:11:19 -04008000/*
8001 * checks to see if its even possible to relocate this block group.
8002 *
8003 * @return - -1 if it's not a good idea to relocate this block group, 0 if its
8004 * ok to go ahead and try.
8005 */
8006int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr)
Zheng Yan1a40e232008-09-26 10:09:34 -04008007{
Zheng Yan1a40e232008-09-26 10:09:34 -04008008 struct btrfs_block_group_cache *block_group;
Josef Bacikba1bf482009-09-11 16:11:19 -04008009 struct btrfs_space_info *space_info;
8010 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
8011 struct btrfs_device *device;
8012 int full = 0;
8013 int ret = 0;
Chris Masonedbd8d42007-12-21 16:27:24 -05008014
Josef Bacikba1bf482009-09-11 16:11:19 -04008015 block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
Zheng Yan1a40e232008-09-26 10:09:34 -04008016
Josef Bacikba1bf482009-09-11 16:11:19 -04008017 /* odd, couldn't find the block group, leave it alone */
8018 if (!block_group)
8019 return -1;
Chris Masonedbd8d42007-12-21 16:27:24 -05008020
Josef Bacikba1bf482009-09-11 16:11:19 -04008021 /* no bytes used, we're good */
8022 if (!btrfs_block_group_used(&block_group->item))
8023 goto out;
Chris Mason323da792008-05-09 11:46:48 -04008024
Josef Bacikba1bf482009-09-11 16:11:19 -04008025 space_info = block_group->space_info;
8026 spin_lock(&space_info->lock);
Chris Mason323da792008-05-09 11:46:48 -04008027
Josef Bacikba1bf482009-09-11 16:11:19 -04008028 full = space_info->full;
Zheng Yan1a40e232008-09-26 10:09:34 -04008029
Josef Bacikba1bf482009-09-11 16:11:19 -04008030 /*
8031 * if this is the last block group we have in this space, we can't
Chris Mason7ce618d2009-09-22 14:48:44 -04008032 * relocate it unless we're able to allocate a new chunk below.
8033 *
8034 * Otherwise, we need to make sure we have room in the space to handle
8035 * all of the extents from this block group. If we can, we're good
Josef Bacikba1bf482009-09-11 16:11:19 -04008036 */
Chris Mason7ce618d2009-09-22 14:48:44 -04008037 if ((space_info->total_bytes != block_group->key.offset) &&
8038 (space_info->bytes_used + space_info->bytes_reserved +
Josef Bacikba1bf482009-09-11 16:11:19 -04008039 space_info->bytes_pinned + space_info->bytes_readonly +
8040 btrfs_block_group_used(&block_group->item) <
Chris Mason7ce618d2009-09-22 14:48:44 -04008041 space_info->total_bytes)) {
Josef Bacikba1bf482009-09-11 16:11:19 -04008042 spin_unlock(&space_info->lock);
8043 goto out;
8044 }
8045 spin_unlock(&space_info->lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04008046
Josef Bacikba1bf482009-09-11 16:11:19 -04008047 /*
8048 * ok we don't have enough space, but maybe we have free space on our
8049 * devices to allocate new chunks for relocation, so loop through our
8050 * alloc devices and guess if we have enough space. However, if we
8051 * were marked as full, then we know there aren't enough chunks, and we
8052 * can just return.
8053 */
8054 ret = -1;
8055 if (full)
8056 goto out;
Chris Mason4313b392008-01-03 09:08:48 -05008057
Josef Bacikba1bf482009-09-11 16:11:19 -04008058 mutex_lock(&root->fs_info->chunk_mutex);
8059 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
8060 u64 min_free = btrfs_block_group_used(&block_group->item);
8061 u64 dev_offset, max_avail;
Chris Masonea8c2812008-08-04 23:17:27 -04008062
Josef Bacikba1bf482009-09-11 16:11:19 -04008063 /*
8064 * check to make sure we can actually find a chunk with enough
8065 * space to fit our block group in.
8066 */
8067 if (device->total_bytes > device->bytes_used + min_free) {
8068 ret = find_free_dev_extent(NULL, device, min_free,
8069 &dev_offset, &max_avail);
8070 if (!ret)
Yan73e48b22008-01-03 14:14:39 -05008071 break;
Josef Bacikba1bf482009-09-11 16:11:19 -04008072 ret = -1;
Yan73e48b22008-01-03 14:14:39 -05008073 }
Chris Masonedbd8d42007-12-21 16:27:24 -05008074 }
Josef Bacikba1bf482009-09-11 16:11:19 -04008075 mutex_unlock(&root->fs_info->chunk_mutex);
Chris Masonedbd8d42007-12-21 16:27:24 -05008076out:
Josef Bacikba1bf482009-09-11 16:11:19 -04008077 btrfs_put_block_group(block_group);
Chris Masonedbd8d42007-12-21 16:27:24 -05008078 return ret;
8079}
8080
Christoph Hellwigb2950862008-12-02 09:54:17 -05008081static int find_first_block_group(struct btrfs_root *root,
8082 struct btrfs_path *path, struct btrfs_key *key)
Chris Mason0b86a832008-03-24 15:01:56 -04008083{
Chris Mason925baed2008-06-25 16:01:30 -04008084 int ret = 0;
Chris Mason0b86a832008-03-24 15:01:56 -04008085 struct btrfs_key found_key;
8086 struct extent_buffer *leaf;
8087 int slot;
8088
8089 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
8090 if (ret < 0)
Chris Mason925baed2008-06-25 16:01:30 -04008091 goto out;
8092
Chris Masond3977122009-01-05 21:25:51 -05008093 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -04008094 slot = path->slots[0];
8095 leaf = path->nodes[0];
8096 if (slot >= btrfs_header_nritems(leaf)) {
8097 ret = btrfs_next_leaf(root, path);
8098 if (ret == 0)
8099 continue;
8100 if (ret < 0)
Chris Mason925baed2008-06-25 16:01:30 -04008101 goto out;
Chris Mason0b86a832008-03-24 15:01:56 -04008102 break;
8103 }
8104 btrfs_item_key_to_cpu(leaf, &found_key, slot);
8105
8106 if (found_key.objectid >= key->objectid &&
Chris Mason925baed2008-06-25 16:01:30 -04008107 found_key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
8108 ret = 0;
8109 goto out;
8110 }
Chris Mason0b86a832008-03-24 15:01:56 -04008111 path->slots[0]++;
8112 }
Chris Mason925baed2008-06-25 16:01:30 -04008113out:
Chris Mason0b86a832008-03-24 15:01:56 -04008114 return ret;
8115}
8116
Josef Bacik0af3d002010-06-21 14:48:16 -04008117void btrfs_put_block_group_cache(struct btrfs_fs_info *info)
8118{
8119 struct btrfs_block_group_cache *block_group;
8120 u64 last = 0;
8121
8122 while (1) {
8123 struct inode *inode;
8124
8125 block_group = btrfs_lookup_first_block_group(info, last);
8126 while (block_group) {
8127 spin_lock(&block_group->lock);
8128 if (block_group->iref)
8129 break;
8130 spin_unlock(&block_group->lock);
8131 block_group = next_block_group(info->tree_root,
8132 block_group);
8133 }
8134 if (!block_group) {
8135 if (last == 0)
8136 break;
8137 last = 0;
8138 continue;
8139 }
8140
8141 inode = block_group->inode;
8142 block_group->iref = 0;
8143 block_group->inode = NULL;
8144 spin_unlock(&block_group->lock);
8145 iput(inode);
8146 last = block_group->key.objectid + block_group->key.offset;
8147 btrfs_put_block_group(block_group);
8148 }
8149}
8150
Zheng Yan1a40e232008-09-26 10:09:34 -04008151int btrfs_free_block_groups(struct btrfs_fs_info *info)
8152{
8153 struct btrfs_block_group_cache *block_group;
Chris Mason4184ea72009-03-10 12:39:20 -04008154 struct btrfs_space_info *space_info;
Yan Zheng11833d62009-09-11 16:11:19 -04008155 struct btrfs_caching_control *caching_ctl;
Zheng Yan1a40e232008-09-26 10:09:34 -04008156 struct rb_node *n;
8157
Yan Zheng11833d62009-09-11 16:11:19 -04008158 down_write(&info->extent_commit_sem);
8159 while (!list_empty(&info->caching_block_groups)) {
8160 caching_ctl = list_entry(info->caching_block_groups.next,
8161 struct btrfs_caching_control, list);
8162 list_del(&caching_ctl->list);
8163 put_caching_control(caching_ctl);
8164 }
8165 up_write(&info->extent_commit_sem);
8166
Zheng Yan1a40e232008-09-26 10:09:34 -04008167 spin_lock(&info->block_group_cache_lock);
8168 while ((n = rb_last(&info->block_group_cache_tree)) != NULL) {
8169 block_group = rb_entry(n, struct btrfs_block_group_cache,
8170 cache_node);
Zheng Yan1a40e232008-09-26 10:09:34 -04008171 rb_erase(&block_group->cache_node,
8172 &info->block_group_cache_tree);
Yan Zhengd899e052008-10-30 14:25:28 -04008173 spin_unlock(&info->block_group_cache_lock);
8174
Josef Bacik80eb2342008-10-29 14:49:05 -04008175 down_write(&block_group->space_info->groups_sem);
Zheng Yan1a40e232008-09-26 10:09:34 -04008176 list_del(&block_group->list);
Josef Bacik80eb2342008-10-29 14:49:05 -04008177 up_write(&block_group->space_info->groups_sem);
Yan Zhengd2fb3432008-12-11 16:30:39 -05008178
Josef Bacik817d52f2009-07-13 21:29:25 -04008179 if (block_group->cached == BTRFS_CACHE_STARTED)
Yan Zheng11833d62009-09-11 16:11:19 -04008180 wait_block_group_cache_done(block_group);
Josef Bacik817d52f2009-07-13 21:29:25 -04008181
8182 btrfs_remove_free_space_cache(block_group);
Josef Bacik11dfe352009-11-13 20:12:59 +00008183 btrfs_put_block_group(block_group);
Yan Zhengd899e052008-10-30 14:25:28 -04008184
8185 spin_lock(&info->block_group_cache_lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04008186 }
8187 spin_unlock(&info->block_group_cache_lock);
Chris Mason4184ea72009-03-10 12:39:20 -04008188
8189 /* now that all the block groups are freed, go through and
8190 * free all the space_info structs. This is only called during
8191 * the final stages of unmount, and so we know nobody is
8192 * using them. We call synchronize_rcu() once before we start,
8193 * just to be on the safe side.
8194 */
8195 synchronize_rcu();
8196
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04008197 release_global_block_rsv(info);
8198
Chris Mason4184ea72009-03-10 12:39:20 -04008199 while(!list_empty(&info->space_info)) {
8200 space_info = list_entry(info->space_info.next,
8201 struct btrfs_space_info,
8202 list);
Yan, Zhengf0486c62010-05-16 10:46:25 -04008203 if (space_info->bytes_pinned > 0 ||
8204 space_info->bytes_reserved > 0) {
8205 WARN_ON(1);
8206 dump_space_info(space_info, 0, 0);
8207 }
Chris Mason4184ea72009-03-10 12:39:20 -04008208 list_del(&space_info->list);
8209 kfree(space_info);
8210 }
Zheng Yan1a40e232008-09-26 10:09:34 -04008211 return 0;
8212}
8213
Yan, Zhengb742bb82010-05-16 10:46:24 -04008214static void __link_block_group(struct btrfs_space_info *space_info,
8215 struct btrfs_block_group_cache *cache)
8216{
8217 int index = get_block_group_index(cache);
8218
8219 down_write(&space_info->groups_sem);
8220 list_add_tail(&cache->list, &space_info->block_groups[index]);
8221 up_write(&space_info->groups_sem);
8222}
8223
Chris Mason9078a3e2007-04-26 16:46:15 -04008224int btrfs_read_block_groups(struct btrfs_root *root)
8225{
8226 struct btrfs_path *path;
8227 int ret;
Chris Mason9078a3e2007-04-26 16:46:15 -04008228 struct btrfs_block_group_cache *cache;
Chris Masonbe744172007-05-06 10:15:01 -04008229 struct btrfs_fs_info *info = root->fs_info;
Chris Mason6324fbf2008-03-24 15:01:59 -04008230 struct btrfs_space_info *space_info;
Chris Mason9078a3e2007-04-26 16:46:15 -04008231 struct btrfs_key key;
8232 struct btrfs_key found_key;
Chris Mason5f39d392007-10-15 16:14:19 -04008233 struct extent_buffer *leaf;
Josef Bacik0af3d002010-06-21 14:48:16 -04008234 int need_clear = 0;
8235 u64 cache_gen;
Chris Mason96b51792007-10-15 16:15:19 -04008236
Chris Masonbe744172007-05-06 10:15:01 -04008237 root = info->extent_root;
Chris Mason9078a3e2007-04-26 16:46:15 -04008238 key.objectid = 0;
Chris Mason0b86a832008-03-24 15:01:56 -04008239 key.offset = 0;
Chris Mason9078a3e2007-04-26 16:46:15 -04008240 btrfs_set_key_type(&key, BTRFS_BLOCK_GROUP_ITEM_KEY);
Chris Mason9078a3e2007-04-26 16:46:15 -04008241 path = btrfs_alloc_path();
8242 if (!path)
8243 return -ENOMEM;
8244
Josef Bacik0af3d002010-06-21 14:48:16 -04008245 cache_gen = btrfs_super_cache_generation(&root->fs_info->super_copy);
8246 if (cache_gen != 0 &&
8247 btrfs_super_generation(&root->fs_info->super_copy) != cache_gen)
8248 need_clear = 1;
Josef Bacik88c2ba32010-09-21 14:21:34 -04008249 if (btrfs_test_opt(root, CLEAR_CACHE))
8250 need_clear = 1;
Josef Bacik8216ef82010-10-28 16:55:47 -04008251 if (!btrfs_test_opt(root, SPACE_CACHE) && cache_gen)
8252 printk(KERN_INFO "btrfs: disk space caching is enabled\n");
Josef Bacik0af3d002010-06-21 14:48:16 -04008253
Chris Masond3977122009-01-05 21:25:51 -05008254 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -04008255 ret = find_first_block_group(root, path, &key);
Yan, Zhengb742bb82010-05-16 10:46:24 -04008256 if (ret > 0)
8257 break;
Chris Mason0b86a832008-03-24 15:01:56 -04008258 if (ret != 0)
8259 goto error;
8260
Chris Mason5f39d392007-10-15 16:14:19 -04008261 leaf = path->nodes[0];
8262 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
Chris Mason8f18cf12008-04-25 16:53:30 -04008263 cache = kzalloc(sizeof(*cache), GFP_NOFS);
Chris Mason9078a3e2007-04-26 16:46:15 -04008264 if (!cache) {
Chris Mason0b86a832008-03-24 15:01:56 -04008265 ret = -ENOMEM;
Yan, Zhengf0486c62010-05-16 10:46:25 -04008266 goto error;
Chris Mason9078a3e2007-04-26 16:46:15 -04008267 }
Chris Mason3e1ad542007-05-07 20:03:49 -04008268
Yan Zhengd2fb3432008-12-11 16:30:39 -05008269 atomic_set(&cache->count, 1);
Chris Masonc286ac42008-07-22 23:06:41 -04008270 spin_lock_init(&cache->lock);
Josef Bacik6226cb02009-04-03 10:14:18 -04008271 spin_lock_init(&cache->tree_lock);
Josef Bacik817d52f2009-07-13 21:29:25 -04008272 cache->fs_info = info;
Josef Bacik0f9dd462008-09-23 13:14:11 -04008273 INIT_LIST_HEAD(&cache->list);
Chris Masonfa9c0d72009-04-03 09:47:43 -04008274 INIT_LIST_HEAD(&cache->cluster_list);
Josef Bacik96303082009-07-13 21:29:25 -04008275
Josef Bacik0af3d002010-06-21 14:48:16 -04008276 if (need_clear)
8277 cache->disk_cache_state = BTRFS_DC_CLEAR;
8278
Josef Bacik96303082009-07-13 21:29:25 -04008279 /*
8280 * we only want to have 32k of ram per block group for keeping
8281 * track of free space, and if we pass 1/2 of that we want to
8282 * start converting things over to using bitmaps
8283 */
8284 cache->extents_thresh = ((1024 * 32) / 2) /
8285 sizeof(struct btrfs_free_space);
8286
Chris Mason5f39d392007-10-15 16:14:19 -04008287 read_extent_buffer(leaf, &cache->item,
8288 btrfs_item_ptr_offset(leaf, path->slots[0]),
8289 sizeof(cache->item));
Chris Mason9078a3e2007-04-26 16:46:15 -04008290 memcpy(&cache->key, &found_key, sizeof(found_key));
Chris Mason0b86a832008-03-24 15:01:56 -04008291
Chris Mason9078a3e2007-04-26 16:46:15 -04008292 key.objectid = found_key.objectid + found_key.offset;
8293 btrfs_release_path(root, path);
Chris Mason0b86a832008-03-24 15:01:56 -04008294 cache->flags = btrfs_block_group_flags(&cache->item);
Josef Bacik817d52f2009-07-13 21:29:25 -04008295 cache->sectorsize = root->sectorsize;
8296
Josef Bacik817d52f2009-07-13 21:29:25 -04008297 /*
8298 * check for two cases, either we are full, and therefore
8299 * don't need to bother with the caching work since we won't
8300 * find any space, or we are empty, and we can just add all
8301 * the space in and be done with it. This saves us _alot_ of
8302 * time, particularly in the full case.
8303 */
8304 if (found_key.offset == btrfs_block_group_used(&cache->item)) {
Josef Bacik1b2da372009-09-11 16:11:20 -04008305 exclude_super_stripes(root, cache);
Yan Zheng11833d62009-09-11 16:11:19 -04008306 cache->last_byte_to_unpin = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -04008307 cache->cached = BTRFS_CACHE_FINISHED;
Josef Bacik1b2da372009-09-11 16:11:20 -04008308 free_excluded_extents(root, cache);
Josef Bacik817d52f2009-07-13 21:29:25 -04008309 } else if (btrfs_block_group_used(&cache->item) == 0) {
Yan Zheng11833d62009-09-11 16:11:19 -04008310 exclude_super_stripes(root, cache);
8311 cache->last_byte_to_unpin = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -04008312 cache->cached = BTRFS_CACHE_FINISHED;
8313 add_new_free_space(cache, root->fs_info,
8314 found_key.objectid,
8315 found_key.objectid +
8316 found_key.offset);
Yan Zheng11833d62009-09-11 16:11:19 -04008317 free_excluded_extents(root, cache);
Josef Bacik817d52f2009-07-13 21:29:25 -04008318 }
Chris Mason96b51792007-10-15 16:15:19 -04008319
Chris Mason6324fbf2008-03-24 15:01:59 -04008320 ret = update_space_info(info, cache->flags, found_key.offset,
8321 btrfs_block_group_used(&cache->item),
8322 &space_info);
8323 BUG_ON(ret);
8324 cache->space_info = space_info;
Josef Bacik1b2da372009-09-11 16:11:20 -04008325 spin_lock(&cache->space_info->lock);
Yan, Zhengf0486c62010-05-16 10:46:25 -04008326 cache->space_info->bytes_readonly += cache->bytes_super;
Josef Bacik1b2da372009-09-11 16:11:20 -04008327 spin_unlock(&cache->space_info->lock);
8328
Yan, Zhengb742bb82010-05-16 10:46:24 -04008329 __link_block_group(space_info, cache);
Chris Mason6324fbf2008-03-24 15:01:59 -04008330
Josef Bacik0f9dd462008-09-23 13:14:11 -04008331 ret = btrfs_add_block_group_cache(root->fs_info, cache);
8332 BUG_ON(ret);
Chris Mason75ccf472008-09-30 19:24:06 -04008333
8334 set_avail_alloc_bits(root->fs_info, cache->flags);
Yan Zheng2b820322008-11-17 21:11:30 -05008335 if (btrfs_chunk_readonly(root, cache->key.objectid))
Yan, Zhengf0486c62010-05-16 10:46:25 -04008336 set_block_group_ro(cache);
Chris Mason9078a3e2007-04-26 16:46:15 -04008337 }
Yan, Zhengb742bb82010-05-16 10:46:24 -04008338
8339 list_for_each_entry_rcu(space_info, &root->fs_info->space_info, list) {
8340 if (!(get_alloc_profile(root, space_info->flags) &
8341 (BTRFS_BLOCK_GROUP_RAID10 |
8342 BTRFS_BLOCK_GROUP_RAID1 |
8343 BTRFS_BLOCK_GROUP_DUP)))
8344 continue;
8345 /*
8346 * avoid allocating from un-mirrored block group if there are
8347 * mirrored block groups.
8348 */
8349 list_for_each_entry(cache, &space_info->block_groups[3], list)
Yan, Zhengf0486c62010-05-16 10:46:25 -04008350 set_block_group_ro(cache);
Yan, Zhengb742bb82010-05-16 10:46:24 -04008351 list_for_each_entry(cache, &space_info->block_groups[4], list)
Yan, Zhengf0486c62010-05-16 10:46:25 -04008352 set_block_group_ro(cache);
Yan, Zhengb742bb82010-05-16 10:46:24 -04008353 }
Yan, Zhengf0486c62010-05-16 10:46:25 -04008354
8355 init_global_block_rsv(info);
Chris Mason0b86a832008-03-24 15:01:56 -04008356 ret = 0;
8357error:
Chris Mason9078a3e2007-04-26 16:46:15 -04008358 btrfs_free_path(path);
Chris Mason0b86a832008-03-24 15:01:56 -04008359 return ret;
Chris Mason9078a3e2007-04-26 16:46:15 -04008360}
Chris Mason6324fbf2008-03-24 15:01:59 -04008361
8362int btrfs_make_block_group(struct btrfs_trans_handle *trans,
8363 struct btrfs_root *root, u64 bytes_used,
Chris Masone17cade2008-04-15 15:41:47 -04008364 u64 type, u64 chunk_objectid, u64 chunk_offset,
Chris Mason6324fbf2008-03-24 15:01:59 -04008365 u64 size)
8366{
8367 int ret;
Chris Mason6324fbf2008-03-24 15:01:59 -04008368 struct btrfs_root *extent_root;
8369 struct btrfs_block_group_cache *cache;
Chris Mason6324fbf2008-03-24 15:01:59 -04008370
8371 extent_root = root->fs_info->extent_root;
Chris Mason6324fbf2008-03-24 15:01:59 -04008372
Chris Mason12fcfd22009-03-24 10:24:20 -04008373 root->fs_info->last_trans_log_full_commit = trans->transid;
Chris Masone02119d2008-09-05 16:13:11 -04008374
Chris Mason8f18cf12008-04-25 16:53:30 -04008375 cache = kzalloc(sizeof(*cache), GFP_NOFS);
Josef Bacik0f9dd462008-09-23 13:14:11 -04008376 if (!cache)
8377 return -ENOMEM;
8378
Chris Masone17cade2008-04-15 15:41:47 -04008379 cache->key.objectid = chunk_offset;
Chris Mason6324fbf2008-03-24 15:01:59 -04008380 cache->key.offset = size;
Yan Zhengd2fb3432008-12-11 16:30:39 -05008381 cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
Josef Bacik96303082009-07-13 21:29:25 -04008382 cache->sectorsize = root->sectorsize;
Josef Bacik0af3d002010-06-21 14:48:16 -04008383 cache->fs_info = root->fs_info;
Josef Bacik96303082009-07-13 21:29:25 -04008384
8385 /*
8386 * we only want to have 32k of ram per block group for keeping track
8387 * of free space, and if we pass 1/2 of that we want to start
8388 * converting things over to using bitmaps
8389 */
8390 cache->extents_thresh = ((1024 * 32) / 2) /
8391 sizeof(struct btrfs_free_space);
Yan Zhengd2fb3432008-12-11 16:30:39 -05008392 atomic_set(&cache->count, 1);
Chris Masonc286ac42008-07-22 23:06:41 -04008393 spin_lock_init(&cache->lock);
Josef Bacik6226cb02009-04-03 10:14:18 -04008394 spin_lock_init(&cache->tree_lock);
Josef Bacik0f9dd462008-09-23 13:14:11 -04008395 INIT_LIST_HEAD(&cache->list);
Chris Masonfa9c0d72009-04-03 09:47:43 -04008396 INIT_LIST_HEAD(&cache->cluster_list);
Chris Mason0ef3e662008-05-24 14:04:53 -04008397
Chris Mason6324fbf2008-03-24 15:01:59 -04008398 btrfs_set_block_group_used(&cache->item, bytes_used);
Chris Mason6324fbf2008-03-24 15:01:59 -04008399 btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);
8400 cache->flags = type;
8401 btrfs_set_block_group_flags(&cache->item, type);
8402
Yan Zheng11833d62009-09-11 16:11:19 -04008403 cache->last_byte_to_unpin = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -04008404 cache->cached = BTRFS_CACHE_FINISHED;
Yan Zheng11833d62009-09-11 16:11:19 -04008405 exclude_super_stripes(root, cache);
Josef Bacik96303082009-07-13 21:29:25 -04008406
Josef Bacik817d52f2009-07-13 21:29:25 -04008407 add_new_free_space(cache, root->fs_info, chunk_offset,
8408 chunk_offset + size);
8409
Yan Zheng11833d62009-09-11 16:11:19 -04008410 free_excluded_extents(root, cache);
8411
Chris Mason6324fbf2008-03-24 15:01:59 -04008412 ret = update_space_info(root->fs_info, cache->flags, size, bytes_used,
8413 &cache->space_info);
8414 BUG_ON(ret);
Josef Bacik1b2da372009-09-11 16:11:20 -04008415
8416 spin_lock(&cache->space_info->lock);
Yan, Zhengf0486c62010-05-16 10:46:25 -04008417 cache->space_info->bytes_readonly += cache->bytes_super;
Josef Bacik1b2da372009-09-11 16:11:20 -04008418 spin_unlock(&cache->space_info->lock);
8419
Yan, Zhengb742bb82010-05-16 10:46:24 -04008420 __link_block_group(cache->space_info, cache);
Chris Mason6324fbf2008-03-24 15:01:59 -04008421
Josef Bacik0f9dd462008-09-23 13:14:11 -04008422 ret = btrfs_add_block_group_cache(root->fs_info, cache);
8423 BUG_ON(ret);
Chris Masonc286ac42008-07-22 23:06:41 -04008424
Chris Mason6324fbf2008-03-24 15:01:59 -04008425 ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item,
8426 sizeof(cache->item));
8427 BUG_ON(ret);
8428
Chris Masond18a2c42008-04-04 15:40:00 -04008429 set_avail_alloc_bits(extent_root->fs_info, type);
Chris Mason925baed2008-06-25 16:01:30 -04008430
Chris Mason6324fbf2008-03-24 15:01:59 -04008431 return 0;
8432}
Zheng Yan1a40e232008-09-26 10:09:34 -04008433
8434int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
8435 struct btrfs_root *root, u64 group_start)
8436{
8437 struct btrfs_path *path;
8438 struct btrfs_block_group_cache *block_group;
Chris Mason44fb5512009-06-04 15:34:51 -04008439 struct btrfs_free_cluster *cluster;
Josef Bacik0af3d002010-06-21 14:48:16 -04008440 struct btrfs_root *tree_root = root->fs_info->tree_root;
Zheng Yan1a40e232008-09-26 10:09:34 -04008441 struct btrfs_key key;
Josef Bacik0af3d002010-06-21 14:48:16 -04008442 struct inode *inode;
Zheng Yan1a40e232008-09-26 10:09:34 -04008443 int ret;
Josef Bacik89a55892010-10-14 14:52:27 -04008444 int factor;
Zheng Yan1a40e232008-09-26 10:09:34 -04008445
Zheng Yan1a40e232008-09-26 10:09:34 -04008446 root = root->fs_info->extent_root;
8447
8448 block_group = btrfs_lookup_block_group(root->fs_info, group_start);
8449 BUG_ON(!block_group);
Yan Zhengc146afa2008-11-12 14:34:12 -05008450 BUG_ON(!block_group->ro);
Zheng Yan1a40e232008-09-26 10:09:34 -04008451
8452 memcpy(&key, &block_group->key, sizeof(key));
Josef Bacik89a55892010-10-14 14:52:27 -04008453 if (block_group->flags & (BTRFS_BLOCK_GROUP_DUP |
8454 BTRFS_BLOCK_GROUP_RAID1 |
8455 BTRFS_BLOCK_GROUP_RAID10))
8456 factor = 2;
8457 else
8458 factor = 1;
Zheng Yan1a40e232008-09-26 10:09:34 -04008459
Chris Mason44fb5512009-06-04 15:34:51 -04008460 /* make sure this block group isn't part of an allocation cluster */
8461 cluster = &root->fs_info->data_alloc_cluster;
8462 spin_lock(&cluster->refill_lock);
8463 btrfs_return_cluster_to_free_space(block_group, cluster);
8464 spin_unlock(&cluster->refill_lock);
8465
8466 /*
8467 * make sure this block group isn't part of a metadata
8468 * allocation cluster
8469 */
8470 cluster = &root->fs_info->meta_alloc_cluster;
8471 spin_lock(&cluster->refill_lock);
8472 btrfs_return_cluster_to_free_space(block_group, cluster);
8473 spin_unlock(&cluster->refill_lock);
8474
Zheng Yan1a40e232008-09-26 10:09:34 -04008475 path = btrfs_alloc_path();
8476 BUG_ON(!path);
8477
Josef Bacik0af3d002010-06-21 14:48:16 -04008478 inode = lookup_free_space_inode(root, block_group, path);
8479 if (!IS_ERR(inode)) {
8480 btrfs_orphan_add(trans, inode);
8481 clear_nlink(inode);
8482 /* One for the block groups ref */
8483 spin_lock(&block_group->lock);
8484 if (block_group->iref) {
8485 block_group->iref = 0;
8486 block_group->inode = NULL;
8487 spin_unlock(&block_group->lock);
8488 iput(inode);
8489 } else {
8490 spin_unlock(&block_group->lock);
8491 }
8492 /* One for our lookup ref */
8493 iput(inode);
8494 }
8495
8496 key.objectid = BTRFS_FREE_SPACE_OBJECTID;
8497 key.offset = block_group->key.objectid;
8498 key.type = 0;
8499
8500 ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
8501 if (ret < 0)
8502 goto out;
8503 if (ret > 0)
8504 btrfs_release_path(tree_root, path);
8505 if (ret == 0) {
8506 ret = btrfs_del_item(trans, tree_root, path);
8507 if (ret)
8508 goto out;
8509 btrfs_release_path(tree_root, path);
8510 }
8511
Yan Zheng3dfdb932009-01-21 10:49:16 -05008512 spin_lock(&root->fs_info->block_group_cache_lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04008513 rb_erase(&block_group->cache_node,
8514 &root->fs_info->block_group_cache_tree);
Yan Zheng3dfdb932009-01-21 10:49:16 -05008515 spin_unlock(&root->fs_info->block_group_cache_lock);
Josef Bacik817d52f2009-07-13 21:29:25 -04008516
Josef Bacik80eb2342008-10-29 14:49:05 -04008517 down_write(&block_group->space_info->groups_sem);
Chris Mason44fb5512009-06-04 15:34:51 -04008518 /*
8519 * we must use list_del_init so people can check to see if they
8520 * are still on the list after taking the semaphore
8521 */
8522 list_del_init(&block_group->list);
Josef Bacik80eb2342008-10-29 14:49:05 -04008523 up_write(&block_group->space_info->groups_sem);
Zheng Yan1a40e232008-09-26 10:09:34 -04008524
Josef Bacik817d52f2009-07-13 21:29:25 -04008525 if (block_group->cached == BTRFS_CACHE_STARTED)
Yan Zheng11833d62009-09-11 16:11:19 -04008526 wait_block_group_cache_done(block_group);
Josef Bacik817d52f2009-07-13 21:29:25 -04008527
8528 btrfs_remove_free_space_cache(block_group);
8529
Yan Zhengc146afa2008-11-12 14:34:12 -05008530 spin_lock(&block_group->space_info->lock);
8531 block_group->space_info->total_bytes -= block_group->key.offset;
8532 block_group->space_info->bytes_readonly -= block_group->key.offset;
Josef Bacik89a55892010-10-14 14:52:27 -04008533 block_group->space_info->disk_total -= block_group->key.offset * factor;
Yan Zhengc146afa2008-11-12 14:34:12 -05008534 spin_unlock(&block_group->space_info->lock);
Chris Mason283bb192009-07-24 16:30:55 -04008535
Josef Bacik0af3d002010-06-21 14:48:16 -04008536 memcpy(&key, &block_group->key, sizeof(key));
8537
Chris Mason283bb192009-07-24 16:30:55 -04008538 btrfs_clear_space_info_full(root->fs_info);
Yan Zhengc146afa2008-11-12 14:34:12 -05008539
Chris Masonfa9c0d72009-04-03 09:47:43 -04008540 btrfs_put_block_group(block_group);
8541 btrfs_put_block_group(block_group);
Zheng Yan1a40e232008-09-26 10:09:34 -04008542
8543 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
8544 if (ret > 0)
8545 ret = -EIO;
8546 if (ret < 0)
8547 goto out;
8548
8549 ret = btrfs_del_item(trans, root, path);
8550out:
8551 btrfs_free_path(path);
8552 return ret;
8553}