blob: 2846cebc94273acb373e83e85ac313d78f260e2e [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
245 ctl = cache->caching_ctl;
246 atomic_inc(&ctl->count);
247 spin_unlock(&cache->lock);
248 return ctl;
249}
250
251static void put_caching_control(struct btrfs_caching_control *ctl)
252{
253 if (atomic_dec_and_test(&ctl->count))
254 kfree(ctl);
255}
256
Josef Bacik0f9dd462008-09-23 13:14:11 -0400257/*
258 * this is only called by cache_block_group, since we could have freed extents
259 * we need to check the pinned_extents for any extents that can't be used yet
260 * since their free space will be released as soon as the transaction commits.
261 */
Josef Bacik817d52f2009-07-13 21:29:25 -0400262static u64 add_new_free_space(struct btrfs_block_group_cache *block_group,
Josef Bacik0f9dd462008-09-23 13:14:11 -0400263 struct btrfs_fs_info *info, u64 start, u64 end)
264{
Josef Bacik817d52f2009-07-13 21:29:25 -0400265 u64 extent_start, extent_end, size, total_added = 0;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400266 int ret;
267
268 while (start < end) {
Yan Zheng11833d62009-09-11 16:11:19 -0400269 ret = find_first_extent_bit(info->pinned_extents, start,
Josef Bacik0f9dd462008-09-23 13:14:11 -0400270 &extent_start, &extent_end,
Yan Zheng11833d62009-09-11 16:11:19 -0400271 EXTENT_DIRTY | EXTENT_UPTODATE);
Josef Bacik0f9dd462008-09-23 13:14:11 -0400272 if (ret)
273 break;
274
Yan, Zheng06b23312009-11-26 09:31:11 +0000275 if (extent_start <= start) {
Josef Bacik0f9dd462008-09-23 13:14:11 -0400276 start = extent_end + 1;
277 } else if (extent_start > start && extent_start < end) {
278 size = extent_start - start;
Josef Bacik817d52f2009-07-13 21:29:25 -0400279 total_added += size;
Josef Bacikea6a4782008-11-20 12:16:16 -0500280 ret = btrfs_add_free_space(block_group, start,
281 size);
Josef Bacik0f9dd462008-09-23 13:14:11 -0400282 BUG_ON(ret);
283 start = extent_end + 1;
284 } else {
285 break;
286 }
287 }
288
289 if (start < end) {
290 size = end - start;
Josef Bacik817d52f2009-07-13 21:29:25 -0400291 total_added += size;
Josef Bacikea6a4782008-11-20 12:16:16 -0500292 ret = btrfs_add_free_space(block_group, start, size);
Josef Bacik0f9dd462008-09-23 13:14:11 -0400293 BUG_ON(ret);
294 }
295
Josef Bacik817d52f2009-07-13 21:29:25 -0400296 return total_added;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400297}
298
Josef Bacik817d52f2009-07-13 21:29:25 -0400299static int caching_kthread(void *data)
Chris Masone37c9e62007-05-09 20:13:14 -0400300{
Josef Bacik817d52f2009-07-13 21:29:25 -0400301 struct btrfs_block_group_cache *block_group = data;
302 struct btrfs_fs_info *fs_info = block_group->fs_info;
Yan Zheng11833d62009-09-11 16:11:19 -0400303 struct btrfs_caching_control *caching_ctl = block_group->caching_ctl;
304 struct btrfs_root *extent_root = fs_info->extent_root;
Chris Masone37c9e62007-05-09 20:13:14 -0400305 struct btrfs_path *path;
Chris Mason5f39d392007-10-15 16:14:19 -0400306 struct extent_buffer *leaf;
Yan Zheng11833d62009-09-11 16:11:19 -0400307 struct btrfs_key key;
Josef Bacik817d52f2009-07-13 21:29:25 -0400308 u64 total_found = 0;
Yan Zheng11833d62009-09-11 16:11:19 -0400309 u64 last = 0;
310 u32 nritems;
311 int ret = 0;
Chris Masonf510cfe2007-10-15 16:14:48 -0400312
Chris Masone37c9e62007-05-09 20:13:14 -0400313 path = btrfs_alloc_path();
314 if (!path)
315 return -ENOMEM;
Yan7d7d6062007-09-14 16:15:28 -0400316
Yan Zheng11833d62009-09-11 16:11:19 -0400317 exclude_super_stripes(extent_root, block_group);
Josef Bacik1b2da372009-09-11 16:11:20 -0400318 spin_lock(&block_group->space_info->lock);
Yan, Zhengf0486c62010-05-16 10:46:25 -0400319 block_group->space_info->bytes_readonly += block_group->bytes_super;
Josef Bacik1b2da372009-09-11 16:11:20 -0400320 spin_unlock(&block_group->space_info->lock);
Yan Zheng11833d62009-09-11 16:11:19 -0400321
Josef Bacik817d52f2009-07-13 21:29:25 -0400322 last = max_t(u64, block_group->key.objectid, BTRFS_SUPER_INFO_OFFSET);
Yan Zheng11833d62009-09-11 16:11:19 -0400323
Chris Mason5cd57b22008-06-25 16:01:30 -0400324 /*
Josef Bacik817d52f2009-07-13 21:29:25 -0400325 * We don't want to deadlock with somebody trying to allocate a new
326 * extent for the extent root while also trying to search the extent
327 * root to add free space. So we skip locking and search the commit
328 * root, since its read-only
Chris Mason5cd57b22008-06-25 16:01:30 -0400329 */
330 path->skip_locking = 1;
Josef Bacik817d52f2009-07-13 21:29:25 -0400331 path->search_commit_root = 1;
332 path->reada = 2;
333
Yan Zhenge4404d62008-12-12 10:03:26 -0500334 key.objectid = last;
Chris Masone37c9e62007-05-09 20:13:14 -0400335 key.offset = 0;
Yan Zheng11833d62009-09-11 16:11:19 -0400336 key.type = BTRFS_EXTENT_ITEM_KEY;
Chris Mason013f1b12009-07-31 14:57:55 -0400337again:
Yan Zheng11833d62009-09-11 16:11:19 -0400338 mutex_lock(&caching_ctl->mutex);
Chris Mason013f1b12009-07-31 14:57:55 -0400339 /* need to make sure the commit_root doesn't disappear */
340 down_read(&fs_info->extent_commit_sem);
341
Yan Zheng11833d62009-09-11 16:11:19 -0400342 ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
Chris Masone37c9e62007-05-09 20:13:14 -0400343 if (ret < 0)
Josef Bacikef8bbdf2008-09-23 13:14:11 -0400344 goto err;
Yan Zhenga512bbf2008-12-08 16:46:26 -0500345
Yan Zheng11833d62009-09-11 16:11:19 -0400346 leaf = path->nodes[0];
347 nritems = btrfs_header_nritems(leaf);
348
Chris Masond3977122009-01-05 21:25:51 -0500349 while (1) {
Josef Bacik817d52f2009-07-13 21:29:25 -0400350 smp_mb();
Yan Zheng11833d62009-09-11 16:11:19 -0400351 if (fs_info->closing > 1) {
Yan Zhengf25784b2009-07-28 08:41:57 -0400352 last = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -0400353 break;
Yan Zhengf25784b2009-07-28 08:41:57 -0400354 }
Josef Bacik817d52f2009-07-13 21:29:25 -0400355
Yan Zheng11833d62009-09-11 16:11:19 -0400356 if (path->slots[0] < nritems) {
357 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
358 } else {
359 ret = find_next_key(path, 0, &key);
360 if (ret)
Chris Masone37c9e62007-05-09 20:13:14 -0400361 break;
Josef Bacik817d52f2009-07-13 21:29:25 -0400362
Yan Zheng11833d62009-09-11 16:11:19 -0400363 caching_ctl->progress = last;
364 btrfs_release_path(extent_root, path);
365 up_read(&fs_info->extent_commit_sem);
366 mutex_unlock(&caching_ctl->mutex);
367 if (btrfs_transaction_in_commit(fs_info))
Chris Masonf36f3042009-07-30 10:04:48 -0400368 schedule_timeout(1);
Yan Zheng11833d62009-09-11 16:11:19 -0400369 else
370 cond_resched();
371 goto again;
372 }
Josef Bacik817d52f2009-07-13 21:29:25 -0400373
Yan Zheng11833d62009-09-11 16:11:19 -0400374 if (key.objectid < block_group->key.objectid) {
375 path->slots[0]++;
Josef Bacik817d52f2009-07-13 21:29:25 -0400376 continue;
Chris Masone37c9e62007-05-09 20:13:14 -0400377 }
Josef Bacik0f9dd462008-09-23 13:14:11 -0400378
Chris Masone37c9e62007-05-09 20:13:14 -0400379 if (key.objectid >= block_group->key.objectid +
Josef Bacik0f9dd462008-09-23 13:14:11 -0400380 block_group->key.offset)
Yan7d7d6062007-09-14 16:15:28 -0400381 break;
Yan7d7d6062007-09-14 16:15:28 -0400382
Yan Zheng11833d62009-09-11 16:11:19 -0400383 if (key.type == BTRFS_EXTENT_ITEM_KEY) {
Josef Bacik817d52f2009-07-13 21:29:25 -0400384 total_found += add_new_free_space(block_group,
385 fs_info, last,
386 key.objectid);
Yan7d7d6062007-09-14 16:15:28 -0400387 last = key.objectid + key.offset;
Josef Bacik817d52f2009-07-13 21:29:25 -0400388
Yan Zheng11833d62009-09-11 16:11:19 -0400389 if (total_found > (1024 * 1024 * 2)) {
390 total_found = 0;
391 wake_up(&caching_ctl->wait);
392 }
Josef Bacik817d52f2009-07-13 21:29:25 -0400393 }
Chris Masone37c9e62007-05-09 20:13:14 -0400394 path->slots[0]++;
395 }
Josef Bacikef8bbdf2008-09-23 13:14:11 -0400396 ret = 0;
Josef Bacik817d52f2009-07-13 21:29:25 -0400397
398 total_found += add_new_free_space(block_group, fs_info, last,
399 block_group->key.objectid +
400 block_group->key.offset);
Yan Zheng11833d62009-09-11 16:11:19 -0400401 caching_ctl->progress = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -0400402
403 spin_lock(&block_group->lock);
Yan Zheng11833d62009-09-11 16:11:19 -0400404 block_group->caching_ctl = NULL;
Josef Bacik817d52f2009-07-13 21:29:25 -0400405 block_group->cached = BTRFS_CACHE_FINISHED;
406 spin_unlock(&block_group->lock);
407
Chris Mason54aa1f42007-06-22 14:16:25 -0400408err:
Chris Masone37c9e62007-05-09 20:13:14 -0400409 btrfs_free_path(path);
Yan Zheng276e6802009-07-30 09:40:40 -0400410 up_read(&fs_info->extent_commit_sem);
Josef Bacik817d52f2009-07-13 21:29:25 -0400411
Yan Zheng11833d62009-09-11 16:11:19 -0400412 free_excluded_extents(extent_root, block_group);
413
414 mutex_unlock(&caching_ctl->mutex);
415 wake_up(&caching_ctl->wait);
416
417 put_caching_control(caching_ctl);
418 atomic_dec(&block_group->space_info->caching_threads);
Josef Bacik11dfe352009-11-13 20:12:59 +0000419 btrfs_put_block_group(block_group);
420
Josef Bacik817d52f2009-07-13 21:29:25 -0400421 return 0;
422}
423
424static int cache_block_group(struct btrfs_block_group_cache *cache)
425{
Yan Zheng11833d62009-09-11 16:11:19 -0400426 struct btrfs_fs_info *fs_info = cache->fs_info;
427 struct btrfs_caching_control *caching_ctl;
Josef Bacik817d52f2009-07-13 21:29:25 -0400428 struct task_struct *tsk;
429 int ret = 0;
430
Yan Zheng11833d62009-09-11 16:11:19 -0400431 smp_mb();
432 if (cache->cached != BTRFS_CACHE_NO)
433 return 0;
434
435 caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_KERNEL);
436 BUG_ON(!caching_ctl);
437
438 INIT_LIST_HEAD(&caching_ctl->list);
439 mutex_init(&caching_ctl->mutex);
440 init_waitqueue_head(&caching_ctl->wait);
441 caching_ctl->block_group = cache;
442 caching_ctl->progress = cache->key.objectid;
443 /* one for caching kthread, one for caching block group list */
444 atomic_set(&caching_ctl->count, 2);
445
Josef Bacik817d52f2009-07-13 21:29:25 -0400446 spin_lock(&cache->lock);
447 if (cache->cached != BTRFS_CACHE_NO) {
448 spin_unlock(&cache->lock);
Yan Zheng11833d62009-09-11 16:11:19 -0400449 kfree(caching_ctl);
450 return 0;
Josef Bacik817d52f2009-07-13 21:29:25 -0400451 }
Yan Zheng11833d62009-09-11 16:11:19 -0400452 cache->caching_ctl = caching_ctl;
Josef Bacik817d52f2009-07-13 21:29:25 -0400453 cache->cached = BTRFS_CACHE_STARTED;
454 spin_unlock(&cache->lock);
455
Yan Zheng11833d62009-09-11 16:11:19 -0400456 down_write(&fs_info->extent_commit_sem);
457 list_add_tail(&caching_ctl->list, &fs_info->caching_block_groups);
458 up_write(&fs_info->extent_commit_sem);
459
460 atomic_inc(&cache->space_info->caching_threads);
Josef Bacik11dfe352009-11-13 20:12:59 +0000461 btrfs_get_block_group(cache);
Yan Zheng11833d62009-09-11 16:11:19 -0400462
Josef Bacik817d52f2009-07-13 21:29:25 -0400463 tsk = kthread_run(caching_kthread, cache, "btrfs-cache-%llu\n",
464 cache->key.objectid);
465 if (IS_ERR(tsk)) {
466 ret = PTR_ERR(tsk);
467 printk(KERN_ERR "error running thread %d\n", ret);
468 BUG();
469 }
470
Josef Bacikef8bbdf2008-09-23 13:14:11 -0400471 return ret;
Chris Masone37c9e62007-05-09 20:13:14 -0400472}
473
Josef Bacik0f9dd462008-09-23 13:14:11 -0400474/*
475 * return the block group that starts at or after bytenr
476 */
Chris Masond3977122009-01-05 21:25:51 -0500477static struct btrfs_block_group_cache *
478btrfs_lookup_first_block_group(struct btrfs_fs_info *info, u64 bytenr)
Chris Mason0ef3e662008-05-24 14:04:53 -0400479{
Josef Bacik0f9dd462008-09-23 13:14:11 -0400480 struct btrfs_block_group_cache *cache;
Chris Mason0ef3e662008-05-24 14:04:53 -0400481
Josef Bacik0f9dd462008-09-23 13:14:11 -0400482 cache = block_group_cache_tree_search(info, bytenr, 0);
Chris Mason0ef3e662008-05-24 14:04:53 -0400483
Josef Bacik0f9dd462008-09-23 13:14:11 -0400484 return cache;
Chris Mason0ef3e662008-05-24 14:04:53 -0400485}
486
Josef Bacik0f9dd462008-09-23 13:14:11 -0400487/*
Sankar P9f556842009-05-14 13:52:22 -0400488 * return the block group that contains the given bytenr
Josef Bacik0f9dd462008-09-23 13:14:11 -0400489 */
Chris Masond3977122009-01-05 21:25:51 -0500490struct btrfs_block_group_cache *btrfs_lookup_block_group(
491 struct btrfs_fs_info *info,
492 u64 bytenr)
Chris Masonbe744172007-05-06 10:15:01 -0400493{
Josef Bacik0f9dd462008-09-23 13:14:11 -0400494 struct btrfs_block_group_cache *cache;
Chris Masonbe744172007-05-06 10:15:01 -0400495
Josef Bacik0f9dd462008-09-23 13:14:11 -0400496 cache = block_group_cache_tree_search(info, bytenr, 1);
Chris Mason96b51792007-10-15 16:15:19 -0400497
Josef Bacik0f9dd462008-09-23 13:14:11 -0400498 return cache;
Chris Masonbe744172007-05-06 10:15:01 -0400499}
Chris Mason0b86a832008-03-24 15:01:56 -0400500
Josef Bacik0f9dd462008-09-23 13:14:11 -0400501static struct btrfs_space_info *__find_space_info(struct btrfs_fs_info *info,
502 u64 flags)
Chris Mason6324fbf2008-03-24 15:01:59 -0400503{
Josef Bacik0f9dd462008-09-23 13:14:11 -0400504 struct list_head *head = &info->space_info;
Josef Bacik0f9dd462008-09-23 13:14:11 -0400505 struct btrfs_space_info *found;
Chris Mason4184ea72009-03-10 12:39:20 -0400506
Yan, Zhengb742bb82010-05-16 10:46:24 -0400507 flags &= BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_SYSTEM |
508 BTRFS_BLOCK_GROUP_METADATA;
509
Chris Mason4184ea72009-03-10 12:39:20 -0400510 rcu_read_lock();
511 list_for_each_entry_rcu(found, head, list) {
512 if (found->flags == flags) {
513 rcu_read_unlock();
Josef Bacik0f9dd462008-09-23 13:14:11 -0400514 return found;
Chris Mason4184ea72009-03-10 12:39:20 -0400515 }
Josef Bacik0f9dd462008-09-23 13:14:11 -0400516 }
Chris Mason4184ea72009-03-10 12:39:20 -0400517 rcu_read_unlock();
Josef Bacik0f9dd462008-09-23 13:14:11 -0400518 return NULL;
Chris Mason6324fbf2008-03-24 15:01:59 -0400519}
520
Chris Mason4184ea72009-03-10 12:39:20 -0400521/*
522 * after adding space to the filesystem, we need to clear the full flags
523 * on all the space infos.
524 */
525void btrfs_clear_space_info_full(struct btrfs_fs_info *info)
526{
527 struct list_head *head = &info->space_info;
528 struct btrfs_space_info *found;
529
530 rcu_read_lock();
531 list_for_each_entry_rcu(found, head, list)
532 found->full = 0;
533 rcu_read_unlock();
534}
535
Josef Bacik80eb2342008-10-29 14:49:05 -0400536static u64 div_factor(u64 num, int factor)
537{
538 if (factor == 10)
539 return num;
540 num *= factor;
541 do_div(num, 10);
542 return num;
543}
544
Yan Zhengd2fb3432008-12-11 16:30:39 -0500545u64 btrfs_find_block_group(struct btrfs_root *root,
546 u64 search_start, u64 search_hint, int owner)
Chris Masoncd1bc462007-04-27 10:08:34 -0400547{
Chris Mason96b51792007-10-15 16:15:19 -0400548 struct btrfs_block_group_cache *cache;
Chris Masoncd1bc462007-04-27 10:08:34 -0400549 u64 used;
Yan Zhengd2fb3432008-12-11 16:30:39 -0500550 u64 last = max(search_hint, search_start);
551 u64 group_start = 0;
Chris Mason31f3c992007-04-30 15:25:45 -0400552 int full_search = 0;
Yan Zhengd2fb3432008-12-11 16:30:39 -0500553 int factor = 9;
Chris Mason0ef3e662008-05-24 14:04:53 -0400554 int wrapped = 0;
Chris Mason31f3c992007-04-30 15:25:45 -0400555again:
Zheng Yane8569812008-09-26 10:05:48 -0400556 while (1) {
557 cache = btrfs_lookup_first_block_group(root->fs_info, last);
Josef Bacik0f9dd462008-09-23 13:14:11 -0400558 if (!cache)
Chris Masoncd1bc462007-04-27 10:08:34 -0400559 break;
Chris Mason96b51792007-10-15 16:15:19 -0400560
Chris Masonc286ac42008-07-22 23:06:41 -0400561 spin_lock(&cache->lock);
Chris Mason96b51792007-10-15 16:15:19 -0400562 last = cache->key.objectid + cache->key.offset;
563 used = btrfs_block_group_used(&cache->item);
564
Yan Zhengd2fb3432008-12-11 16:30:39 -0500565 if ((full_search || !cache->ro) &&
566 block_group_bits(cache, BTRFS_BLOCK_GROUP_METADATA)) {
Zheng Yane8569812008-09-26 10:05:48 -0400567 if (used + cache->pinned + cache->reserved <
Yan Zhengd2fb3432008-12-11 16:30:39 -0500568 div_factor(cache->key.offset, factor)) {
569 group_start = cache->key.objectid;
Chris Masonc286ac42008-07-22 23:06:41 -0400570 spin_unlock(&cache->lock);
Chris Masonfa9c0d72009-04-03 09:47:43 -0400571 btrfs_put_block_group(cache);
Chris Mason8790d502008-04-03 16:29:03 -0400572 goto found;
573 }
Chris Masoncd1bc462007-04-27 10:08:34 -0400574 }
Chris Masonc286ac42008-07-22 23:06:41 -0400575 spin_unlock(&cache->lock);
Chris Masonfa9c0d72009-04-03 09:47:43 -0400576 btrfs_put_block_group(cache);
Chris Masonde428b62007-05-18 13:28:27 -0400577 cond_resched();
Chris Masoncd1bc462007-04-27 10:08:34 -0400578 }
Chris Mason0ef3e662008-05-24 14:04:53 -0400579 if (!wrapped) {
580 last = search_start;
581 wrapped = 1;
582 goto again;
583 }
584 if (!full_search && factor < 10) {
Chris Masonbe744172007-05-06 10:15:01 -0400585 last = search_start;
Chris Mason31f3c992007-04-30 15:25:45 -0400586 full_search = 1;
Chris Mason0ef3e662008-05-24 14:04:53 -0400587 factor = 10;
Chris Mason31f3c992007-04-30 15:25:45 -0400588 goto again;
589 }
Chris Masonbe744172007-05-06 10:15:01 -0400590found:
Yan Zhengd2fb3432008-12-11 16:30:39 -0500591 return group_start;
Chris Mason925baed2008-06-25 16:01:30 -0400592}
Josef Bacik0f9dd462008-09-23 13:14:11 -0400593
Chris Masone02119d2008-09-05 16:13:11 -0400594/* simple helper to search for an existing extent at a given offset */
Zheng Yan31840ae2008-09-23 13:14:14 -0400595int btrfs_lookup_extent(struct btrfs_root *root, u64 start, u64 len)
Chris Masone02119d2008-09-05 16:13:11 -0400596{
597 int ret;
598 struct btrfs_key key;
Zheng Yan31840ae2008-09-23 13:14:14 -0400599 struct btrfs_path *path;
Chris Masone02119d2008-09-05 16:13:11 -0400600
Zheng Yan31840ae2008-09-23 13:14:14 -0400601 path = btrfs_alloc_path();
602 BUG_ON(!path);
Chris Masone02119d2008-09-05 16:13:11 -0400603 key.objectid = start;
604 key.offset = len;
605 btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY);
606 ret = btrfs_search_slot(NULL, root->fs_info->extent_root, &key, path,
607 0, 0);
Zheng Yan31840ae2008-09-23 13:14:14 -0400608 btrfs_free_path(path);
Chris Mason7bb86312007-12-11 09:25:06 -0500609 return ret;
610}
611
Chris Masond8d5f3e2007-12-11 12:42:00 -0500612/*
Yan, Zhenga22285a2010-05-16 10:48:46 -0400613 * helper function to lookup reference count and flags of extent.
614 *
615 * the head node for delayed ref is used to store the sum of all the
616 * reference count modifications queued up in the rbtree. the head
617 * node may also store the extent flags to set. This way you can check
618 * to see what the reference count and extent flags would be if all of
619 * the delayed refs are not processed.
620 */
621int btrfs_lookup_extent_info(struct btrfs_trans_handle *trans,
622 struct btrfs_root *root, u64 bytenr,
623 u64 num_bytes, u64 *refs, u64 *flags)
624{
625 struct btrfs_delayed_ref_head *head;
626 struct btrfs_delayed_ref_root *delayed_refs;
627 struct btrfs_path *path;
628 struct btrfs_extent_item *ei;
629 struct extent_buffer *leaf;
630 struct btrfs_key key;
631 u32 item_size;
632 u64 num_refs;
633 u64 extent_flags;
634 int ret;
635
636 path = btrfs_alloc_path();
637 if (!path)
638 return -ENOMEM;
639
640 key.objectid = bytenr;
641 key.type = BTRFS_EXTENT_ITEM_KEY;
642 key.offset = num_bytes;
643 if (!trans) {
644 path->skip_locking = 1;
645 path->search_commit_root = 1;
646 }
647again:
648 ret = btrfs_search_slot(trans, root->fs_info->extent_root,
649 &key, path, 0, 0);
650 if (ret < 0)
651 goto out_free;
652
653 if (ret == 0) {
654 leaf = path->nodes[0];
655 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
656 if (item_size >= sizeof(*ei)) {
657 ei = btrfs_item_ptr(leaf, path->slots[0],
658 struct btrfs_extent_item);
659 num_refs = btrfs_extent_refs(leaf, ei);
660 extent_flags = btrfs_extent_flags(leaf, ei);
661 } else {
662#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
663 struct btrfs_extent_item_v0 *ei0;
664 BUG_ON(item_size != sizeof(*ei0));
665 ei0 = btrfs_item_ptr(leaf, path->slots[0],
666 struct btrfs_extent_item_v0);
667 num_refs = btrfs_extent_refs_v0(leaf, ei0);
668 /* FIXME: this isn't correct for data */
669 extent_flags = BTRFS_BLOCK_FLAG_FULL_BACKREF;
670#else
671 BUG();
672#endif
673 }
674 BUG_ON(num_refs == 0);
675 } else {
676 num_refs = 0;
677 extent_flags = 0;
678 ret = 0;
679 }
680
681 if (!trans)
682 goto out;
683
684 delayed_refs = &trans->transaction->delayed_refs;
685 spin_lock(&delayed_refs->lock);
686 head = btrfs_find_delayed_ref_head(trans, bytenr);
687 if (head) {
688 if (!mutex_trylock(&head->mutex)) {
689 atomic_inc(&head->node.refs);
690 spin_unlock(&delayed_refs->lock);
691
692 btrfs_release_path(root->fs_info->extent_root, path);
693
694 mutex_lock(&head->mutex);
695 mutex_unlock(&head->mutex);
696 btrfs_put_delayed_ref(&head->node);
697 goto again;
698 }
699 if (head->extent_op && head->extent_op->update_flags)
700 extent_flags |= head->extent_op->flags_to_set;
701 else
702 BUG_ON(num_refs == 0);
703
704 num_refs += head->node.ref_mod;
705 mutex_unlock(&head->mutex);
706 }
707 spin_unlock(&delayed_refs->lock);
708out:
709 WARN_ON(num_refs == 0);
710 if (refs)
711 *refs = num_refs;
712 if (flags)
713 *flags = extent_flags;
714out_free:
715 btrfs_free_path(path);
716 return ret;
717}
718
719/*
Chris Masond8d5f3e2007-12-11 12:42:00 -0500720 * Back reference rules. Back refs have three main goals:
721 *
722 * 1) differentiate between all holders of references to an extent so that
723 * when a reference is dropped we can make sure it was a valid reference
724 * before freeing the extent.
725 *
726 * 2) Provide enough information to quickly find the holders of an extent
727 * if we notice a given block is corrupted or bad.
728 *
729 * 3) Make it easy to migrate blocks for FS shrinking or storage pool
730 * maintenance. This is actually the same as #2, but with a slightly
731 * different use case.
732 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400733 * There are two kinds of back refs. The implicit back refs is optimized
734 * for pointers in non-shared tree blocks. For a given pointer in a block,
735 * back refs of this kind provide information about the block's owner tree
736 * and the pointer's key. These information allow us to find the block by
737 * b-tree searching. The full back refs is for pointers in tree blocks not
738 * referenced by their owner trees. The location of tree block is recorded
739 * in the back refs. Actually the full back refs is generic, and can be
740 * used in all cases the implicit back refs is used. The major shortcoming
741 * of the full back refs is its overhead. Every time a tree block gets
742 * COWed, we have to update back refs entry for all pointers in it.
743 *
744 * For a newly allocated tree block, we use implicit back refs for
745 * pointers in it. This means most tree related operations only involve
746 * implicit back refs. For a tree block created in old transaction, the
747 * only way to drop a reference to it is COW it. So we can detect the
748 * event that tree block loses its owner tree's reference and do the
749 * back refs conversion.
750 *
751 * When a tree block is COW'd through a tree, there are four cases:
752 *
753 * The reference count of the block is one and the tree is the block's
754 * owner tree. Nothing to do in this case.
755 *
756 * The reference count of the block is one and the tree is not the
757 * block's owner tree. In this case, full back refs is used for pointers
758 * in the block. Remove these full back refs, add implicit back refs for
759 * every pointers in the new block.
760 *
761 * The reference count of the block is greater than one and the tree is
762 * the block's owner tree. In this case, implicit back refs is used for
763 * pointers in the block. Add full back refs for every pointers in the
764 * block, increase lower level extents' reference counts. The original
765 * implicit back refs are entailed to the new block.
766 *
767 * The reference count of the block is greater than one and the tree is
768 * not the block's owner tree. Add implicit back refs for every pointer in
769 * the new block, increase lower level extents' reference count.
770 *
771 * Back Reference Key composing:
772 *
773 * The key objectid corresponds to the first byte in the extent,
774 * The key type is used to differentiate between types of back refs.
775 * There are different meanings of the key offset for different types
776 * of back refs.
777 *
Chris Masond8d5f3e2007-12-11 12:42:00 -0500778 * File extents can be referenced by:
779 *
780 * - multiple snapshots, subvolumes, or different generations in one subvol
Zheng Yan31840ae2008-09-23 13:14:14 -0400781 * - different files inside a single subvolume
Chris Masond8d5f3e2007-12-11 12:42:00 -0500782 * - different offsets inside a file (bookend extents in file.c)
783 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400784 * The extent ref structure for the implicit back refs has fields for:
Chris Masond8d5f3e2007-12-11 12:42:00 -0500785 *
786 * - Objectid of the subvolume root
Chris Masond8d5f3e2007-12-11 12:42:00 -0500787 * - objectid of the file holding the reference
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400788 * - original offset in the file
789 * - how many bookend extents
Zheng Yan31840ae2008-09-23 13:14:14 -0400790 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400791 * The key offset for the implicit back refs is hash of the first
792 * three fields.
Chris Masond8d5f3e2007-12-11 12:42:00 -0500793 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400794 * The extent ref structure for the full back refs has field for:
Chris Masond8d5f3e2007-12-11 12:42:00 -0500795 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400796 * - number of pointers in the tree leaf
Chris Masond8d5f3e2007-12-11 12:42:00 -0500797 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400798 * The key offset for the implicit back refs is the first byte of
799 * the tree leaf
Chris Masond8d5f3e2007-12-11 12:42:00 -0500800 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400801 * When a file extent is allocated, The implicit back refs is used.
802 * the fields are filled in:
Chris Masond8d5f3e2007-12-11 12:42:00 -0500803 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400804 * (root_key.objectid, inode objectid, offset in file, 1)
805 *
806 * When a file extent is removed file truncation, we find the
807 * corresponding implicit back refs and check the following fields:
808 *
809 * (btrfs_header_owner(leaf), inode objectid, offset in file)
Chris Masond8d5f3e2007-12-11 12:42:00 -0500810 *
811 * Btree extents can be referenced by:
812 *
813 * - Different subvolumes
Chris Masond8d5f3e2007-12-11 12:42:00 -0500814 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400815 * Both the implicit back refs and the full back refs for tree blocks
816 * only consist of key. The key offset for the implicit back refs is
817 * objectid of block's owner tree. The key offset for the full back refs
818 * is the first byte of parent block.
Chris Masond8d5f3e2007-12-11 12:42:00 -0500819 *
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400820 * When implicit back refs is used, information about the lowest key and
821 * level of the tree block are required. These information are stored in
822 * tree block info structure.
Chris Masond8d5f3e2007-12-11 12:42:00 -0500823 */
Zheng Yan31840ae2008-09-23 13:14:14 -0400824
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400825#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
826static int convert_extent_item_v0(struct btrfs_trans_handle *trans,
827 struct btrfs_root *root,
828 struct btrfs_path *path,
829 u64 owner, u32 extra_size)
Chris Mason74493f72007-12-11 09:25:06 -0500830{
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400831 struct btrfs_extent_item *item;
832 struct btrfs_extent_item_v0 *ei0;
833 struct btrfs_extent_ref_v0 *ref0;
834 struct btrfs_tree_block_info *bi;
Zheng Yan31840ae2008-09-23 13:14:14 -0400835 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400836 struct btrfs_key key;
837 struct btrfs_key found_key;
838 u32 new_size = sizeof(*item);
839 u64 refs;
Chris Mason74493f72007-12-11 09:25:06 -0500840 int ret;
841
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400842 leaf = path->nodes[0];
843 BUG_ON(btrfs_item_size_nr(leaf, path->slots[0]) != sizeof(*ei0));
Chris Mason74493f72007-12-11 09:25:06 -0500844
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400845 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
846 ei0 = btrfs_item_ptr(leaf, path->slots[0],
847 struct btrfs_extent_item_v0);
848 refs = btrfs_extent_refs_v0(leaf, ei0);
849
850 if (owner == (u64)-1) {
851 while (1) {
852 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
853 ret = btrfs_next_leaf(root, path);
854 if (ret < 0)
855 return ret;
856 BUG_ON(ret > 0);
857 leaf = path->nodes[0];
858 }
859 btrfs_item_key_to_cpu(leaf, &found_key,
860 path->slots[0]);
861 BUG_ON(key.objectid != found_key.objectid);
862 if (found_key.type != BTRFS_EXTENT_REF_V0_KEY) {
863 path->slots[0]++;
864 continue;
865 }
866 ref0 = btrfs_item_ptr(leaf, path->slots[0],
867 struct btrfs_extent_ref_v0);
868 owner = btrfs_ref_objectid_v0(leaf, ref0);
869 break;
870 }
871 }
872 btrfs_release_path(root, path);
873
874 if (owner < BTRFS_FIRST_FREE_OBJECTID)
875 new_size += sizeof(*bi);
876
877 new_size -= sizeof(*ei0);
878 ret = btrfs_search_slot(trans, root, &key, path,
879 new_size + extra_size, 1);
Zheng Yan31840ae2008-09-23 13:14:14 -0400880 if (ret < 0)
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400881 return ret;
882 BUG_ON(ret);
883
884 ret = btrfs_extend_item(trans, root, path, new_size);
885 BUG_ON(ret);
886
887 leaf = path->nodes[0];
888 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
889 btrfs_set_extent_refs(leaf, item, refs);
890 /* FIXME: get real generation */
891 btrfs_set_extent_generation(leaf, item, 0);
892 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
893 btrfs_set_extent_flags(leaf, item,
894 BTRFS_EXTENT_FLAG_TREE_BLOCK |
895 BTRFS_BLOCK_FLAG_FULL_BACKREF);
896 bi = (struct btrfs_tree_block_info *)(item + 1);
897 /* FIXME: get first key of the block */
898 memset_extent_buffer(leaf, 0, (unsigned long)bi, sizeof(*bi));
899 btrfs_set_tree_block_level(leaf, bi, (int)owner);
900 } else {
901 btrfs_set_extent_flags(leaf, item, BTRFS_EXTENT_FLAG_DATA);
902 }
903 btrfs_mark_buffer_dirty(leaf);
904 return 0;
905}
906#endif
907
908static u64 hash_extent_data_ref(u64 root_objectid, u64 owner, u64 offset)
909{
910 u32 high_crc = ~(u32)0;
911 u32 low_crc = ~(u32)0;
912 __le64 lenum;
913
914 lenum = cpu_to_le64(root_objectid);
David Woodhouse163e7832009-04-19 13:02:41 +0100915 high_crc = crc32c(high_crc, &lenum, sizeof(lenum));
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400916 lenum = cpu_to_le64(owner);
David Woodhouse163e7832009-04-19 13:02:41 +0100917 low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400918 lenum = cpu_to_le64(offset);
David Woodhouse163e7832009-04-19 13:02:41 +0100919 low_crc = crc32c(low_crc, &lenum, sizeof(lenum));
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400920
921 return ((u64)high_crc << 31) ^ (u64)low_crc;
922}
923
924static u64 hash_extent_data_ref_item(struct extent_buffer *leaf,
925 struct btrfs_extent_data_ref *ref)
926{
927 return hash_extent_data_ref(btrfs_extent_data_ref_root(leaf, ref),
928 btrfs_extent_data_ref_objectid(leaf, ref),
929 btrfs_extent_data_ref_offset(leaf, ref));
930}
931
932static int match_extent_data_ref(struct extent_buffer *leaf,
933 struct btrfs_extent_data_ref *ref,
934 u64 root_objectid, u64 owner, u64 offset)
935{
936 if (btrfs_extent_data_ref_root(leaf, ref) != root_objectid ||
937 btrfs_extent_data_ref_objectid(leaf, ref) != owner ||
938 btrfs_extent_data_ref_offset(leaf, ref) != offset)
939 return 0;
940 return 1;
941}
942
943static noinline int lookup_extent_data_ref(struct btrfs_trans_handle *trans,
944 struct btrfs_root *root,
945 struct btrfs_path *path,
946 u64 bytenr, u64 parent,
947 u64 root_objectid,
948 u64 owner, u64 offset)
949{
950 struct btrfs_key key;
951 struct btrfs_extent_data_ref *ref;
952 struct extent_buffer *leaf;
953 u32 nritems;
954 int ret;
955 int recow;
956 int err = -ENOENT;
957
958 key.objectid = bytenr;
959 if (parent) {
960 key.type = BTRFS_SHARED_DATA_REF_KEY;
961 key.offset = parent;
962 } else {
963 key.type = BTRFS_EXTENT_DATA_REF_KEY;
964 key.offset = hash_extent_data_ref(root_objectid,
965 owner, offset);
966 }
967again:
968 recow = 0;
969 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
970 if (ret < 0) {
971 err = ret;
972 goto fail;
973 }
974
975 if (parent) {
976 if (!ret)
977 return 0;
978#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
979 key.type = BTRFS_EXTENT_REF_V0_KEY;
980 btrfs_release_path(root, path);
981 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
982 if (ret < 0) {
983 err = ret;
984 goto fail;
985 }
986 if (!ret)
987 return 0;
988#endif
989 goto fail;
Zheng Yan31840ae2008-09-23 13:14:14 -0400990 }
991
992 leaf = path->nodes[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -0400993 nritems = btrfs_header_nritems(leaf);
994 while (1) {
995 if (path->slots[0] >= nritems) {
996 ret = btrfs_next_leaf(root, path);
997 if (ret < 0)
998 err = ret;
999 if (ret)
1000 goto fail;
1001
1002 leaf = path->nodes[0];
1003 nritems = btrfs_header_nritems(leaf);
1004 recow = 1;
1005 }
1006
1007 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1008 if (key.objectid != bytenr ||
1009 key.type != BTRFS_EXTENT_DATA_REF_KEY)
1010 goto fail;
1011
1012 ref = btrfs_item_ptr(leaf, path->slots[0],
1013 struct btrfs_extent_data_ref);
1014
1015 if (match_extent_data_ref(leaf, ref, root_objectid,
1016 owner, offset)) {
1017 if (recow) {
1018 btrfs_release_path(root, path);
1019 goto again;
1020 }
1021 err = 0;
1022 break;
1023 }
1024 path->slots[0]++;
Zheng Yan31840ae2008-09-23 13:14:14 -04001025 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001026fail:
1027 return err;
Zheng Yan31840ae2008-09-23 13:14:14 -04001028}
1029
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001030static noinline int insert_extent_data_ref(struct btrfs_trans_handle *trans,
1031 struct btrfs_root *root,
1032 struct btrfs_path *path,
1033 u64 bytenr, u64 parent,
1034 u64 root_objectid, u64 owner,
1035 u64 offset, int refs_to_add)
Zheng Yan31840ae2008-09-23 13:14:14 -04001036{
1037 struct btrfs_key key;
1038 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001039 u32 size;
Zheng Yan31840ae2008-09-23 13:14:14 -04001040 u32 num_refs;
1041 int ret;
1042
1043 key.objectid = bytenr;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001044 if (parent) {
1045 key.type = BTRFS_SHARED_DATA_REF_KEY;
1046 key.offset = parent;
1047 size = sizeof(struct btrfs_shared_data_ref);
Zheng Yan31840ae2008-09-23 13:14:14 -04001048 } else {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001049 key.type = BTRFS_EXTENT_DATA_REF_KEY;
1050 key.offset = hash_extent_data_ref(root_objectid,
1051 owner, offset);
1052 size = sizeof(struct btrfs_extent_data_ref);
Zheng Yan31840ae2008-09-23 13:14:14 -04001053 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001054
1055 ret = btrfs_insert_empty_item(trans, root, path, &key, size);
1056 if (ret && ret != -EEXIST)
1057 goto fail;
1058
1059 leaf = path->nodes[0];
1060 if (parent) {
1061 struct btrfs_shared_data_ref *ref;
1062 ref = btrfs_item_ptr(leaf, path->slots[0],
1063 struct btrfs_shared_data_ref);
1064 if (ret == 0) {
1065 btrfs_set_shared_data_ref_count(leaf, ref, refs_to_add);
1066 } else {
1067 num_refs = btrfs_shared_data_ref_count(leaf, ref);
1068 num_refs += refs_to_add;
1069 btrfs_set_shared_data_ref_count(leaf, ref, num_refs);
1070 }
1071 } else {
1072 struct btrfs_extent_data_ref *ref;
1073 while (ret == -EEXIST) {
1074 ref = btrfs_item_ptr(leaf, path->slots[0],
1075 struct btrfs_extent_data_ref);
1076 if (match_extent_data_ref(leaf, ref, root_objectid,
1077 owner, offset))
1078 break;
1079 btrfs_release_path(root, path);
1080 key.offset++;
1081 ret = btrfs_insert_empty_item(trans, root, path, &key,
1082 size);
1083 if (ret && ret != -EEXIST)
1084 goto fail;
1085
1086 leaf = path->nodes[0];
1087 }
1088 ref = btrfs_item_ptr(leaf, path->slots[0],
1089 struct btrfs_extent_data_ref);
1090 if (ret == 0) {
1091 btrfs_set_extent_data_ref_root(leaf, ref,
1092 root_objectid);
1093 btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
1094 btrfs_set_extent_data_ref_offset(leaf, ref, offset);
1095 btrfs_set_extent_data_ref_count(leaf, ref, refs_to_add);
1096 } else {
1097 num_refs = btrfs_extent_data_ref_count(leaf, ref);
1098 num_refs += refs_to_add;
1099 btrfs_set_extent_data_ref_count(leaf, ref, num_refs);
1100 }
1101 }
1102 btrfs_mark_buffer_dirty(leaf);
1103 ret = 0;
1104fail:
Chris Mason7bb86312007-12-11 09:25:06 -05001105 btrfs_release_path(root, path);
1106 return ret;
Chris Mason74493f72007-12-11 09:25:06 -05001107}
1108
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001109static noinline int remove_extent_data_ref(struct btrfs_trans_handle *trans,
1110 struct btrfs_root *root,
1111 struct btrfs_path *path,
1112 int refs_to_drop)
Zheng Yan31840ae2008-09-23 13:14:14 -04001113{
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001114 struct btrfs_key key;
1115 struct btrfs_extent_data_ref *ref1 = NULL;
1116 struct btrfs_shared_data_ref *ref2 = NULL;
Zheng Yan31840ae2008-09-23 13:14:14 -04001117 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001118 u32 num_refs = 0;
Zheng Yan31840ae2008-09-23 13:14:14 -04001119 int ret = 0;
1120
1121 leaf = path->nodes[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001122 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1123
1124 if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1125 ref1 = btrfs_item_ptr(leaf, path->slots[0],
1126 struct btrfs_extent_data_ref);
1127 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1128 } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1129 ref2 = btrfs_item_ptr(leaf, path->slots[0],
1130 struct btrfs_shared_data_ref);
1131 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1132#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1133 } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1134 struct btrfs_extent_ref_v0 *ref0;
1135 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1136 struct btrfs_extent_ref_v0);
1137 num_refs = btrfs_ref_count_v0(leaf, ref0);
1138#endif
1139 } else {
1140 BUG();
1141 }
1142
Chris Mason56bec292009-03-13 10:10:06 -04001143 BUG_ON(num_refs < refs_to_drop);
1144 num_refs -= refs_to_drop;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001145
Zheng Yan31840ae2008-09-23 13:14:14 -04001146 if (num_refs == 0) {
1147 ret = btrfs_del_item(trans, root, path);
1148 } else {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001149 if (key.type == BTRFS_EXTENT_DATA_REF_KEY)
1150 btrfs_set_extent_data_ref_count(leaf, ref1, num_refs);
1151 else if (key.type == BTRFS_SHARED_DATA_REF_KEY)
1152 btrfs_set_shared_data_ref_count(leaf, ref2, num_refs);
1153#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1154 else {
1155 struct btrfs_extent_ref_v0 *ref0;
1156 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1157 struct btrfs_extent_ref_v0);
1158 btrfs_set_ref_count_v0(leaf, ref0, num_refs);
1159 }
1160#endif
Zheng Yan31840ae2008-09-23 13:14:14 -04001161 btrfs_mark_buffer_dirty(leaf);
1162 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001163 return ret;
1164}
1165
1166static noinline u32 extent_data_ref_count(struct btrfs_root *root,
1167 struct btrfs_path *path,
1168 struct btrfs_extent_inline_ref *iref)
1169{
1170 struct btrfs_key key;
1171 struct extent_buffer *leaf;
1172 struct btrfs_extent_data_ref *ref1;
1173 struct btrfs_shared_data_ref *ref2;
1174 u32 num_refs = 0;
1175
1176 leaf = path->nodes[0];
1177 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
1178 if (iref) {
1179 if (btrfs_extent_inline_ref_type(leaf, iref) ==
1180 BTRFS_EXTENT_DATA_REF_KEY) {
1181 ref1 = (struct btrfs_extent_data_ref *)(&iref->offset);
1182 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1183 } else {
1184 ref2 = (struct btrfs_shared_data_ref *)(iref + 1);
1185 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1186 }
1187 } else if (key.type == BTRFS_EXTENT_DATA_REF_KEY) {
1188 ref1 = btrfs_item_ptr(leaf, path->slots[0],
1189 struct btrfs_extent_data_ref);
1190 num_refs = btrfs_extent_data_ref_count(leaf, ref1);
1191 } else if (key.type == BTRFS_SHARED_DATA_REF_KEY) {
1192 ref2 = btrfs_item_ptr(leaf, path->slots[0],
1193 struct btrfs_shared_data_ref);
1194 num_refs = btrfs_shared_data_ref_count(leaf, ref2);
1195#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1196 } else if (key.type == BTRFS_EXTENT_REF_V0_KEY) {
1197 struct btrfs_extent_ref_v0 *ref0;
1198 ref0 = btrfs_item_ptr(leaf, path->slots[0],
1199 struct btrfs_extent_ref_v0);
1200 num_refs = btrfs_ref_count_v0(leaf, ref0);
1201#endif
1202 } else {
1203 WARN_ON(1);
1204 }
1205 return num_refs;
1206}
1207
1208static noinline int lookup_tree_block_ref(struct btrfs_trans_handle *trans,
1209 struct btrfs_root *root,
1210 struct btrfs_path *path,
1211 u64 bytenr, u64 parent,
1212 u64 root_objectid)
1213{
1214 struct btrfs_key key;
1215 int ret;
1216
1217 key.objectid = bytenr;
1218 if (parent) {
1219 key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1220 key.offset = parent;
1221 } else {
1222 key.type = BTRFS_TREE_BLOCK_REF_KEY;
1223 key.offset = root_objectid;
1224 }
1225
1226 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1227 if (ret > 0)
1228 ret = -ENOENT;
1229#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1230 if (ret == -ENOENT && parent) {
1231 btrfs_release_path(root, path);
1232 key.type = BTRFS_EXTENT_REF_V0_KEY;
1233 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
1234 if (ret > 0)
1235 ret = -ENOENT;
1236 }
1237#endif
1238 return ret;
1239}
1240
1241static noinline int insert_tree_block_ref(struct btrfs_trans_handle *trans,
1242 struct btrfs_root *root,
1243 struct btrfs_path *path,
1244 u64 bytenr, u64 parent,
1245 u64 root_objectid)
1246{
1247 struct btrfs_key key;
1248 int ret;
1249
1250 key.objectid = bytenr;
1251 if (parent) {
1252 key.type = BTRFS_SHARED_BLOCK_REF_KEY;
1253 key.offset = parent;
1254 } else {
1255 key.type = BTRFS_TREE_BLOCK_REF_KEY;
1256 key.offset = root_objectid;
1257 }
1258
1259 ret = btrfs_insert_empty_item(trans, root, path, &key, 0);
Zheng Yan31840ae2008-09-23 13:14:14 -04001260 btrfs_release_path(root, path);
1261 return ret;
1262}
1263
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001264static inline int extent_ref_type(u64 parent, u64 owner)
1265{
1266 int type;
1267 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1268 if (parent > 0)
1269 type = BTRFS_SHARED_BLOCK_REF_KEY;
1270 else
1271 type = BTRFS_TREE_BLOCK_REF_KEY;
1272 } else {
1273 if (parent > 0)
1274 type = BTRFS_SHARED_DATA_REF_KEY;
1275 else
1276 type = BTRFS_EXTENT_DATA_REF_KEY;
1277 }
1278 return type;
1279}
1280
Yan Zheng2c47e6052009-06-27 21:07:35 -04001281static int find_next_key(struct btrfs_path *path, int level,
1282 struct btrfs_key *key)
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001283
1284{
Yan Zheng2c47e6052009-06-27 21:07:35 -04001285 for (; level < BTRFS_MAX_LEVEL; level++) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001286 if (!path->nodes[level])
1287 break;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001288 if (path->slots[level] + 1 >=
1289 btrfs_header_nritems(path->nodes[level]))
1290 continue;
1291 if (level == 0)
1292 btrfs_item_key_to_cpu(path->nodes[level], key,
1293 path->slots[level] + 1);
1294 else
1295 btrfs_node_key_to_cpu(path->nodes[level], key,
1296 path->slots[level] + 1);
1297 return 0;
1298 }
1299 return 1;
1300}
1301
1302/*
1303 * look for inline back ref. if back ref is found, *ref_ret is set
1304 * to the address of inline back ref, and 0 is returned.
1305 *
1306 * if back ref isn't found, *ref_ret is set to the address where it
1307 * should be inserted, and -ENOENT is returned.
1308 *
1309 * if insert is true and there are too many inline back refs, the path
1310 * points to the extent item, and -EAGAIN is returned.
1311 *
1312 * NOTE: inline back refs are ordered in the same way that back ref
1313 * items in the tree are ordered.
1314 */
1315static noinline_for_stack
1316int lookup_inline_extent_backref(struct btrfs_trans_handle *trans,
1317 struct btrfs_root *root,
1318 struct btrfs_path *path,
1319 struct btrfs_extent_inline_ref **ref_ret,
1320 u64 bytenr, u64 num_bytes,
1321 u64 parent, u64 root_objectid,
1322 u64 owner, u64 offset, int insert)
1323{
1324 struct btrfs_key key;
1325 struct extent_buffer *leaf;
1326 struct btrfs_extent_item *ei;
1327 struct btrfs_extent_inline_ref *iref;
1328 u64 flags;
1329 u64 item_size;
1330 unsigned long ptr;
1331 unsigned long end;
1332 int extra_size;
1333 int type;
1334 int want;
1335 int ret;
1336 int err = 0;
1337
1338 key.objectid = bytenr;
1339 key.type = BTRFS_EXTENT_ITEM_KEY;
1340 key.offset = num_bytes;
1341
1342 want = extent_ref_type(parent, owner);
1343 if (insert) {
1344 extra_size = btrfs_extent_inline_ref_size(want);
Yan Zheng85d41982009-06-11 08:51:10 -04001345 path->keep_locks = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001346 } else
1347 extra_size = -1;
1348 ret = btrfs_search_slot(trans, root, &key, path, extra_size, 1);
1349 if (ret < 0) {
1350 err = ret;
1351 goto out;
1352 }
1353 BUG_ON(ret);
1354
1355 leaf = path->nodes[0];
1356 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1357#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1358 if (item_size < sizeof(*ei)) {
1359 if (!insert) {
1360 err = -ENOENT;
1361 goto out;
1362 }
1363 ret = convert_extent_item_v0(trans, root, path, owner,
1364 extra_size);
1365 if (ret < 0) {
1366 err = ret;
1367 goto out;
1368 }
1369 leaf = path->nodes[0];
1370 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1371 }
1372#endif
1373 BUG_ON(item_size < sizeof(*ei));
1374
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001375 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1376 flags = btrfs_extent_flags(leaf, ei);
1377
1378 ptr = (unsigned long)(ei + 1);
1379 end = (unsigned long)ei + item_size;
1380
1381 if (flags & BTRFS_EXTENT_FLAG_TREE_BLOCK) {
1382 ptr += sizeof(struct btrfs_tree_block_info);
1383 BUG_ON(ptr > end);
1384 } else {
1385 BUG_ON(!(flags & BTRFS_EXTENT_FLAG_DATA));
1386 }
1387
1388 err = -ENOENT;
1389 while (1) {
1390 if (ptr >= end) {
1391 WARN_ON(ptr > end);
1392 break;
1393 }
1394 iref = (struct btrfs_extent_inline_ref *)ptr;
1395 type = btrfs_extent_inline_ref_type(leaf, iref);
1396 if (want < type)
1397 break;
1398 if (want > type) {
1399 ptr += btrfs_extent_inline_ref_size(type);
1400 continue;
1401 }
1402
1403 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1404 struct btrfs_extent_data_ref *dref;
1405 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1406 if (match_extent_data_ref(leaf, dref, root_objectid,
1407 owner, offset)) {
1408 err = 0;
1409 break;
1410 }
1411 if (hash_extent_data_ref_item(leaf, dref) <
1412 hash_extent_data_ref(root_objectid, owner, offset))
1413 break;
1414 } else {
1415 u64 ref_offset;
1416 ref_offset = btrfs_extent_inline_ref_offset(leaf, iref);
1417 if (parent > 0) {
1418 if (parent == ref_offset) {
1419 err = 0;
1420 break;
1421 }
1422 if (ref_offset < parent)
1423 break;
1424 } else {
1425 if (root_objectid == ref_offset) {
1426 err = 0;
1427 break;
1428 }
1429 if (ref_offset < root_objectid)
1430 break;
1431 }
1432 }
1433 ptr += btrfs_extent_inline_ref_size(type);
1434 }
1435 if (err == -ENOENT && insert) {
1436 if (item_size + extra_size >=
1437 BTRFS_MAX_EXTENT_ITEM_SIZE(root)) {
1438 err = -EAGAIN;
1439 goto out;
1440 }
1441 /*
1442 * To add new inline back ref, we have to make sure
1443 * there is no corresponding back ref item.
1444 * For simplicity, we just do not add new inline back
1445 * ref if there is any kind of item for this block
1446 */
Yan Zheng2c47e6052009-06-27 21:07:35 -04001447 if (find_next_key(path, 0, &key) == 0 &&
1448 key.objectid == bytenr &&
Yan Zheng85d41982009-06-11 08:51:10 -04001449 key.type < BTRFS_BLOCK_GROUP_ITEM_KEY) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001450 err = -EAGAIN;
1451 goto out;
1452 }
1453 }
1454 *ref_ret = (struct btrfs_extent_inline_ref *)ptr;
1455out:
Yan Zheng85d41982009-06-11 08:51:10 -04001456 if (insert) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001457 path->keep_locks = 0;
1458 btrfs_unlock_up_safe(path, 1);
1459 }
1460 return err;
1461}
1462
1463/*
1464 * helper to add new inline back ref
1465 */
1466static noinline_for_stack
1467int setup_inline_extent_backref(struct btrfs_trans_handle *trans,
1468 struct btrfs_root *root,
1469 struct btrfs_path *path,
1470 struct btrfs_extent_inline_ref *iref,
1471 u64 parent, u64 root_objectid,
1472 u64 owner, u64 offset, int refs_to_add,
1473 struct btrfs_delayed_extent_op *extent_op)
1474{
1475 struct extent_buffer *leaf;
1476 struct btrfs_extent_item *ei;
1477 unsigned long ptr;
1478 unsigned long end;
1479 unsigned long item_offset;
1480 u64 refs;
1481 int size;
1482 int type;
1483 int ret;
1484
1485 leaf = path->nodes[0];
1486 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1487 item_offset = (unsigned long)iref - (unsigned long)ei;
1488
1489 type = extent_ref_type(parent, owner);
1490 size = btrfs_extent_inline_ref_size(type);
1491
1492 ret = btrfs_extend_item(trans, root, path, size);
1493 BUG_ON(ret);
1494
1495 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1496 refs = btrfs_extent_refs(leaf, ei);
1497 refs += refs_to_add;
1498 btrfs_set_extent_refs(leaf, ei, refs);
1499 if (extent_op)
1500 __run_delayed_extent_op(extent_op, leaf, ei);
1501
1502 ptr = (unsigned long)ei + item_offset;
1503 end = (unsigned long)ei + btrfs_item_size_nr(leaf, path->slots[0]);
1504 if (ptr < end - size)
1505 memmove_extent_buffer(leaf, ptr + size, ptr,
1506 end - size - ptr);
1507
1508 iref = (struct btrfs_extent_inline_ref *)ptr;
1509 btrfs_set_extent_inline_ref_type(leaf, iref, type);
1510 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1511 struct btrfs_extent_data_ref *dref;
1512 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1513 btrfs_set_extent_data_ref_root(leaf, dref, root_objectid);
1514 btrfs_set_extent_data_ref_objectid(leaf, dref, owner);
1515 btrfs_set_extent_data_ref_offset(leaf, dref, offset);
1516 btrfs_set_extent_data_ref_count(leaf, dref, refs_to_add);
1517 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1518 struct btrfs_shared_data_ref *sref;
1519 sref = (struct btrfs_shared_data_ref *)(iref + 1);
1520 btrfs_set_shared_data_ref_count(leaf, sref, refs_to_add);
1521 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1522 } else if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
1523 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
1524 } else {
1525 btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
1526 }
1527 btrfs_mark_buffer_dirty(leaf);
1528 return 0;
1529}
1530
1531static int lookup_extent_backref(struct btrfs_trans_handle *trans,
1532 struct btrfs_root *root,
1533 struct btrfs_path *path,
1534 struct btrfs_extent_inline_ref **ref_ret,
1535 u64 bytenr, u64 num_bytes, u64 parent,
1536 u64 root_objectid, u64 owner, u64 offset)
1537{
1538 int ret;
1539
1540 ret = lookup_inline_extent_backref(trans, root, path, ref_ret,
1541 bytenr, num_bytes, parent,
1542 root_objectid, owner, offset, 0);
1543 if (ret != -ENOENT)
1544 return ret;
1545
1546 btrfs_release_path(root, path);
1547 *ref_ret = NULL;
1548
1549 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1550 ret = lookup_tree_block_ref(trans, root, path, bytenr, parent,
1551 root_objectid);
1552 } else {
1553 ret = lookup_extent_data_ref(trans, root, path, bytenr, parent,
1554 root_objectid, owner, offset);
1555 }
1556 return ret;
1557}
1558
1559/*
1560 * helper to update/remove inline back ref
1561 */
1562static noinline_for_stack
1563int update_inline_extent_backref(struct btrfs_trans_handle *trans,
1564 struct btrfs_root *root,
1565 struct btrfs_path *path,
1566 struct btrfs_extent_inline_ref *iref,
1567 int refs_to_mod,
1568 struct btrfs_delayed_extent_op *extent_op)
1569{
1570 struct extent_buffer *leaf;
1571 struct btrfs_extent_item *ei;
1572 struct btrfs_extent_data_ref *dref = NULL;
1573 struct btrfs_shared_data_ref *sref = NULL;
1574 unsigned long ptr;
1575 unsigned long end;
1576 u32 item_size;
1577 int size;
1578 int type;
1579 int ret;
1580 u64 refs;
1581
1582 leaf = path->nodes[0];
1583 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1584 refs = btrfs_extent_refs(leaf, ei);
1585 WARN_ON(refs_to_mod < 0 && refs + refs_to_mod <= 0);
1586 refs += refs_to_mod;
1587 btrfs_set_extent_refs(leaf, ei, refs);
1588 if (extent_op)
1589 __run_delayed_extent_op(extent_op, leaf, ei);
1590
1591 type = btrfs_extent_inline_ref_type(leaf, iref);
1592
1593 if (type == BTRFS_EXTENT_DATA_REF_KEY) {
1594 dref = (struct btrfs_extent_data_ref *)(&iref->offset);
1595 refs = btrfs_extent_data_ref_count(leaf, dref);
1596 } else if (type == BTRFS_SHARED_DATA_REF_KEY) {
1597 sref = (struct btrfs_shared_data_ref *)(iref + 1);
1598 refs = btrfs_shared_data_ref_count(leaf, sref);
1599 } else {
1600 refs = 1;
1601 BUG_ON(refs_to_mod != -1);
1602 }
1603
1604 BUG_ON(refs_to_mod < 0 && refs < -refs_to_mod);
1605 refs += refs_to_mod;
1606
1607 if (refs > 0) {
1608 if (type == BTRFS_EXTENT_DATA_REF_KEY)
1609 btrfs_set_extent_data_ref_count(leaf, dref, refs);
1610 else
1611 btrfs_set_shared_data_ref_count(leaf, sref, refs);
1612 } else {
1613 size = btrfs_extent_inline_ref_size(type);
1614 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1615 ptr = (unsigned long)iref;
1616 end = (unsigned long)ei + item_size;
1617 if (ptr + size < end)
1618 memmove_extent_buffer(leaf, ptr, ptr + size,
1619 end - ptr - size);
1620 item_size -= size;
1621 ret = btrfs_truncate_item(trans, root, path, item_size, 1);
1622 BUG_ON(ret);
1623 }
1624 btrfs_mark_buffer_dirty(leaf);
1625 return 0;
1626}
1627
1628static noinline_for_stack
1629int insert_inline_extent_backref(struct btrfs_trans_handle *trans,
1630 struct btrfs_root *root,
1631 struct btrfs_path *path,
1632 u64 bytenr, u64 num_bytes, u64 parent,
1633 u64 root_objectid, u64 owner,
1634 u64 offset, int refs_to_add,
1635 struct btrfs_delayed_extent_op *extent_op)
1636{
1637 struct btrfs_extent_inline_ref *iref;
1638 int ret;
1639
1640 ret = lookup_inline_extent_backref(trans, root, path, &iref,
1641 bytenr, num_bytes, parent,
1642 root_objectid, owner, offset, 1);
1643 if (ret == 0) {
1644 BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID);
1645 ret = update_inline_extent_backref(trans, root, path, iref,
1646 refs_to_add, extent_op);
1647 } else if (ret == -ENOENT) {
1648 ret = setup_inline_extent_backref(trans, root, path, iref,
1649 parent, root_objectid,
1650 owner, offset, refs_to_add,
1651 extent_op);
1652 }
1653 return ret;
1654}
1655
1656static int insert_extent_backref(struct btrfs_trans_handle *trans,
1657 struct btrfs_root *root,
1658 struct btrfs_path *path,
1659 u64 bytenr, u64 parent, u64 root_objectid,
1660 u64 owner, u64 offset, int refs_to_add)
1661{
1662 int ret;
1663 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1664 BUG_ON(refs_to_add != 1);
1665 ret = insert_tree_block_ref(trans, root, path, bytenr,
1666 parent, root_objectid);
1667 } else {
1668 ret = insert_extent_data_ref(trans, root, path, bytenr,
1669 parent, root_objectid,
1670 owner, offset, refs_to_add);
1671 }
1672 return ret;
1673}
1674
1675static int remove_extent_backref(struct btrfs_trans_handle *trans,
1676 struct btrfs_root *root,
1677 struct btrfs_path *path,
1678 struct btrfs_extent_inline_ref *iref,
1679 int refs_to_drop, int is_data)
1680{
1681 int ret;
1682
1683 BUG_ON(!is_data && refs_to_drop != 1);
1684 if (iref) {
1685 ret = update_inline_extent_backref(trans, root, path, iref,
1686 -refs_to_drop, NULL);
1687 } else if (is_data) {
1688 ret = remove_extent_data_ref(trans, root, path, refs_to_drop);
1689 } else {
1690 ret = btrfs_del_item(trans, root, path);
1691 }
1692 return ret;
1693}
1694
Chris Mason15916de2008-11-19 21:17:22 -05001695static void btrfs_issue_discard(struct block_device *bdev,
1696 u64 start, u64 len)
1697{
Christoph Hellwig746cd1e2009-09-12 07:35:43 +02001698 blkdev_issue_discard(bdev, start >> 9, len >> 9, GFP_KERNEL,
Dmitry Monakhovfbd9b092010-04-28 17:55:06 +04001699 BLKDEV_IFL_WAIT | BLKDEV_IFL_BARRIER);
Chris Mason15916de2008-11-19 21:17:22 -05001700}
Chris Mason15916de2008-11-19 21:17:22 -05001701
Liu Hui1f3c79a2009-01-05 15:57:51 -05001702static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr,
1703 u64 num_bytes)
1704{
Liu Hui1f3c79a2009-01-05 15:57:51 -05001705 int ret;
1706 u64 map_length = num_bytes;
1707 struct btrfs_multi_bio *multi = NULL;
1708
Christoph Hellwige244a0a2009-10-14 09:24:59 -04001709 if (!btrfs_test_opt(root, DISCARD))
1710 return 0;
1711
Liu Hui1f3c79a2009-01-05 15:57:51 -05001712 /* Tell the block device(s) that the sectors can be discarded */
1713 ret = btrfs_map_block(&root->fs_info->mapping_tree, READ,
1714 bytenr, &map_length, &multi, 0);
1715 if (!ret) {
1716 struct btrfs_bio_stripe *stripe = multi->stripes;
1717 int i;
1718
1719 if (map_length > num_bytes)
1720 map_length = num_bytes;
1721
1722 for (i = 0; i < multi->num_stripes; i++, stripe++) {
1723 btrfs_issue_discard(stripe->dev->bdev,
1724 stripe->physical,
1725 map_length);
1726 }
1727 kfree(multi);
1728 }
1729
1730 return ret;
Liu Hui1f3c79a2009-01-05 15:57:51 -05001731}
1732
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001733int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
1734 struct btrfs_root *root,
1735 u64 bytenr, u64 num_bytes, u64 parent,
1736 u64 root_objectid, u64 owner, u64 offset)
Zheng Yan31840ae2008-09-23 13:14:14 -04001737{
1738 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001739 BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID &&
1740 root_objectid == BTRFS_TREE_LOG_OBJECTID);
Zheng Yan31840ae2008-09-23 13:14:14 -04001741
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001742 if (owner < BTRFS_FIRST_FREE_OBJECTID) {
1743 ret = btrfs_add_delayed_tree_ref(trans, bytenr, num_bytes,
1744 parent, root_objectid, (int)owner,
1745 BTRFS_ADD_DELAYED_REF, NULL);
1746 } else {
1747 ret = btrfs_add_delayed_data_ref(trans, bytenr, num_bytes,
1748 parent, root_objectid, owner, offset,
1749 BTRFS_ADD_DELAYED_REF, NULL);
1750 }
Zheng Yan31840ae2008-09-23 13:14:14 -04001751 return ret;
1752}
1753
Chris Mason925baed2008-06-25 16:01:30 -04001754static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001755 struct btrfs_root *root,
1756 u64 bytenr, u64 num_bytes,
1757 u64 parent, u64 root_objectid,
1758 u64 owner, u64 offset, int refs_to_add,
1759 struct btrfs_delayed_extent_op *extent_op)
Chris Mason56bec292009-03-13 10:10:06 -04001760{
Chris Mason5caf2a02007-04-02 11:20:42 -04001761 struct btrfs_path *path;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001762 struct extent_buffer *leaf;
Chris Mason234b63a2007-03-13 10:46:10 -04001763 struct btrfs_extent_item *item;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001764 u64 refs;
1765 int ret;
1766 int err = 0;
Chris Mason037e6392007-03-07 11:50:24 -05001767
Chris Mason5caf2a02007-04-02 11:20:42 -04001768 path = btrfs_alloc_path();
Chris Mason54aa1f42007-06-22 14:16:25 -04001769 if (!path)
1770 return -ENOMEM;
Chris Mason26b80032007-08-08 20:17:12 -04001771
Chris Mason3c12ac72008-04-21 12:01:38 -04001772 path->reada = 1;
Chris Masonb9473432009-03-13 11:00:37 -04001773 path->leave_spinning = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001774 /* this will setup the path even if it fails to insert the back ref */
1775 ret = insert_inline_extent_backref(trans, root->fs_info->extent_root,
1776 path, bytenr, num_bytes, parent,
1777 root_objectid, owner, offset,
1778 refs_to_add, extent_op);
1779 if (ret == 0)
1780 goto out;
Zheng Yan31840ae2008-09-23 13:14:14 -04001781
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001782 if (ret != -EAGAIN) {
1783 err = ret;
1784 goto out;
Chris Masonb9473432009-03-13 11:00:37 -04001785 }
Zheng Yan31840ae2008-09-23 13:14:14 -04001786
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001787 leaf = path->nodes[0];
1788 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1789 refs = btrfs_extent_refs(leaf, item);
1790 btrfs_set_extent_refs(leaf, item, refs + refs_to_add);
1791 if (extent_op)
1792 __run_delayed_extent_op(extent_op, leaf, item);
Zheng Yan31840ae2008-09-23 13:14:14 -04001793
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001794 btrfs_mark_buffer_dirty(leaf);
Chris Mason5caf2a02007-04-02 11:20:42 -04001795 btrfs_release_path(root->fs_info->extent_root, path);
Chris Mason7bb86312007-12-11 09:25:06 -05001796
Chris Mason3c12ac72008-04-21 12:01:38 -04001797 path->reada = 1;
Chris Masonb9473432009-03-13 11:00:37 -04001798 path->leave_spinning = 1;
1799
Chris Mason56bec292009-03-13 10:10:06 -04001800 /* now insert the actual backref */
Zheng Yan31840ae2008-09-23 13:14:14 -04001801 ret = insert_extent_backref(trans, root->fs_info->extent_root,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001802 path, bytenr, parent, root_objectid,
1803 owner, offset, refs_to_add);
Chris Mason7bb86312007-12-11 09:25:06 -05001804 BUG_ON(ret);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001805out:
Chris Mason74493f72007-12-11 09:25:06 -05001806 btrfs_free_path(path);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001807 return err;
Chris Mason02217ed2007-03-02 16:08:05 -05001808}
1809
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001810static int run_delayed_data_ref(struct btrfs_trans_handle *trans,
1811 struct btrfs_root *root,
1812 struct btrfs_delayed_ref_node *node,
1813 struct btrfs_delayed_extent_op *extent_op,
1814 int insert_reserved)
Chris Masone9d0b132007-08-10 14:06:19 -04001815{
Chris Mason56bec292009-03-13 10:10:06 -04001816 int ret = 0;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001817 struct btrfs_delayed_data_ref *ref;
1818 struct btrfs_key ins;
1819 u64 parent = 0;
1820 u64 ref_root = 0;
1821 u64 flags = 0;
Chris Mason56bec292009-03-13 10:10:06 -04001822
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001823 ins.objectid = node->bytenr;
1824 ins.offset = node->num_bytes;
1825 ins.type = BTRFS_EXTENT_ITEM_KEY;
Chris Mason56bec292009-03-13 10:10:06 -04001826
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001827 ref = btrfs_delayed_node_to_data_ref(node);
1828 if (node->type == BTRFS_SHARED_DATA_REF_KEY)
1829 parent = ref->parent;
1830 else
1831 ref_root = ref->root;
1832
1833 if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
1834 if (extent_op) {
1835 BUG_ON(extent_op->update_key);
1836 flags |= extent_op->flags_to_set;
1837 }
1838 ret = alloc_reserved_file_extent(trans, root,
1839 parent, ref_root, flags,
1840 ref->objectid, ref->offset,
1841 &ins, node->ref_mod);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001842 } else if (node->action == BTRFS_ADD_DELAYED_REF) {
1843 ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
1844 node->num_bytes, parent,
1845 ref_root, ref->objectid,
1846 ref->offset, node->ref_mod,
1847 extent_op);
1848 } else if (node->action == BTRFS_DROP_DELAYED_REF) {
1849 ret = __btrfs_free_extent(trans, root, node->bytenr,
1850 node->num_bytes, parent,
1851 ref_root, ref->objectid,
1852 ref->offset, node->ref_mod,
1853 extent_op);
1854 } else {
1855 BUG();
1856 }
Chris Mason56bec292009-03-13 10:10:06 -04001857 return ret;
1858}
1859
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001860static void __run_delayed_extent_op(struct btrfs_delayed_extent_op *extent_op,
1861 struct extent_buffer *leaf,
1862 struct btrfs_extent_item *ei)
1863{
1864 u64 flags = btrfs_extent_flags(leaf, ei);
1865 if (extent_op->update_flags) {
1866 flags |= extent_op->flags_to_set;
1867 btrfs_set_extent_flags(leaf, ei, flags);
1868 }
1869
1870 if (extent_op->update_key) {
1871 struct btrfs_tree_block_info *bi;
1872 BUG_ON(!(flags & BTRFS_EXTENT_FLAG_TREE_BLOCK));
1873 bi = (struct btrfs_tree_block_info *)(ei + 1);
1874 btrfs_set_tree_block_key(leaf, bi, &extent_op->key);
1875 }
1876}
1877
1878static int run_delayed_extent_op(struct btrfs_trans_handle *trans,
1879 struct btrfs_root *root,
1880 struct btrfs_delayed_ref_node *node,
1881 struct btrfs_delayed_extent_op *extent_op)
1882{
1883 struct btrfs_key key;
1884 struct btrfs_path *path;
1885 struct btrfs_extent_item *ei;
1886 struct extent_buffer *leaf;
1887 u32 item_size;
1888 int ret;
1889 int err = 0;
1890
1891 path = btrfs_alloc_path();
1892 if (!path)
1893 return -ENOMEM;
1894
1895 key.objectid = node->bytenr;
1896 key.type = BTRFS_EXTENT_ITEM_KEY;
1897 key.offset = node->num_bytes;
1898
1899 path->reada = 1;
1900 path->leave_spinning = 1;
1901 ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key,
1902 path, 0, 1);
1903 if (ret < 0) {
1904 err = ret;
1905 goto out;
1906 }
1907 if (ret > 0) {
1908 err = -EIO;
1909 goto out;
1910 }
1911
1912 leaf = path->nodes[0];
1913 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1914#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
1915 if (item_size < sizeof(*ei)) {
1916 ret = convert_extent_item_v0(trans, root->fs_info->extent_root,
1917 path, (u64)-1, 0);
1918 if (ret < 0) {
1919 err = ret;
1920 goto out;
1921 }
1922 leaf = path->nodes[0];
1923 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
1924 }
1925#endif
1926 BUG_ON(item_size < sizeof(*ei));
1927 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
1928 __run_delayed_extent_op(extent_op, leaf, ei);
1929
1930 btrfs_mark_buffer_dirty(leaf);
1931out:
1932 btrfs_free_path(path);
1933 return err;
1934}
1935
1936static int run_delayed_tree_ref(struct btrfs_trans_handle *trans,
1937 struct btrfs_root *root,
1938 struct btrfs_delayed_ref_node *node,
1939 struct btrfs_delayed_extent_op *extent_op,
1940 int insert_reserved)
1941{
1942 int ret = 0;
1943 struct btrfs_delayed_tree_ref *ref;
1944 struct btrfs_key ins;
1945 u64 parent = 0;
1946 u64 ref_root = 0;
1947
1948 ins.objectid = node->bytenr;
1949 ins.offset = node->num_bytes;
1950 ins.type = BTRFS_EXTENT_ITEM_KEY;
1951
1952 ref = btrfs_delayed_node_to_tree_ref(node);
1953 if (node->type == BTRFS_SHARED_BLOCK_REF_KEY)
1954 parent = ref->parent;
1955 else
1956 ref_root = ref->root;
1957
1958 BUG_ON(node->ref_mod != 1);
1959 if (node->action == BTRFS_ADD_DELAYED_REF && insert_reserved) {
1960 BUG_ON(!extent_op || !extent_op->update_flags ||
1961 !extent_op->update_key);
1962 ret = alloc_reserved_tree_block(trans, root,
1963 parent, ref_root,
1964 extent_op->flags_to_set,
1965 &extent_op->key,
1966 ref->level, &ins);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001967 } else if (node->action == BTRFS_ADD_DELAYED_REF) {
1968 ret = __btrfs_inc_extent_ref(trans, root, node->bytenr,
1969 node->num_bytes, parent, ref_root,
1970 ref->level, 0, 1, extent_op);
1971 } else if (node->action == BTRFS_DROP_DELAYED_REF) {
1972 ret = __btrfs_free_extent(trans, root, node->bytenr,
1973 node->num_bytes, parent, ref_root,
1974 ref->level, 0, 1, extent_op);
1975 } else {
1976 BUG();
1977 }
1978 return ret;
1979}
1980
Chris Mason56bec292009-03-13 10:10:06 -04001981/* helper function to actually process a single delayed ref entry */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001982static int run_one_delayed_ref(struct btrfs_trans_handle *trans,
1983 struct btrfs_root *root,
1984 struct btrfs_delayed_ref_node *node,
1985 struct btrfs_delayed_extent_op *extent_op,
1986 int insert_reserved)
Chris Mason56bec292009-03-13 10:10:06 -04001987{
Josef Bacikeb099672009-02-12 09:27:38 -05001988 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001989 if (btrfs_delayed_ref_is_head(node)) {
Chris Mason56bec292009-03-13 10:10:06 -04001990 struct btrfs_delayed_ref_head *head;
1991 /*
1992 * we've hit the end of the chain and we were supposed
1993 * to insert this extent into the tree. But, it got
1994 * deleted before we ever needed to insert it, so all
1995 * we have to do is clean up the accounting
1996 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04001997 BUG_ON(extent_op);
1998 head = btrfs_delayed_node_to_head(node);
Chris Mason56bec292009-03-13 10:10:06 -04001999 if (insert_reserved) {
Yan, Zhengf0486c62010-05-16 10:46:25 -04002000 btrfs_pin_extent(root, node->bytenr,
2001 node->num_bytes, 1);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002002 if (head->is_data) {
2003 ret = btrfs_del_csums(trans, root,
2004 node->bytenr,
2005 node->num_bytes);
2006 BUG_ON(ret);
2007 }
Chris Mason56bec292009-03-13 10:10:06 -04002008 }
Chris Mason56bec292009-03-13 10:10:06 -04002009 mutex_unlock(&head->mutex);
2010 return 0;
2011 }
Josef Bacikeb099672009-02-12 09:27:38 -05002012
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002013 if (node->type == BTRFS_TREE_BLOCK_REF_KEY ||
2014 node->type == BTRFS_SHARED_BLOCK_REF_KEY)
2015 ret = run_delayed_tree_ref(trans, root, node, extent_op,
2016 insert_reserved);
2017 else if (node->type == BTRFS_EXTENT_DATA_REF_KEY ||
2018 node->type == BTRFS_SHARED_DATA_REF_KEY)
2019 ret = run_delayed_data_ref(trans, root, node, extent_op,
2020 insert_reserved);
2021 else
2022 BUG();
2023 return ret;
Chris Masone9d0b132007-08-10 14:06:19 -04002024}
2025
Chris Mason56bec292009-03-13 10:10:06 -04002026static noinline struct btrfs_delayed_ref_node *
2027select_delayed_ref(struct btrfs_delayed_ref_head *head)
Chris Masona28ec192007-03-06 20:08:01 -05002028{
Chris Mason56bec292009-03-13 10:10:06 -04002029 struct rb_node *node;
2030 struct btrfs_delayed_ref_node *ref;
2031 int action = BTRFS_ADD_DELAYED_REF;
2032again:
2033 /*
2034 * select delayed ref of type BTRFS_ADD_DELAYED_REF first.
2035 * this prevents ref count from going down to zero when
2036 * there still are pending delayed ref.
2037 */
2038 node = rb_prev(&head->node.rb_node);
2039 while (1) {
2040 if (!node)
2041 break;
2042 ref = rb_entry(node, struct btrfs_delayed_ref_node,
2043 rb_node);
2044 if (ref->bytenr != head->node.bytenr)
2045 break;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002046 if (ref->action == action)
Chris Mason56bec292009-03-13 10:10:06 -04002047 return ref;
2048 node = rb_prev(node);
Chris Mason5f39d392007-10-15 16:14:19 -04002049 }
Chris Mason56bec292009-03-13 10:10:06 -04002050 if (action == BTRFS_ADD_DELAYED_REF) {
2051 action = BTRFS_DROP_DELAYED_REF;
2052 goto again;
2053 }
2054 return NULL;
2055}
2056
Chris Masonc3e69d52009-03-13 10:17:05 -04002057static noinline int run_clustered_refs(struct btrfs_trans_handle *trans,
2058 struct btrfs_root *root,
2059 struct list_head *cluster)
Chris Mason56bec292009-03-13 10:10:06 -04002060{
Chris Mason56bec292009-03-13 10:10:06 -04002061 struct btrfs_delayed_ref_root *delayed_refs;
2062 struct btrfs_delayed_ref_node *ref;
2063 struct btrfs_delayed_ref_head *locked_ref = NULL;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002064 struct btrfs_delayed_extent_op *extent_op;
Chris Mason56bec292009-03-13 10:10:06 -04002065 int ret;
Chris Masonc3e69d52009-03-13 10:17:05 -04002066 int count = 0;
Chris Mason56bec292009-03-13 10:10:06 -04002067 int must_insert_reserved = 0;
Chris Mason56bec292009-03-13 10:10:06 -04002068
2069 delayed_refs = &trans->transaction->delayed_refs;
Chris Mason56bec292009-03-13 10:10:06 -04002070 while (1) {
2071 if (!locked_ref) {
Chris Masonc3e69d52009-03-13 10:17:05 -04002072 /* pick a new head ref from the cluster list */
2073 if (list_empty(cluster))
Chris Mason56bec292009-03-13 10:10:06 -04002074 break;
Chris Mason56bec292009-03-13 10:10:06 -04002075
Chris Masonc3e69d52009-03-13 10:17:05 -04002076 locked_ref = list_entry(cluster->next,
2077 struct btrfs_delayed_ref_head, cluster);
2078
2079 /* grab the lock that says we are going to process
2080 * all the refs for this head */
2081 ret = btrfs_delayed_ref_lock(trans, locked_ref);
2082
2083 /*
2084 * we may have dropped the spin lock to get the head
2085 * mutex lock, and that might have given someone else
2086 * time to free the head. If that's true, it has been
2087 * removed from our list and we can move on.
2088 */
2089 if (ret == -EAGAIN) {
2090 locked_ref = NULL;
2091 count++;
2092 continue;
Chris Mason56bec292009-03-13 10:10:06 -04002093 }
2094 }
2095
2096 /*
2097 * record the must insert reserved flag before we
2098 * drop the spin lock.
2099 */
2100 must_insert_reserved = locked_ref->must_insert_reserved;
2101 locked_ref->must_insert_reserved = 0;
2102
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002103 extent_op = locked_ref->extent_op;
2104 locked_ref->extent_op = NULL;
2105
Chris Mason56bec292009-03-13 10:10:06 -04002106 /*
2107 * locked_ref is the head node, so we have to go one
2108 * node back for any delayed ref updates
2109 */
Chris Mason56bec292009-03-13 10:10:06 -04002110 ref = select_delayed_ref(locked_ref);
2111 if (!ref) {
2112 /* All delayed refs have been processed, Go ahead
2113 * and send the head node to run_one_delayed_ref,
2114 * so that any accounting fixes can happen
2115 */
2116 ref = &locked_ref->node;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002117
2118 if (extent_op && must_insert_reserved) {
2119 kfree(extent_op);
2120 extent_op = NULL;
2121 }
2122
2123 if (extent_op) {
2124 spin_unlock(&delayed_refs->lock);
2125
2126 ret = run_delayed_extent_op(trans, root,
2127 ref, extent_op);
2128 BUG_ON(ret);
2129 kfree(extent_op);
2130
2131 cond_resched();
2132 spin_lock(&delayed_refs->lock);
2133 continue;
2134 }
2135
Chris Masonc3e69d52009-03-13 10:17:05 -04002136 list_del_init(&locked_ref->cluster);
Chris Mason56bec292009-03-13 10:10:06 -04002137 locked_ref = NULL;
2138 }
2139
2140 ref->in_tree = 0;
2141 rb_erase(&ref->rb_node, &delayed_refs->root);
2142 delayed_refs->num_entries--;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002143
Chris Mason56bec292009-03-13 10:10:06 -04002144 spin_unlock(&delayed_refs->lock);
2145
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002146 ret = run_one_delayed_ref(trans, root, ref, extent_op,
Chris Mason56bec292009-03-13 10:10:06 -04002147 must_insert_reserved);
2148 BUG_ON(ret);
Chris Mason56bec292009-03-13 10:10:06 -04002149
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002150 btrfs_put_delayed_ref(ref);
2151 kfree(extent_op);
Chris Masonc3e69d52009-03-13 10:17:05 -04002152 count++;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002153
Chris Mason1887be62009-03-13 10:11:24 -04002154 cond_resched();
Chris Mason56bec292009-03-13 10:10:06 -04002155 spin_lock(&delayed_refs->lock);
2156 }
Chris Masonc3e69d52009-03-13 10:17:05 -04002157 return count;
2158}
2159
2160/*
2161 * this starts processing the delayed reference count updates and
2162 * extent insertions we have queued up so far. count can be
2163 * 0, which means to process everything in the tree at the start
2164 * of the run (but not newly added entries), or it can be some target
2165 * number you'd like to process.
2166 */
2167int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans,
2168 struct btrfs_root *root, unsigned long count)
2169{
2170 struct rb_node *node;
2171 struct btrfs_delayed_ref_root *delayed_refs;
2172 struct btrfs_delayed_ref_node *ref;
2173 struct list_head cluster;
2174 int ret;
2175 int run_all = count == (unsigned long)-1;
2176 int run_most = 0;
2177
2178 if (root == root->fs_info->extent_root)
2179 root = root->fs_info->tree_root;
2180
2181 delayed_refs = &trans->transaction->delayed_refs;
2182 INIT_LIST_HEAD(&cluster);
2183again:
2184 spin_lock(&delayed_refs->lock);
2185 if (count == 0) {
2186 count = delayed_refs->num_entries * 2;
2187 run_most = 1;
2188 }
2189 while (1) {
2190 if (!(run_all || run_most) &&
2191 delayed_refs->num_heads_ready < 64)
2192 break;
2193
2194 /*
2195 * go find something we can process in the rbtree. We start at
2196 * the beginning of the tree, and then build a cluster
2197 * of refs to process starting at the first one we are able to
2198 * lock
2199 */
2200 ret = btrfs_find_ref_cluster(trans, &cluster,
2201 delayed_refs->run_delayed_start);
2202 if (ret)
2203 break;
2204
2205 ret = run_clustered_refs(trans, root, &cluster);
2206 BUG_ON(ret < 0);
2207
2208 count -= min_t(unsigned long, ret, count);
2209
2210 if (count == 0)
2211 break;
2212 }
2213
Chris Mason56bec292009-03-13 10:10:06 -04002214 if (run_all) {
Chris Mason56bec292009-03-13 10:10:06 -04002215 node = rb_first(&delayed_refs->root);
Chris Masonc3e69d52009-03-13 10:17:05 -04002216 if (!node)
Chris Mason56bec292009-03-13 10:10:06 -04002217 goto out;
Chris Masonc3e69d52009-03-13 10:17:05 -04002218 count = (unsigned long)-1;
Chris Mason56bec292009-03-13 10:10:06 -04002219
2220 while (node) {
2221 ref = rb_entry(node, struct btrfs_delayed_ref_node,
2222 rb_node);
2223 if (btrfs_delayed_ref_is_head(ref)) {
2224 struct btrfs_delayed_ref_head *head;
2225
2226 head = btrfs_delayed_node_to_head(ref);
2227 atomic_inc(&ref->refs);
2228
2229 spin_unlock(&delayed_refs->lock);
2230 mutex_lock(&head->mutex);
2231 mutex_unlock(&head->mutex);
2232
2233 btrfs_put_delayed_ref(ref);
Chris Mason1887be62009-03-13 10:11:24 -04002234 cond_resched();
Chris Mason56bec292009-03-13 10:10:06 -04002235 goto again;
2236 }
2237 node = rb_next(node);
2238 }
2239 spin_unlock(&delayed_refs->lock);
Chris Mason56bec292009-03-13 10:10:06 -04002240 schedule_timeout(1);
2241 goto again;
2242 }
Chris Mason54aa1f42007-06-22 14:16:25 -04002243out:
Chris Masonc3e69d52009-03-13 10:17:05 -04002244 spin_unlock(&delayed_refs->lock);
Chris Masona28ec192007-03-06 20:08:01 -05002245 return 0;
2246}
2247
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002248int btrfs_set_disk_extent_flags(struct btrfs_trans_handle *trans,
2249 struct btrfs_root *root,
2250 u64 bytenr, u64 num_bytes, u64 flags,
2251 int is_data)
2252{
2253 struct btrfs_delayed_extent_op *extent_op;
2254 int ret;
2255
2256 extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
2257 if (!extent_op)
2258 return -ENOMEM;
2259
2260 extent_op->flags_to_set = flags;
2261 extent_op->update_flags = 1;
2262 extent_op->update_key = 0;
2263 extent_op->is_data = is_data ? 1 : 0;
2264
2265 ret = btrfs_add_delayed_extent_op(trans, bytenr, num_bytes, extent_op);
2266 if (ret)
2267 kfree(extent_op);
2268 return ret;
2269}
2270
2271static noinline int check_delayed_ref(struct btrfs_trans_handle *trans,
2272 struct btrfs_root *root,
2273 struct btrfs_path *path,
2274 u64 objectid, u64 offset, u64 bytenr)
2275{
2276 struct btrfs_delayed_ref_head *head;
2277 struct btrfs_delayed_ref_node *ref;
2278 struct btrfs_delayed_data_ref *data_ref;
2279 struct btrfs_delayed_ref_root *delayed_refs;
2280 struct rb_node *node;
2281 int ret = 0;
2282
2283 ret = -ENOENT;
2284 delayed_refs = &trans->transaction->delayed_refs;
2285 spin_lock(&delayed_refs->lock);
2286 head = btrfs_find_delayed_ref_head(trans, bytenr);
2287 if (!head)
2288 goto out;
2289
2290 if (!mutex_trylock(&head->mutex)) {
2291 atomic_inc(&head->node.refs);
2292 spin_unlock(&delayed_refs->lock);
2293
2294 btrfs_release_path(root->fs_info->extent_root, path);
2295
2296 mutex_lock(&head->mutex);
2297 mutex_unlock(&head->mutex);
2298 btrfs_put_delayed_ref(&head->node);
2299 return -EAGAIN;
2300 }
2301
2302 node = rb_prev(&head->node.rb_node);
2303 if (!node)
2304 goto out_unlock;
2305
2306 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2307
2308 if (ref->bytenr != bytenr)
2309 goto out_unlock;
2310
2311 ret = 1;
2312 if (ref->type != BTRFS_EXTENT_DATA_REF_KEY)
2313 goto out_unlock;
2314
2315 data_ref = btrfs_delayed_node_to_data_ref(ref);
2316
2317 node = rb_prev(node);
2318 if (node) {
2319 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
2320 if (ref->bytenr == bytenr)
2321 goto out_unlock;
2322 }
2323
2324 if (data_ref->root != root->root_key.objectid ||
2325 data_ref->objectid != objectid || data_ref->offset != offset)
2326 goto out_unlock;
2327
2328 ret = 0;
2329out_unlock:
2330 mutex_unlock(&head->mutex);
2331out:
2332 spin_unlock(&delayed_refs->lock);
2333 return ret;
2334}
2335
2336static noinline int check_committed_ref(struct btrfs_trans_handle *trans,
2337 struct btrfs_root *root,
2338 struct btrfs_path *path,
2339 u64 objectid, u64 offset, u64 bytenr)
Chris Masonbe20aa92007-12-17 20:14:01 -05002340{
2341 struct btrfs_root *extent_root = root->fs_info->extent_root;
Yan Zhengf321e492008-07-30 09:26:11 -04002342 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002343 struct btrfs_extent_data_ref *ref;
2344 struct btrfs_extent_inline_ref *iref;
2345 struct btrfs_extent_item *ei;
Chris Masonbe20aa92007-12-17 20:14:01 -05002346 struct btrfs_key key;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002347 u32 item_size;
Yan Zhengf321e492008-07-30 09:26:11 -04002348 int ret;
Chris Masonbe20aa92007-12-17 20:14:01 -05002349
Chris Masonbe20aa92007-12-17 20:14:01 -05002350 key.objectid = bytenr;
Zheng Yan31840ae2008-09-23 13:14:14 -04002351 key.offset = (u64)-1;
Yan Zhengf321e492008-07-30 09:26:11 -04002352 key.type = BTRFS_EXTENT_ITEM_KEY;
Chris Masonbe20aa92007-12-17 20:14:01 -05002353
Chris Masonbe20aa92007-12-17 20:14:01 -05002354 ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0);
2355 if (ret < 0)
2356 goto out;
2357 BUG_ON(ret == 0);
Yan Zheng80ff3852008-10-30 14:20:02 -04002358
2359 ret = -ENOENT;
2360 if (path->slots[0] == 0)
Zheng Yan31840ae2008-09-23 13:14:14 -04002361 goto out;
Chris Masonbe20aa92007-12-17 20:14:01 -05002362
Zheng Yan31840ae2008-09-23 13:14:14 -04002363 path->slots[0]--;
Yan Zhengf321e492008-07-30 09:26:11 -04002364 leaf = path->nodes[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002365 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
Chris Masonbe20aa92007-12-17 20:14:01 -05002366
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002367 if (key.objectid != bytenr || key.type != BTRFS_EXTENT_ITEM_KEY)
Chris Masonbe20aa92007-12-17 20:14:01 -05002368 goto out;
Chris Masonbe20aa92007-12-17 20:14:01 -05002369
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002370 ret = 1;
2371 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
2372#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
2373 if (item_size < sizeof(*ei)) {
2374 WARN_ON(item_size != sizeof(struct btrfs_extent_item_v0));
2375 goto out;
Chris Masonbe20aa92007-12-17 20:14:01 -05002376 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002377#endif
2378 ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item);
2379
2380 if (item_size != sizeof(*ei) +
2381 btrfs_extent_inline_ref_size(BTRFS_EXTENT_DATA_REF_KEY))
2382 goto out;
2383
2384 if (btrfs_extent_generation(leaf, ei) <=
2385 btrfs_root_last_snapshot(&root->root_item))
2386 goto out;
2387
2388 iref = (struct btrfs_extent_inline_ref *)(ei + 1);
2389 if (btrfs_extent_inline_ref_type(leaf, iref) !=
2390 BTRFS_EXTENT_DATA_REF_KEY)
2391 goto out;
2392
2393 ref = (struct btrfs_extent_data_ref *)(&iref->offset);
2394 if (btrfs_extent_refs(leaf, ei) !=
2395 btrfs_extent_data_ref_count(leaf, ref) ||
2396 btrfs_extent_data_ref_root(leaf, ref) !=
2397 root->root_key.objectid ||
2398 btrfs_extent_data_ref_objectid(leaf, ref) != objectid ||
2399 btrfs_extent_data_ref_offset(leaf, ref) != offset)
2400 goto out;
2401
Yan Zhengf321e492008-07-30 09:26:11 -04002402 ret = 0;
Chris Masonbe20aa92007-12-17 20:14:01 -05002403out:
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002404 return ret;
2405}
2406
2407int btrfs_cross_ref_exist(struct btrfs_trans_handle *trans,
2408 struct btrfs_root *root,
2409 u64 objectid, u64 offset, u64 bytenr)
2410{
2411 struct btrfs_path *path;
2412 int ret;
2413 int ret2;
2414
2415 path = btrfs_alloc_path();
2416 if (!path)
2417 return -ENOENT;
2418
2419 do {
2420 ret = check_committed_ref(trans, root, path, objectid,
2421 offset, bytenr);
2422 if (ret && ret != -ENOENT)
2423 goto out;
2424
2425 ret2 = check_delayed_ref(trans, root, path, objectid,
2426 offset, bytenr);
2427 } while (ret2 == -EAGAIN);
2428
2429 if (ret2 && ret2 != -ENOENT) {
2430 ret = ret2;
2431 goto out;
2432 }
2433
2434 if (ret != -ENOENT || ret2 != -ENOENT)
2435 ret = 0;
2436out:
Yan Zhengf321e492008-07-30 09:26:11 -04002437 btrfs_free_path(path);
Yan, Zhengf0486c62010-05-16 10:46:25 -04002438 if (root->root_key.objectid == BTRFS_DATA_RELOC_TREE_OBJECTID)
2439 WARN_ON(ret > 0);
Yan Zhengf321e492008-07-30 09:26:11 -04002440 return ret;
2441}
2442
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002443#if 0
Zheng Yan31840ae2008-09-23 13:14:14 -04002444int btrfs_cache_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2445 struct extent_buffer *buf, u32 nr_extents)
Chris Mason02217ed2007-03-02 16:08:05 -05002446{
Chris Mason5f39d392007-10-15 16:14:19 -04002447 struct btrfs_key key;
Chris Mason6407bf62007-03-27 06:33:00 -04002448 struct btrfs_file_extent_item *fi;
Zheng Yane4657682008-09-26 10:04:53 -04002449 u64 root_gen;
2450 u32 nritems;
Chris Mason02217ed2007-03-02 16:08:05 -05002451 int i;
Chris Masondb945352007-10-15 16:15:53 -04002452 int level;
Zheng Yan31840ae2008-09-23 13:14:14 -04002453 int ret = 0;
Zheng Yane4657682008-09-26 10:04:53 -04002454 int shared = 0;
Chris Masona28ec192007-03-06 20:08:01 -05002455
Chris Mason3768f362007-03-13 16:47:54 -04002456 if (!root->ref_cows)
Chris Masona28ec192007-03-06 20:08:01 -05002457 return 0;
Chris Mason5f39d392007-10-15 16:14:19 -04002458
Zheng Yane4657682008-09-26 10:04:53 -04002459 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
2460 shared = 0;
2461 root_gen = root->root_key.offset;
2462 } else {
2463 shared = 1;
2464 root_gen = trans->transid - 1;
2465 }
2466
Chris Masondb945352007-10-15 16:15:53 -04002467 level = btrfs_header_level(buf);
Chris Mason5f39d392007-10-15 16:14:19 -04002468 nritems = btrfs_header_nritems(buf);
Chris Mason4a096752008-07-21 10:29:44 -04002469
Zheng Yan31840ae2008-09-23 13:14:14 -04002470 if (level == 0) {
Yan Zheng31153d82008-07-28 15:32:19 -04002471 struct btrfs_leaf_ref *ref;
2472 struct btrfs_extent_info *info;
2473
Zheng Yan31840ae2008-09-23 13:14:14 -04002474 ref = btrfs_alloc_leaf_ref(root, nr_extents);
Yan Zheng31153d82008-07-28 15:32:19 -04002475 if (!ref) {
Zheng Yan31840ae2008-09-23 13:14:14 -04002476 ret = -ENOMEM;
Yan Zheng31153d82008-07-28 15:32:19 -04002477 goto out;
2478 }
2479
Zheng Yane4657682008-09-26 10:04:53 -04002480 ref->root_gen = root_gen;
Yan Zheng31153d82008-07-28 15:32:19 -04002481 ref->bytenr = buf->start;
2482 ref->owner = btrfs_header_owner(buf);
2483 ref->generation = btrfs_header_generation(buf);
Zheng Yan31840ae2008-09-23 13:14:14 -04002484 ref->nritems = nr_extents;
Yan Zheng31153d82008-07-28 15:32:19 -04002485 info = ref->extents;
Yanbcc63ab2008-07-30 16:29:20 -04002486
Zheng Yan31840ae2008-09-23 13:14:14 -04002487 for (i = 0; nr_extents > 0 && i < nritems; i++) {
Yan Zheng31153d82008-07-28 15:32:19 -04002488 u64 disk_bytenr;
2489 btrfs_item_key_to_cpu(buf, &key, i);
2490 if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
2491 continue;
2492 fi = btrfs_item_ptr(buf, i,
2493 struct btrfs_file_extent_item);
2494 if (btrfs_file_extent_type(buf, fi) ==
2495 BTRFS_FILE_EXTENT_INLINE)
2496 continue;
2497 disk_bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
2498 if (disk_bytenr == 0)
2499 continue;
2500
2501 info->bytenr = disk_bytenr;
2502 info->num_bytes =
2503 btrfs_file_extent_disk_num_bytes(buf, fi);
2504 info->objectid = key.objectid;
2505 info->offset = key.offset;
2506 info++;
2507 }
2508
Zheng Yane4657682008-09-26 10:04:53 -04002509 ret = btrfs_add_leaf_ref(root, ref, shared);
Yan Zheng5b84e8d2008-10-09 11:46:19 -04002510 if (ret == -EEXIST && shared) {
2511 struct btrfs_leaf_ref *old;
2512 old = btrfs_lookup_leaf_ref(root, ref->bytenr);
2513 BUG_ON(!old);
2514 btrfs_remove_leaf_ref(root, old);
2515 btrfs_free_leaf_ref(root, old);
2516 ret = btrfs_add_leaf_ref(root, ref, shared);
2517 }
Yan Zheng31153d82008-07-28 15:32:19 -04002518 WARN_ON(ret);
Yanbcc63ab2008-07-30 16:29:20 -04002519 btrfs_free_leaf_ref(root, ref);
Yan Zheng31153d82008-07-28 15:32:19 -04002520 }
2521out:
Zheng Yan31840ae2008-09-23 13:14:14 -04002522 return ret;
2523}
2524
Chris Masonb7a9f292009-02-04 09:23:45 -05002525/* when a block goes through cow, we update the reference counts of
2526 * everything that block points to. The internal pointers of the block
2527 * can be in just about any order, and it is likely to have clusters of
2528 * things that are close together and clusters of things that are not.
2529 *
2530 * To help reduce the seeks that come with updating all of these reference
2531 * counts, sort them by byte number before actual updates are done.
2532 *
2533 * struct refsort is used to match byte number to slot in the btree block.
2534 * we sort based on the byte number and then use the slot to actually
2535 * find the item.
Chris Masonbd56b302009-02-04 09:27:02 -05002536 *
2537 * struct refsort is smaller than strcut btrfs_item and smaller than
2538 * struct btrfs_key_ptr. Since we're currently limited to the page size
2539 * for a btree block, there's no way for a kmalloc of refsorts for a
2540 * single node to be bigger than a page.
Chris Masonb7a9f292009-02-04 09:23:45 -05002541 */
2542struct refsort {
2543 u64 bytenr;
2544 u32 slot;
2545};
2546
2547/*
2548 * for passing into sort()
2549 */
2550static int refsort_cmp(const void *a_void, const void *b_void)
2551{
2552 const struct refsort *a = a_void;
2553 const struct refsort *b = b_void;
2554
2555 if (a->bytenr < b->bytenr)
2556 return -1;
2557 if (a->bytenr > b->bytenr)
2558 return 1;
2559 return 0;
2560}
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002561#endif
Chris Masonb7a9f292009-02-04 09:23:45 -05002562
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002563static int __btrfs_mod_ref(struct btrfs_trans_handle *trans,
Chris Masonb7a9f292009-02-04 09:23:45 -05002564 struct btrfs_root *root,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002565 struct extent_buffer *buf,
2566 int full_backref, int inc)
Zheng Yan31840ae2008-09-23 13:14:14 -04002567{
2568 u64 bytenr;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002569 u64 num_bytes;
2570 u64 parent;
Zheng Yan31840ae2008-09-23 13:14:14 -04002571 u64 ref_root;
Zheng Yan31840ae2008-09-23 13:14:14 -04002572 u32 nritems;
Zheng Yan31840ae2008-09-23 13:14:14 -04002573 struct btrfs_key key;
2574 struct btrfs_file_extent_item *fi;
2575 int i;
2576 int level;
2577 int ret = 0;
Zheng Yan31840ae2008-09-23 13:14:14 -04002578 int (*process_func)(struct btrfs_trans_handle *, struct btrfs_root *,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002579 u64, u64, u64, u64, u64, u64);
Zheng Yan31840ae2008-09-23 13:14:14 -04002580
2581 ref_root = btrfs_header_owner(buf);
Zheng Yan31840ae2008-09-23 13:14:14 -04002582 nritems = btrfs_header_nritems(buf);
2583 level = btrfs_header_level(buf);
2584
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002585 if (!root->ref_cows && level == 0)
2586 return 0;
Chris Masonb7a9f292009-02-04 09:23:45 -05002587
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002588 if (inc)
2589 process_func = btrfs_inc_extent_ref;
2590 else
2591 process_func = btrfs_free_extent;
Zheng Yan31840ae2008-09-23 13:14:14 -04002592
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002593 if (full_backref)
2594 parent = buf->start;
2595 else
2596 parent = 0;
2597
Zheng Yan31840ae2008-09-23 13:14:14 -04002598 for (i = 0; i < nritems; i++) {
Chris Masondb945352007-10-15 16:15:53 -04002599 if (level == 0) {
Chris Mason5f39d392007-10-15 16:14:19 -04002600 btrfs_item_key_to_cpu(buf, &key, i);
2601 if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
Chris Mason54aa1f42007-06-22 14:16:25 -04002602 continue;
Chris Mason5f39d392007-10-15 16:14:19 -04002603 fi = btrfs_item_ptr(buf, i,
Chris Mason54aa1f42007-06-22 14:16:25 -04002604 struct btrfs_file_extent_item);
Chris Mason5f39d392007-10-15 16:14:19 -04002605 if (btrfs_file_extent_type(buf, fi) ==
Chris Mason54aa1f42007-06-22 14:16:25 -04002606 BTRFS_FILE_EXTENT_INLINE)
2607 continue;
Zheng Yan31840ae2008-09-23 13:14:14 -04002608 bytenr = btrfs_file_extent_disk_bytenr(buf, fi);
2609 if (bytenr == 0)
Chris Mason54aa1f42007-06-22 14:16:25 -04002610 continue;
Zheng Yan31840ae2008-09-23 13:14:14 -04002611
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002612 num_bytes = btrfs_file_extent_disk_num_bytes(buf, fi);
2613 key.offset -= btrfs_file_extent_offset(buf, fi);
2614 ret = process_func(trans, root, bytenr, num_bytes,
2615 parent, ref_root, key.objectid,
2616 key.offset);
2617 if (ret)
2618 goto fail;
Chris Masonb7a9f292009-02-04 09:23:45 -05002619 } else {
2620 bytenr = btrfs_node_blockptr(buf, i);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002621 num_bytes = btrfs_level_size(root, level - 1);
2622 ret = process_func(trans, root, bytenr, num_bytes,
2623 parent, ref_root, level - 1, 0);
2624 if (ret)
Zheng Yan31840ae2008-09-23 13:14:14 -04002625 goto fail;
Chris Mason54aa1f42007-06-22 14:16:25 -04002626 }
2627 }
Zheng Yan31840ae2008-09-23 13:14:14 -04002628 return 0;
2629fail:
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002630 BUG();
Chris Mason54aa1f42007-06-22 14:16:25 -04002631 return ret;
Chris Mason02217ed2007-03-02 16:08:05 -05002632}
2633
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002634int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2635 struct extent_buffer *buf, int full_backref)
Zheng Yan31840ae2008-09-23 13:14:14 -04002636{
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002637 return __btrfs_mod_ref(trans, root, buf, full_backref, 1);
2638}
Zheng Yan31840ae2008-09-23 13:14:14 -04002639
Yan Zheng5d4f98a2009-06-10 10:45:14 -04002640int btrfs_dec_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root,
2641 struct extent_buffer *buf, int full_backref)
2642{
2643 return __btrfs_mod_ref(trans, root, buf, full_backref, 0);
Zheng Yan31840ae2008-09-23 13:14:14 -04002644}
2645
Chris Mason9078a3e2007-04-26 16:46:15 -04002646static int write_one_cache_group(struct btrfs_trans_handle *trans,
2647 struct btrfs_root *root,
2648 struct btrfs_path *path,
2649 struct btrfs_block_group_cache *cache)
2650{
2651 int ret;
Chris Mason9078a3e2007-04-26 16:46:15 -04002652 struct btrfs_root *extent_root = root->fs_info->extent_root;
Chris Mason5f39d392007-10-15 16:14:19 -04002653 unsigned long bi;
2654 struct extent_buffer *leaf;
Chris Mason9078a3e2007-04-26 16:46:15 -04002655
Chris Mason9078a3e2007-04-26 16:46:15 -04002656 ret = btrfs_search_slot(trans, extent_root, &cache->key, path, 0, 1);
Chris Mason54aa1f42007-06-22 14:16:25 -04002657 if (ret < 0)
2658 goto fail;
Chris Mason9078a3e2007-04-26 16:46:15 -04002659 BUG_ON(ret);
Chris Mason5f39d392007-10-15 16:14:19 -04002660
2661 leaf = path->nodes[0];
2662 bi = btrfs_item_ptr_offset(leaf, path->slots[0]);
2663 write_extent_buffer(leaf, &cache->item, bi, sizeof(cache->item));
2664 btrfs_mark_buffer_dirty(leaf);
Chris Mason9078a3e2007-04-26 16:46:15 -04002665 btrfs_release_path(extent_root, path);
Chris Mason54aa1f42007-06-22 14:16:25 -04002666fail:
Chris Mason9078a3e2007-04-26 16:46:15 -04002667 if (ret)
2668 return ret;
Chris Mason9078a3e2007-04-26 16:46:15 -04002669 return 0;
2670
2671}
2672
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002673static struct btrfs_block_group_cache *
2674next_block_group(struct btrfs_root *root,
2675 struct btrfs_block_group_cache *cache)
2676{
2677 struct rb_node *node;
2678 spin_lock(&root->fs_info->block_group_cache_lock);
2679 node = rb_next(&cache->cache_node);
2680 btrfs_put_block_group(cache);
2681 if (node) {
2682 cache = rb_entry(node, struct btrfs_block_group_cache,
2683 cache_node);
Josef Bacik11dfe352009-11-13 20:12:59 +00002684 btrfs_get_block_group(cache);
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002685 } else
2686 cache = NULL;
2687 spin_unlock(&root->fs_info->block_group_cache_lock);
2688 return cache;
2689}
2690
Chris Mason96b51792007-10-15 16:15:19 -04002691int btrfs_write_dirty_block_groups(struct btrfs_trans_handle *trans,
2692 struct btrfs_root *root)
Chris Mason9078a3e2007-04-26 16:46:15 -04002693{
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002694 struct btrfs_block_group_cache *cache;
Chris Mason9078a3e2007-04-26 16:46:15 -04002695 int err = 0;
Chris Mason9078a3e2007-04-26 16:46:15 -04002696 struct btrfs_path *path;
Chris Mason96b51792007-10-15 16:15:19 -04002697 u64 last = 0;
Chris Mason9078a3e2007-04-26 16:46:15 -04002698
2699 path = btrfs_alloc_path();
2700 if (!path)
2701 return -ENOMEM;
2702
Chris Masond3977122009-01-05 21:25:51 -05002703 while (1) {
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002704 if (last == 0) {
2705 err = btrfs_run_delayed_refs(trans, root,
2706 (unsigned long)-1);
2707 BUG_ON(err);
Josef Bacik0f9dd462008-09-23 13:14:11 -04002708 }
Josef Bacik0f9dd462008-09-23 13:14:11 -04002709
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002710 cache = btrfs_lookup_first_block_group(root->fs_info, last);
2711 while (cache) {
2712 if (cache->dirty)
2713 break;
2714 cache = next_block_group(root, cache);
2715 }
2716 if (!cache) {
2717 if (last == 0)
2718 break;
2719 last = 0;
Chris Mason96b51792007-10-15 16:15:19 -04002720 continue;
Chris Mason9078a3e2007-04-26 16:46:15 -04002721 }
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002722
2723 cache->dirty = 0;
2724 last = cache->key.objectid + cache->key.offset;
2725
2726 err = write_one_cache_group(trans, root, path, cache);
2727 BUG_ON(err);
2728 btrfs_put_block_group(cache);
Chris Mason9078a3e2007-04-26 16:46:15 -04002729 }
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002730
Chris Mason9078a3e2007-04-26 16:46:15 -04002731 btrfs_free_path(path);
Yan Zheng4a8c9a62009-07-22 10:07:05 -04002732 return 0;
Chris Mason9078a3e2007-04-26 16:46:15 -04002733}
2734
Yan Zhengd2fb3432008-12-11 16:30:39 -05002735int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr)
2736{
2737 struct btrfs_block_group_cache *block_group;
2738 int readonly = 0;
2739
2740 block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
2741 if (!block_group || block_group->ro)
2742 readonly = 1;
2743 if (block_group)
Chris Masonfa9c0d72009-04-03 09:47:43 -04002744 btrfs_put_block_group(block_group);
Yan Zhengd2fb3432008-12-11 16:30:39 -05002745 return readonly;
2746}
2747
Chris Mason593060d2008-03-25 16:50:33 -04002748static int update_space_info(struct btrfs_fs_info *info, u64 flags,
2749 u64 total_bytes, u64 bytes_used,
2750 struct btrfs_space_info **space_info)
2751{
2752 struct btrfs_space_info *found;
Yan, Zhengb742bb82010-05-16 10:46:24 -04002753 int i;
2754 int factor;
2755
2756 if (flags & (BTRFS_BLOCK_GROUP_DUP | BTRFS_BLOCK_GROUP_RAID1 |
2757 BTRFS_BLOCK_GROUP_RAID10))
2758 factor = 2;
2759 else
2760 factor = 1;
Chris Mason593060d2008-03-25 16:50:33 -04002761
2762 found = __find_space_info(info, flags);
2763 if (found) {
Josef Bacik25179202008-10-29 14:49:05 -04002764 spin_lock(&found->lock);
Chris Mason593060d2008-03-25 16:50:33 -04002765 found->total_bytes += total_bytes;
Josef Bacik89a55892010-10-14 14:52:27 -04002766 found->disk_total += total_bytes * factor;
Chris Mason593060d2008-03-25 16:50:33 -04002767 found->bytes_used += bytes_used;
Yan, Zhengb742bb82010-05-16 10:46:24 -04002768 found->disk_used += bytes_used * factor;
Chris Mason8f18cf12008-04-25 16:53:30 -04002769 found->full = 0;
Josef Bacik25179202008-10-29 14:49:05 -04002770 spin_unlock(&found->lock);
Chris Mason593060d2008-03-25 16:50:33 -04002771 *space_info = found;
2772 return 0;
2773 }
Yan Zhengc146afa2008-11-12 14:34:12 -05002774 found = kzalloc(sizeof(*found), GFP_NOFS);
Chris Mason593060d2008-03-25 16:50:33 -04002775 if (!found)
2776 return -ENOMEM;
2777
Yan, Zhengb742bb82010-05-16 10:46:24 -04002778 for (i = 0; i < BTRFS_NR_RAID_TYPES; i++)
2779 INIT_LIST_HEAD(&found->block_groups[i]);
Josef Bacik80eb2342008-10-29 14:49:05 -04002780 init_rwsem(&found->groups_sem);
Josef Bacik0f9dd462008-09-23 13:14:11 -04002781 spin_lock_init(&found->lock);
Yan, Zhengb742bb82010-05-16 10:46:24 -04002782 found->flags = flags & (BTRFS_BLOCK_GROUP_DATA |
2783 BTRFS_BLOCK_GROUP_SYSTEM |
2784 BTRFS_BLOCK_GROUP_METADATA);
Chris Mason593060d2008-03-25 16:50:33 -04002785 found->total_bytes = total_bytes;
Josef Bacik89a55892010-10-14 14:52:27 -04002786 found->disk_total = total_bytes * factor;
Chris Mason593060d2008-03-25 16:50:33 -04002787 found->bytes_used = bytes_used;
Yan, Zhengb742bb82010-05-16 10:46:24 -04002788 found->disk_used = bytes_used * factor;
Chris Mason593060d2008-03-25 16:50:33 -04002789 found->bytes_pinned = 0;
Zheng Yane8569812008-09-26 10:05:48 -04002790 found->bytes_reserved = 0;
Yan Zhengc146afa2008-11-12 14:34:12 -05002791 found->bytes_readonly = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -04002792 found->bytes_may_use = 0;
Chris Mason593060d2008-03-25 16:50:33 -04002793 found->full = 0;
Chris Mason0ef3e662008-05-24 14:04:53 -04002794 found->force_alloc = 0;
Chris Mason593060d2008-03-25 16:50:33 -04002795 *space_info = found;
Chris Mason4184ea72009-03-10 12:39:20 -04002796 list_add_rcu(&found->list, &info->space_info);
Josef Bacik817d52f2009-07-13 21:29:25 -04002797 atomic_set(&found->caching_threads, 0);
Chris Mason593060d2008-03-25 16:50:33 -04002798 return 0;
2799}
2800
Chris Mason8790d502008-04-03 16:29:03 -04002801static void set_avail_alloc_bits(struct btrfs_fs_info *fs_info, u64 flags)
2802{
2803 u64 extra_flags = flags & (BTRFS_BLOCK_GROUP_RAID0 |
Chris Mason611f0e02008-04-03 16:29:03 -04002804 BTRFS_BLOCK_GROUP_RAID1 |
Chris Mason321aecc2008-04-16 10:49:51 -04002805 BTRFS_BLOCK_GROUP_RAID10 |
Chris Mason611f0e02008-04-03 16:29:03 -04002806 BTRFS_BLOCK_GROUP_DUP);
Chris Mason8790d502008-04-03 16:29:03 -04002807 if (extra_flags) {
2808 if (flags & BTRFS_BLOCK_GROUP_DATA)
2809 fs_info->avail_data_alloc_bits |= extra_flags;
2810 if (flags & BTRFS_BLOCK_GROUP_METADATA)
2811 fs_info->avail_metadata_alloc_bits |= extra_flags;
2812 if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
2813 fs_info->avail_system_alloc_bits |= extra_flags;
2814 }
2815}
Chris Mason593060d2008-03-25 16:50:33 -04002816
Yan Zheng2b820322008-11-17 21:11:30 -05002817u64 btrfs_reduce_alloc_profile(struct btrfs_root *root, u64 flags)
Chris Masonec44a352008-04-28 15:29:52 -04002818{
Yan Zheng2b820322008-11-17 21:11:30 -05002819 u64 num_devices = root->fs_info->fs_devices->rw_devices;
Chris Masona061fc82008-05-07 11:43:44 -04002820
2821 if (num_devices == 1)
2822 flags &= ~(BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID0);
2823 if (num_devices < 4)
2824 flags &= ~BTRFS_BLOCK_GROUP_RAID10;
2825
Chris Masonec44a352008-04-28 15:29:52 -04002826 if ((flags & BTRFS_BLOCK_GROUP_DUP) &&
2827 (flags & (BTRFS_BLOCK_GROUP_RAID1 |
Chris Masona061fc82008-05-07 11:43:44 -04002828 BTRFS_BLOCK_GROUP_RAID10))) {
Chris Masonec44a352008-04-28 15:29:52 -04002829 flags &= ~BTRFS_BLOCK_GROUP_DUP;
Chris Masona061fc82008-05-07 11:43:44 -04002830 }
Chris Masonec44a352008-04-28 15:29:52 -04002831
2832 if ((flags & BTRFS_BLOCK_GROUP_RAID1) &&
Chris Masona061fc82008-05-07 11:43:44 -04002833 (flags & BTRFS_BLOCK_GROUP_RAID10)) {
Chris Masonec44a352008-04-28 15:29:52 -04002834 flags &= ~BTRFS_BLOCK_GROUP_RAID1;
Chris Masona061fc82008-05-07 11:43:44 -04002835 }
Chris Masonec44a352008-04-28 15:29:52 -04002836
2837 if ((flags & BTRFS_BLOCK_GROUP_RAID0) &&
2838 ((flags & BTRFS_BLOCK_GROUP_RAID1) |
2839 (flags & BTRFS_BLOCK_GROUP_RAID10) |
2840 (flags & BTRFS_BLOCK_GROUP_DUP)))
2841 flags &= ~BTRFS_BLOCK_GROUP_RAID0;
2842 return flags;
2843}
2844
Yan, Zhengb742bb82010-05-16 10:46:24 -04002845static u64 get_alloc_profile(struct btrfs_root *root, u64 flags)
Josef Bacik6a632092009-02-20 11:00:09 -05002846{
Yan, Zhengb742bb82010-05-16 10:46:24 -04002847 if (flags & BTRFS_BLOCK_GROUP_DATA)
2848 flags |= root->fs_info->avail_data_alloc_bits &
2849 root->fs_info->data_alloc_profile;
2850 else if (flags & BTRFS_BLOCK_GROUP_SYSTEM)
2851 flags |= root->fs_info->avail_system_alloc_bits &
2852 root->fs_info->system_alloc_profile;
2853 else if (flags & BTRFS_BLOCK_GROUP_METADATA)
2854 flags |= root->fs_info->avail_metadata_alloc_bits &
2855 root->fs_info->metadata_alloc_profile;
2856 return btrfs_reduce_alloc_profile(root, flags);
2857}
Josef Bacik6a632092009-02-20 11:00:09 -05002858
Yan, Zhengb742bb82010-05-16 10:46:24 -04002859static u64 btrfs_get_alloc_profile(struct btrfs_root *root, int data)
2860{
2861 u64 flags;
Josef Bacik6a632092009-02-20 11:00:09 -05002862
Yan, Zhengb742bb82010-05-16 10:46:24 -04002863 if (data)
2864 flags = BTRFS_BLOCK_GROUP_DATA;
2865 else if (root == root->fs_info->chunk_root)
2866 flags = BTRFS_BLOCK_GROUP_SYSTEM;
2867 else
2868 flags = BTRFS_BLOCK_GROUP_METADATA;
2869
2870 return get_alloc_profile(root, flags);
Josef Bacik6a632092009-02-20 11:00:09 -05002871}
2872
2873void btrfs_set_inode_space_info(struct btrfs_root *root, struct inode *inode)
2874{
Josef Bacik6a632092009-02-20 11:00:09 -05002875 BTRFS_I(inode)->space_info = __find_space_info(root->fs_info,
Yan, Zhengf0486c62010-05-16 10:46:25 -04002876 BTRFS_BLOCK_GROUP_DATA);
Josef Bacik6a632092009-02-20 11:00:09 -05002877}
2878
2879/*
2880 * This will check the space that the inode allocates from to make sure we have
2881 * enough space for bytes.
2882 */
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04002883int btrfs_check_data_free_space(struct inode *inode, u64 bytes)
Josef Bacik6a632092009-02-20 11:00:09 -05002884{
2885 struct btrfs_space_info *data_sinfo;
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04002886 struct btrfs_root *root = BTRFS_I(inode)->root;
Josef Bacikab6e2412010-03-19 14:38:13 +00002887 u64 used;
Yan, Zheng5da9d012010-05-16 10:46:25 -04002888 int ret = 0, committed = 0;
Josef Bacik6a632092009-02-20 11:00:09 -05002889
2890 /* make sure bytes are sectorsize aligned */
2891 bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
2892
2893 data_sinfo = BTRFS_I(inode)->space_info;
Chris Mason33b4d472009-09-22 14:45:50 -04002894 if (!data_sinfo)
2895 goto alloc;
2896
Josef Bacik6a632092009-02-20 11:00:09 -05002897again:
2898 /* make sure we have enough space to handle the data first */
2899 spin_lock(&data_sinfo->lock);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04002900 used = data_sinfo->bytes_used + data_sinfo->bytes_reserved +
2901 data_sinfo->bytes_pinned + data_sinfo->bytes_readonly +
2902 data_sinfo->bytes_may_use;
Josef Bacikab6e2412010-03-19 14:38:13 +00002903
2904 if (used + bytes > data_sinfo->total_bytes) {
Josef Bacik4e06bdd2009-02-20 10:59:53 -05002905 struct btrfs_trans_handle *trans;
2906
Josef Bacik6a632092009-02-20 11:00:09 -05002907 /*
2908 * if we don't have enough free bytes in this space then we need
2909 * to alloc a new chunk.
2910 */
2911 if (!data_sinfo->full) {
2912 u64 alloc_target;
Josef Bacik6a632092009-02-20 11:00:09 -05002913
2914 data_sinfo->force_alloc = 1;
2915 spin_unlock(&data_sinfo->lock);
Chris Mason33b4d472009-09-22 14:45:50 -04002916alloc:
Josef Bacik6a632092009-02-20 11:00:09 -05002917 alloc_target = btrfs_get_alloc_profile(root, 1);
Yan, Zhenga22285a2010-05-16 10:48:46 -04002918 trans = btrfs_join_transaction(root, 1);
2919 if (IS_ERR(trans))
2920 return PTR_ERR(trans);
Josef Bacik6a632092009-02-20 11:00:09 -05002921
2922 ret = do_chunk_alloc(trans, root->fs_info->extent_root,
2923 bytes + 2 * 1024 * 1024,
2924 alloc_target, 0);
2925 btrfs_end_transaction(trans, root);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04002926 if (ret < 0)
Josef Bacik6a632092009-02-20 11:00:09 -05002927 return ret;
Chris Mason33b4d472009-09-22 14:45:50 -04002928
2929 if (!data_sinfo) {
2930 btrfs_set_inode_space_info(root, inode);
2931 data_sinfo = BTRFS_I(inode)->space_info;
2932 }
Josef Bacik6a632092009-02-20 11:00:09 -05002933 goto again;
2934 }
2935 spin_unlock(&data_sinfo->lock);
Josef Bacik4e06bdd2009-02-20 10:59:53 -05002936
2937 /* commit the current transaction and try again */
Sage Weildd7e0b72009-09-29 18:38:44 -04002938 if (!committed && !root->fs_info->open_ioctl_trans) {
Josef Bacik4e06bdd2009-02-20 10:59:53 -05002939 committed = 1;
2940 trans = btrfs_join_transaction(root, 1);
Yan, Zhenga22285a2010-05-16 10:48:46 -04002941 if (IS_ERR(trans))
2942 return PTR_ERR(trans);
Josef Bacik4e06bdd2009-02-20 10:59:53 -05002943 ret = btrfs_commit_transaction(trans, root);
2944 if (ret)
2945 return ret;
2946 goto again;
2947 }
2948
Chris Mason933b5852010-05-26 11:31:00 -04002949#if 0 /* I hope we never need this code again, just in case */
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04002950 printk(KERN_ERR "no space left, need %llu, %llu bytes_used, "
2951 "%llu bytes_reserved, " "%llu bytes_pinned, "
2952 "%llu bytes_readonly, %llu may use %llu total\n",
2953 (unsigned long long)bytes,
Joel Becker21380932009-04-21 12:38:29 -07002954 (unsigned long long)data_sinfo->bytes_used,
2955 (unsigned long long)data_sinfo->bytes_reserved,
2956 (unsigned long long)data_sinfo->bytes_pinned,
2957 (unsigned long long)data_sinfo->bytes_readonly,
2958 (unsigned long long)data_sinfo->bytes_may_use,
2959 (unsigned long long)data_sinfo->total_bytes);
Chris Mason933b5852010-05-26 11:31:00 -04002960#endif
Josef Bacik6a632092009-02-20 11:00:09 -05002961 return -ENOSPC;
2962 }
2963 data_sinfo->bytes_may_use += bytes;
2964 BTRFS_I(inode)->reserved_bytes += bytes;
2965 spin_unlock(&data_sinfo->lock);
2966
Josef Bacik9ed74f22009-09-11 16:12:44 -04002967 return 0;
Josef Bacik6a632092009-02-20 11:00:09 -05002968}
2969
2970/*
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04002971 * called when we are clearing an delalloc extent from the
2972 * inode's io_tree or there was an error for whatever reason
2973 * after calling btrfs_check_data_free_space
Josef Bacik6a632092009-02-20 11:00:09 -05002974 */
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04002975void btrfs_free_reserved_data_space(struct inode *inode, u64 bytes)
Josef Bacik6a632092009-02-20 11:00:09 -05002976{
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04002977 struct btrfs_root *root = BTRFS_I(inode)->root;
Josef Bacik6a632092009-02-20 11:00:09 -05002978 struct btrfs_space_info *data_sinfo;
2979
2980 /* make sure bytes are sectorsize aligned */
2981 bytes = (bytes + root->sectorsize - 1) & ~((u64)root->sectorsize - 1);
2982
2983 data_sinfo = BTRFS_I(inode)->space_info;
2984 spin_lock(&data_sinfo->lock);
2985 data_sinfo->bytes_may_use -= bytes;
2986 BTRFS_I(inode)->reserved_bytes -= bytes;
2987 spin_unlock(&data_sinfo->lock);
2988}
2989
Josef Bacik97e728d2009-04-21 17:40:57 -04002990static void force_metadata_allocation(struct btrfs_fs_info *info)
2991{
2992 struct list_head *head = &info->space_info;
2993 struct btrfs_space_info *found;
2994
2995 rcu_read_lock();
2996 list_for_each_entry_rcu(found, head, list) {
2997 if (found->flags & BTRFS_BLOCK_GROUP_METADATA)
2998 found->force_alloc = 1;
2999 }
3000 rcu_read_unlock();
3001}
3002
Yan, Zheng424499d2010-05-16 10:46:25 -04003003static int should_alloc_chunk(struct btrfs_space_info *sinfo,
3004 u64 alloc_bytes)
3005{
3006 u64 num_bytes = sinfo->total_bytes - sinfo->bytes_readonly;
3007
3008 if (sinfo->bytes_used + sinfo->bytes_reserved +
3009 alloc_bytes + 256 * 1024 * 1024 < num_bytes)
3010 return 0;
3011
3012 if (sinfo->bytes_used + sinfo->bytes_reserved +
3013 alloc_bytes < div_factor(num_bytes, 8))
3014 return 0;
3015
3016 return 1;
3017}
3018
Chris Mason6324fbf2008-03-24 15:01:59 -04003019static int do_chunk_alloc(struct btrfs_trans_handle *trans,
3020 struct btrfs_root *extent_root, u64 alloc_bytes,
Chris Mason0ef3e662008-05-24 14:04:53 -04003021 u64 flags, int force)
Chris Mason6324fbf2008-03-24 15:01:59 -04003022{
3023 struct btrfs_space_info *space_info;
Josef Bacik97e728d2009-04-21 17:40:57 -04003024 struct btrfs_fs_info *fs_info = extent_root->fs_info;
Yan Zhengc146afa2008-11-12 14:34:12 -05003025 int ret = 0;
3026
Josef Bacik97e728d2009-04-21 17:40:57 -04003027 mutex_lock(&fs_info->chunk_mutex);
Chris Mason6324fbf2008-03-24 15:01:59 -04003028
Yan Zheng2b820322008-11-17 21:11:30 -05003029 flags = btrfs_reduce_alloc_profile(extent_root, flags);
Chris Masonec44a352008-04-28 15:29:52 -04003030
Chris Mason6324fbf2008-03-24 15:01:59 -04003031 space_info = __find_space_info(extent_root->fs_info, flags);
Chris Mason593060d2008-03-25 16:50:33 -04003032 if (!space_info) {
3033 ret = update_space_info(extent_root->fs_info, flags,
3034 0, 0, &space_info);
3035 BUG_ON(ret);
3036 }
Chris Mason6324fbf2008-03-24 15:01:59 -04003037 BUG_ON(!space_info);
3038
Josef Bacik25179202008-10-29 14:49:05 -04003039 spin_lock(&space_info->lock);
Josef Bacik9ed74f22009-09-11 16:12:44 -04003040 if (space_info->force_alloc)
Chris Mason0ef3e662008-05-24 14:04:53 -04003041 force = 1;
Josef Bacik25179202008-10-29 14:49:05 -04003042 if (space_info->full) {
3043 spin_unlock(&space_info->lock);
Chris Mason925baed2008-06-25 16:01:30 -04003044 goto out;
Josef Bacik25179202008-10-29 14:49:05 -04003045 }
Chris Mason6324fbf2008-03-24 15:01:59 -04003046
Yan, Zheng424499d2010-05-16 10:46:25 -04003047 if (!force && !should_alloc_chunk(space_info, alloc_bytes)) {
Josef Bacik25179202008-10-29 14:49:05 -04003048 spin_unlock(&space_info->lock);
Chris Mason925baed2008-06-25 16:01:30 -04003049 goto out;
Josef Bacik25179202008-10-29 14:49:05 -04003050 }
Josef Bacik25179202008-10-29 14:49:05 -04003051 spin_unlock(&space_info->lock);
3052
Josef Bacik97e728d2009-04-21 17:40:57 -04003053 /*
3054 * if we're doing a data chunk, go ahead and make sure that
3055 * we keep a reasonable number of metadata chunks allocated in the
3056 * FS as well.
3057 */
Josef Bacik9ed74f22009-09-11 16:12:44 -04003058 if (flags & BTRFS_BLOCK_GROUP_DATA && fs_info->metadata_ratio) {
Josef Bacik97e728d2009-04-21 17:40:57 -04003059 fs_info->data_chunk_allocations++;
3060 if (!(fs_info->data_chunk_allocations %
3061 fs_info->metadata_ratio))
3062 force_metadata_allocation(fs_info);
3063 }
3064
Yan Zheng2b820322008-11-17 21:11:30 -05003065 ret = btrfs_alloc_chunk(trans, extent_root, flags);
Josef Bacik9ed74f22009-09-11 16:12:44 -04003066 spin_lock(&space_info->lock);
Chris Masond3977122009-01-05 21:25:51 -05003067 if (ret)
Chris Mason6324fbf2008-03-24 15:01:59 -04003068 space_info->full = 1;
Yan, Zheng424499d2010-05-16 10:46:25 -04003069 else
3070 ret = 1;
Josef Bacik9ed74f22009-09-11 16:12:44 -04003071 space_info->force_alloc = 0;
3072 spin_unlock(&space_info->lock);
Chris Masona74a4b92008-06-25 16:01:31 -04003073out:
Yan Zhengc146afa2008-11-12 14:34:12 -05003074 mutex_unlock(&extent_root->fs_info->chunk_mutex);
Josef Bacik0f9dd462008-09-23 13:14:11 -04003075 return ret;
Chris Mason6324fbf2008-03-24 15:01:59 -04003076}
3077
Yan, Zheng424499d2010-05-16 10:46:25 -04003078static int maybe_allocate_chunk(struct btrfs_trans_handle *trans,
3079 struct btrfs_root *root,
3080 struct btrfs_space_info *sinfo, u64 num_bytes)
3081{
3082 int ret;
3083 int end_trans = 0;
3084
3085 if (sinfo->full)
3086 return 0;
3087
3088 spin_lock(&sinfo->lock);
3089 ret = should_alloc_chunk(sinfo, num_bytes + 2 * 1024 * 1024);
3090 spin_unlock(&sinfo->lock);
3091 if (!ret)
3092 return 0;
3093
3094 if (!trans) {
3095 trans = btrfs_join_transaction(root, 1);
3096 BUG_ON(IS_ERR(trans));
3097 end_trans = 1;
3098 }
3099
3100 ret = do_chunk_alloc(trans, root->fs_info->extent_root,
3101 num_bytes + 2 * 1024 * 1024,
3102 get_alloc_profile(root, sinfo->flags), 0);
3103
3104 if (end_trans)
3105 btrfs_end_transaction(trans, root);
3106
3107 return ret == 1 ? 1 : 0;
3108}
3109
Yan, Zheng5da9d012010-05-16 10:46:25 -04003110/*
3111 * shrink metadata reservation for delalloc
3112 */
3113static int shrink_delalloc(struct btrfs_trans_handle *trans,
Josef Bacik0019f102010-10-15 15:18:40 -04003114 struct btrfs_root *root, u64 to_reclaim, int sync)
Yan, Zheng5da9d012010-05-16 10:46:25 -04003115{
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003116 struct btrfs_block_rsv *block_rsv;
Josef Bacik0019f102010-10-15 15:18:40 -04003117 struct btrfs_space_info *space_info;
Yan, Zheng5da9d012010-05-16 10:46:25 -04003118 u64 reserved;
3119 u64 max_reclaim;
3120 u64 reclaimed = 0;
Josef Bacika1f76502010-09-16 14:29:55 -04003121 int no_reclaim = 0;
Yan, Zheng5da9d012010-05-16 10:46:25 -04003122 int pause = 1;
3123 int ret;
3124
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003125 block_rsv = &root->fs_info->delalloc_block_rsv;
Josef Bacik0019f102010-10-15 15:18:40 -04003126 space_info = block_rsv->space_info;
3127 spin_lock(&space_info->lock);
3128 reserved = space_info->bytes_reserved;
3129 spin_unlock(&space_info->lock);
Yan, Zheng5da9d012010-05-16 10:46:25 -04003130
3131 if (reserved == 0)
3132 return 0;
3133
3134 max_reclaim = min(reserved, to_reclaim);
3135
3136 while (1) {
Josef Bacik0019f102010-10-15 15:18:40 -04003137 ret = btrfs_start_one_delalloc_inode(root, trans ? 1 : 0, sync);
Yan, Zheng5da9d012010-05-16 10:46:25 -04003138 if (!ret) {
Josef Bacika1f76502010-09-16 14:29:55 -04003139 if (no_reclaim > 2)
3140 break;
3141 no_reclaim++;
Yan, Zheng5da9d012010-05-16 10:46:25 -04003142 __set_current_state(TASK_INTERRUPTIBLE);
3143 schedule_timeout(pause);
3144 pause <<= 1;
3145 if (pause > HZ / 10)
3146 pause = HZ / 10;
3147 } else {
Josef Bacika1f76502010-09-16 14:29:55 -04003148 no_reclaim = 0;
Yan, Zheng5da9d012010-05-16 10:46:25 -04003149 pause = 1;
3150 }
3151
Josef Bacik0019f102010-10-15 15:18:40 -04003152 spin_lock(&space_info->lock);
3153 if (reserved > space_info->bytes_reserved)
3154 reclaimed += reserved - space_info->bytes_reserved;
3155 reserved = space_info->bytes_reserved;
3156 spin_unlock(&space_info->lock);
Yan, Zheng5da9d012010-05-16 10:46:25 -04003157
3158 if (reserved == 0 || reclaimed >= max_reclaim)
3159 break;
3160
3161 if (trans && trans->transaction->blocked)
3162 return -EAGAIN;
3163 }
3164 return reclaimed >= to_reclaim;
3165}
3166
Yan, Zhengf0486c62010-05-16 10:46:25 -04003167static int should_retry_reserve(struct btrfs_trans_handle *trans,
3168 struct btrfs_root *root,
3169 struct btrfs_block_rsv *block_rsv,
3170 u64 num_bytes, int *retries)
3171{
3172 struct btrfs_space_info *space_info = block_rsv->space_info;
3173 int ret;
3174
3175 if ((*retries) > 2)
3176 return -ENOSPC;
3177
3178 ret = maybe_allocate_chunk(trans, root, space_info, num_bytes);
3179 if (ret)
3180 return 1;
3181
3182 if (trans && trans->transaction->in_commit)
3183 return -ENOSPC;
3184
Josef Bacik0019f102010-10-15 15:18:40 -04003185 ret = shrink_delalloc(trans, root, num_bytes, 0);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003186 if (ret)
3187 return ret;
3188
3189 spin_lock(&space_info->lock);
3190 if (space_info->bytes_pinned < num_bytes)
3191 ret = 1;
3192 spin_unlock(&space_info->lock);
3193 if (ret)
3194 return -ENOSPC;
3195
3196 (*retries)++;
3197
3198 if (trans)
3199 return -EAGAIN;
3200
3201 trans = btrfs_join_transaction(root, 1);
3202 BUG_ON(IS_ERR(trans));
3203 ret = btrfs_commit_transaction(trans, root);
3204 BUG_ON(ret);
3205
3206 return 1;
3207}
3208
3209static int reserve_metadata_bytes(struct btrfs_block_rsv *block_rsv,
3210 u64 num_bytes)
3211{
3212 struct btrfs_space_info *space_info = block_rsv->space_info;
3213 u64 unused;
3214 int ret = -ENOSPC;
3215
3216 spin_lock(&space_info->lock);
3217 unused = space_info->bytes_used + space_info->bytes_reserved +
Josef Bacik6d487552010-10-15 15:13:32 -04003218 space_info->bytes_pinned + space_info->bytes_readonly +
3219 space_info->bytes_may_use;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003220
3221 if (unused < space_info->total_bytes)
3222 unused = space_info->total_bytes - unused;
3223 else
3224 unused = 0;
3225
3226 if (unused >= num_bytes) {
3227 if (block_rsv->priority >= 10) {
3228 space_info->bytes_reserved += num_bytes;
3229 ret = 0;
3230 } else {
3231 if ((unused + block_rsv->reserved) *
3232 block_rsv->priority >=
3233 (num_bytes + block_rsv->reserved) * 10) {
3234 space_info->bytes_reserved += num_bytes;
3235 ret = 0;
3236 }
3237 }
3238 }
3239 spin_unlock(&space_info->lock);
3240
3241 return ret;
3242}
3243
3244static struct btrfs_block_rsv *get_block_rsv(struct btrfs_trans_handle *trans,
3245 struct btrfs_root *root)
3246{
3247 struct btrfs_block_rsv *block_rsv;
3248 if (root->ref_cows)
3249 block_rsv = trans->block_rsv;
3250 else
3251 block_rsv = root->block_rsv;
3252
3253 if (!block_rsv)
3254 block_rsv = &root->fs_info->empty_block_rsv;
3255
3256 return block_rsv;
3257}
3258
3259static int block_rsv_use_bytes(struct btrfs_block_rsv *block_rsv,
3260 u64 num_bytes)
3261{
3262 int ret = -ENOSPC;
3263 spin_lock(&block_rsv->lock);
3264 if (block_rsv->reserved >= num_bytes) {
3265 block_rsv->reserved -= num_bytes;
3266 if (block_rsv->reserved < block_rsv->size)
3267 block_rsv->full = 0;
3268 ret = 0;
3269 }
3270 spin_unlock(&block_rsv->lock);
3271 return ret;
3272}
3273
3274static void block_rsv_add_bytes(struct btrfs_block_rsv *block_rsv,
3275 u64 num_bytes, int update_size)
3276{
3277 spin_lock(&block_rsv->lock);
3278 block_rsv->reserved += num_bytes;
3279 if (update_size)
3280 block_rsv->size += num_bytes;
3281 else if (block_rsv->reserved >= block_rsv->size)
3282 block_rsv->full = 1;
3283 spin_unlock(&block_rsv->lock);
3284}
3285
3286void block_rsv_release_bytes(struct btrfs_block_rsv *block_rsv,
3287 struct btrfs_block_rsv *dest, u64 num_bytes)
3288{
3289 struct btrfs_space_info *space_info = block_rsv->space_info;
3290
3291 spin_lock(&block_rsv->lock);
3292 if (num_bytes == (u64)-1)
3293 num_bytes = block_rsv->size;
3294 block_rsv->size -= num_bytes;
3295 if (block_rsv->reserved >= block_rsv->size) {
3296 num_bytes = block_rsv->reserved - block_rsv->size;
3297 block_rsv->reserved = block_rsv->size;
3298 block_rsv->full = 1;
3299 } else {
3300 num_bytes = 0;
3301 }
3302 spin_unlock(&block_rsv->lock);
3303
3304 if (num_bytes > 0) {
3305 if (dest) {
3306 block_rsv_add_bytes(dest, num_bytes, 0);
3307 } else {
3308 spin_lock(&space_info->lock);
3309 space_info->bytes_reserved -= num_bytes;
3310 spin_unlock(&space_info->lock);
3311 }
3312 }
3313}
3314
3315static int block_rsv_migrate_bytes(struct btrfs_block_rsv *src,
3316 struct btrfs_block_rsv *dst, u64 num_bytes)
3317{
3318 int ret;
3319
3320 ret = block_rsv_use_bytes(src, num_bytes);
3321 if (ret)
3322 return ret;
3323
3324 block_rsv_add_bytes(dst, num_bytes, 1);
3325 return 0;
3326}
3327
3328void btrfs_init_block_rsv(struct btrfs_block_rsv *rsv)
3329{
3330 memset(rsv, 0, sizeof(*rsv));
3331 spin_lock_init(&rsv->lock);
3332 atomic_set(&rsv->usage, 1);
3333 rsv->priority = 6;
3334 INIT_LIST_HEAD(&rsv->list);
3335}
3336
3337struct btrfs_block_rsv *btrfs_alloc_block_rsv(struct btrfs_root *root)
3338{
3339 struct btrfs_block_rsv *block_rsv;
3340 struct btrfs_fs_info *fs_info = root->fs_info;
3341 u64 alloc_target;
3342
3343 block_rsv = kmalloc(sizeof(*block_rsv), GFP_NOFS);
3344 if (!block_rsv)
3345 return NULL;
3346
3347 btrfs_init_block_rsv(block_rsv);
3348
3349 alloc_target = btrfs_get_alloc_profile(root, 0);
3350 block_rsv->space_info = __find_space_info(fs_info,
3351 BTRFS_BLOCK_GROUP_METADATA);
3352
3353 return block_rsv;
3354}
3355
3356void btrfs_free_block_rsv(struct btrfs_root *root,
3357 struct btrfs_block_rsv *rsv)
3358{
3359 if (rsv && atomic_dec_and_test(&rsv->usage)) {
3360 btrfs_block_rsv_release(root, rsv, (u64)-1);
3361 if (!rsv->durable)
3362 kfree(rsv);
3363 }
3364}
3365
3366/*
3367 * make the block_rsv struct be able to capture freed space.
3368 * the captured space will re-add to the the block_rsv struct
3369 * after transaction commit
3370 */
3371void btrfs_add_durable_block_rsv(struct btrfs_fs_info *fs_info,
3372 struct btrfs_block_rsv *block_rsv)
3373{
3374 block_rsv->durable = 1;
3375 mutex_lock(&fs_info->durable_block_rsv_mutex);
3376 list_add_tail(&block_rsv->list, &fs_info->durable_block_rsv_list);
3377 mutex_unlock(&fs_info->durable_block_rsv_mutex);
3378}
3379
3380int btrfs_block_rsv_add(struct btrfs_trans_handle *trans,
3381 struct btrfs_root *root,
3382 struct btrfs_block_rsv *block_rsv,
3383 u64 num_bytes, int *retries)
3384{
3385 int ret;
3386
3387 if (num_bytes == 0)
3388 return 0;
3389again:
3390 ret = reserve_metadata_bytes(block_rsv, num_bytes);
3391 if (!ret) {
3392 block_rsv_add_bytes(block_rsv, num_bytes, 1);
3393 return 0;
3394 }
3395
3396 ret = should_retry_reserve(trans, root, block_rsv, num_bytes, retries);
3397 if (ret > 0)
3398 goto again;
3399
3400 return ret;
3401}
3402
3403int btrfs_block_rsv_check(struct btrfs_trans_handle *trans,
3404 struct btrfs_root *root,
3405 struct btrfs_block_rsv *block_rsv,
3406 u64 min_reserved, int min_factor)
3407{
3408 u64 num_bytes = 0;
3409 int commit_trans = 0;
3410 int ret = -ENOSPC;
3411
3412 if (!block_rsv)
3413 return 0;
3414
3415 spin_lock(&block_rsv->lock);
3416 if (min_factor > 0)
3417 num_bytes = div_factor(block_rsv->size, min_factor);
3418 if (min_reserved > num_bytes)
3419 num_bytes = min_reserved;
3420
3421 if (block_rsv->reserved >= num_bytes) {
3422 ret = 0;
3423 } else {
3424 num_bytes -= block_rsv->reserved;
3425 if (block_rsv->durable &&
3426 block_rsv->freed[0] + block_rsv->freed[1] >= num_bytes)
3427 commit_trans = 1;
3428 }
3429 spin_unlock(&block_rsv->lock);
3430 if (!ret)
3431 return 0;
3432
3433 if (block_rsv->refill_used) {
3434 ret = reserve_metadata_bytes(block_rsv, num_bytes);
3435 if (!ret) {
3436 block_rsv_add_bytes(block_rsv, num_bytes, 0);
3437 return 0;
3438 }
3439 }
3440
3441 if (commit_trans) {
3442 if (trans)
3443 return -EAGAIN;
3444
3445 trans = btrfs_join_transaction(root, 1);
3446 BUG_ON(IS_ERR(trans));
3447 ret = btrfs_commit_transaction(trans, root);
3448 return 0;
3449 }
3450
3451 WARN_ON(1);
3452 printk(KERN_INFO"block_rsv size %llu reserved %llu freed %llu %llu\n",
3453 block_rsv->size, block_rsv->reserved,
3454 block_rsv->freed[0], block_rsv->freed[1]);
3455
3456 return -ENOSPC;
3457}
3458
3459int btrfs_block_rsv_migrate(struct btrfs_block_rsv *src_rsv,
3460 struct btrfs_block_rsv *dst_rsv,
3461 u64 num_bytes)
3462{
3463 return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
3464}
3465
3466void btrfs_block_rsv_release(struct btrfs_root *root,
3467 struct btrfs_block_rsv *block_rsv,
3468 u64 num_bytes)
3469{
3470 struct btrfs_block_rsv *global_rsv = &root->fs_info->global_block_rsv;
3471 if (global_rsv->full || global_rsv == block_rsv ||
3472 block_rsv->space_info != global_rsv->space_info)
3473 global_rsv = NULL;
3474 block_rsv_release_bytes(block_rsv, global_rsv, num_bytes);
3475}
3476
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003477/*
3478 * helper to calculate size of global block reservation.
3479 * the desired value is sum of space used by extent tree,
3480 * checksum tree and root tree
3481 */
3482static u64 calc_global_metadata_size(struct btrfs_fs_info *fs_info)
3483{
3484 struct btrfs_space_info *sinfo;
3485 u64 num_bytes;
3486 u64 meta_used;
3487 u64 data_used;
3488 int csum_size = btrfs_super_csum_size(&fs_info->super_copy);
3489#if 0
3490 /*
3491 * per tree used space accounting can be inaccuracy, so we
3492 * can't rely on it.
3493 */
3494 spin_lock(&fs_info->extent_root->accounting_lock);
3495 num_bytes = btrfs_root_used(&fs_info->extent_root->root_item);
3496 spin_unlock(&fs_info->extent_root->accounting_lock);
3497
3498 spin_lock(&fs_info->csum_root->accounting_lock);
3499 num_bytes += btrfs_root_used(&fs_info->csum_root->root_item);
3500 spin_unlock(&fs_info->csum_root->accounting_lock);
3501
3502 spin_lock(&fs_info->tree_root->accounting_lock);
3503 num_bytes += btrfs_root_used(&fs_info->tree_root->root_item);
3504 spin_unlock(&fs_info->tree_root->accounting_lock);
3505#endif
3506 sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_DATA);
3507 spin_lock(&sinfo->lock);
3508 data_used = sinfo->bytes_used;
3509 spin_unlock(&sinfo->lock);
3510
3511 sinfo = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
3512 spin_lock(&sinfo->lock);
Josef Bacik6d487552010-10-15 15:13:32 -04003513 if (sinfo->flags & BTRFS_BLOCK_GROUP_DATA)
3514 data_used = 0;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003515 meta_used = sinfo->bytes_used;
3516 spin_unlock(&sinfo->lock);
3517
3518 num_bytes = (data_used >> fs_info->sb->s_blocksize_bits) *
3519 csum_size * 2;
3520 num_bytes += div64_u64(data_used + meta_used, 50);
3521
3522 if (num_bytes * 3 > meta_used)
3523 num_bytes = div64_u64(meta_used, 3);
3524
3525 return ALIGN(num_bytes, fs_info->extent_root->leafsize << 10);
3526}
3527
3528static void update_global_block_rsv(struct btrfs_fs_info *fs_info)
3529{
3530 struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
3531 struct btrfs_space_info *sinfo = block_rsv->space_info;
3532 u64 num_bytes;
3533
3534 num_bytes = calc_global_metadata_size(fs_info);
3535
3536 spin_lock(&block_rsv->lock);
3537 spin_lock(&sinfo->lock);
3538
3539 block_rsv->size = num_bytes;
3540
3541 num_bytes = sinfo->bytes_used + sinfo->bytes_pinned +
Josef Bacik6d487552010-10-15 15:13:32 -04003542 sinfo->bytes_reserved + sinfo->bytes_readonly +
3543 sinfo->bytes_may_use;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003544
3545 if (sinfo->total_bytes > num_bytes) {
3546 num_bytes = sinfo->total_bytes - num_bytes;
3547 block_rsv->reserved += num_bytes;
3548 sinfo->bytes_reserved += num_bytes;
3549 }
3550
3551 if (block_rsv->reserved >= block_rsv->size) {
3552 num_bytes = block_rsv->reserved - block_rsv->size;
3553 sinfo->bytes_reserved -= num_bytes;
3554 block_rsv->reserved = block_rsv->size;
3555 block_rsv->full = 1;
3556 }
3557#if 0
3558 printk(KERN_INFO"global block rsv size %llu reserved %llu\n",
3559 block_rsv->size, block_rsv->reserved);
3560#endif
3561 spin_unlock(&sinfo->lock);
3562 spin_unlock(&block_rsv->lock);
3563}
3564
Yan, Zhengf0486c62010-05-16 10:46:25 -04003565static void init_global_block_rsv(struct btrfs_fs_info *fs_info)
3566{
3567 struct btrfs_space_info *space_info;
3568
3569 space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_SYSTEM);
3570 fs_info->chunk_block_rsv.space_info = space_info;
3571 fs_info->chunk_block_rsv.priority = 10;
3572
3573 space_info = __find_space_info(fs_info, BTRFS_BLOCK_GROUP_METADATA);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003574 fs_info->global_block_rsv.space_info = space_info;
3575 fs_info->global_block_rsv.priority = 10;
3576 fs_info->global_block_rsv.refill_used = 1;
3577 fs_info->delalloc_block_rsv.space_info = space_info;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003578 fs_info->trans_block_rsv.space_info = space_info;
3579 fs_info->empty_block_rsv.space_info = space_info;
3580 fs_info->empty_block_rsv.priority = 10;
3581
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003582 fs_info->extent_root->block_rsv = &fs_info->global_block_rsv;
3583 fs_info->csum_root->block_rsv = &fs_info->global_block_rsv;
3584 fs_info->dev_root->block_rsv = &fs_info->global_block_rsv;
3585 fs_info->tree_root->block_rsv = &fs_info->global_block_rsv;
Yan, Zhengf0486c62010-05-16 10:46:25 -04003586 fs_info->chunk_root->block_rsv = &fs_info->chunk_block_rsv;
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003587
3588 btrfs_add_durable_block_rsv(fs_info, &fs_info->global_block_rsv);
3589
3590 btrfs_add_durable_block_rsv(fs_info, &fs_info->delalloc_block_rsv);
3591
3592 update_global_block_rsv(fs_info);
3593}
3594
3595static void release_global_block_rsv(struct btrfs_fs_info *fs_info)
3596{
3597 block_rsv_release_bytes(&fs_info->global_block_rsv, NULL, (u64)-1);
3598 WARN_ON(fs_info->delalloc_block_rsv.size > 0);
3599 WARN_ON(fs_info->delalloc_block_rsv.reserved > 0);
3600 WARN_ON(fs_info->trans_block_rsv.size > 0);
3601 WARN_ON(fs_info->trans_block_rsv.reserved > 0);
3602 WARN_ON(fs_info->chunk_block_rsv.size > 0);
3603 WARN_ON(fs_info->chunk_block_rsv.reserved > 0);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003604}
3605
Yan, Zhenga22285a2010-05-16 10:48:46 -04003606static u64 calc_trans_metadata_size(struct btrfs_root *root, int num_items)
3607{
3608 return (root->leafsize + root->nodesize * (BTRFS_MAX_LEVEL - 1)) *
3609 3 * num_items;
3610}
3611
3612int btrfs_trans_reserve_metadata(struct btrfs_trans_handle *trans,
3613 struct btrfs_root *root,
3614 int num_items, int *retries)
3615{
3616 u64 num_bytes;
3617 int ret;
3618
3619 if (num_items == 0 || root->fs_info->chunk_root == root)
3620 return 0;
3621
3622 num_bytes = calc_trans_metadata_size(root, num_items);
3623 ret = btrfs_block_rsv_add(trans, root, &root->fs_info->trans_block_rsv,
3624 num_bytes, retries);
3625 if (!ret) {
3626 trans->bytes_reserved += num_bytes;
3627 trans->block_rsv = &root->fs_info->trans_block_rsv;
3628 }
3629 return ret;
3630}
3631
3632void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans,
3633 struct btrfs_root *root)
3634{
3635 if (!trans->bytes_reserved)
3636 return;
3637
3638 BUG_ON(trans->block_rsv != &root->fs_info->trans_block_rsv);
3639 btrfs_block_rsv_release(root, trans->block_rsv,
3640 trans->bytes_reserved);
3641 trans->bytes_reserved = 0;
3642}
3643
Yan, Zhengd68fc572010-05-16 10:49:58 -04003644int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans,
3645 struct inode *inode)
3646{
3647 struct btrfs_root *root = BTRFS_I(inode)->root;
3648 struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
3649 struct btrfs_block_rsv *dst_rsv = root->orphan_block_rsv;
3650
3651 /*
3652 * one for deleting orphan item, one for updating inode and
3653 * two for calling btrfs_truncate_inode_items.
3654 *
3655 * btrfs_truncate_inode_items is a delete operation, it frees
3656 * more space than it uses in most cases. So two units of
3657 * metadata space should be enough for calling it many times.
3658 * If all of the metadata space is used, we can commit
3659 * transaction and use space it freed.
3660 */
3661 u64 num_bytes = calc_trans_metadata_size(root, 4);
3662 return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
3663}
3664
3665void btrfs_orphan_release_metadata(struct inode *inode)
3666{
3667 struct btrfs_root *root = BTRFS_I(inode)->root;
3668 u64 num_bytes = calc_trans_metadata_size(root, 4);
3669 btrfs_block_rsv_release(root, root->orphan_block_rsv, num_bytes);
3670}
3671
Yan, Zhenga22285a2010-05-16 10:48:46 -04003672int btrfs_snap_reserve_metadata(struct btrfs_trans_handle *trans,
3673 struct btrfs_pending_snapshot *pending)
3674{
3675 struct btrfs_root *root = pending->root;
3676 struct btrfs_block_rsv *src_rsv = get_block_rsv(trans, root);
3677 struct btrfs_block_rsv *dst_rsv = &pending->block_rsv;
3678 /*
3679 * two for root back/forward refs, two for directory entries
3680 * and one for root of the snapshot.
3681 */
3682 u64 num_bytes = calc_trans_metadata_size(root, 5);
3683 dst_rsv->space_info = src_rsv->space_info;
3684 return block_rsv_migrate_bytes(src_rsv, dst_rsv, num_bytes);
3685}
3686
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003687static u64 calc_csum_metadata_size(struct inode *inode, u64 num_bytes)
3688{
3689 return num_bytes >>= 3;
3690}
3691
3692int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
3693{
3694 struct btrfs_root *root = BTRFS_I(inode)->root;
3695 struct btrfs_block_rsv *block_rsv = &root->fs_info->delalloc_block_rsv;
3696 u64 to_reserve;
3697 int nr_extents;
3698 int retries = 0;
3699 int ret;
3700
3701 if (btrfs_transaction_in_commit(root->fs_info))
3702 schedule_timeout(1);
3703
3704 num_bytes = ALIGN(num_bytes, root->sectorsize);
3705again:
3706 spin_lock(&BTRFS_I(inode)->accounting_lock);
3707 nr_extents = atomic_read(&BTRFS_I(inode)->outstanding_extents) + 1;
3708 if (nr_extents > BTRFS_I(inode)->reserved_extents) {
3709 nr_extents -= BTRFS_I(inode)->reserved_extents;
3710 to_reserve = calc_trans_metadata_size(root, nr_extents);
3711 } else {
3712 nr_extents = 0;
3713 to_reserve = 0;
3714 }
3715
3716 to_reserve += calc_csum_metadata_size(inode, num_bytes);
3717 ret = reserve_metadata_bytes(block_rsv, to_reserve);
3718 if (ret) {
3719 spin_unlock(&BTRFS_I(inode)->accounting_lock);
3720 ret = should_retry_reserve(NULL, root, block_rsv, to_reserve,
3721 &retries);
3722 if (ret > 0)
3723 goto again;
3724 return ret;
3725 }
3726
3727 BTRFS_I(inode)->reserved_extents += nr_extents;
3728 atomic_inc(&BTRFS_I(inode)->outstanding_extents);
3729 spin_unlock(&BTRFS_I(inode)->accounting_lock);
3730
3731 block_rsv_add_bytes(block_rsv, to_reserve, 1);
3732
3733 if (block_rsv->size > 512 * 1024 * 1024)
Josef Bacik0019f102010-10-15 15:18:40 -04003734 shrink_delalloc(NULL, root, to_reserve, 0);
Yan, Zheng0ca1f7c2010-05-16 10:48:47 -04003735
3736 return 0;
3737}
3738
3739void btrfs_delalloc_release_metadata(struct inode *inode, u64 num_bytes)
3740{
3741 struct btrfs_root *root = BTRFS_I(inode)->root;
3742 u64 to_free;
3743 int nr_extents;
3744
3745 num_bytes = ALIGN(num_bytes, root->sectorsize);
3746 atomic_dec(&BTRFS_I(inode)->outstanding_extents);
3747
3748 spin_lock(&BTRFS_I(inode)->accounting_lock);
3749 nr_extents = atomic_read(&BTRFS_I(inode)->outstanding_extents);
3750 if (nr_extents < BTRFS_I(inode)->reserved_extents) {
3751 nr_extents = BTRFS_I(inode)->reserved_extents - nr_extents;
3752 BTRFS_I(inode)->reserved_extents -= nr_extents;
3753 } else {
3754 nr_extents = 0;
3755 }
3756 spin_unlock(&BTRFS_I(inode)->accounting_lock);
3757
3758 to_free = calc_csum_metadata_size(inode, num_bytes);
3759 if (nr_extents > 0)
3760 to_free += calc_trans_metadata_size(root, nr_extents);
3761
3762 btrfs_block_rsv_release(root, &root->fs_info->delalloc_block_rsv,
3763 to_free);
3764}
3765
3766int btrfs_delalloc_reserve_space(struct inode *inode, u64 num_bytes)
3767{
3768 int ret;
3769
3770 ret = btrfs_check_data_free_space(inode, num_bytes);
3771 if (ret)
3772 return ret;
3773
3774 ret = btrfs_delalloc_reserve_metadata(inode, num_bytes);
3775 if (ret) {
3776 btrfs_free_reserved_data_space(inode, num_bytes);
3777 return ret;
3778 }
3779
3780 return 0;
3781}
3782
3783void btrfs_delalloc_release_space(struct inode *inode, u64 num_bytes)
3784{
3785 btrfs_delalloc_release_metadata(inode, num_bytes);
3786 btrfs_free_reserved_data_space(inode, num_bytes);
3787}
3788
Chris Mason9078a3e2007-04-26 16:46:15 -04003789static int update_block_group(struct btrfs_trans_handle *trans,
3790 struct btrfs_root *root,
Yan, Zhengf0486c62010-05-16 10:46:25 -04003791 u64 bytenr, u64 num_bytes, int alloc)
Chris Mason9078a3e2007-04-26 16:46:15 -04003792{
3793 struct btrfs_block_group_cache *cache;
3794 struct btrfs_fs_info *info = root->fs_info;
Yan, Zhengb742bb82010-05-16 10:46:24 -04003795 int factor;
Chris Masondb945352007-10-15 16:15:53 -04003796 u64 total = num_bytes;
Chris Mason9078a3e2007-04-26 16:46:15 -04003797 u64 old_val;
Chris Masondb945352007-10-15 16:15:53 -04003798 u64 byte_in_group;
Chris Mason3e1ad542007-05-07 20:03:49 -04003799
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003800 /* block accounting for super block */
3801 spin_lock(&info->delalloc_lock);
3802 old_val = btrfs_super_bytes_used(&info->super_copy);
3803 if (alloc)
3804 old_val += num_bytes;
3805 else
3806 old_val -= num_bytes;
3807 btrfs_set_super_bytes_used(&info->super_copy, old_val);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04003808 spin_unlock(&info->delalloc_lock);
3809
Chris Masond3977122009-01-05 21:25:51 -05003810 while (total) {
Chris Masondb945352007-10-15 16:15:53 -04003811 cache = btrfs_lookup_block_group(info, bytenr);
Josef Bacikf3465ca2008-11-12 14:19:50 -05003812 if (!cache)
Chris Mason9078a3e2007-04-26 16:46:15 -04003813 return -1;
Yan, Zhengb742bb82010-05-16 10:46:24 -04003814 if (cache->flags & (BTRFS_BLOCK_GROUP_DUP |
3815 BTRFS_BLOCK_GROUP_RAID1 |
3816 BTRFS_BLOCK_GROUP_RAID10))
3817 factor = 2;
3818 else
3819 factor = 1;
Chris Masondb945352007-10-15 16:15:53 -04003820 byte_in_group = bytenr - cache->key.objectid;
3821 WARN_ON(byte_in_group > cache->key.offset);
Chris Mason9078a3e2007-04-26 16:46:15 -04003822
Josef Bacik25179202008-10-29 14:49:05 -04003823 spin_lock(&cache->space_info->lock);
Chris Masonc286ac42008-07-22 23:06:41 -04003824 spin_lock(&cache->lock);
Josef Bacik0f9dd462008-09-23 13:14:11 -04003825 cache->dirty = 1;
Chris Mason9078a3e2007-04-26 16:46:15 -04003826 old_val = btrfs_block_group_used(&cache->item);
Chris Masondb945352007-10-15 16:15:53 -04003827 num_bytes = min(total, cache->key.offset - byte_in_group);
Chris Masoncd1bc462007-04-27 10:08:34 -04003828 if (alloc) {
Chris Masondb945352007-10-15 16:15:53 -04003829 old_val += num_bytes;
Yan Zheng11833d62009-09-11 16:11:19 -04003830 btrfs_set_block_group_used(&cache->item, old_val);
3831 cache->reserved -= num_bytes;
Yan Zheng11833d62009-09-11 16:11:19 -04003832 cache->space_info->bytes_reserved -= num_bytes;
Yan, Zhengb742bb82010-05-16 10:46:24 -04003833 cache->space_info->bytes_used += num_bytes;
3834 cache->space_info->disk_used += num_bytes * factor;
Chris Masonc286ac42008-07-22 23:06:41 -04003835 spin_unlock(&cache->lock);
Josef Bacik25179202008-10-29 14:49:05 -04003836 spin_unlock(&cache->space_info->lock);
Chris Masoncd1bc462007-04-27 10:08:34 -04003837 } else {
Chris Masondb945352007-10-15 16:15:53 -04003838 old_val -= num_bytes;
Chris Masonc286ac42008-07-22 23:06:41 -04003839 btrfs_set_block_group_used(&cache->item, old_val);
Yan, Zhengf0486c62010-05-16 10:46:25 -04003840 cache->pinned += num_bytes;
3841 cache->space_info->bytes_pinned += num_bytes;
Chris Mason9078a3e2007-04-26 16:46:15 -04003842 cache->space_info->bytes_used -= num_bytes;
Yan, Zhengb742bb82010-05-16 10:46:24 -04003843 cache->space_info->disk_used -= num_bytes * factor;
Chris Masonc286ac42008-07-22 23:06:41 -04003844 spin_unlock(&cache->lock);
Josef Bacik25179202008-10-29 14:49:05 -04003845 spin_unlock(&cache->space_info->lock);
Liu Hui1f3c79a2009-01-05 15:57:51 -05003846
Yan, Zhengf0486c62010-05-16 10:46:25 -04003847 set_extent_dirty(info->pinned_extents,
3848 bytenr, bytenr + num_bytes - 1,
3849 GFP_NOFS | __GFP_NOFAIL);
Chris Masoncd1bc462007-04-27 10:08:34 -04003850 }
Chris Masonfa9c0d72009-04-03 09:47:43 -04003851 btrfs_put_block_group(cache);
Chris Masondb945352007-10-15 16:15:53 -04003852 total -= num_bytes;
3853 bytenr += num_bytes;
Chris Mason9078a3e2007-04-26 16:46:15 -04003854 }
3855 return 0;
3856}
Chris Mason6324fbf2008-03-24 15:01:59 -04003857
Chris Masona061fc82008-05-07 11:43:44 -04003858static u64 first_logical_byte(struct btrfs_root *root, u64 search_start)
3859{
Josef Bacik0f9dd462008-09-23 13:14:11 -04003860 struct btrfs_block_group_cache *cache;
Yan Zhengd2fb3432008-12-11 16:30:39 -05003861 u64 bytenr;
Josef Bacik0f9dd462008-09-23 13:14:11 -04003862
3863 cache = btrfs_lookup_first_block_group(root->fs_info, search_start);
3864 if (!cache)
Chris Masona061fc82008-05-07 11:43:44 -04003865 return 0;
Josef Bacik0f9dd462008-09-23 13:14:11 -04003866
Yan Zhengd2fb3432008-12-11 16:30:39 -05003867 bytenr = cache->key.objectid;
Chris Masonfa9c0d72009-04-03 09:47:43 -04003868 btrfs_put_block_group(cache);
Yan Zhengd2fb3432008-12-11 16:30:39 -05003869
3870 return bytenr;
Chris Masona061fc82008-05-07 11:43:44 -04003871}
3872
Yan, Zhengf0486c62010-05-16 10:46:25 -04003873static int pin_down_extent(struct btrfs_root *root,
3874 struct btrfs_block_group_cache *cache,
3875 u64 bytenr, u64 num_bytes, int reserved)
Yan324ae4d2007-11-16 14:57:08 -05003876{
Yan Zheng11833d62009-09-11 16:11:19 -04003877 spin_lock(&cache->space_info->lock);
3878 spin_lock(&cache->lock);
3879 cache->pinned += num_bytes;
3880 cache->space_info->bytes_pinned += num_bytes;
3881 if (reserved) {
3882 cache->reserved -= num_bytes;
3883 cache->space_info->bytes_reserved -= num_bytes;
Yan324ae4d2007-11-16 14:57:08 -05003884 }
Yan Zheng11833d62009-09-11 16:11:19 -04003885 spin_unlock(&cache->lock);
3886 spin_unlock(&cache->space_info->lock);
3887
Yan, Zhengf0486c62010-05-16 10:46:25 -04003888 set_extent_dirty(root->fs_info->pinned_extents, bytenr,
3889 bytenr + num_bytes - 1, GFP_NOFS | __GFP_NOFAIL);
Yan324ae4d2007-11-16 14:57:08 -05003890 return 0;
3891}
Chris Mason9078a3e2007-04-26 16:46:15 -04003892
Yan, Zhengf0486c62010-05-16 10:46:25 -04003893/*
3894 * this function must be called within transaction
3895 */
3896int btrfs_pin_extent(struct btrfs_root *root,
3897 u64 bytenr, u64 num_bytes, int reserved)
Zheng Yane8569812008-09-26 10:05:48 -04003898{
Yan, Zhengf0486c62010-05-16 10:46:25 -04003899 struct btrfs_block_group_cache *cache;
3900
3901 cache = btrfs_lookup_block_group(root->fs_info, bytenr);
3902 BUG_ON(!cache);
3903
3904 pin_down_extent(root, cache, bytenr, num_bytes, reserved);
3905
3906 btrfs_put_block_group(cache);
Yan Zheng11833d62009-09-11 16:11:19 -04003907 return 0;
3908}
Zheng Yane8569812008-09-26 10:05:48 -04003909
Yan, Zhengf0486c62010-05-16 10:46:25 -04003910/*
3911 * update size of reserved extents. this function may return -EAGAIN
3912 * if 'reserve' is true or 'sinfo' is false.
3913 */
3914static int update_reserved_bytes(struct btrfs_block_group_cache *cache,
3915 u64 num_bytes, int reserve, int sinfo)
3916{
3917 int ret = 0;
3918 if (sinfo) {
3919 struct btrfs_space_info *space_info = cache->space_info;
3920 spin_lock(&space_info->lock);
3921 spin_lock(&cache->lock);
3922 if (reserve) {
3923 if (cache->ro) {
3924 ret = -EAGAIN;
3925 } else {
3926 cache->reserved += num_bytes;
3927 space_info->bytes_reserved += num_bytes;
3928 }
3929 } else {
3930 if (cache->ro)
3931 space_info->bytes_readonly += num_bytes;
3932 cache->reserved -= num_bytes;
3933 space_info->bytes_reserved -= num_bytes;
3934 }
3935 spin_unlock(&cache->lock);
3936 spin_unlock(&space_info->lock);
3937 } else {
3938 spin_lock(&cache->lock);
3939 if (cache->ro) {
3940 ret = -EAGAIN;
3941 } else {
3942 if (reserve)
3943 cache->reserved += num_bytes;
3944 else
3945 cache->reserved -= num_bytes;
3946 }
3947 spin_unlock(&cache->lock);
3948 }
3949 return ret;
3950}
3951
Yan Zheng11833d62009-09-11 16:11:19 -04003952int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans,
3953 struct btrfs_root *root)
3954{
3955 struct btrfs_fs_info *fs_info = root->fs_info;
3956 struct btrfs_caching_control *next;
3957 struct btrfs_caching_control *caching_ctl;
3958 struct btrfs_block_group_cache *cache;
3959
3960 down_write(&fs_info->extent_commit_sem);
3961
3962 list_for_each_entry_safe(caching_ctl, next,
3963 &fs_info->caching_block_groups, list) {
3964 cache = caching_ctl->block_group;
3965 if (block_group_cache_done(cache)) {
3966 cache->last_byte_to_unpin = (u64)-1;
3967 list_del_init(&caching_ctl->list);
3968 put_caching_control(caching_ctl);
3969 } else {
3970 cache->last_byte_to_unpin = caching_ctl->progress;
3971 }
3972 }
3973
3974 if (fs_info->pinned_extents == &fs_info->freed_extents[0])
3975 fs_info->pinned_extents = &fs_info->freed_extents[1];
3976 else
3977 fs_info->pinned_extents = &fs_info->freed_extents[0];
3978
3979 up_write(&fs_info->extent_commit_sem);
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04003980
3981 update_global_block_rsv(fs_info);
Yan Zheng11833d62009-09-11 16:11:19 -04003982 return 0;
3983}
3984
3985static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end)
3986{
3987 struct btrfs_fs_info *fs_info = root->fs_info;
3988 struct btrfs_block_group_cache *cache = NULL;
3989 u64 len;
3990
3991 while (start <= end) {
3992 if (!cache ||
3993 start >= cache->key.objectid + cache->key.offset) {
3994 if (cache)
3995 btrfs_put_block_group(cache);
3996 cache = btrfs_lookup_block_group(fs_info, start);
3997 BUG_ON(!cache);
3998 }
3999
4000 len = cache->key.objectid + cache->key.offset - start;
4001 len = min(len, end + 1 - start);
4002
4003 if (start < cache->last_byte_to_unpin) {
4004 len = min(len, cache->last_byte_to_unpin - start);
4005 btrfs_add_free_space(cache, start, len);
4006 }
Josef Bacik25179202008-10-29 14:49:05 -04004007
Yan, Zhengf0486c62010-05-16 10:46:25 -04004008 start += len;
4009
Josef Bacik25179202008-10-29 14:49:05 -04004010 spin_lock(&cache->space_info->lock);
4011 spin_lock(&cache->lock);
Yan Zheng11833d62009-09-11 16:11:19 -04004012 cache->pinned -= len;
4013 cache->space_info->bytes_pinned -= len;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004014 if (cache->ro) {
4015 cache->space_info->bytes_readonly += len;
4016 } else if (cache->reserved_pinned > 0) {
4017 len = min(len, cache->reserved_pinned);
4018 cache->reserved_pinned -= len;
4019 cache->space_info->bytes_reserved += len;
4020 }
Josef Bacik25179202008-10-29 14:49:05 -04004021 spin_unlock(&cache->lock);
4022 spin_unlock(&cache->space_info->lock);
Yan Zheng11833d62009-09-11 16:11:19 -04004023 }
4024
4025 if (cache)
Chris Masonfa9c0d72009-04-03 09:47:43 -04004026 btrfs_put_block_group(cache);
Chris Masonccd467d2007-06-28 15:57:36 -04004027 return 0;
4028}
4029
4030int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans,
Yan Zheng11833d62009-09-11 16:11:19 -04004031 struct btrfs_root *root)
Chris Masona28ec192007-03-06 20:08:01 -05004032{
Yan Zheng11833d62009-09-11 16:11:19 -04004033 struct btrfs_fs_info *fs_info = root->fs_info;
4034 struct extent_io_tree *unpin;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004035 struct btrfs_block_rsv *block_rsv;
4036 struct btrfs_block_rsv *next_rsv;
Chris Mason1a5bc162007-10-15 16:15:26 -04004037 u64 start;
4038 u64 end;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004039 int idx;
Chris Masona28ec192007-03-06 20:08:01 -05004040 int ret;
Chris Masona28ec192007-03-06 20:08:01 -05004041
Yan Zheng11833d62009-09-11 16:11:19 -04004042 if (fs_info->pinned_extents == &fs_info->freed_extents[0])
4043 unpin = &fs_info->freed_extents[1];
4044 else
4045 unpin = &fs_info->freed_extents[0];
4046
Chris Masond3977122009-01-05 21:25:51 -05004047 while (1) {
Chris Mason1a5bc162007-10-15 16:15:26 -04004048 ret = find_first_extent_bit(unpin, 0, &start, &end,
4049 EXTENT_DIRTY);
4050 if (ret)
Chris Masona28ec192007-03-06 20:08:01 -05004051 break;
Liu Hui1f3c79a2009-01-05 15:57:51 -05004052
4053 ret = btrfs_discard_extent(root, start, end + 1 - start);
4054
Chris Mason1a5bc162007-10-15 16:15:26 -04004055 clear_extent_dirty(unpin, start, end, GFP_NOFS);
Yan Zheng11833d62009-09-11 16:11:19 -04004056 unpin_extent_range(root, start, end);
Chris Masonb9473432009-03-13 11:00:37 -04004057 cond_resched();
Chris Masona28ec192007-03-06 20:08:01 -05004058 }
Josef Bacik817d52f2009-07-13 21:29:25 -04004059
Yan, Zhengf0486c62010-05-16 10:46:25 -04004060 mutex_lock(&fs_info->durable_block_rsv_mutex);
4061 list_for_each_entry_safe(block_rsv, next_rsv,
4062 &fs_info->durable_block_rsv_list, list) {
Chris Masona28ec192007-03-06 20:08:01 -05004063
Yan, Zhengf0486c62010-05-16 10:46:25 -04004064 idx = trans->transid & 0x1;
4065 if (block_rsv->freed[idx] > 0) {
4066 block_rsv_add_bytes(block_rsv,
4067 block_rsv->freed[idx], 0);
4068 block_rsv->freed[idx] = 0;
Chris Mason8ef97622007-03-26 10:15:30 -04004069 }
Yan, Zhengf0486c62010-05-16 10:46:25 -04004070 if (atomic_read(&block_rsv->usage) == 0) {
4071 btrfs_block_rsv_release(root, block_rsv, (u64)-1);
Zheng Yan31840ae2008-09-23 13:14:14 -04004072
Yan, Zhengf0486c62010-05-16 10:46:25 -04004073 if (block_rsv->freed[0] == 0 &&
4074 block_rsv->freed[1] == 0) {
4075 list_del_init(&block_rsv->list);
4076 kfree(block_rsv);
4077 }
4078 } else {
4079 btrfs_block_rsv_release(root, block_rsv, 0);
4080 }
4081 }
4082 mutex_unlock(&fs_info->durable_block_rsv_mutex);
4083
Chris Masone20d96d2007-03-22 12:13:20 -04004084 return 0;
4085}
4086
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004087static int __btrfs_free_extent(struct btrfs_trans_handle *trans,
4088 struct btrfs_root *root,
4089 u64 bytenr, u64 num_bytes, u64 parent,
4090 u64 root_objectid, u64 owner_objectid,
4091 u64 owner_offset, int refs_to_drop,
4092 struct btrfs_delayed_extent_op *extent_op)
Chris Masona28ec192007-03-06 20:08:01 -05004093{
Chris Masone2fa7222007-03-12 16:22:34 -04004094 struct btrfs_key key;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004095 struct btrfs_path *path;
Chris Mason1261ec42007-03-20 20:35:03 -04004096 struct btrfs_fs_info *info = root->fs_info;
4097 struct btrfs_root *extent_root = info->extent_root;
Chris Mason5f39d392007-10-15 16:14:19 -04004098 struct extent_buffer *leaf;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004099 struct btrfs_extent_item *ei;
4100 struct btrfs_extent_inline_ref *iref;
Chris Masona28ec192007-03-06 20:08:01 -05004101 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004102 int is_data;
Chris Mason952fcca2008-02-18 16:33:44 -05004103 int extent_slot = 0;
4104 int found_extent = 0;
4105 int num_to_del = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004106 u32 item_size;
4107 u64 refs;
Chris Mason037e6392007-03-07 11:50:24 -05004108
Chris Mason5caf2a02007-04-02 11:20:42 -04004109 path = btrfs_alloc_path();
Chris Mason54aa1f42007-06-22 14:16:25 -04004110 if (!path)
4111 return -ENOMEM;
4112
Chris Mason3c12ac72008-04-21 12:01:38 -04004113 path->reada = 1;
Chris Masonb9473432009-03-13 11:00:37 -04004114 path->leave_spinning = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004115
4116 is_data = owner_objectid >= BTRFS_FIRST_FREE_OBJECTID;
4117 BUG_ON(!is_data && refs_to_drop != 1);
4118
4119 ret = lookup_extent_backref(trans, extent_root, path, &iref,
4120 bytenr, num_bytes, parent,
4121 root_objectid, owner_objectid,
4122 owner_offset);
Chris Mason7bb86312007-12-11 09:25:06 -05004123 if (ret == 0) {
Chris Mason952fcca2008-02-18 16:33:44 -05004124 extent_slot = path->slots[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004125 while (extent_slot >= 0) {
4126 btrfs_item_key_to_cpu(path->nodes[0], &key,
Chris Mason952fcca2008-02-18 16:33:44 -05004127 extent_slot);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004128 if (key.objectid != bytenr)
Chris Mason952fcca2008-02-18 16:33:44 -05004129 break;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004130 if (key.type == BTRFS_EXTENT_ITEM_KEY &&
4131 key.offset == num_bytes) {
Chris Mason952fcca2008-02-18 16:33:44 -05004132 found_extent = 1;
4133 break;
4134 }
4135 if (path->slots[0] - extent_slot > 5)
4136 break;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004137 extent_slot--;
Chris Mason952fcca2008-02-18 16:33:44 -05004138 }
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004139#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
4140 item_size = btrfs_item_size_nr(path->nodes[0], extent_slot);
4141 if (found_extent && item_size < sizeof(*ei))
4142 found_extent = 0;
4143#endif
Zheng Yan31840ae2008-09-23 13:14:14 -04004144 if (!found_extent) {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004145 BUG_ON(iref);
Chris Mason56bec292009-03-13 10:10:06 -04004146 ret = remove_extent_backref(trans, extent_root, path,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004147 NULL, refs_to_drop,
4148 is_data);
Zheng Yan31840ae2008-09-23 13:14:14 -04004149 BUG_ON(ret);
4150 btrfs_release_path(extent_root, path);
Chris Masonb9473432009-03-13 11:00:37 -04004151 path->leave_spinning = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004152
4153 key.objectid = bytenr;
4154 key.type = BTRFS_EXTENT_ITEM_KEY;
4155 key.offset = num_bytes;
4156
Zheng Yan31840ae2008-09-23 13:14:14 -04004157 ret = btrfs_search_slot(trans, extent_root,
4158 &key, path, -1, 1);
Josef Bacikf3465ca2008-11-12 14:19:50 -05004159 if (ret) {
4160 printk(KERN_ERR "umm, got %d back from search"
Chris Masond3977122009-01-05 21:25:51 -05004161 ", was looking for %llu\n", ret,
4162 (unsigned long long)bytenr);
Josef Bacikf3465ca2008-11-12 14:19:50 -05004163 btrfs_print_leaf(extent_root, path->nodes[0]);
4164 }
Zheng Yan31840ae2008-09-23 13:14:14 -04004165 BUG_ON(ret);
4166 extent_slot = path->slots[0];
4167 }
Chris Mason7bb86312007-12-11 09:25:06 -05004168 } else {
4169 btrfs_print_leaf(extent_root, path->nodes[0]);
4170 WARN_ON(1);
Chris Masond3977122009-01-05 21:25:51 -05004171 printk(KERN_ERR "btrfs unable to find ref byte nr %llu "
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004172 "parent %llu root %llu owner %llu offset %llu\n",
Chris Masond3977122009-01-05 21:25:51 -05004173 (unsigned long long)bytenr,
Chris Mason56bec292009-03-13 10:10:06 -04004174 (unsigned long long)parent,
Chris Masond3977122009-01-05 21:25:51 -05004175 (unsigned long long)root_objectid,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004176 (unsigned long long)owner_objectid,
4177 (unsigned long long)owner_offset);
Chris Mason7bb86312007-12-11 09:25:06 -05004178 }
Chris Mason5f39d392007-10-15 16:14:19 -04004179
4180 leaf = path->nodes[0];
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004181 item_size = btrfs_item_size_nr(leaf, extent_slot);
4182#ifdef BTRFS_COMPAT_EXTENT_TREE_V0
4183 if (item_size < sizeof(*ei)) {
4184 BUG_ON(found_extent || extent_slot != path->slots[0]);
4185 ret = convert_extent_item_v0(trans, extent_root, path,
4186 owner_objectid, 0);
4187 BUG_ON(ret < 0);
4188
4189 btrfs_release_path(extent_root, path);
4190 path->leave_spinning = 1;
4191
4192 key.objectid = bytenr;
4193 key.type = BTRFS_EXTENT_ITEM_KEY;
4194 key.offset = num_bytes;
4195
4196 ret = btrfs_search_slot(trans, extent_root, &key, path,
4197 -1, 1);
4198 if (ret) {
4199 printk(KERN_ERR "umm, got %d back from search"
4200 ", was looking for %llu\n", ret,
4201 (unsigned long long)bytenr);
4202 btrfs_print_leaf(extent_root, path->nodes[0]);
4203 }
4204 BUG_ON(ret);
4205 extent_slot = path->slots[0];
4206 leaf = path->nodes[0];
4207 item_size = btrfs_item_size_nr(leaf, extent_slot);
4208 }
4209#endif
4210 BUG_ON(item_size < sizeof(*ei));
Chris Mason952fcca2008-02-18 16:33:44 -05004211 ei = btrfs_item_ptr(leaf, extent_slot,
Chris Mason123abc82007-03-14 14:14:43 -04004212 struct btrfs_extent_item);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004213 if (owner_objectid < BTRFS_FIRST_FREE_OBJECTID) {
4214 struct btrfs_tree_block_info *bi;
4215 BUG_ON(item_size < sizeof(*ei) + sizeof(*bi));
4216 bi = (struct btrfs_tree_block_info *)(ei + 1);
4217 WARN_ON(owner_objectid != btrfs_tree_block_level(leaf, bi));
Chris Mason952fcca2008-02-18 16:33:44 -05004218 }
4219
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004220 refs = btrfs_extent_refs(leaf, ei);
4221 BUG_ON(refs < refs_to_drop);
4222 refs -= refs_to_drop;
4223
4224 if (refs > 0) {
4225 if (extent_op)
4226 __run_delayed_extent_op(extent_op, leaf, ei);
4227 /*
4228 * In the case of inline back ref, reference count will
4229 * be updated by remove_extent_backref
4230 */
4231 if (iref) {
4232 BUG_ON(!found_extent);
4233 } else {
4234 btrfs_set_extent_refs(leaf, ei, refs);
4235 btrfs_mark_buffer_dirty(leaf);
4236 }
4237 if (found_extent) {
4238 ret = remove_extent_backref(trans, extent_root, path,
4239 iref, refs_to_drop,
4240 is_data);
4241 BUG_ON(ret);
4242 }
4243 } else {
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004244 if (found_extent) {
4245 BUG_ON(is_data && refs_to_drop !=
4246 extent_data_ref_count(root, path, iref));
4247 if (iref) {
4248 BUG_ON(path->slots[0] != extent_slot);
4249 } else {
4250 BUG_ON(path->slots[0] != extent_slot + 1);
4251 path->slots[0] = extent_slot;
4252 num_to_del = 2;
4253 }
Chris Mason78fae272007-03-25 11:35:08 -04004254 }
Chris Masonb9473432009-03-13 11:00:37 -04004255
Chris Mason952fcca2008-02-18 16:33:44 -05004256 ret = btrfs_del_items(trans, extent_root, path, path->slots[0],
4257 num_to_del);
Zheng Yan31840ae2008-09-23 13:14:14 -04004258 BUG_ON(ret);
Josef Bacik25179202008-10-29 14:49:05 -04004259 btrfs_release_path(extent_root, path);
David Woodhouse21af8042008-08-12 14:13:26 +01004260
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004261 if (is_data) {
Chris Mason459931e2008-12-10 09:10:46 -05004262 ret = btrfs_del_csums(trans, root, bytenr, num_bytes);
4263 BUG_ON(ret);
Chris Masond57e62b2009-03-31 13:47:50 -04004264 } else {
4265 invalidate_mapping_pages(info->btree_inode->i_mapping,
4266 bytenr >> PAGE_CACHE_SHIFT,
4267 (bytenr + num_bytes - 1) >> PAGE_CACHE_SHIFT);
Chris Mason459931e2008-12-10 09:10:46 -05004268 }
4269
Yan, Zhengf0486c62010-05-16 10:46:25 -04004270 ret = update_block_group(trans, root, bytenr, num_bytes, 0);
Chris Masondcbdd4d2008-12-16 13:51:01 -05004271 BUG_ON(ret);
Chris Masona28ec192007-03-06 20:08:01 -05004272 }
Chris Mason5caf2a02007-04-02 11:20:42 -04004273 btrfs_free_path(path);
Chris Masona28ec192007-03-06 20:08:01 -05004274 return ret;
4275}
4276
4277/*
Yan, Zhengf0486c62010-05-16 10:46:25 -04004278 * when we free an block, it is possible (and likely) that we free the last
Chris Mason1887be62009-03-13 10:11:24 -04004279 * delayed ref for that extent as well. This searches the delayed ref tree for
4280 * a given extent, and if there are no other delayed refs to be processed, it
4281 * removes it from the tree.
4282 */
4283static noinline int check_ref_cleanup(struct btrfs_trans_handle *trans,
4284 struct btrfs_root *root, u64 bytenr)
4285{
4286 struct btrfs_delayed_ref_head *head;
4287 struct btrfs_delayed_ref_root *delayed_refs;
4288 struct btrfs_delayed_ref_node *ref;
4289 struct rb_node *node;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004290 int ret = 0;
Chris Mason1887be62009-03-13 10:11:24 -04004291
4292 delayed_refs = &trans->transaction->delayed_refs;
4293 spin_lock(&delayed_refs->lock);
4294 head = btrfs_find_delayed_ref_head(trans, bytenr);
4295 if (!head)
4296 goto out;
4297
4298 node = rb_prev(&head->node.rb_node);
4299 if (!node)
4300 goto out;
4301
4302 ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
4303
4304 /* there are still entries for this ref, we can't drop it */
4305 if (ref->bytenr == bytenr)
4306 goto out;
4307
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004308 if (head->extent_op) {
4309 if (!head->must_insert_reserved)
4310 goto out;
4311 kfree(head->extent_op);
4312 head->extent_op = NULL;
4313 }
4314
Chris Mason1887be62009-03-13 10:11:24 -04004315 /*
4316 * waiting for the lock here would deadlock. If someone else has it
4317 * locked they are already in the process of dropping it anyway
4318 */
4319 if (!mutex_trylock(&head->mutex))
4320 goto out;
4321
4322 /*
4323 * at this point we have a head with no other entries. Go
4324 * ahead and process it.
4325 */
4326 head->node.in_tree = 0;
4327 rb_erase(&head->node.rb_node, &delayed_refs->root);
Chris Masonc3e69d52009-03-13 10:17:05 -04004328
Chris Mason1887be62009-03-13 10:11:24 -04004329 delayed_refs->num_entries--;
4330
4331 /*
4332 * we don't take a ref on the node because we're removing it from the
4333 * tree, so we just steal the ref the tree was holding.
4334 */
Chris Masonc3e69d52009-03-13 10:17:05 -04004335 delayed_refs->num_heads--;
4336 if (list_empty(&head->cluster))
4337 delayed_refs->num_heads_ready--;
4338
4339 list_del_init(&head->cluster);
Chris Mason1887be62009-03-13 10:11:24 -04004340 spin_unlock(&delayed_refs->lock);
4341
Yan, Zhengf0486c62010-05-16 10:46:25 -04004342 BUG_ON(head->extent_op);
4343 if (head->must_insert_reserved)
4344 ret = 1;
4345
4346 mutex_unlock(&head->mutex);
Chris Mason1887be62009-03-13 10:11:24 -04004347 btrfs_put_delayed_ref(&head->node);
Yan, Zhengf0486c62010-05-16 10:46:25 -04004348 return ret;
Chris Mason1887be62009-03-13 10:11:24 -04004349out:
4350 spin_unlock(&delayed_refs->lock);
4351 return 0;
4352}
4353
Yan, Zhengf0486c62010-05-16 10:46:25 -04004354void btrfs_free_tree_block(struct btrfs_trans_handle *trans,
4355 struct btrfs_root *root,
4356 struct extent_buffer *buf,
4357 u64 parent, int last_ref)
4358{
4359 struct btrfs_block_rsv *block_rsv;
4360 struct btrfs_block_group_cache *cache = NULL;
4361 int ret;
4362
4363 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
4364 ret = btrfs_add_delayed_tree_ref(trans, buf->start, buf->len,
4365 parent, root->root_key.objectid,
4366 btrfs_header_level(buf),
4367 BTRFS_DROP_DELAYED_REF, NULL);
4368 BUG_ON(ret);
4369 }
4370
4371 if (!last_ref)
4372 return;
4373
4374 block_rsv = get_block_rsv(trans, root);
4375 cache = btrfs_lookup_block_group(root->fs_info, buf->start);
Yan, Zheng3bf84a52010-05-31 09:04:46 +00004376 if (block_rsv->space_info != cache->space_info)
4377 goto out;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004378
4379 if (btrfs_header_generation(buf) == trans->transid) {
4380 if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
4381 ret = check_ref_cleanup(trans, root, buf->start);
4382 if (!ret)
4383 goto pin;
4384 }
4385
4386 if (btrfs_header_flag(buf, BTRFS_HEADER_FLAG_WRITTEN)) {
4387 pin_down_extent(root, cache, buf->start, buf->len, 1);
4388 goto pin;
4389 }
4390
4391 WARN_ON(test_bit(EXTENT_BUFFER_DIRTY, &buf->bflags));
4392
4393 btrfs_add_free_space(cache, buf->start, buf->len);
4394 ret = update_reserved_bytes(cache, buf->len, 0, 0);
4395 if (ret == -EAGAIN) {
4396 /* block group became read-only */
4397 update_reserved_bytes(cache, buf->len, 0, 1);
4398 goto out;
4399 }
4400
4401 ret = 1;
4402 spin_lock(&block_rsv->lock);
4403 if (block_rsv->reserved < block_rsv->size) {
4404 block_rsv->reserved += buf->len;
4405 ret = 0;
4406 }
4407 spin_unlock(&block_rsv->lock);
4408
4409 if (ret) {
4410 spin_lock(&cache->space_info->lock);
4411 cache->space_info->bytes_reserved -= buf->len;
4412 spin_unlock(&cache->space_info->lock);
4413 }
4414 goto out;
4415 }
4416pin:
4417 if (block_rsv->durable && !cache->ro) {
4418 ret = 0;
4419 spin_lock(&cache->lock);
4420 if (!cache->ro) {
4421 cache->reserved_pinned += buf->len;
4422 ret = 1;
4423 }
4424 spin_unlock(&cache->lock);
4425
4426 if (ret) {
4427 spin_lock(&block_rsv->lock);
4428 block_rsv->freed[trans->transid & 0x1] += buf->len;
4429 spin_unlock(&block_rsv->lock);
4430 }
4431 }
4432out:
4433 btrfs_put_block_group(cache);
4434}
4435
Chris Mason925baed2008-06-25 16:01:30 -04004436int btrfs_free_extent(struct btrfs_trans_handle *trans,
Zheng Yan31840ae2008-09-23 13:14:14 -04004437 struct btrfs_root *root,
4438 u64 bytenr, u64 num_bytes, u64 parent,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004439 u64 root_objectid, u64 owner, u64 offset)
Chris Mason925baed2008-06-25 16:01:30 -04004440{
4441 int ret;
4442
Chris Mason56bec292009-03-13 10:10:06 -04004443 /*
4444 * tree log blocks never actually go into the extent allocation
4445 * tree, just update pinning info and exit early.
Chris Mason56bec292009-03-13 10:10:06 -04004446 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004447 if (root_objectid == BTRFS_TREE_LOG_OBJECTID) {
4448 WARN_ON(owner >= BTRFS_FIRST_FREE_OBJECTID);
Chris Masonb9473432009-03-13 11:00:37 -04004449 /* unlocks the pinned mutex */
Yan Zheng11833d62009-09-11 16:11:19 -04004450 btrfs_pin_extent(root, bytenr, num_bytes, 1);
Chris Mason56bec292009-03-13 10:10:06 -04004451 ret = 0;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004452 } else if (owner < BTRFS_FIRST_FREE_OBJECTID) {
4453 ret = btrfs_add_delayed_tree_ref(trans, bytenr, num_bytes,
4454 parent, root_objectid, (int)owner,
4455 BTRFS_DROP_DELAYED_REF, NULL);
Chris Mason1887be62009-03-13 10:11:24 -04004456 BUG_ON(ret);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04004457 } else {
4458 ret = btrfs_add_delayed_data_ref(trans, bytenr, num_bytes,
4459 parent, root_objectid, owner,
4460 offset, BTRFS_DROP_DELAYED_REF, NULL);
4461 BUG_ON(ret);
Chris Mason56bec292009-03-13 10:10:06 -04004462 }
Chris Mason925baed2008-06-25 16:01:30 -04004463 return ret;
4464}
4465
Chris Mason87ee04e2007-11-30 11:30:34 -05004466static u64 stripe_align(struct btrfs_root *root, u64 val)
4467{
4468 u64 mask = ((u64)root->stripesize - 1);
4469 u64 ret = (val + mask) & ~mask;
4470 return ret;
4471}
4472
Chris Masonfec577f2007-02-26 10:40:21 -05004473/*
Josef Bacik817d52f2009-07-13 21:29:25 -04004474 * when we wait for progress in the block group caching, its because
4475 * our allocation attempt failed at least once. So, we must sleep
4476 * and let some progress happen before we try again.
4477 *
4478 * This function will sleep at least once waiting for new free space to
4479 * show up, and then it will check the block group free space numbers
4480 * for our min num_bytes. Another option is to have it go ahead
4481 * and look in the rbtree for a free extent of a given size, but this
4482 * is a good start.
4483 */
4484static noinline int
4485wait_block_group_cache_progress(struct btrfs_block_group_cache *cache,
4486 u64 num_bytes)
4487{
Yan Zheng11833d62009-09-11 16:11:19 -04004488 struct btrfs_caching_control *caching_ctl;
Josef Bacik817d52f2009-07-13 21:29:25 -04004489 DEFINE_WAIT(wait);
4490
Yan Zheng11833d62009-09-11 16:11:19 -04004491 caching_ctl = get_caching_control(cache);
4492 if (!caching_ctl)
Josef Bacik817d52f2009-07-13 21:29:25 -04004493 return 0;
Josef Bacik817d52f2009-07-13 21:29:25 -04004494
Yan Zheng11833d62009-09-11 16:11:19 -04004495 wait_event(caching_ctl->wait, block_group_cache_done(cache) ||
Josef Bacik817d52f2009-07-13 21:29:25 -04004496 (cache->free_space >= num_bytes));
Yan Zheng11833d62009-09-11 16:11:19 -04004497
4498 put_caching_control(caching_ctl);
4499 return 0;
4500}
4501
4502static noinline int
4503wait_block_group_cache_done(struct btrfs_block_group_cache *cache)
4504{
4505 struct btrfs_caching_control *caching_ctl;
4506 DEFINE_WAIT(wait);
4507
4508 caching_ctl = get_caching_control(cache);
4509 if (!caching_ctl)
4510 return 0;
4511
4512 wait_event(caching_ctl->wait, block_group_cache_done(cache));
4513
4514 put_caching_control(caching_ctl);
Josef Bacik817d52f2009-07-13 21:29:25 -04004515 return 0;
4516}
4517
Yan, Zhengb742bb82010-05-16 10:46:24 -04004518static int get_block_group_index(struct btrfs_block_group_cache *cache)
4519{
4520 int index;
4521 if (cache->flags & BTRFS_BLOCK_GROUP_RAID10)
4522 index = 0;
4523 else if (cache->flags & BTRFS_BLOCK_GROUP_RAID1)
4524 index = 1;
4525 else if (cache->flags & BTRFS_BLOCK_GROUP_DUP)
4526 index = 2;
4527 else if (cache->flags & BTRFS_BLOCK_GROUP_RAID0)
4528 index = 3;
4529 else
4530 index = 4;
4531 return index;
4532}
4533
Josef Bacik817d52f2009-07-13 21:29:25 -04004534enum btrfs_loop_type {
Josef Bacikccf0e722009-11-10 21:23:48 -05004535 LOOP_FIND_IDEAL = 0,
Josef Bacik817d52f2009-07-13 21:29:25 -04004536 LOOP_CACHING_NOWAIT = 1,
4537 LOOP_CACHING_WAIT = 2,
4538 LOOP_ALLOC_CHUNK = 3,
4539 LOOP_NO_EMPTY_SIZE = 4,
4540};
4541
4542/*
Chris Masonfec577f2007-02-26 10:40:21 -05004543 * walks the btree of allocated extents and find a hole of a given size.
4544 * The key ins is changed to record the hole:
4545 * ins->objectid == block start
Chris Mason62e27492007-03-15 12:56:47 -04004546 * ins->flags = BTRFS_EXTENT_ITEM_KEY
Chris Masonfec577f2007-02-26 10:40:21 -05004547 * ins->offset == number of blocks
4548 * Any available blocks before search_start are skipped.
4549 */
Chris Masond3977122009-01-05 21:25:51 -05004550static noinline int find_free_extent(struct btrfs_trans_handle *trans,
Chris Mason98ed5172008-01-03 10:01:48 -05004551 struct btrfs_root *orig_root,
4552 u64 num_bytes, u64 empty_size,
4553 u64 search_start, u64 search_end,
4554 u64 hint_byte, struct btrfs_key *ins,
Chris Mason98ed5172008-01-03 10:01:48 -05004555 int data)
Chris Masonfec577f2007-02-26 10:40:21 -05004556{
Josef Bacik80eb2342008-10-29 14:49:05 -04004557 int ret = 0;
Chris Masond3977122009-01-05 21:25:51 -05004558 struct btrfs_root *root = orig_root->fs_info->extent_root;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004559 struct btrfs_free_cluster *last_ptr = NULL;
Josef Bacik80eb2342008-10-29 14:49:05 -04004560 struct btrfs_block_group_cache *block_group = NULL;
Chris Mason239b14b2008-03-24 15:02:07 -04004561 int empty_cluster = 2 * 1024 * 1024;
Chris Mason0ef3e662008-05-24 14:04:53 -04004562 int allowed_chunk_alloc = 0;
Josef Bacikccf0e722009-11-10 21:23:48 -05004563 int done_chunk_alloc = 0;
Josef Bacik80eb2342008-10-29 14:49:05 -04004564 struct btrfs_space_info *space_info;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004565 int last_ptr_loop = 0;
4566 int loop = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -04004567 int index = 0;
Josef Bacik817d52f2009-07-13 21:29:25 -04004568 bool found_uncached_bg = false;
Josef Bacik0a243252009-09-11 16:11:20 -04004569 bool failed_cluster_refill = false;
Josef Bacik1cdda9b2009-10-06 10:04:28 -04004570 bool failed_alloc = false;
Josef Bacikccf0e722009-11-10 21:23:48 -05004571 u64 ideal_cache_percent = 0;
4572 u64 ideal_cache_offset = 0;
Chris Masonfec577f2007-02-26 10:40:21 -05004573
Chris Masondb945352007-10-15 16:15:53 -04004574 WARN_ON(num_bytes < root->sectorsize);
Chris Masonb1a4d962007-04-04 15:27:52 -04004575 btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY);
Josef Bacik80eb2342008-10-29 14:49:05 -04004576 ins->objectid = 0;
4577 ins->offset = 0;
Chris Masonb1a4d962007-04-04 15:27:52 -04004578
Josef Bacik2552d172009-04-03 10:14:19 -04004579 space_info = __find_space_info(root->fs_info, data);
Josef Bacik1b1d1f62010-03-19 20:49:55 +00004580 if (!space_info) {
4581 printk(KERN_ERR "No space info for %d\n", data);
4582 return -ENOSPC;
4583 }
Josef Bacik2552d172009-04-03 10:14:19 -04004584
Chris Mason0ef3e662008-05-24 14:04:53 -04004585 if (orig_root->ref_cows || empty_size)
4586 allowed_chunk_alloc = 1;
4587
Chris Mason239b14b2008-03-24 15:02:07 -04004588 if (data & BTRFS_BLOCK_GROUP_METADATA) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004589 last_ptr = &root->fs_info->meta_alloc_cluster;
Chris Mason536ac8a2009-02-12 09:41:38 -05004590 if (!btrfs_test_opt(root, SSD))
4591 empty_cluster = 64 * 1024;
Chris Mason239b14b2008-03-24 15:02:07 -04004592 }
4593
Chris Masonfa9c0d72009-04-03 09:47:43 -04004594 if ((data & BTRFS_BLOCK_GROUP_DATA) && btrfs_test_opt(root, SSD)) {
4595 last_ptr = &root->fs_info->data_alloc_cluster;
4596 }
Josef Bacik0f9dd462008-09-23 13:14:11 -04004597
Chris Mason239b14b2008-03-24 15:02:07 -04004598 if (last_ptr) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004599 spin_lock(&last_ptr->lock);
4600 if (last_ptr->block_group)
4601 hint_byte = last_ptr->window_start;
4602 spin_unlock(&last_ptr->lock);
Chris Mason239b14b2008-03-24 15:02:07 -04004603 }
Chris Masonfa9c0d72009-04-03 09:47:43 -04004604
Chris Masona061fc82008-05-07 11:43:44 -04004605 search_start = max(search_start, first_logical_byte(root, 0));
Chris Mason239b14b2008-03-24 15:02:07 -04004606 search_start = max(search_start, hint_byte);
Chris Mason0b86a832008-03-24 15:01:56 -04004607
Josef Bacik817d52f2009-07-13 21:29:25 -04004608 if (!last_ptr)
Chris Masonfa9c0d72009-04-03 09:47:43 -04004609 empty_cluster = 0;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004610
Josef Bacik2552d172009-04-03 10:14:19 -04004611 if (search_start == hint_byte) {
Josef Bacikccf0e722009-11-10 21:23:48 -05004612ideal_cache:
Josef Bacik2552d172009-04-03 10:14:19 -04004613 block_group = btrfs_lookup_block_group(root->fs_info,
4614 search_start);
Josef Bacik817d52f2009-07-13 21:29:25 -04004615 /*
4616 * we don't want to use the block group if it doesn't match our
4617 * allocation bits, or if its not cached.
Josef Bacikccf0e722009-11-10 21:23:48 -05004618 *
4619 * However if we are re-searching with an ideal block group
4620 * picked out then we don't care that the block group is cached.
Josef Bacik817d52f2009-07-13 21:29:25 -04004621 */
4622 if (block_group && block_group_bits(block_group, data) &&
Josef Bacikccf0e722009-11-10 21:23:48 -05004623 (block_group->cached != BTRFS_CACHE_NO ||
4624 search_start == ideal_cache_offset)) {
Josef Bacik2552d172009-04-03 10:14:19 -04004625 down_read(&space_info->groups_sem);
Chris Mason44fb5512009-06-04 15:34:51 -04004626 if (list_empty(&block_group->list) ||
4627 block_group->ro) {
4628 /*
4629 * someone is removing this block group,
4630 * we can't jump into the have_block_group
4631 * target because our list pointers are not
4632 * valid
4633 */
4634 btrfs_put_block_group(block_group);
4635 up_read(&space_info->groups_sem);
Josef Bacikccf0e722009-11-10 21:23:48 -05004636 } else {
Yan, Zhengb742bb82010-05-16 10:46:24 -04004637 index = get_block_group_index(block_group);
Chris Mason44fb5512009-06-04 15:34:51 -04004638 goto have_block_group;
Josef Bacikccf0e722009-11-10 21:23:48 -05004639 }
Josef Bacik2552d172009-04-03 10:14:19 -04004640 } else if (block_group) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004641 btrfs_put_block_group(block_group);
Josef Bacik2552d172009-04-03 10:14:19 -04004642 }
Chris Mason42e70e72008-11-07 18:17:11 -05004643 }
Josef Bacik2552d172009-04-03 10:14:19 -04004644search:
Josef Bacik80eb2342008-10-29 14:49:05 -04004645 down_read(&space_info->groups_sem);
Yan, Zhengb742bb82010-05-16 10:46:24 -04004646 list_for_each_entry(block_group, &space_info->block_groups[index],
4647 list) {
Josef Bacik6226cb02009-04-03 10:14:18 -04004648 u64 offset;
Josef Bacik817d52f2009-07-13 21:29:25 -04004649 int cached;
Chris Mason8a1413a2008-11-10 16:13:54 -05004650
Josef Bacik11dfe352009-11-13 20:12:59 +00004651 btrfs_get_block_group(block_group);
Josef Bacik2552d172009-04-03 10:14:19 -04004652 search_start = block_group->key.objectid;
Chris Mason42e70e72008-11-07 18:17:11 -05004653
Josef Bacik2552d172009-04-03 10:14:19 -04004654have_block_group:
Josef Bacik817d52f2009-07-13 21:29:25 -04004655 if (unlikely(block_group->cached == BTRFS_CACHE_NO)) {
Josef Bacikccf0e722009-11-10 21:23:48 -05004656 u64 free_percent;
4657
4658 free_percent = btrfs_block_group_used(&block_group->item);
4659 free_percent *= 100;
4660 free_percent = div64_u64(free_percent,
4661 block_group->key.offset);
4662 free_percent = 100 - free_percent;
4663 if (free_percent > ideal_cache_percent &&
4664 likely(!block_group->ro)) {
4665 ideal_cache_offset = block_group->key.objectid;
4666 ideal_cache_percent = free_percent;
4667 }
4668
Josef Bacik817d52f2009-07-13 21:29:25 -04004669 /*
Josef Bacikccf0e722009-11-10 21:23:48 -05004670 * We only want to start kthread caching if we are at
4671 * the point where we will wait for caching to make
4672 * progress, or if our ideal search is over and we've
4673 * found somebody to start caching.
Josef Bacik817d52f2009-07-13 21:29:25 -04004674 */
4675 if (loop > LOOP_CACHING_NOWAIT ||
Josef Bacikccf0e722009-11-10 21:23:48 -05004676 (loop > LOOP_FIND_IDEAL &&
4677 atomic_read(&space_info->caching_threads) < 2)) {
Josef Bacik817d52f2009-07-13 21:29:25 -04004678 ret = cache_block_group(block_group);
4679 BUG_ON(ret);
Josef Bacik2552d172009-04-03 10:14:19 -04004680 }
Josef Bacikccf0e722009-11-10 21:23:48 -05004681 found_uncached_bg = true;
4682
4683 /*
4684 * If loop is set for cached only, try the next block
4685 * group.
4686 */
4687 if (loop == LOOP_FIND_IDEAL)
4688 goto loop;
Josef Bacikea6a4782008-11-20 12:16:16 -05004689 }
4690
Josef Bacik817d52f2009-07-13 21:29:25 -04004691 cached = block_group_cache_done(block_group);
Josef Bacikccf0e722009-11-10 21:23:48 -05004692 if (unlikely(!cached))
Josef Bacik817d52f2009-07-13 21:29:25 -04004693 found_uncached_bg = true;
4694
Josef Bacikea6a4782008-11-20 12:16:16 -05004695 if (unlikely(block_group->ro))
Josef Bacik2552d172009-04-03 10:14:19 -04004696 goto loop;
Josef Bacik0f9dd462008-09-23 13:14:11 -04004697
Josef Bacik0a243252009-09-11 16:11:20 -04004698 /*
4699 * Ok we want to try and use the cluster allocator, so lets look
4700 * there, unless we are on LOOP_NO_EMPTY_SIZE, since we will
4701 * have tried the cluster allocator plenty of times at this
4702 * point and not have found anything, so we are likely way too
4703 * fragmented for the clustering stuff to find anything, so lets
4704 * just skip it and let the allocator find whatever block it can
4705 * find
4706 */
4707 if (last_ptr && loop < LOOP_NO_EMPTY_SIZE) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004708 /*
4709 * the refill lock keeps out other
4710 * people trying to start a new cluster
4711 */
4712 spin_lock(&last_ptr->refill_lock);
Chris Mason44fb5512009-06-04 15:34:51 -04004713 if (last_ptr->block_group &&
4714 (last_ptr->block_group->ro ||
4715 !block_group_bits(last_ptr->block_group, data))) {
4716 offset = 0;
4717 goto refill_cluster;
4718 }
4719
Chris Masonfa9c0d72009-04-03 09:47:43 -04004720 offset = btrfs_alloc_from_cluster(block_group, last_ptr,
4721 num_bytes, search_start);
4722 if (offset) {
4723 /* we have a block, we're done */
4724 spin_unlock(&last_ptr->refill_lock);
4725 goto checks;
4726 }
4727
4728 spin_lock(&last_ptr->lock);
4729 /*
4730 * whoops, this cluster doesn't actually point to
4731 * this block group. Get a ref on the block
4732 * group is does point to and try again
4733 */
4734 if (!last_ptr_loop && last_ptr->block_group &&
4735 last_ptr->block_group != block_group) {
4736
4737 btrfs_put_block_group(block_group);
4738 block_group = last_ptr->block_group;
Josef Bacik11dfe352009-11-13 20:12:59 +00004739 btrfs_get_block_group(block_group);
Chris Masonfa9c0d72009-04-03 09:47:43 -04004740 spin_unlock(&last_ptr->lock);
4741 spin_unlock(&last_ptr->refill_lock);
4742
4743 last_ptr_loop = 1;
4744 search_start = block_group->key.objectid;
Chris Mason44fb5512009-06-04 15:34:51 -04004745 /*
4746 * we know this block group is properly
4747 * in the list because
4748 * btrfs_remove_block_group, drops the
4749 * cluster before it removes the block
4750 * group from the list
4751 */
Chris Masonfa9c0d72009-04-03 09:47:43 -04004752 goto have_block_group;
4753 }
4754 spin_unlock(&last_ptr->lock);
Chris Mason44fb5512009-06-04 15:34:51 -04004755refill_cluster:
Chris Masonfa9c0d72009-04-03 09:47:43 -04004756 /*
4757 * this cluster didn't work out, free it and
4758 * start over
4759 */
4760 btrfs_return_cluster_to_free_space(NULL, last_ptr);
4761
4762 last_ptr_loop = 0;
4763
4764 /* allocate a cluster in this block group */
Chris Mason451d7582009-06-09 20:28:34 -04004765 ret = btrfs_find_space_cluster(trans, root,
Chris Masonfa9c0d72009-04-03 09:47:43 -04004766 block_group, last_ptr,
4767 offset, num_bytes,
4768 empty_cluster + empty_size);
4769 if (ret == 0) {
4770 /*
4771 * now pull our allocation out of this
4772 * cluster
4773 */
4774 offset = btrfs_alloc_from_cluster(block_group,
4775 last_ptr, num_bytes,
4776 search_start);
4777 if (offset) {
4778 /* we found one, proceed */
4779 spin_unlock(&last_ptr->refill_lock);
4780 goto checks;
4781 }
Josef Bacik0a243252009-09-11 16:11:20 -04004782 } else if (!cached && loop > LOOP_CACHING_NOWAIT
4783 && !failed_cluster_refill) {
Josef Bacik817d52f2009-07-13 21:29:25 -04004784 spin_unlock(&last_ptr->refill_lock);
4785
Josef Bacik0a243252009-09-11 16:11:20 -04004786 failed_cluster_refill = true;
Josef Bacik817d52f2009-07-13 21:29:25 -04004787 wait_block_group_cache_progress(block_group,
4788 num_bytes + empty_cluster + empty_size);
4789 goto have_block_group;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004790 }
Josef Bacik817d52f2009-07-13 21:29:25 -04004791
Chris Masonfa9c0d72009-04-03 09:47:43 -04004792 /*
4793 * at this point we either didn't find a cluster
4794 * or we weren't able to allocate a block from our
4795 * cluster. Free the cluster we've been trying
4796 * to use, and go to the next block group
4797 */
Josef Bacik0a243252009-09-11 16:11:20 -04004798 btrfs_return_cluster_to_free_space(NULL, last_ptr);
Chris Masonfa9c0d72009-04-03 09:47:43 -04004799 spin_unlock(&last_ptr->refill_lock);
Josef Bacik0a243252009-09-11 16:11:20 -04004800 goto loop;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004801 }
4802
Josef Bacik6226cb02009-04-03 10:14:18 -04004803 offset = btrfs_find_space_for_alloc(block_group, search_start,
4804 num_bytes, empty_size);
Josef Bacik1cdda9b2009-10-06 10:04:28 -04004805 /*
4806 * If we didn't find a chunk, and we haven't failed on this
4807 * block group before, and this block group is in the middle of
4808 * caching and we are ok with waiting, then go ahead and wait
4809 * for progress to be made, and set failed_alloc to true.
4810 *
4811 * If failed_alloc is true then we've already waited on this
4812 * block group once and should move on to the next block group.
4813 */
4814 if (!offset && !failed_alloc && !cached &&
4815 loop > LOOP_CACHING_NOWAIT) {
Josef Bacik817d52f2009-07-13 21:29:25 -04004816 wait_block_group_cache_progress(block_group,
Josef Bacik1cdda9b2009-10-06 10:04:28 -04004817 num_bytes + empty_size);
4818 failed_alloc = true;
Josef Bacik817d52f2009-07-13 21:29:25 -04004819 goto have_block_group;
Josef Bacik1cdda9b2009-10-06 10:04:28 -04004820 } else if (!offset) {
4821 goto loop;
Josef Bacik817d52f2009-07-13 21:29:25 -04004822 }
Chris Masonfa9c0d72009-04-03 09:47:43 -04004823checks:
Josef Bacik6226cb02009-04-03 10:14:18 -04004824 search_start = stripe_align(root, offset);
Josef Bacik2552d172009-04-03 10:14:19 -04004825 /* move on to the next group */
Josef Bacik6226cb02009-04-03 10:14:18 -04004826 if (search_start + num_bytes >= search_end) {
4827 btrfs_add_free_space(block_group, offset, num_bytes);
Josef Bacik2552d172009-04-03 10:14:19 -04004828 goto loop;
Josef Bacik6226cb02009-04-03 10:14:18 -04004829 }
Chris Masone37c9e62007-05-09 20:13:14 -04004830
Josef Bacik2552d172009-04-03 10:14:19 -04004831 /* move on to the next group */
4832 if (search_start + num_bytes >
Josef Bacik6226cb02009-04-03 10:14:18 -04004833 block_group->key.objectid + block_group->key.offset) {
4834 btrfs_add_free_space(block_group, offset, num_bytes);
Josef Bacik2552d172009-04-03 10:14:19 -04004835 goto loop;
Josef Bacik6226cb02009-04-03 10:14:18 -04004836 }
Josef Bacik80eb2342008-10-29 14:49:05 -04004837
Josef Bacik2552d172009-04-03 10:14:19 -04004838 ins->objectid = search_start;
4839 ins->offset = num_bytes;
4840
Josef Bacik6226cb02009-04-03 10:14:18 -04004841 if (offset < search_start)
4842 btrfs_add_free_space(block_group, offset,
4843 search_start - offset);
4844 BUG_ON(offset > search_start);
4845
Yan, Zhengf0486c62010-05-16 10:46:25 -04004846 ret = update_reserved_bytes(block_group, num_bytes, 1,
4847 (data & BTRFS_BLOCK_GROUP_DATA));
4848 if (ret == -EAGAIN) {
4849 btrfs_add_free_space(block_group, offset, num_bytes);
4850 goto loop;
4851 }
Yan Zheng11833d62009-09-11 16:11:19 -04004852
Josef Bacik2552d172009-04-03 10:14:19 -04004853 /* we are all good, lets return */
Yan, Zhengf0486c62010-05-16 10:46:25 -04004854 ins->objectid = search_start;
4855 ins->offset = num_bytes;
4856
4857 if (offset < search_start)
4858 btrfs_add_free_space(block_group, offset,
4859 search_start - offset);
4860 BUG_ON(offset > search_start);
Josef Bacik2552d172009-04-03 10:14:19 -04004861 break;
4862loop:
Josef Bacik0a243252009-09-11 16:11:20 -04004863 failed_cluster_refill = false;
Josef Bacik1cdda9b2009-10-06 10:04:28 -04004864 failed_alloc = false;
Yan, Zhengb742bb82010-05-16 10:46:24 -04004865 BUG_ON(index != get_block_group_index(block_group));
Chris Masonfa9c0d72009-04-03 09:47:43 -04004866 btrfs_put_block_group(block_group);
Josef Bacik2552d172009-04-03 10:14:19 -04004867 }
4868 up_read(&space_info->groups_sem);
Chris Masonf5a31e12008-11-10 11:47:09 -05004869
Yan, Zhengb742bb82010-05-16 10:46:24 -04004870 if (!ins->objectid && ++index < BTRFS_NR_RAID_TYPES)
4871 goto search;
4872
Josef Bacikccf0e722009-11-10 21:23:48 -05004873 /* LOOP_FIND_IDEAL, only search caching/cached bg's, and don't wait for
4874 * for them to make caching progress. Also
4875 * determine the best possible bg to cache
4876 * LOOP_CACHING_NOWAIT, search partially cached block groups, kicking
4877 * caching kthreads as we move along
Josef Bacik817d52f2009-07-13 21:29:25 -04004878 * LOOP_CACHING_WAIT, search everything, and wait if our bg is caching
4879 * LOOP_ALLOC_CHUNK, force a chunk allocation and try again
4880 * LOOP_NO_EMPTY_SIZE, set empty_size and empty_cluster to 0 and try
4881 * again
Chris Masonfa9c0d72009-04-03 09:47:43 -04004882 */
Josef Bacik817d52f2009-07-13 21:29:25 -04004883 if (!ins->objectid && loop < LOOP_NO_EMPTY_SIZE &&
4884 (found_uncached_bg || empty_size || empty_cluster ||
4885 allowed_chunk_alloc)) {
Yan, Zhengb742bb82010-05-16 10:46:24 -04004886 index = 0;
Josef Bacikccf0e722009-11-10 21:23:48 -05004887 if (loop == LOOP_FIND_IDEAL && found_uncached_bg) {
Josef Bacik817d52f2009-07-13 21:29:25 -04004888 found_uncached_bg = false;
Josef Bacikccf0e722009-11-10 21:23:48 -05004889 loop++;
4890 if (!ideal_cache_percent &&
4891 atomic_read(&space_info->caching_threads))
Josef Bacik817d52f2009-07-13 21:29:25 -04004892 goto search;
Josef Bacikccf0e722009-11-10 21:23:48 -05004893
4894 /*
4895 * 1 of the following 2 things have happened so far
4896 *
4897 * 1) We found an ideal block group for caching that
4898 * is mostly full and will cache quickly, so we might
4899 * as well wait for it.
4900 *
4901 * 2) We searched for cached only and we didn't find
4902 * anything, and we didn't start any caching kthreads
4903 * either, so chances are we will loop through and
4904 * start a couple caching kthreads, and then come back
4905 * around and just wait for them. This will be slower
4906 * because we will have 2 caching kthreads reading at
4907 * the same time when we could have just started one
4908 * and waited for it to get far enough to give us an
4909 * allocation, so go ahead and go to the wait caching
4910 * loop.
4911 */
4912 loop = LOOP_CACHING_WAIT;
4913 search_start = ideal_cache_offset;
4914 ideal_cache_percent = 0;
4915 goto ideal_cache;
4916 } else if (loop == LOOP_FIND_IDEAL) {
4917 /*
4918 * Didn't find a uncached bg, wait on anything we find
4919 * next.
4920 */
4921 loop = LOOP_CACHING_WAIT;
4922 goto search;
4923 }
4924
4925 if (loop < LOOP_CACHING_WAIT) {
4926 loop++;
4927 goto search;
Josef Bacik817d52f2009-07-13 21:29:25 -04004928 }
4929
4930 if (loop == LOOP_ALLOC_CHUNK) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004931 empty_size = 0;
4932 empty_cluster = 0;
4933 }
Chris Mason42e70e72008-11-07 18:17:11 -05004934
Josef Bacik2552d172009-04-03 10:14:19 -04004935 if (allowed_chunk_alloc) {
4936 ret = do_chunk_alloc(trans, root, num_bytes +
4937 2 * 1024 * 1024, data, 1);
Josef Bacik2552d172009-04-03 10:14:19 -04004938 allowed_chunk_alloc = 0;
Josef Bacikccf0e722009-11-10 21:23:48 -05004939 done_chunk_alloc = 1;
4940 } else if (!done_chunk_alloc) {
Josef Bacik2552d172009-04-03 10:14:19 -04004941 space_info->force_alloc = 1;
Josef Bacik0f9dd462008-09-23 13:14:11 -04004942 }
Josef Bacik80eb2342008-10-29 14:49:05 -04004943
Josef Bacik817d52f2009-07-13 21:29:25 -04004944 if (loop < LOOP_NO_EMPTY_SIZE) {
Chris Masonfa9c0d72009-04-03 09:47:43 -04004945 loop++;
Josef Bacik2552d172009-04-03 10:14:19 -04004946 goto search;
Chris Masonfa9c0d72009-04-03 09:47:43 -04004947 }
Josef Bacik2552d172009-04-03 10:14:19 -04004948 ret = -ENOSPC;
4949 } else if (!ins->objectid) {
4950 ret = -ENOSPC;
Chris Masone19caa52007-10-15 16:17:44 -04004951 }
Chris Mason0b86a832008-03-24 15:01:56 -04004952
Josef Bacik80eb2342008-10-29 14:49:05 -04004953 /* we found what we needed */
4954 if (ins->objectid) {
4955 if (!(data & BTRFS_BLOCK_GROUP_DATA))
Yan Zhengd2fb3432008-12-11 16:30:39 -05004956 trans->block_group = block_group->key.objectid;
Josef Bacik80eb2342008-10-29 14:49:05 -04004957
Chris Masonfa9c0d72009-04-03 09:47:43 -04004958 btrfs_put_block_group(block_group);
Josef Bacik2552d172009-04-03 10:14:19 -04004959 ret = 0;
4960 }
Chris Mason0b86a832008-03-24 15:01:56 -04004961
Chris Mason0f70abe2007-02-28 16:46:22 -05004962 return ret;
Chris Masonfec577f2007-02-26 10:40:21 -05004963}
Chris Masonec44a352008-04-28 15:29:52 -04004964
Josef Bacik9ed74f22009-09-11 16:12:44 -04004965static void dump_space_info(struct btrfs_space_info *info, u64 bytes,
4966 int dump_block_groups)
Josef Bacik0f9dd462008-09-23 13:14:11 -04004967{
4968 struct btrfs_block_group_cache *cache;
Yan, Zhengb742bb82010-05-16 10:46:24 -04004969 int index = 0;
Josef Bacik0f9dd462008-09-23 13:14:11 -04004970
Josef Bacik9ed74f22009-09-11 16:12:44 -04004971 spin_lock(&info->lock);
Chris Masond3977122009-01-05 21:25:51 -05004972 printk(KERN_INFO "space_info has %llu free, is %sfull\n",
4973 (unsigned long long)(info->total_bytes - info->bytes_used -
Josef Bacik9ed74f22009-09-11 16:12:44 -04004974 info->bytes_pinned - info->bytes_reserved -
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04004975 info->bytes_readonly),
Chris Masond3977122009-01-05 21:25:51 -05004976 (info->full) ? "" : "not ");
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04004977 printk(KERN_INFO "space_info total=%llu, used=%llu, pinned=%llu, "
4978 "reserved=%llu, may_use=%llu, readonly=%llu\n",
Joel Becker21380932009-04-21 12:38:29 -07004979 (unsigned long long)info->total_bytes,
Josef Bacik9ed74f22009-09-11 16:12:44 -04004980 (unsigned long long)info->bytes_used,
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04004981 (unsigned long long)info->bytes_pinned,
4982 (unsigned long long)info->bytes_reserved,
4983 (unsigned long long)info->bytes_may_use,
4984 (unsigned long long)info->bytes_readonly);
Josef Bacik9ed74f22009-09-11 16:12:44 -04004985 spin_unlock(&info->lock);
4986
4987 if (!dump_block_groups)
4988 return;
Josef Bacik0f9dd462008-09-23 13:14:11 -04004989
Josef Bacik80eb2342008-10-29 14:49:05 -04004990 down_read(&info->groups_sem);
Yan, Zhengb742bb82010-05-16 10:46:24 -04004991again:
4992 list_for_each_entry(cache, &info->block_groups[index], list) {
Josef Bacik0f9dd462008-09-23 13:14:11 -04004993 spin_lock(&cache->lock);
Chris Masond3977122009-01-05 21:25:51 -05004994 printk(KERN_INFO "block group %llu has %llu bytes, %llu used "
4995 "%llu pinned %llu reserved\n",
4996 (unsigned long long)cache->key.objectid,
4997 (unsigned long long)cache->key.offset,
4998 (unsigned long long)btrfs_block_group_used(&cache->item),
4999 (unsigned long long)cache->pinned,
5000 (unsigned long long)cache->reserved);
Josef Bacik0f9dd462008-09-23 13:14:11 -04005001 btrfs_dump_free_space(cache, bytes);
5002 spin_unlock(&cache->lock);
5003 }
Yan, Zhengb742bb82010-05-16 10:46:24 -04005004 if (++index < BTRFS_NR_RAID_TYPES)
5005 goto again;
Josef Bacik80eb2342008-10-29 14:49:05 -04005006 up_read(&info->groups_sem);
Josef Bacik0f9dd462008-09-23 13:14:11 -04005007}
Zheng Yane8569812008-09-26 10:05:48 -04005008
Yan Zheng11833d62009-09-11 16:11:19 -04005009int btrfs_reserve_extent(struct btrfs_trans_handle *trans,
5010 struct btrfs_root *root,
5011 u64 num_bytes, u64 min_alloc_size,
5012 u64 empty_size, u64 hint_byte,
5013 u64 search_end, struct btrfs_key *ins,
5014 u64 data)
Chris Masonfec577f2007-02-26 10:40:21 -05005015{
5016 int ret;
Chris Masonfbdc7622007-05-30 10:22:12 -04005017 u64 search_start = 0;
Chris Mason925baed2008-06-25 16:01:30 -04005018
Josef Bacik6a632092009-02-20 11:00:09 -05005019 data = btrfs_get_alloc_profile(root, data);
Chris Mason98d20f62008-04-14 09:46:10 -04005020again:
Chris Mason0ef3e662008-05-24 14:04:53 -04005021 /*
5022 * the only place that sets empty_size is btrfs_realloc_node, which
5023 * is not called recursively on allocations
5024 */
Josef Bacik83d3c962009-12-07 21:45:59 +00005025 if (empty_size || root->ref_cows)
Chris Mason6324fbf2008-03-24 15:01:59 -04005026 ret = do_chunk_alloc(trans, root->fs_info->extent_root,
Chris Mason0ef3e662008-05-24 14:04:53 -04005027 num_bytes + 2 * 1024 * 1024, data, 0);
Chris Mason0b86a832008-03-24 15:01:56 -04005028
Chris Masondb945352007-10-15 16:15:53 -04005029 WARN_ON(num_bytes < root->sectorsize);
5030 ret = find_free_extent(trans, root, num_bytes, empty_size,
Yan, Zhengf0486c62010-05-16 10:46:25 -04005031 search_start, search_end, hint_byte,
5032 ins, data);
Chris Mason3b951512008-04-17 11:29:12 -04005033
Chris Mason98d20f62008-04-14 09:46:10 -04005034 if (ret == -ENOSPC && num_bytes > min_alloc_size) {
5035 num_bytes = num_bytes >> 1;
Josef Bacik0f9dd462008-09-23 13:14:11 -04005036 num_bytes = num_bytes & ~(root->sectorsize - 1);
Chris Mason98d20f62008-04-14 09:46:10 -04005037 num_bytes = max(num_bytes, min_alloc_size);
Chris Mason0ef3e662008-05-24 14:04:53 -04005038 do_chunk_alloc(trans, root->fs_info->extent_root,
5039 num_bytes, data, 1);
Chris Mason98d20f62008-04-14 09:46:10 -04005040 goto again;
5041 }
Josef Bacik817d52f2009-07-13 21:29:25 -04005042 if (ret == -ENOSPC) {
Josef Bacik0f9dd462008-09-23 13:14:11 -04005043 struct btrfs_space_info *sinfo;
5044
5045 sinfo = __find_space_info(root->fs_info, data);
Chris Masond3977122009-01-05 21:25:51 -05005046 printk(KERN_ERR "btrfs allocation failed flags %llu, "
5047 "wanted %llu\n", (unsigned long long)data,
5048 (unsigned long long)num_bytes);
Josef Bacik9ed74f22009-09-11 16:12:44 -04005049 dump_space_info(sinfo, num_bytes, 1);
Chris Mason925baed2008-06-25 16:01:30 -04005050 }
Josef Bacik0f9dd462008-09-23 13:14:11 -04005051
5052 return ret;
Chris Masone6dcd2d2008-07-17 12:53:50 -04005053}
5054
Chris Mason65b51a02008-08-01 15:11:20 -04005055int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len)
5056{
Josef Bacik0f9dd462008-09-23 13:14:11 -04005057 struct btrfs_block_group_cache *cache;
Liu Hui1f3c79a2009-01-05 15:57:51 -05005058 int ret = 0;
Josef Bacik0f9dd462008-09-23 13:14:11 -04005059
Josef Bacik0f9dd462008-09-23 13:14:11 -04005060 cache = btrfs_lookup_block_group(root->fs_info, start);
5061 if (!cache) {
Chris Masond3977122009-01-05 21:25:51 -05005062 printk(KERN_ERR "Unable to find block group for %llu\n",
5063 (unsigned long long)start);
Josef Bacik0f9dd462008-09-23 13:14:11 -04005064 return -ENOSPC;
5065 }
Liu Hui1f3c79a2009-01-05 15:57:51 -05005066
5067 ret = btrfs_discard_extent(root, start, len);
5068
Josef Bacik0f9dd462008-09-23 13:14:11 -04005069 btrfs_add_free_space(cache, start, len);
Yan, Zhengf0486c62010-05-16 10:46:25 -04005070 update_reserved_bytes(cache, len, 0, 1);
Chris Masonfa9c0d72009-04-03 09:47:43 -04005071 btrfs_put_block_group(cache);
Josef Bacik817d52f2009-07-13 21:29:25 -04005072
Chris Masone6dcd2d2008-07-17 12:53:50 -04005073 return ret;
5074}
5075
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005076static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
5077 struct btrfs_root *root,
5078 u64 parent, u64 root_objectid,
5079 u64 flags, u64 owner, u64 offset,
5080 struct btrfs_key *ins, int ref_mod)
Chris Masone6dcd2d2008-07-17 12:53:50 -04005081{
5082 int ret;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005083 struct btrfs_fs_info *fs_info = root->fs_info;
Chris Masone6dcd2d2008-07-17 12:53:50 -04005084 struct btrfs_extent_item *extent_item;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005085 struct btrfs_extent_inline_ref *iref;
Chris Masone6dcd2d2008-07-17 12:53:50 -04005086 struct btrfs_path *path;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005087 struct extent_buffer *leaf;
5088 int type;
5089 u32 size;
Chris Masonf2654de2007-06-26 12:20:46 -04005090
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005091 if (parent > 0)
5092 type = BTRFS_SHARED_DATA_REF_KEY;
5093 else
5094 type = BTRFS_EXTENT_DATA_REF_KEY;
Zheng Yan31840ae2008-09-23 13:14:14 -04005095
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005096 size = sizeof(*extent_item) + btrfs_extent_inline_ref_size(type);
Chris Mason7bb86312007-12-11 09:25:06 -05005097
5098 path = btrfs_alloc_path();
5099 BUG_ON(!path);
Chris Mason47e4bb92008-02-01 14:51:59 -05005100
Chris Masonb9473432009-03-13 11:00:37 -04005101 path->leave_spinning = 1;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005102 ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
5103 ins, size);
Chris Masonccd467d2007-06-28 15:57:36 -04005104 BUG_ON(ret);
Josef Bacik0f9dd462008-09-23 13:14:11 -04005105
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005106 leaf = path->nodes[0];
5107 extent_item = btrfs_item_ptr(leaf, path->slots[0],
Chris Mason47e4bb92008-02-01 14:51:59 -05005108 struct btrfs_extent_item);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005109 btrfs_set_extent_refs(leaf, extent_item, ref_mod);
5110 btrfs_set_extent_generation(leaf, extent_item, trans->transid);
5111 btrfs_set_extent_flags(leaf, extent_item,
5112 flags | BTRFS_EXTENT_FLAG_DATA);
Chris Mason47e4bb92008-02-01 14:51:59 -05005113
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005114 iref = (struct btrfs_extent_inline_ref *)(extent_item + 1);
5115 btrfs_set_extent_inline_ref_type(leaf, iref, type);
5116 if (parent > 0) {
5117 struct btrfs_shared_data_ref *ref;
5118 ref = (struct btrfs_shared_data_ref *)(iref + 1);
5119 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
5120 btrfs_set_shared_data_ref_count(leaf, ref, ref_mod);
5121 } else {
5122 struct btrfs_extent_data_ref *ref;
5123 ref = (struct btrfs_extent_data_ref *)(&iref->offset);
5124 btrfs_set_extent_data_ref_root(leaf, ref, root_objectid);
5125 btrfs_set_extent_data_ref_objectid(leaf, ref, owner);
5126 btrfs_set_extent_data_ref_offset(leaf, ref, offset);
5127 btrfs_set_extent_data_ref_count(leaf, ref, ref_mod);
5128 }
Chris Mason47e4bb92008-02-01 14:51:59 -05005129
5130 btrfs_mark_buffer_dirty(path->nodes[0]);
Chris Mason7bb86312007-12-11 09:25:06 -05005131 btrfs_free_path(path);
Chris Masonf510cfe2007-10-15 16:14:48 -04005132
Yan, Zhengf0486c62010-05-16 10:46:25 -04005133 ret = update_block_group(trans, root, ins->objectid, ins->offset, 1);
Chris Masonf5947062008-02-04 10:10:13 -05005134 if (ret) {
Chris Masond3977122009-01-05 21:25:51 -05005135 printk(KERN_ERR "btrfs update block group failed for %llu "
5136 "%llu\n", (unsigned long long)ins->objectid,
5137 (unsigned long long)ins->offset);
Chris Masonf5947062008-02-04 10:10:13 -05005138 BUG();
5139 }
Chris Masone6dcd2d2008-07-17 12:53:50 -04005140 return ret;
5141}
5142
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005143static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans,
5144 struct btrfs_root *root,
5145 u64 parent, u64 root_objectid,
5146 u64 flags, struct btrfs_disk_key *key,
5147 int level, struct btrfs_key *ins)
5148{
5149 int ret;
5150 struct btrfs_fs_info *fs_info = root->fs_info;
5151 struct btrfs_extent_item *extent_item;
5152 struct btrfs_tree_block_info *block_info;
5153 struct btrfs_extent_inline_ref *iref;
5154 struct btrfs_path *path;
5155 struct extent_buffer *leaf;
5156 u32 size = sizeof(*extent_item) + sizeof(*block_info) + sizeof(*iref);
5157
5158 path = btrfs_alloc_path();
5159 BUG_ON(!path);
5160
5161 path->leave_spinning = 1;
5162 ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path,
5163 ins, size);
5164 BUG_ON(ret);
5165
5166 leaf = path->nodes[0];
5167 extent_item = btrfs_item_ptr(leaf, path->slots[0],
5168 struct btrfs_extent_item);
5169 btrfs_set_extent_refs(leaf, extent_item, 1);
5170 btrfs_set_extent_generation(leaf, extent_item, trans->transid);
5171 btrfs_set_extent_flags(leaf, extent_item,
5172 flags | BTRFS_EXTENT_FLAG_TREE_BLOCK);
5173 block_info = (struct btrfs_tree_block_info *)(extent_item + 1);
5174
5175 btrfs_set_tree_block_key(leaf, block_info, key);
5176 btrfs_set_tree_block_level(leaf, block_info, level);
5177
5178 iref = (struct btrfs_extent_inline_ref *)(block_info + 1);
5179 if (parent > 0) {
5180 BUG_ON(!(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF));
5181 btrfs_set_extent_inline_ref_type(leaf, iref,
5182 BTRFS_SHARED_BLOCK_REF_KEY);
5183 btrfs_set_extent_inline_ref_offset(leaf, iref, parent);
5184 } else {
5185 btrfs_set_extent_inline_ref_type(leaf, iref,
5186 BTRFS_TREE_BLOCK_REF_KEY);
5187 btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid);
5188 }
5189
5190 btrfs_mark_buffer_dirty(leaf);
5191 btrfs_free_path(path);
5192
Yan, Zhengf0486c62010-05-16 10:46:25 -04005193 ret = update_block_group(trans, root, ins->objectid, ins->offset, 1);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005194 if (ret) {
5195 printk(KERN_ERR "btrfs update block group failed for %llu "
5196 "%llu\n", (unsigned long long)ins->objectid,
5197 (unsigned long long)ins->offset);
5198 BUG();
5199 }
5200 return ret;
5201}
5202
5203int btrfs_alloc_reserved_file_extent(struct btrfs_trans_handle *trans,
5204 struct btrfs_root *root,
5205 u64 root_objectid, u64 owner,
5206 u64 offset, struct btrfs_key *ins)
Chris Masone6dcd2d2008-07-17 12:53:50 -04005207{
5208 int ret;
Chris Mason1c2308f2008-09-23 13:14:13 -04005209
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005210 BUG_ON(root_objectid == BTRFS_TREE_LOG_OBJECTID);
Chris Mason56bec292009-03-13 10:10:06 -04005211
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005212 ret = btrfs_add_delayed_data_ref(trans, ins->objectid, ins->offset,
5213 0, root_objectid, owner, offset,
5214 BTRFS_ADD_DELAYED_EXTENT, NULL);
Chris Masone6dcd2d2008-07-17 12:53:50 -04005215 return ret;
5216}
Chris Masone02119d2008-09-05 16:13:11 -04005217
5218/*
5219 * this is used by the tree logging recovery code. It records that
5220 * an extent has been allocated and makes sure to clear the free
5221 * space cache bits as well
5222 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005223int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans,
5224 struct btrfs_root *root,
5225 u64 root_objectid, u64 owner, u64 offset,
5226 struct btrfs_key *ins)
Chris Masone02119d2008-09-05 16:13:11 -04005227{
5228 int ret;
5229 struct btrfs_block_group_cache *block_group;
Yan Zheng11833d62009-09-11 16:11:19 -04005230 struct btrfs_caching_control *caching_ctl;
5231 u64 start = ins->objectid;
5232 u64 num_bytes = ins->offset;
Chris Masone02119d2008-09-05 16:13:11 -04005233
Chris Masone02119d2008-09-05 16:13:11 -04005234 block_group = btrfs_lookup_block_group(root->fs_info, ins->objectid);
Josef Bacik817d52f2009-07-13 21:29:25 -04005235 cache_block_group(block_group);
Yan Zheng11833d62009-09-11 16:11:19 -04005236 caching_ctl = get_caching_control(block_group);
Chris Masone02119d2008-09-05 16:13:11 -04005237
Yan Zheng11833d62009-09-11 16:11:19 -04005238 if (!caching_ctl) {
5239 BUG_ON(!block_group_cache_done(block_group));
5240 ret = btrfs_remove_free_space(block_group, start, num_bytes);
5241 BUG_ON(ret);
5242 } else {
5243 mutex_lock(&caching_ctl->mutex);
5244
5245 if (start >= caching_ctl->progress) {
5246 ret = add_excluded_extent(root, start, num_bytes);
5247 BUG_ON(ret);
5248 } else if (start + num_bytes <= caching_ctl->progress) {
5249 ret = btrfs_remove_free_space(block_group,
5250 start, num_bytes);
5251 BUG_ON(ret);
5252 } else {
5253 num_bytes = caching_ctl->progress - start;
5254 ret = btrfs_remove_free_space(block_group,
5255 start, num_bytes);
5256 BUG_ON(ret);
5257
5258 start = caching_ctl->progress;
5259 num_bytes = ins->objectid + ins->offset -
5260 caching_ctl->progress;
5261 ret = add_excluded_extent(root, start, num_bytes);
5262 BUG_ON(ret);
5263 }
5264
5265 mutex_unlock(&caching_ctl->mutex);
5266 put_caching_control(caching_ctl);
5267 }
5268
Yan, Zhengf0486c62010-05-16 10:46:25 -04005269 ret = update_reserved_bytes(block_group, ins->offset, 1, 1);
5270 BUG_ON(ret);
Chris Masonfa9c0d72009-04-03 09:47:43 -04005271 btrfs_put_block_group(block_group);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005272 ret = alloc_reserved_file_extent(trans, root, 0, root_objectid,
5273 0, owner, offset, ins, 1);
Chris Masone02119d2008-09-05 16:13:11 -04005274 return ret;
5275}
5276
Chris Mason65b51a02008-08-01 15:11:20 -04005277struct extent_buffer *btrfs_init_new_buffer(struct btrfs_trans_handle *trans,
5278 struct btrfs_root *root,
Chris Mason4008c042009-02-12 14:09:45 -05005279 u64 bytenr, u32 blocksize,
5280 int level)
Chris Mason65b51a02008-08-01 15:11:20 -04005281{
5282 struct extent_buffer *buf;
5283
5284 buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
5285 if (!buf)
5286 return ERR_PTR(-ENOMEM);
5287 btrfs_set_header_generation(buf, trans->transid);
Chris Mason4008c042009-02-12 14:09:45 -05005288 btrfs_set_buffer_lockdep_class(buf, level);
Chris Mason65b51a02008-08-01 15:11:20 -04005289 btrfs_tree_lock(buf);
5290 clean_tree_block(trans, root, buf);
Chris Masonb4ce94d2009-02-04 09:25:08 -05005291
5292 btrfs_set_lock_blocking(buf);
Chris Mason65b51a02008-08-01 15:11:20 -04005293 btrfs_set_buffer_uptodate(buf);
Chris Masonb4ce94d2009-02-04 09:25:08 -05005294
Chris Masond0c803c2008-09-11 16:17:57 -04005295 if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
Yan, Zheng8cef4e12009-11-12 09:33:26 +00005296 /*
5297 * we allow two log transactions at a time, use different
5298 * EXENT bit to differentiate dirty pages.
5299 */
5300 if (root->log_transid % 2 == 0)
5301 set_extent_dirty(&root->dirty_log_pages, buf->start,
5302 buf->start + buf->len - 1, GFP_NOFS);
5303 else
5304 set_extent_new(&root->dirty_log_pages, buf->start,
5305 buf->start + buf->len - 1, GFP_NOFS);
Chris Masond0c803c2008-09-11 16:17:57 -04005306 } else {
5307 set_extent_dirty(&trans->transaction->dirty_pages, buf->start,
5308 buf->start + buf->len - 1, GFP_NOFS);
5309 }
Chris Mason65b51a02008-08-01 15:11:20 -04005310 trans->blocks_used++;
Chris Masonb4ce94d2009-02-04 09:25:08 -05005311 /* this returns a buffer locked for blocking */
Chris Mason65b51a02008-08-01 15:11:20 -04005312 return buf;
5313}
5314
Yan, Zhengf0486c62010-05-16 10:46:25 -04005315static struct btrfs_block_rsv *
5316use_block_rsv(struct btrfs_trans_handle *trans,
5317 struct btrfs_root *root, u32 blocksize)
5318{
5319 struct btrfs_block_rsv *block_rsv;
5320 int ret;
5321
5322 block_rsv = get_block_rsv(trans, root);
5323
5324 if (block_rsv->size == 0) {
5325 ret = reserve_metadata_bytes(block_rsv, blocksize);
5326 if (ret)
5327 return ERR_PTR(ret);
5328 return block_rsv;
5329 }
5330
5331 ret = block_rsv_use_bytes(block_rsv, blocksize);
5332 if (!ret)
5333 return block_rsv;
5334
5335 WARN_ON(1);
5336 printk(KERN_INFO"block_rsv size %llu reserved %llu freed %llu %llu\n",
5337 block_rsv->size, block_rsv->reserved,
5338 block_rsv->freed[0], block_rsv->freed[1]);
5339
5340 return ERR_PTR(-ENOSPC);
5341}
5342
5343static void unuse_block_rsv(struct btrfs_block_rsv *block_rsv, u32 blocksize)
5344{
5345 block_rsv_add_bytes(block_rsv, blocksize, 0);
5346 block_rsv_release_bytes(block_rsv, NULL, 0);
5347}
5348
Chris Masonfec577f2007-02-26 10:40:21 -05005349/*
Yan, Zhengf0486c62010-05-16 10:46:25 -04005350 * finds a free extent and does all the dirty work required for allocation
5351 * returns the key for the extent through ins, and a tree buffer for
5352 * the first block of the extent through buf.
5353 *
Chris Masonfec577f2007-02-26 10:40:21 -05005354 * returns the tree buffer or NULL.
5355 */
Chris Mason5f39d392007-10-15 16:14:19 -04005356struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans,
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005357 struct btrfs_root *root, u32 blocksize,
5358 u64 parent, u64 root_objectid,
5359 struct btrfs_disk_key *key, int level,
5360 u64 hint, u64 empty_size)
Chris Masonfec577f2007-02-26 10:40:21 -05005361{
Chris Masone2fa7222007-03-12 16:22:34 -04005362 struct btrfs_key ins;
Yan, Zhengf0486c62010-05-16 10:46:25 -04005363 struct btrfs_block_rsv *block_rsv;
Chris Mason5f39d392007-10-15 16:14:19 -04005364 struct extent_buffer *buf;
Yan, Zhengf0486c62010-05-16 10:46:25 -04005365 u64 flags = 0;
5366 int ret;
Chris Masonfec577f2007-02-26 10:40:21 -05005367
Yan, Zhengf0486c62010-05-16 10:46:25 -04005368
5369 block_rsv = use_block_rsv(trans, root, blocksize);
5370 if (IS_ERR(block_rsv))
5371 return ERR_CAST(block_rsv);
5372
5373 ret = btrfs_reserve_extent(trans, root, blocksize, blocksize,
5374 empty_size, hint, (u64)-1, &ins, 0);
Chris Masonfec577f2007-02-26 10:40:21 -05005375 if (ret) {
Yan, Zhengf0486c62010-05-16 10:46:25 -04005376 unuse_block_rsv(block_rsv, blocksize);
Chris Mason54aa1f42007-06-22 14:16:25 -04005377 return ERR_PTR(ret);
Chris Masonfec577f2007-02-26 10:40:21 -05005378 }
Chris Mason55c69072008-01-09 15:55:33 -05005379
Chris Mason4008c042009-02-12 14:09:45 -05005380 buf = btrfs_init_new_buffer(trans, root, ins.objectid,
5381 blocksize, level);
Yan, Zhengf0486c62010-05-16 10:46:25 -04005382 BUG_ON(IS_ERR(buf));
5383
5384 if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) {
5385 if (parent == 0)
5386 parent = ins.objectid;
5387 flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF;
5388 } else
5389 BUG_ON(parent > 0);
5390
5391 if (root_objectid != BTRFS_TREE_LOG_OBJECTID) {
5392 struct btrfs_delayed_extent_op *extent_op;
5393 extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS);
5394 BUG_ON(!extent_op);
5395 if (key)
5396 memcpy(&extent_op->key, key, sizeof(extent_op->key));
5397 else
5398 memset(&extent_op->key, 0, sizeof(extent_op->key));
5399 extent_op->flags_to_set = flags;
5400 extent_op->update_key = 1;
5401 extent_op->update_flags = 1;
5402 extent_op->is_data = 0;
5403
5404 ret = btrfs_add_delayed_tree_ref(trans, ins.objectid,
5405 ins.offset, parent, root_objectid,
5406 level, BTRFS_ADD_DELAYED_EXTENT,
5407 extent_op);
5408 BUG_ON(ret);
5409 }
Chris Masonfec577f2007-02-26 10:40:21 -05005410 return buf;
5411}
Chris Masona28ec192007-03-06 20:08:01 -05005412
Yan Zheng2c47e6052009-06-27 21:07:35 -04005413struct walk_control {
5414 u64 refs[BTRFS_MAX_LEVEL];
5415 u64 flags[BTRFS_MAX_LEVEL];
5416 struct btrfs_key update_progress;
5417 int stage;
5418 int level;
5419 int shared_level;
5420 int update_ref;
5421 int keep_locks;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005422 int reada_slot;
5423 int reada_count;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005424};
5425
5426#define DROP_REFERENCE 1
5427#define UPDATE_BACKREF 2
5428
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005429static noinline void reada_walk_down(struct btrfs_trans_handle *trans,
5430 struct btrfs_root *root,
5431 struct walk_control *wc,
5432 struct btrfs_path *path)
5433{
5434 u64 bytenr;
5435 u64 generation;
5436 u64 refs;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005437 u64 flags;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005438 u64 last = 0;
5439 u32 nritems;
5440 u32 blocksize;
5441 struct btrfs_key key;
5442 struct extent_buffer *eb;
5443 int ret;
5444 int slot;
5445 int nread = 0;
5446
5447 if (path->slots[wc->level] < wc->reada_slot) {
5448 wc->reada_count = wc->reada_count * 2 / 3;
5449 wc->reada_count = max(wc->reada_count, 2);
5450 } else {
5451 wc->reada_count = wc->reada_count * 3 / 2;
5452 wc->reada_count = min_t(int, wc->reada_count,
5453 BTRFS_NODEPTRS_PER_BLOCK(root));
5454 }
5455
5456 eb = path->nodes[wc->level];
5457 nritems = btrfs_header_nritems(eb);
5458 blocksize = btrfs_level_size(root, wc->level - 1);
5459
5460 for (slot = path->slots[wc->level]; slot < nritems; slot++) {
5461 if (nread >= wc->reada_count)
5462 break;
5463
5464 cond_resched();
5465 bytenr = btrfs_node_blockptr(eb, slot);
5466 generation = btrfs_node_ptr_generation(eb, slot);
5467
5468 if (slot == path->slots[wc->level])
5469 goto reada;
5470
5471 if (wc->stage == UPDATE_BACKREF &&
5472 generation <= root->root_key.offset)
5473 continue;
5474
Yan, Zheng94fcca92009-10-09 09:25:16 -04005475 /* We don't lock the tree block, it's OK to be racy here */
5476 ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
5477 &refs, &flags);
5478 BUG_ON(ret);
5479 BUG_ON(refs == 0);
5480
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005481 if (wc->stage == DROP_REFERENCE) {
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005482 if (refs == 1)
5483 goto reada;
5484
Yan, Zheng94fcca92009-10-09 09:25:16 -04005485 if (wc->level == 1 &&
5486 (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5487 continue;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005488 if (!wc->update_ref ||
5489 generation <= root->root_key.offset)
5490 continue;
5491 btrfs_node_key_to_cpu(eb, &key, slot);
5492 ret = btrfs_comp_cpu_keys(&key,
5493 &wc->update_progress);
5494 if (ret < 0)
5495 continue;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005496 } else {
5497 if (wc->level == 1 &&
5498 (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5499 continue;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005500 }
5501reada:
5502 ret = readahead_tree_block(root, bytenr, blocksize,
5503 generation);
5504 if (ret)
5505 break;
5506 last = bytenr + blocksize;
5507 nread++;
5508 }
5509 wc->reada_slot = slot;
5510}
5511
Chris Mason9aca1d52007-03-13 11:09:37 -04005512/*
Yan Zheng2c47e6052009-06-27 21:07:35 -04005513 * hepler to process tree block while walking down the tree.
5514 *
Yan Zheng2c47e6052009-06-27 21:07:35 -04005515 * when wc->stage == UPDATE_BACKREF, this function updates
5516 * back refs for pointers in the block.
5517 *
5518 * NOTE: return value 1 means we should stop walking down.
Yan Zhengf82d02d2008-10-29 14:49:05 -04005519 */
Yan Zheng2c47e6052009-06-27 21:07:35 -04005520static noinline int walk_down_proc(struct btrfs_trans_handle *trans,
5521 struct btrfs_root *root,
5522 struct btrfs_path *path,
Yan, Zheng94fcca92009-10-09 09:25:16 -04005523 struct walk_control *wc, int lookup_info)
Yan Zheng2c47e6052009-06-27 21:07:35 -04005524{
5525 int level = wc->level;
5526 struct extent_buffer *eb = path->nodes[level];
Yan Zheng2c47e6052009-06-27 21:07:35 -04005527 u64 flag = BTRFS_BLOCK_FLAG_FULL_BACKREF;
5528 int ret;
5529
5530 if (wc->stage == UPDATE_BACKREF &&
5531 btrfs_header_owner(eb) != root->root_key.objectid)
5532 return 1;
5533
5534 /*
5535 * when reference count of tree block is 1, it won't increase
5536 * again. once full backref flag is set, we never clear it.
5537 */
Yan, Zheng94fcca92009-10-09 09:25:16 -04005538 if (lookup_info &&
5539 ((wc->stage == DROP_REFERENCE && wc->refs[level] != 1) ||
5540 (wc->stage == UPDATE_BACKREF && !(wc->flags[level] & flag)))) {
Yan Zheng2c47e6052009-06-27 21:07:35 -04005541 BUG_ON(!path->locks[level]);
5542 ret = btrfs_lookup_extent_info(trans, root,
5543 eb->start, eb->len,
5544 &wc->refs[level],
5545 &wc->flags[level]);
5546 BUG_ON(ret);
5547 BUG_ON(wc->refs[level] == 0);
5548 }
5549
Yan Zheng2c47e6052009-06-27 21:07:35 -04005550 if (wc->stage == DROP_REFERENCE) {
5551 if (wc->refs[level] > 1)
5552 return 1;
5553
5554 if (path->locks[level] && !wc->keep_locks) {
5555 btrfs_tree_unlock(eb);
5556 path->locks[level] = 0;
5557 }
5558 return 0;
5559 }
5560
5561 /* wc->stage == UPDATE_BACKREF */
5562 if (!(wc->flags[level] & flag)) {
5563 BUG_ON(!path->locks[level]);
5564 ret = btrfs_inc_ref(trans, root, eb, 1);
5565 BUG_ON(ret);
5566 ret = btrfs_dec_ref(trans, root, eb, 0);
5567 BUG_ON(ret);
5568 ret = btrfs_set_disk_extent_flags(trans, root, eb->start,
5569 eb->len, flag, 0);
5570 BUG_ON(ret);
5571 wc->flags[level] |= flag;
5572 }
5573
5574 /*
5575 * the block is shared by multiple trees, so it's not good to
5576 * keep the tree lock
5577 */
5578 if (path->locks[level] && level > 0) {
5579 btrfs_tree_unlock(eb);
5580 path->locks[level] = 0;
5581 }
5582 return 0;
5583}
5584
5585/*
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005586 * hepler to process tree block pointer.
5587 *
5588 * when wc->stage == DROP_REFERENCE, this function checks
5589 * reference count of the block pointed to. if the block
5590 * is shared and we need update back refs for the subtree
5591 * rooted at the block, this function changes wc->stage to
5592 * UPDATE_BACKREF. if the block is shared and there is no
5593 * need to update back, this function drops the reference
5594 * to the block.
5595 *
5596 * NOTE: return value 1 means we should stop walking down.
5597 */
5598static noinline int do_walk_down(struct btrfs_trans_handle *trans,
5599 struct btrfs_root *root,
5600 struct btrfs_path *path,
Yan, Zheng94fcca92009-10-09 09:25:16 -04005601 struct walk_control *wc, int *lookup_info)
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005602{
5603 u64 bytenr;
5604 u64 generation;
5605 u64 parent;
5606 u32 blocksize;
5607 struct btrfs_key key;
5608 struct extent_buffer *next;
5609 int level = wc->level;
5610 int reada = 0;
5611 int ret = 0;
5612
5613 generation = btrfs_node_ptr_generation(path->nodes[level],
5614 path->slots[level]);
5615 /*
5616 * if the lower level block was created before the snapshot
5617 * was created, we know there is no need to update back refs
5618 * for the subtree
5619 */
5620 if (wc->stage == UPDATE_BACKREF &&
Yan, Zheng94fcca92009-10-09 09:25:16 -04005621 generation <= root->root_key.offset) {
5622 *lookup_info = 1;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005623 return 1;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005624 }
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005625
5626 bytenr = btrfs_node_blockptr(path->nodes[level], path->slots[level]);
5627 blocksize = btrfs_level_size(root, level - 1);
5628
5629 next = btrfs_find_tree_block(root, bytenr, blocksize);
5630 if (!next) {
5631 next = btrfs_find_create_tree_block(root, bytenr, blocksize);
Miao Xie90d2c512010-03-25 12:37:12 +00005632 if (!next)
5633 return -ENOMEM;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005634 reada = 1;
5635 }
5636 btrfs_tree_lock(next);
5637 btrfs_set_lock_blocking(next);
5638
Yan, Zheng94fcca92009-10-09 09:25:16 -04005639 ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize,
5640 &wc->refs[level - 1],
5641 &wc->flags[level - 1]);
5642 BUG_ON(ret);
5643 BUG_ON(wc->refs[level - 1] == 0);
5644 *lookup_info = 0;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005645
Yan, Zheng94fcca92009-10-09 09:25:16 -04005646 if (wc->stage == DROP_REFERENCE) {
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005647 if (wc->refs[level - 1] > 1) {
Yan, Zheng94fcca92009-10-09 09:25:16 -04005648 if (level == 1 &&
5649 (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5650 goto skip;
5651
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005652 if (!wc->update_ref ||
5653 generation <= root->root_key.offset)
5654 goto skip;
5655
5656 btrfs_node_key_to_cpu(path->nodes[level], &key,
5657 path->slots[level]);
5658 ret = btrfs_comp_cpu_keys(&key, &wc->update_progress);
5659 if (ret < 0)
5660 goto skip;
5661
5662 wc->stage = UPDATE_BACKREF;
5663 wc->shared_level = level - 1;
5664 }
Yan, Zheng94fcca92009-10-09 09:25:16 -04005665 } else {
5666 if (level == 1 &&
5667 (wc->flags[0] & BTRFS_BLOCK_FLAG_FULL_BACKREF))
5668 goto skip;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005669 }
5670
5671 if (!btrfs_buffer_uptodate(next, generation)) {
5672 btrfs_tree_unlock(next);
5673 free_extent_buffer(next);
5674 next = NULL;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005675 *lookup_info = 1;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005676 }
5677
5678 if (!next) {
5679 if (reada && level == 1)
5680 reada_walk_down(trans, root, wc, path);
5681 next = read_tree_block(root, bytenr, blocksize, generation);
5682 btrfs_tree_lock(next);
5683 btrfs_set_lock_blocking(next);
5684 }
5685
5686 level--;
5687 BUG_ON(level != btrfs_header_level(next));
5688 path->nodes[level] = next;
5689 path->slots[level] = 0;
5690 path->locks[level] = 1;
5691 wc->level = level;
5692 if (wc->level == 1)
5693 wc->reada_slot = 0;
5694 return 0;
5695skip:
5696 wc->refs[level - 1] = 0;
5697 wc->flags[level - 1] = 0;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005698 if (wc->stage == DROP_REFERENCE) {
5699 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF) {
5700 parent = path->nodes[level]->start;
5701 } else {
5702 BUG_ON(root->root_key.objectid !=
5703 btrfs_header_owner(path->nodes[level]));
5704 parent = 0;
5705 }
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005706
Yan, Zheng94fcca92009-10-09 09:25:16 -04005707 ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent,
5708 root->root_key.objectid, level - 1, 0);
5709 BUG_ON(ret);
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005710 }
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005711 btrfs_tree_unlock(next);
5712 free_extent_buffer(next);
Yan, Zheng94fcca92009-10-09 09:25:16 -04005713 *lookup_info = 1;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005714 return 1;
5715}
5716
5717/*
Yan Zheng2c47e6052009-06-27 21:07:35 -04005718 * hepler to process tree block while walking up the tree.
5719 *
5720 * when wc->stage == DROP_REFERENCE, this function drops
5721 * reference count on the block.
5722 *
5723 * when wc->stage == UPDATE_BACKREF, this function changes
5724 * wc->stage back to DROP_REFERENCE if we changed wc->stage
5725 * to UPDATE_BACKREF previously while processing the block.
5726 *
5727 * NOTE: return value 1 means we should stop walking up.
5728 */
5729static noinline int walk_up_proc(struct btrfs_trans_handle *trans,
5730 struct btrfs_root *root,
5731 struct btrfs_path *path,
5732 struct walk_control *wc)
5733{
Yan, Zhengf0486c62010-05-16 10:46:25 -04005734 int ret;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005735 int level = wc->level;
5736 struct extent_buffer *eb = path->nodes[level];
5737 u64 parent = 0;
5738
5739 if (wc->stage == UPDATE_BACKREF) {
5740 BUG_ON(wc->shared_level < level);
5741 if (level < wc->shared_level)
5742 goto out;
5743
Yan Zheng2c47e6052009-06-27 21:07:35 -04005744 ret = find_next_key(path, level + 1, &wc->update_progress);
5745 if (ret > 0)
5746 wc->update_ref = 0;
5747
5748 wc->stage = DROP_REFERENCE;
5749 wc->shared_level = -1;
5750 path->slots[level] = 0;
5751
5752 /*
5753 * check reference count again if the block isn't locked.
5754 * we should start walking down the tree again if reference
5755 * count is one.
5756 */
5757 if (!path->locks[level]) {
5758 BUG_ON(level == 0);
5759 btrfs_tree_lock(eb);
5760 btrfs_set_lock_blocking(eb);
5761 path->locks[level] = 1;
5762
5763 ret = btrfs_lookup_extent_info(trans, root,
5764 eb->start, eb->len,
5765 &wc->refs[level],
5766 &wc->flags[level]);
5767 BUG_ON(ret);
5768 BUG_ON(wc->refs[level] == 0);
5769 if (wc->refs[level] == 1) {
5770 btrfs_tree_unlock(eb);
5771 path->locks[level] = 0;
5772 return 1;
5773 }
Yan Zheng2c47e6052009-06-27 21:07:35 -04005774 }
5775 }
5776
5777 /* wc->stage == DROP_REFERENCE */
5778 BUG_ON(wc->refs[level] > 1 && !path->locks[level]);
5779
5780 if (wc->refs[level] == 1) {
5781 if (level == 0) {
5782 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5783 ret = btrfs_dec_ref(trans, root, eb, 1);
5784 else
5785 ret = btrfs_dec_ref(trans, root, eb, 0);
5786 BUG_ON(ret);
5787 }
5788 /* make block locked assertion in clean_tree_block happy */
5789 if (!path->locks[level] &&
5790 btrfs_header_generation(eb) == trans->transid) {
5791 btrfs_tree_lock(eb);
5792 btrfs_set_lock_blocking(eb);
5793 path->locks[level] = 1;
5794 }
5795 clean_tree_block(trans, root, eb);
5796 }
5797
5798 if (eb == root->node) {
5799 if (wc->flags[level] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5800 parent = eb->start;
5801 else
5802 BUG_ON(root->root_key.objectid !=
5803 btrfs_header_owner(eb));
5804 } else {
5805 if (wc->flags[level + 1] & BTRFS_BLOCK_FLAG_FULL_BACKREF)
5806 parent = path->nodes[level + 1]->start;
5807 else
5808 BUG_ON(root->root_key.objectid !=
5809 btrfs_header_owner(path->nodes[level + 1]));
5810 }
5811
Yan, Zhengf0486c62010-05-16 10:46:25 -04005812 btrfs_free_tree_block(trans, root, eb, parent, wc->refs[level] == 1);
Yan Zheng2c47e6052009-06-27 21:07:35 -04005813out:
5814 wc->refs[level] = 0;
5815 wc->flags[level] = 0;
Yan, Zhengf0486c62010-05-16 10:46:25 -04005816 return 0;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005817}
5818
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005819static noinline int walk_down_tree(struct btrfs_trans_handle *trans,
5820 struct btrfs_root *root,
Yan Zheng2c47e6052009-06-27 21:07:35 -04005821 struct btrfs_path *path,
5822 struct walk_control *wc)
Yan Zhengf82d02d2008-10-29 14:49:05 -04005823{
Yan Zheng2c47e6052009-06-27 21:07:35 -04005824 int level = wc->level;
Yan, Zheng94fcca92009-10-09 09:25:16 -04005825 int lookup_info = 1;
Yan Zhengf82d02d2008-10-29 14:49:05 -04005826 int ret;
5827
Yan Zheng2c47e6052009-06-27 21:07:35 -04005828 while (level >= 0) {
Yan, Zheng94fcca92009-10-09 09:25:16 -04005829 ret = walk_down_proc(trans, root, path, wc, lookup_info);
Yan Zheng2c47e6052009-06-27 21:07:35 -04005830 if (ret > 0)
Yan Zhengf82d02d2008-10-29 14:49:05 -04005831 break;
Yan Zhengf82d02d2008-10-29 14:49:05 -04005832
Yan Zheng2c47e6052009-06-27 21:07:35 -04005833 if (level == 0)
5834 break;
5835
Yan, Zheng7a7965f2010-02-01 02:41:17 +00005836 if (path->slots[level] >=
5837 btrfs_header_nritems(path->nodes[level]))
5838 break;
5839
Yan, Zheng94fcca92009-10-09 09:25:16 -04005840 ret = do_walk_down(trans, root, path, wc, &lookup_info);
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005841 if (ret > 0) {
5842 path->slots[level]++;
5843 continue;
Miao Xie90d2c512010-03-25 12:37:12 +00005844 } else if (ret < 0)
5845 return ret;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005846 level = wc->level;
Yan Zhengf82d02d2008-10-29 14:49:05 -04005847 }
Yan Zhengf82d02d2008-10-29 14:49:05 -04005848 return 0;
5849}
5850
Chris Masond3977122009-01-05 21:25:51 -05005851static noinline int walk_up_tree(struct btrfs_trans_handle *trans,
Chris Mason98ed5172008-01-03 10:01:48 -05005852 struct btrfs_root *root,
Yan Zhengf82d02d2008-10-29 14:49:05 -04005853 struct btrfs_path *path,
Yan Zheng2c47e6052009-06-27 21:07:35 -04005854 struct walk_control *wc, int max_level)
Chris Mason20524f02007-03-10 06:35:47 -05005855{
Yan Zheng2c47e6052009-06-27 21:07:35 -04005856 int level = wc->level;
Chris Mason20524f02007-03-10 06:35:47 -05005857 int ret;
Chris Mason9f3a7422007-08-07 15:52:19 -04005858
Yan Zheng2c47e6052009-06-27 21:07:35 -04005859 path->slots[level] = btrfs_header_nritems(path->nodes[level]);
5860 while (level < max_level && path->nodes[level]) {
5861 wc->level = level;
5862 if (path->slots[level] + 1 <
5863 btrfs_header_nritems(path->nodes[level])) {
5864 path->slots[level]++;
Chris Mason20524f02007-03-10 06:35:47 -05005865 return 0;
5866 } else {
Yan Zheng2c47e6052009-06-27 21:07:35 -04005867 ret = walk_up_proc(trans, root, path, wc);
5868 if (ret > 0)
5869 return 0;
Chris Masonbd56b302009-02-04 09:27:02 -05005870
Yan Zheng2c47e6052009-06-27 21:07:35 -04005871 if (path->locks[level]) {
5872 btrfs_tree_unlock(path->nodes[level]);
5873 path->locks[level] = 0;
Yan Zhengf82d02d2008-10-29 14:49:05 -04005874 }
Yan Zheng2c47e6052009-06-27 21:07:35 -04005875 free_extent_buffer(path->nodes[level]);
5876 path->nodes[level] = NULL;
5877 level++;
Chris Mason20524f02007-03-10 06:35:47 -05005878 }
5879 }
5880 return 1;
5881}
5882
Chris Mason9aca1d52007-03-13 11:09:37 -04005883/*
Yan Zheng2c47e6052009-06-27 21:07:35 -04005884 * drop a subvolume tree.
5885 *
5886 * this function traverses the tree freeing any blocks that only
5887 * referenced by the tree.
5888 *
5889 * when a shared tree block is found. this function decreases its
5890 * reference count by one. if update_ref is true, this function
5891 * also make sure backrefs for the shared block and all lower level
5892 * blocks are properly updated.
Chris Mason9aca1d52007-03-13 11:09:37 -04005893 */
Yan, Zheng3fd0a552010-05-16 10:49:59 -04005894int btrfs_drop_snapshot(struct btrfs_root *root,
5895 struct btrfs_block_rsv *block_rsv, int update_ref)
Chris Mason20524f02007-03-10 06:35:47 -05005896{
Chris Mason5caf2a02007-04-02 11:20:42 -04005897 struct btrfs_path *path;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005898 struct btrfs_trans_handle *trans;
5899 struct btrfs_root *tree_root = root->fs_info->tree_root;
Chris Mason9f3a7422007-08-07 15:52:19 -04005900 struct btrfs_root_item *root_item = &root->root_item;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005901 struct walk_control *wc;
5902 struct btrfs_key key;
5903 int err = 0;
5904 int ret;
5905 int level;
Chris Mason20524f02007-03-10 06:35:47 -05005906
Chris Mason5caf2a02007-04-02 11:20:42 -04005907 path = btrfs_alloc_path();
5908 BUG_ON(!path);
Chris Mason20524f02007-03-10 06:35:47 -05005909
Yan Zheng2c47e6052009-06-27 21:07:35 -04005910 wc = kzalloc(sizeof(*wc), GFP_NOFS);
5911 BUG_ON(!wc);
5912
Yan, Zhenga22285a2010-05-16 10:48:46 -04005913 trans = btrfs_start_transaction(tree_root, 0);
Yan, Zheng3fd0a552010-05-16 10:49:59 -04005914 if (block_rsv)
5915 trans->block_rsv = block_rsv;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005916
Chris Mason9f3a7422007-08-07 15:52:19 -04005917 if (btrfs_disk_key_objectid(&root_item->drop_progress) == 0) {
Yan Zheng2c47e6052009-06-27 21:07:35 -04005918 level = btrfs_header_level(root->node);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005919 path->nodes[level] = btrfs_lock_root_node(root);
5920 btrfs_set_lock_blocking(path->nodes[level]);
Chris Mason9f3a7422007-08-07 15:52:19 -04005921 path->slots[level] = 0;
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005922 path->locks[level] = 1;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005923 memset(&wc->update_progress, 0,
5924 sizeof(wc->update_progress));
Chris Mason9f3a7422007-08-07 15:52:19 -04005925 } else {
Chris Mason9f3a7422007-08-07 15:52:19 -04005926 btrfs_disk_key_to_cpu(&key, &root_item->drop_progress);
Yan Zheng2c47e6052009-06-27 21:07:35 -04005927 memcpy(&wc->update_progress, &key,
5928 sizeof(wc->update_progress));
5929
Chris Mason6702ed42007-08-07 16:15:09 -04005930 level = root_item->drop_level;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005931 BUG_ON(level == 0);
Chris Mason6702ed42007-08-07 16:15:09 -04005932 path->lowest_level = level;
Yan Zheng2c47e6052009-06-27 21:07:35 -04005933 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
5934 path->lowest_level = 0;
5935 if (ret < 0) {
5936 err = ret;
Chris Mason9f3a7422007-08-07 15:52:19 -04005937 goto out;
5938 }
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005939 WARN_ON(ret > 0);
Yan Zheng2c47e6052009-06-27 21:07:35 -04005940
Chris Mason7d9eb122008-07-08 14:19:17 -04005941 /*
5942 * unlock our path, this is safe because only this
5943 * function is allowed to delete this snapshot
5944 */
Yan Zheng5d4f98a2009-06-10 10:45:14 -04005945 btrfs_unlock_up_safe(path, 0);
Chris Mason9aca1d52007-03-13 11:09:37 -04005946
Yan Zheng2c47e6052009-06-27 21:07:35 -04005947 level = btrfs_header_level(root->node);
5948 while (1) {
5949 btrfs_tree_lock(path->nodes[level]);
5950 btrfs_set_lock_blocking(path->nodes[level]);
5951
5952 ret = btrfs_lookup_extent_info(trans, root,
5953 path->nodes[level]->start,
5954 path->nodes[level]->len,
5955 &wc->refs[level],
5956 &wc->flags[level]);
5957 BUG_ON(ret);
5958 BUG_ON(wc->refs[level] == 0);
5959
5960 if (level == root_item->drop_level)
5961 break;
5962
5963 btrfs_tree_unlock(path->nodes[level]);
5964 WARN_ON(wc->refs[level] != 1);
5965 level--;
5966 }
5967 }
5968
5969 wc->level = level;
5970 wc->shared_level = -1;
5971 wc->stage = DROP_REFERENCE;
5972 wc->update_ref = update_ref;
5973 wc->keep_locks = 0;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04005974 wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
Yan Zheng2c47e6052009-06-27 21:07:35 -04005975
5976 while (1) {
5977 ret = walk_down_tree(trans, root, path, wc);
5978 if (ret < 0) {
5979 err = ret;
Chris Masone7a84562008-06-25 16:01:31 -04005980 break;
5981 }
Yan Zheng2c47e6052009-06-27 21:07:35 -04005982
5983 ret = walk_up_tree(trans, root, path, wc, BTRFS_MAX_LEVEL);
5984 if (ret < 0) {
5985 err = ret;
5986 break;
5987 }
5988
5989 if (ret > 0) {
5990 BUG_ON(wc->stage != DROP_REFERENCE);
5991 break;
5992 }
5993
5994 if (wc->stage == DROP_REFERENCE) {
5995 level = wc->level;
5996 btrfs_node_key(path->nodes[level],
5997 &root_item->drop_progress,
5998 path->slots[level]);
5999 root_item->drop_level = level;
6000 }
6001
6002 BUG_ON(wc->level == 0);
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006003 if (btrfs_should_end_transaction(trans, tree_root)) {
Yan Zheng2c47e6052009-06-27 21:07:35 -04006004 ret = btrfs_update_root(trans, tree_root,
6005 &root->root_key,
6006 root_item);
6007 BUG_ON(ret);
6008
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006009 btrfs_end_transaction_throttle(trans, tree_root);
Yan, Zhenga22285a2010-05-16 10:48:46 -04006010 trans = btrfs_start_transaction(tree_root, 0);
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006011 if (block_rsv)
6012 trans->block_rsv = block_rsv;
Chris Masonc3e69d52009-03-13 10:17:05 -04006013 }
Chris Mason20524f02007-03-10 06:35:47 -05006014 }
Yan Zheng2c47e6052009-06-27 21:07:35 -04006015 btrfs_release_path(root, path);
6016 BUG_ON(err);
6017
6018 ret = btrfs_del_root(trans, tree_root, &root->root_key);
6019 BUG_ON(ret);
6020
Yan, Zheng76dda932009-09-21 16:00:26 -04006021 if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) {
6022 ret = btrfs_find_last_root(tree_root, root->root_key.objectid,
6023 NULL, NULL);
6024 BUG_ON(ret < 0);
6025 if (ret > 0) {
6026 ret = btrfs_del_orphan_item(trans, tree_root,
6027 root->root_key.objectid);
6028 BUG_ON(ret);
6029 }
6030 }
6031
6032 if (root->in_radix) {
6033 btrfs_free_fs_root(tree_root->fs_info, root);
6034 } else {
6035 free_extent_buffer(root->node);
6036 free_extent_buffer(root->commit_root);
6037 kfree(root);
6038 }
Chris Mason9f3a7422007-08-07 15:52:19 -04006039out:
Yan, Zheng3fd0a552010-05-16 10:49:59 -04006040 btrfs_end_transaction_throttle(trans, tree_root);
Yan Zheng2c47e6052009-06-27 21:07:35 -04006041 kfree(wc);
Chris Mason5caf2a02007-04-02 11:20:42 -04006042 btrfs_free_path(path);
Yan Zheng2c47e6052009-06-27 21:07:35 -04006043 return err;
Chris Mason20524f02007-03-10 06:35:47 -05006044}
Chris Mason9078a3e2007-04-26 16:46:15 -04006045
Yan Zheng2c47e6052009-06-27 21:07:35 -04006046/*
6047 * drop subtree rooted at tree block 'node'.
6048 *
6049 * NOTE: this function will unlock and release tree block 'node'
6050 */
Yan Zhengf82d02d2008-10-29 14:49:05 -04006051int btrfs_drop_subtree(struct btrfs_trans_handle *trans,
6052 struct btrfs_root *root,
6053 struct extent_buffer *node,
6054 struct extent_buffer *parent)
6055{
6056 struct btrfs_path *path;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006057 struct walk_control *wc;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006058 int level;
6059 int parent_level;
6060 int ret = 0;
6061 int wret;
6062
Yan Zheng2c47e6052009-06-27 21:07:35 -04006063 BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);
6064
Yan Zhengf82d02d2008-10-29 14:49:05 -04006065 path = btrfs_alloc_path();
6066 BUG_ON(!path);
6067
Yan Zheng2c47e6052009-06-27 21:07:35 -04006068 wc = kzalloc(sizeof(*wc), GFP_NOFS);
6069 BUG_ON(!wc);
6070
Chris Masonb9447ef2009-03-09 11:45:38 -04006071 btrfs_assert_tree_locked(parent);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006072 parent_level = btrfs_header_level(parent);
6073 extent_buffer_get(parent);
6074 path->nodes[parent_level] = parent;
6075 path->slots[parent_level] = btrfs_header_nritems(parent);
6076
Chris Masonb9447ef2009-03-09 11:45:38 -04006077 btrfs_assert_tree_locked(node);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006078 level = btrfs_header_level(node);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006079 path->nodes[level] = node;
6080 path->slots[level] = 0;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006081 path->locks[level] = 1;
6082
6083 wc->refs[parent_level] = 1;
6084 wc->flags[parent_level] = BTRFS_BLOCK_FLAG_FULL_BACKREF;
6085 wc->level = level;
6086 wc->shared_level = -1;
6087 wc->stage = DROP_REFERENCE;
6088 wc->update_ref = 0;
6089 wc->keep_locks = 1;
Yan, Zheng1c4850e2009-09-21 15:55:59 -04006090 wc->reada_count = BTRFS_NODEPTRS_PER_BLOCK(root);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006091
6092 while (1) {
Yan Zheng2c47e6052009-06-27 21:07:35 -04006093 wret = walk_down_tree(trans, root, path, wc);
6094 if (wret < 0) {
Yan Zhengf82d02d2008-10-29 14:49:05 -04006095 ret = wret;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006096 break;
Yan Zheng2c47e6052009-06-27 21:07:35 -04006097 }
Yan Zhengf82d02d2008-10-29 14:49:05 -04006098
Yan Zheng2c47e6052009-06-27 21:07:35 -04006099 wret = walk_up_tree(trans, root, path, wc, parent_level);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006100 if (wret < 0)
6101 ret = wret;
6102 if (wret != 0)
6103 break;
6104 }
6105
Yan Zheng2c47e6052009-06-27 21:07:35 -04006106 kfree(wc);
Yan Zhengf82d02d2008-10-29 14:49:05 -04006107 btrfs_free_path(path);
6108 return ret;
6109}
6110
Yan Zheng5d4f98a2009-06-10 10:45:14 -04006111#if 0
Chris Mason8e7bf942008-04-28 09:02:36 -04006112static unsigned long calc_ra(unsigned long start, unsigned long last,
6113 unsigned long nr)
6114{
6115 return min(last, start + nr - 1);
6116}
6117
Chris Masond3977122009-01-05 21:25:51 -05006118static noinline int relocate_inode_pages(struct inode *inode, u64 start,
Chris Mason98ed5172008-01-03 10:01:48 -05006119 u64 len)
Chris Masonedbd8d42007-12-21 16:27:24 -05006120{
6121 u64 page_start;
6122 u64 page_end;
Zheng Yan1a40e232008-09-26 10:09:34 -04006123 unsigned long first_index;
Chris Masonedbd8d42007-12-21 16:27:24 -05006124 unsigned long last_index;
Chris Masonedbd8d42007-12-21 16:27:24 -05006125 unsigned long i;
6126 struct page *page;
Chris Masond1310b22008-01-24 16:13:08 -05006127 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
Chris Mason4313b392008-01-03 09:08:48 -05006128 struct file_ra_state *ra;
Chris Mason3eaa2882008-07-24 11:57:52 -04006129 struct btrfs_ordered_extent *ordered;
Zheng Yan1a40e232008-09-26 10:09:34 -04006130 unsigned int total_read = 0;
6131 unsigned int total_dirty = 0;
6132 int ret = 0;
Chris Mason4313b392008-01-03 09:08:48 -05006133
6134 ra = kzalloc(sizeof(*ra), GFP_NOFS);
Chris Masonedbd8d42007-12-21 16:27:24 -05006135
6136 mutex_lock(&inode->i_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04006137 first_index = start >> PAGE_CACHE_SHIFT;
Chris Masonedbd8d42007-12-21 16:27:24 -05006138 last_index = (start + len - 1) >> PAGE_CACHE_SHIFT;
6139
Zheng Yan1a40e232008-09-26 10:09:34 -04006140 /* make sure the dirty trick played by the caller work */
6141 ret = invalidate_inode_pages2_range(inode->i_mapping,
6142 first_index, last_index);
6143 if (ret)
6144 goto out_unlock;
Chris Mason8e7bf942008-04-28 09:02:36 -04006145
Chris Mason4313b392008-01-03 09:08:48 -05006146 file_ra_state_init(ra, inode->i_mapping);
Chris Masonedbd8d42007-12-21 16:27:24 -05006147
Zheng Yan1a40e232008-09-26 10:09:34 -04006148 for (i = first_index ; i <= last_index; i++) {
6149 if (total_read % ra->ra_pages == 0) {
Chris Mason8e7bf942008-04-28 09:02:36 -04006150 btrfs_force_ra(inode->i_mapping, ra, NULL, i,
Zheng Yan1a40e232008-09-26 10:09:34 -04006151 calc_ra(i, last_index, ra->ra_pages));
Chris Mason8e7bf942008-04-28 09:02:36 -04006152 }
6153 total_read++;
Chris Mason3eaa2882008-07-24 11:57:52 -04006154again:
6155 if (((u64)i << PAGE_CACHE_SHIFT) > i_size_read(inode))
Zheng Yan1a40e232008-09-26 10:09:34 -04006156 BUG_ON(1);
Chris Masonedbd8d42007-12-21 16:27:24 -05006157 page = grab_cache_page(inode->i_mapping, i);
Chris Masona061fc82008-05-07 11:43:44 -04006158 if (!page) {
Zheng Yan1a40e232008-09-26 10:09:34 -04006159 ret = -ENOMEM;
Chris Masonedbd8d42007-12-21 16:27:24 -05006160 goto out_unlock;
Chris Masona061fc82008-05-07 11:43:44 -04006161 }
Chris Masonedbd8d42007-12-21 16:27:24 -05006162 if (!PageUptodate(page)) {
6163 btrfs_readpage(NULL, page);
6164 lock_page(page);
6165 if (!PageUptodate(page)) {
6166 unlock_page(page);
6167 page_cache_release(page);
Zheng Yan1a40e232008-09-26 10:09:34 -04006168 ret = -EIO;
Chris Masonedbd8d42007-12-21 16:27:24 -05006169 goto out_unlock;
6170 }
6171 }
Chris Masonec44a352008-04-28 15:29:52 -04006172 wait_on_page_writeback(page);
Chris Mason3eaa2882008-07-24 11:57:52 -04006173
Chris Masonedbd8d42007-12-21 16:27:24 -05006174 page_start = (u64)page->index << PAGE_CACHE_SHIFT;
6175 page_end = page_start + PAGE_CACHE_SIZE - 1;
Chris Masond1310b22008-01-24 16:13:08 -05006176 lock_extent(io_tree, page_start, page_end, GFP_NOFS);
Chris Masonedbd8d42007-12-21 16:27:24 -05006177
Chris Mason3eaa2882008-07-24 11:57:52 -04006178 ordered = btrfs_lookup_ordered_extent(inode, page_start);
6179 if (ordered) {
6180 unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
6181 unlock_page(page);
6182 page_cache_release(page);
6183 btrfs_start_ordered_extent(inode, ordered, 1);
6184 btrfs_put_ordered_extent(ordered);
6185 goto again;
6186 }
6187 set_page_extent_mapped(page);
6188
Zheng Yan1a40e232008-09-26 10:09:34 -04006189 if (i == first_index)
6190 set_extent_bits(io_tree, page_start, page_end,
6191 EXTENT_BOUNDARY, GFP_NOFS);
Yan Zheng1f80e4d2008-12-19 10:59:04 -05006192 btrfs_set_extent_delalloc(inode, page_start, page_end);
Zheng Yan1a40e232008-09-26 10:09:34 -04006193
Chris Masona061fc82008-05-07 11:43:44 -04006194 set_page_dirty(page);
Zheng Yan1a40e232008-09-26 10:09:34 -04006195 total_dirty++;
Chris Masonedbd8d42007-12-21 16:27:24 -05006196
Chris Masond1310b22008-01-24 16:13:08 -05006197 unlock_extent(io_tree, page_start, page_end, GFP_NOFS);
Chris Masonedbd8d42007-12-21 16:27:24 -05006198 unlock_page(page);
6199 page_cache_release(page);
6200 }
6201
6202out_unlock:
Chris Masonec44a352008-04-28 15:29:52 -04006203 kfree(ra);
Chris Masonedbd8d42007-12-21 16:27:24 -05006204 mutex_unlock(&inode->i_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04006205 balance_dirty_pages_ratelimited_nr(inode->i_mapping, total_dirty);
Chris Masonbf4ef672008-05-08 13:26:18 -04006206 return ret;
6207}
6208
Chris Masond3977122009-01-05 21:25:51 -05006209static noinline int relocate_data_extent(struct inode *reloc_inode,
Zheng Yan1a40e232008-09-26 10:09:34 -04006210 struct btrfs_key *extent_key,
6211 u64 offset)
Chris Masonedbd8d42007-12-21 16:27:24 -05006212{
Zheng Yan1a40e232008-09-26 10:09:34 -04006213 struct btrfs_root *root = BTRFS_I(reloc_inode)->root;
6214 struct extent_map_tree *em_tree = &BTRFS_I(reloc_inode)->extent_tree;
6215 struct extent_map *em;
Yan Zheng66435582008-10-30 14:19:50 -04006216 u64 start = extent_key->objectid - offset;
6217 u64 end = start + extent_key->offset - 1;
Zheng Yan1a40e232008-09-26 10:09:34 -04006218
6219 em = alloc_extent_map(GFP_NOFS);
6220 BUG_ON(!em || IS_ERR(em));
6221
Yan Zheng66435582008-10-30 14:19:50 -04006222 em->start = start;
Zheng Yan1a40e232008-09-26 10:09:34 -04006223 em->len = extent_key->offset;
Chris Masonc8b97812008-10-29 14:49:59 -04006224 em->block_len = extent_key->offset;
Zheng Yan1a40e232008-09-26 10:09:34 -04006225 em->block_start = extent_key->objectid;
6226 em->bdev = root->fs_info->fs_devices->latest_bdev;
6227 set_bit(EXTENT_FLAG_PINNED, &em->flags);
6228
6229 /* setup extent map to cheat btrfs_readpage */
Yan Zheng66435582008-10-30 14:19:50 -04006230 lock_extent(&BTRFS_I(reloc_inode)->io_tree, start, end, GFP_NOFS);
Zheng Yan1a40e232008-09-26 10:09:34 -04006231 while (1) {
6232 int ret;
Chris Mason890871b2009-09-02 16:24:52 -04006233 write_lock(&em_tree->lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04006234 ret = add_extent_mapping(em_tree, em);
Chris Mason890871b2009-09-02 16:24:52 -04006235 write_unlock(&em_tree->lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04006236 if (ret != -EEXIST) {
6237 free_extent_map(em);
6238 break;
6239 }
Yan Zheng66435582008-10-30 14:19:50 -04006240 btrfs_drop_extent_cache(reloc_inode, start, end, 0);
Zheng Yan1a40e232008-09-26 10:09:34 -04006241 }
Yan Zheng66435582008-10-30 14:19:50 -04006242 unlock_extent(&BTRFS_I(reloc_inode)->io_tree, start, end, GFP_NOFS);
Zheng Yan1a40e232008-09-26 10:09:34 -04006243
Yan Zheng66435582008-10-30 14:19:50 -04006244 return relocate_inode_pages(reloc_inode, start, extent_key->offset);
Zheng Yan1a40e232008-09-26 10:09:34 -04006245}
6246
6247struct btrfs_ref_path {
6248 u64 extent_start;
6249 u64 nodes[BTRFS_MAX_LEVEL];
6250 u64 root_objectid;
6251 u64 root_generation;
6252 u64 owner_objectid;
Zheng Yan1a40e232008-09-26 10:09:34 -04006253 u32 num_refs;
6254 int lowest_level;
6255 int current_level;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006256 int shared_level;
6257
6258 struct btrfs_key node_keys[BTRFS_MAX_LEVEL];
6259 u64 new_nodes[BTRFS_MAX_LEVEL];
Zheng Yan1a40e232008-09-26 10:09:34 -04006260};
6261
6262struct disk_extent {
Chris Masonc8b97812008-10-29 14:49:59 -04006263 u64 ram_bytes;
Zheng Yan1a40e232008-09-26 10:09:34 -04006264 u64 disk_bytenr;
6265 u64 disk_num_bytes;
6266 u64 offset;
6267 u64 num_bytes;
Chris Masonc8b97812008-10-29 14:49:59 -04006268 u8 compression;
6269 u8 encryption;
6270 u16 other_encoding;
Zheng Yan1a40e232008-09-26 10:09:34 -04006271};
6272
6273static int is_cowonly_root(u64 root_objectid)
6274{
6275 if (root_objectid == BTRFS_ROOT_TREE_OBJECTID ||
6276 root_objectid == BTRFS_EXTENT_TREE_OBJECTID ||
6277 root_objectid == BTRFS_CHUNK_TREE_OBJECTID ||
6278 root_objectid == BTRFS_DEV_TREE_OBJECTID ||
Yan Zheng0403e472008-12-10 20:32:51 -05006279 root_objectid == BTRFS_TREE_LOG_OBJECTID ||
6280 root_objectid == BTRFS_CSUM_TREE_OBJECTID)
Zheng Yan1a40e232008-09-26 10:09:34 -04006281 return 1;
6282 return 0;
6283}
6284
Chris Masond3977122009-01-05 21:25:51 -05006285static noinline int __next_ref_path(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04006286 struct btrfs_root *extent_root,
6287 struct btrfs_ref_path *ref_path,
6288 int first_time)
6289{
6290 struct extent_buffer *leaf;
6291 struct btrfs_path *path;
Chris Mason4313b392008-01-03 09:08:48 -05006292 struct btrfs_extent_ref *ref;
Chris Masonedbd8d42007-12-21 16:27:24 -05006293 struct btrfs_key key;
6294 struct btrfs_key found_key;
Zheng Yan1a40e232008-09-26 10:09:34 -04006295 u64 bytenr;
Chris Masonedbd8d42007-12-21 16:27:24 -05006296 u32 nritems;
Zheng Yan1a40e232008-09-26 10:09:34 -04006297 int level;
6298 int ret = 1;
Chris Masonedbd8d42007-12-21 16:27:24 -05006299
Zheng Yan1a40e232008-09-26 10:09:34 -04006300 path = btrfs_alloc_path();
6301 if (!path)
6302 return -ENOMEM;
6303
Zheng Yan1a40e232008-09-26 10:09:34 -04006304 if (first_time) {
6305 ref_path->lowest_level = -1;
6306 ref_path->current_level = -1;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006307 ref_path->shared_level = -1;
Zheng Yan1a40e232008-09-26 10:09:34 -04006308 goto walk_up;
Chris Masona061fc82008-05-07 11:43:44 -04006309 }
Zheng Yan1a40e232008-09-26 10:09:34 -04006310walk_down:
6311 level = ref_path->current_level - 1;
6312 while (level >= -1) {
6313 u64 parent;
6314 if (level < ref_path->lowest_level)
6315 break;
Chris Masonedbd8d42007-12-21 16:27:24 -05006316
Chris Masond3977122009-01-05 21:25:51 -05006317 if (level >= 0)
Zheng Yan1a40e232008-09-26 10:09:34 -04006318 bytenr = ref_path->nodes[level];
Chris Masond3977122009-01-05 21:25:51 -05006319 else
Zheng Yan1a40e232008-09-26 10:09:34 -04006320 bytenr = ref_path->extent_start;
Zheng Yan1a40e232008-09-26 10:09:34 -04006321 BUG_ON(bytenr == 0);
Chris Masonedbd8d42007-12-21 16:27:24 -05006322
Zheng Yan1a40e232008-09-26 10:09:34 -04006323 parent = ref_path->nodes[level + 1];
6324 ref_path->nodes[level + 1] = 0;
6325 ref_path->current_level = level;
6326 BUG_ON(parent == 0);
6327
6328 key.objectid = bytenr;
6329 key.offset = parent + 1;
6330 key.type = BTRFS_EXTENT_REF_KEY;
6331
6332 ret = btrfs_search_slot(trans, extent_root, &key, path, 0, 0);
Chris Masonedbd8d42007-12-21 16:27:24 -05006333 if (ret < 0)
6334 goto out;
Zheng Yan1a40e232008-09-26 10:09:34 -04006335 BUG_ON(ret == 0);
Chris Masonedbd8d42007-12-21 16:27:24 -05006336
Chris Masonedbd8d42007-12-21 16:27:24 -05006337 leaf = path->nodes[0];
6338 nritems = btrfs_header_nritems(leaf);
Zheng Yan1a40e232008-09-26 10:09:34 -04006339 if (path->slots[0] >= nritems) {
Chris Masona061fc82008-05-07 11:43:44 -04006340 ret = btrfs_next_leaf(extent_root, path);
Chris Masona061fc82008-05-07 11:43:44 -04006341 if (ret < 0)
6342 goto out;
Zheng Yan1a40e232008-09-26 10:09:34 -04006343 if (ret > 0)
6344 goto next;
Chris Masonbf4ef672008-05-08 13:26:18 -04006345 leaf = path->nodes[0];
Chris Masona061fc82008-05-07 11:43:44 -04006346 }
Chris Masonedbd8d42007-12-21 16:27:24 -05006347
6348 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
Zheng Yan1a40e232008-09-26 10:09:34 -04006349 if (found_key.objectid == bytenr &&
Yan Zhengf82d02d2008-10-29 14:49:05 -04006350 found_key.type == BTRFS_EXTENT_REF_KEY) {
6351 if (level < ref_path->shared_level)
6352 ref_path->shared_level = level;
Zheng Yan1a40e232008-09-26 10:09:34 -04006353 goto found;
Yan Zhengf82d02d2008-10-29 14:49:05 -04006354 }
Zheng Yan1a40e232008-09-26 10:09:34 -04006355next:
6356 level--;
6357 btrfs_release_path(extent_root, path);
Yan Zhengd899e052008-10-30 14:25:28 -04006358 cond_resched();
Zheng Yan1a40e232008-09-26 10:09:34 -04006359 }
6360 /* reached lowest level */
6361 ret = 1;
6362 goto out;
6363walk_up:
6364 level = ref_path->current_level;
6365 while (level < BTRFS_MAX_LEVEL - 1) {
6366 u64 ref_objectid;
Chris Masond3977122009-01-05 21:25:51 -05006367
6368 if (level >= 0)
Zheng Yan1a40e232008-09-26 10:09:34 -04006369 bytenr = ref_path->nodes[level];
Chris Masond3977122009-01-05 21:25:51 -05006370 else
Zheng Yan1a40e232008-09-26 10:09:34 -04006371 bytenr = ref_path->extent_start;
Chris Masond3977122009-01-05 21:25:51 -05006372
Zheng Yan1a40e232008-09-26 10:09:34 -04006373 BUG_ON(bytenr == 0);
Chris Masonedbd8d42007-12-21 16:27:24 -05006374
Zheng Yan1a40e232008-09-26 10:09:34 -04006375 key.objectid = bytenr;
6376 key.offset = 0;
6377 key.type = BTRFS_EXTENT_REF_KEY;
Chris Masonedbd8d42007-12-21 16:27:24 -05006378
Zheng Yan1a40e232008-09-26 10:09:34 -04006379 ret = btrfs_search_slot(trans, extent_root, &key, path, 0, 0);
6380 if (ret < 0)
Chris Masonedbd8d42007-12-21 16:27:24 -05006381 goto out;
Zheng Yan1a40e232008-09-26 10:09:34 -04006382
6383 leaf = path->nodes[0];
6384 nritems = btrfs_header_nritems(leaf);
6385 if (path->slots[0] >= nritems) {
6386 ret = btrfs_next_leaf(extent_root, path);
6387 if (ret < 0)
6388 goto out;
6389 if (ret > 0) {
6390 /* the extent was freed by someone */
6391 if (ref_path->lowest_level == level)
6392 goto out;
6393 btrfs_release_path(extent_root, path);
6394 goto walk_down;
6395 }
6396 leaf = path->nodes[0];
6397 }
6398
6399 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6400 if (found_key.objectid != bytenr ||
6401 found_key.type != BTRFS_EXTENT_REF_KEY) {
6402 /* the extent was freed by someone */
6403 if (ref_path->lowest_level == level) {
6404 ret = 1;
6405 goto out;
6406 }
6407 btrfs_release_path(extent_root, path);
6408 goto walk_down;
6409 }
6410found:
6411 ref = btrfs_item_ptr(leaf, path->slots[0],
6412 struct btrfs_extent_ref);
6413 ref_objectid = btrfs_ref_objectid(leaf, ref);
6414 if (ref_objectid < BTRFS_FIRST_FREE_OBJECTID) {
6415 if (first_time) {
6416 level = (int)ref_objectid;
6417 BUG_ON(level >= BTRFS_MAX_LEVEL);
6418 ref_path->lowest_level = level;
6419 ref_path->current_level = level;
6420 ref_path->nodes[level] = bytenr;
6421 } else {
6422 WARN_ON(ref_objectid != level);
6423 }
6424 } else {
6425 WARN_ON(level != -1);
6426 }
6427 first_time = 0;
6428
6429 if (ref_path->lowest_level == level) {
6430 ref_path->owner_objectid = ref_objectid;
Zheng Yan1a40e232008-09-26 10:09:34 -04006431 ref_path->num_refs = btrfs_ref_num_refs(leaf, ref);
6432 }
6433
6434 /*
6435 * the block is tree root or the block isn't in reference
6436 * counted tree.
6437 */
6438 if (found_key.objectid == found_key.offset ||
6439 is_cowonly_root(btrfs_ref_root(leaf, ref))) {
6440 ref_path->root_objectid = btrfs_ref_root(leaf, ref);
6441 ref_path->root_generation =
6442 btrfs_ref_generation(leaf, ref);
6443 if (level < 0) {
6444 /* special reference from the tree log */
6445 ref_path->nodes[0] = found_key.offset;
6446 ref_path->current_level = 0;
6447 }
6448 ret = 0;
6449 goto out;
6450 }
6451
6452 level++;
6453 BUG_ON(ref_path->nodes[level] != 0);
6454 ref_path->nodes[level] = found_key.offset;
6455 ref_path->current_level = level;
6456
6457 /*
6458 * the reference was created in the running transaction,
6459 * no need to continue walking up.
6460 */
6461 if (btrfs_ref_generation(leaf, ref) == trans->transid) {
6462 ref_path->root_objectid = btrfs_ref_root(leaf, ref);
6463 ref_path->root_generation =
6464 btrfs_ref_generation(leaf, ref);
6465 ret = 0;
6466 goto out;
6467 }
6468
6469 btrfs_release_path(extent_root, path);
Yan Zhengd899e052008-10-30 14:25:28 -04006470 cond_resched();
Zheng Yan1a40e232008-09-26 10:09:34 -04006471 }
6472 /* reached max tree level, but no tree root found. */
6473 BUG();
6474out:
Zheng Yan1a40e232008-09-26 10:09:34 -04006475 btrfs_free_path(path);
6476 return ret;
6477}
6478
6479static int btrfs_first_ref_path(struct btrfs_trans_handle *trans,
6480 struct btrfs_root *extent_root,
6481 struct btrfs_ref_path *ref_path,
6482 u64 extent_start)
6483{
6484 memset(ref_path, 0, sizeof(*ref_path));
6485 ref_path->extent_start = extent_start;
6486
6487 return __next_ref_path(trans, extent_root, ref_path, 1);
6488}
6489
6490static int btrfs_next_ref_path(struct btrfs_trans_handle *trans,
6491 struct btrfs_root *extent_root,
6492 struct btrfs_ref_path *ref_path)
6493{
6494 return __next_ref_path(trans, extent_root, ref_path, 0);
6495}
6496
Chris Masond3977122009-01-05 21:25:51 -05006497static noinline int get_new_locations(struct inode *reloc_inode,
Zheng Yan1a40e232008-09-26 10:09:34 -04006498 struct btrfs_key *extent_key,
6499 u64 offset, int no_fragment,
6500 struct disk_extent **extents,
6501 int *nr_extents)
6502{
6503 struct btrfs_root *root = BTRFS_I(reloc_inode)->root;
6504 struct btrfs_path *path;
6505 struct btrfs_file_extent_item *fi;
6506 struct extent_buffer *leaf;
6507 struct disk_extent *exts = *extents;
6508 struct btrfs_key found_key;
6509 u64 cur_pos;
6510 u64 last_byte;
6511 u32 nritems;
6512 int nr = 0;
6513 int max = *nr_extents;
6514 int ret;
6515
6516 WARN_ON(!no_fragment && *extents);
6517 if (!exts) {
6518 max = 1;
6519 exts = kmalloc(sizeof(*exts) * max, GFP_NOFS);
6520 if (!exts)
6521 return -ENOMEM;
6522 }
6523
6524 path = btrfs_alloc_path();
6525 BUG_ON(!path);
6526
6527 cur_pos = extent_key->objectid - offset;
6528 last_byte = extent_key->objectid + extent_key->offset;
6529 ret = btrfs_lookup_file_extent(NULL, root, path, reloc_inode->i_ino,
6530 cur_pos, 0);
6531 if (ret < 0)
6532 goto out;
6533 if (ret > 0) {
6534 ret = -ENOENT;
6535 goto out;
6536 }
6537
6538 while (1) {
6539 leaf = path->nodes[0];
6540 nritems = btrfs_header_nritems(leaf);
6541 if (path->slots[0] >= nritems) {
6542 ret = btrfs_next_leaf(root, path);
6543 if (ret < 0)
6544 goto out;
6545 if (ret > 0)
6546 break;
6547 leaf = path->nodes[0];
6548 }
6549
6550 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
6551 if (found_key.offset != cur_pos ||
6552 found_key.type != BTRFS_EXTENT_DATA_KEY ||
6553 found_key.objectid != reloc_inode->i_ino)
6554 break;
6555
6556 fi = btrfs_item_ptr(leaf, path->slots[0],
6557 struct btrfs_file_extent_item);
6558 if (btrfs_file_extent_type(leaf, fi) !=
6559 BTRFS_FILE_EXTENT_REG ||
6560 btrfs_file_extent_disk_bytenr(leaf, fi) == 0)
6561 break;
6562
6563 if (nr == max) {
6564 struct disk_extent *old = exts;
6565 max *= 2;
6566 exts = kzalloc(sizeof(*exts) * max, GFP_NOFS);
6567 memcpy(exts, old, sizeof(*exts) * nr);
6568 if (old != *extents)
6569 kfree(old);
6570 }
6571
6572 exts[nr].disk_bytenr =
6573 btrfs_file_extent_disk_bytenr(leaf, fi);
6574 exts[nr].disk_num_bytes =
6575 btrfs_file_extent_disk_num_bytes(leaf, fi);
6576 exts[nr].offset = btrfs_file_extent_offset(leaf, fi);
6577 exts[nr].num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
Chris Masonc8b97812008-10-29 14:49:59 -04006578 exts[nr].ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
6579 exts[nr].compression = btrfs_file_extent_compression(leaf, fi);
6580 exts[nr].encryption = btrfs_file_extent_encryption(leaf, fi);
6581 exts[nr].other_encoding = btrfs_file_extent_other_encoding(leaf,
6582 fi);
Yan Zhengd899e052008-10-30 14:25:28 -04006583 BUG_ON(exts[nr].offset > 0);
6584 BUG_ON(exts[nr].compression || exts[nr].encryption);
6585 BUG_ON(exts[nr].num_bytes != exts[nr].disk_num_bytes);
Zheng Yan1a40e232008-09-26 10:09:34 -04006586
6587 cur_pos += exts[nr].num_bytes;
6588 nr++;
6589
6590 if (cur_pos + offset >= last_byte)
6591 break;
6592
6593 if (no_fragment) {
6594 ret = 1;
6595 goto out;
6596 }
6597 path->slots[0]++;
6598 }
6599
Yan Zheng1f80e4d2008-12-19 10:59:04 -05006600 BUG_ON(cur_pos + offset > last_byte);
Zheng Yan1a40e232008-09-26 10:09:34 -04006601 if (cur_pos + offset < last_byte) {
6602 ret = -ENOENT;
6603 goto out;
Chris Masonedbd8d42007-12-21 16:27:24 -05006604 }
6605 ret = 0;
6606out:
Zheng Yan1a40e232008-09-26 10:09:34 -04006607 btrfs_free_path(path);
6608 if (ret) {
6609 if (exts != *extents)
6610 kfree(exts);
6611 } else {
6612 *extents = exts;
6613 *nr_extents = nr;
6614 }
6615 return ret;
6616}
6617
Chris Masond3977122009-01-05 21:25:51 -05006618static noinline int replace_one_extent(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04006619 struct btrfs_root *root,
6620 struct btrfs_path *path,
6621 struct btrfs_key *extent_key,
6622 struct btrfs_key *leaf_key,
6623 struct btrfs_ref_path *ref_path,
6624 struct disk_extent *new_extents,
6625 int nr_extents)
6626{
6627 struct extent_buffer *leaf;
6628 struct btrfs_file_extent_item *fi;
6629 struct inode *inode = NULL;
6630 struct btrfs_key key;
6631 u64 lock_start = 0;
6632 u64 lock_end = 0;
6633 u64 num_bytes;
6634 u64 ext_offset;
Yan Zheng86288a12009-01-21 10:49:16 -05006635 u64 search_end = (u64)-1;
Zheng Yan1a40e232008-09-26 10:09:34 -04006636 u32 nritems;
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006637 int nr_scaned = 0;
Zheng Yan1a40e232008-09-26 10:09:34 -04006638 int extent_locked = 0;
Yan Zhengd899e052008-10-30 14:25:28 -04006639 int extent_type;
Zheng Yan1a40e232008-09-26 10:09:34 -04006640 int ret;
6641
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006642 memcpy(&key, leaf_key, sizeof(key));
Zheng Yan1a40e232008-09-26 10:09:34 -04006643 if (ref_path->owner_objectid != BTRFS_MULTIPLE_OBJECTIDS) {
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006644 if (key.objectid < ref_path->owner_objectid ||
6645 (key.objectid == ref_path->owner_objectid &&
6646 key.type < BTRFS_EXTENT_DATA_KEY)) {
6647 key.objectid = ref_path->owner_objectid;
6648 key.type = BTRFS_EXTENT_DATA_KEY;
6649 key.offset = 0;
6650 }
Zheng Yan1a40e232008-09-26 10:09:34 -04006651 }
6652
6653 while (1) {
6654 ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
6655 if (ret < 0)
6656 goto out;
6657
6658 leaf = path->nodes[0];
6659 nritems = btrfs_header_nritems(leaf);
6660next:
6661 if (extent_locked && ret > 0) {
6662 /*
6663 * the file extent item was modified by someone
6664 * before the extent got locked.
6665 */
Zheng Yan1a40e232008-09-26 10:09:34 -04006666 unlock_extent(&BTRFS_I(inode)->io_tree, lock_start,
6667 lock_end, GFP_NOFS);
6668 extent_locked = 0;
6669 }
6670
6671 if (path->slots[0] >= nritems) {
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006672 if (++nr_scaned > 2)
Zheng Yan1a40e232008-09-26 10:09:34 -04006673 break;
6674
6675 BUG_ON(extent_locked);
6676 ret = btrfs_next_leaf(root, path);
6677 if (ret < 0)
6678 goto out;
6679 if (ret > 0)
6680 break;
6681 leaf = path->nodes[0];
6682 nritems = btrfs_header_nritems(leaf);
6683 }
6684
6685 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
6686
6687 if (ref_path->owner_objectid != BTRFS_MULTIPLE_OBJECTIDS) {
6688 if ((key.objectid > ref_path->owner_objectid) ||
6689 (key.objectid == ref_path->owner_objectid &&
6690 key.type > BTRFS_EXTENT_DATA_KEY) ||
Yan Zheng86288a12009-01-21 10:49:16 -05006691 key.offset >= search_end)
Zheng Yan1a40e232008-09-26 10:09:34 -04006692 break;
6693 }
6694
6695 if (inode && key.objectid != inode->i_ino) {
6696 BUG_ON(extent_locked);
6697 btrfs_release_path(root, path);
6698 mutex_unlock(&inode->i_mutex);
6699 iput(inode);
6700 inode = NULL;
6701 continue;
6702 }
6703
6704 if (key.type != BTRFS_EXTENT_DATA_KEY) {
6705 path->slots[0]++;
6706 ret = 1;
6707 goto next;
6708 }
6709 fi = btrfs_item_ptr(leaf, path->slots[0],
6710 struct btrfs_file_extent_item);
Yan Zhengd899e052008-10-30 14:25:28 -04006711 extent_type = btrfs_file_extent_type(leaf, fi);
6712 if ((extent_type != BTRFS_FILE_EXTENT_REG &&
6713 extent_type != BTRFS_FILE_EXTENT_PREALLOC) ||
Zheng Yan1a40e232008-09-26 10:09:34 -04006714 (btrfs_file_extent_disk_bytenr(leaf, fi) !=
6715 extent_key->objectid)) {
6716 path->slots[0]++;
6717 ret = 1;
6718 goto next;
6719 }
6720
6721 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
6722 ext_offset = btrfs_file_extent_offset(leaf, fi);
6723
Yan Zheng86288a12009-01-21 10:49:16 -05006724 if (search_end == (u64)-1) {
6725 search_end = key.offset - ext_offset +
6726 btrfs_file_extent_ram_bytes(leaf, fi);
6727 }
Zheng Yan1a40e232008-09-26 10:09:34 -04006728
6729 if (!extent_locked) {
6730 lock_start = key.offset;
6731 lock_end = lock_start + num_bytes - 1;
6732 } else {
Yan Zheng66435582008-10-30 14:19:50 -04006733 if (lock_start > key.offset ||
6734 lock_end + 1 < key.offset + num_bytes) {
6735 unlock_extent(&BTRFS_I(inode)->io_tree,
6736 lock_start, lock_end, GFP_NOFS);
6737 extent_locked = 0;
6738 }
Zheng Yan1a40e232008-09-26 10:09:34 -04006739 }
6740
6741 if (!inode) {
6742 btrfs_release_path(root, path);
6743
6744 inode = btrfs_iget_locked(root->fs_info->sb,
6745 key.objectid, root);
6746 if (inode->i_state & I_NEW) {
6747 BTRFS_I(inode)->root = root;
6748 BTRFS_I(inode)->location.objectid =
6749 key.objectid;
6750 BTRFS_I(inode)->location.type =
6751 BTRFS_INODE_ITEM_KEY;
6752 BTRFS_I(inode)->location.offset = 0;
6753 btrfs_read_locked_inode(inode);
6754 unlock_new_inode(inode);
6755 }
6756 /*
6757 * some code call btrfs_commit_transaction while
6758 * holding the i_mutex, so we can't use mutex_lock
6759 * here.
6760 */
6761 if (is_bad_inode(inode) ||
6762 !mutex_trylock(&inode->i_mutex)) {
6763 iput(inode);
6764 inode = NULL;
6765 key.offset = (u64)-1;
6766 goto skip;
6767 }
6768 }
6769
6770 if (!extent_locked) {
6771 struct btrfs_ordered_extent *ordered;
6772
6773 btrfs_release_path(root, path);
6774
6775 lock_extent(&BTRFS_I(inode)->io_tree, lock_start,
6776 lock_end, GFP_NOFS);
6777 ordered = btrfs_lookup_first_ordered_extent(inode,
6778 lock_end);
6779 if (ordered &&
6780 ordered->file_offset <= lock_end &&
6781 ordered->file_offset + ordered->len > lock_start) {
6782 unlock_extent(&BTRFS_I(inode)->io_tree,
6783 lock_start, lock_end, GFP_NOFS);
6784 btrfs_start_ordered_extent(inode, ordered, 1);
6785 btrfs_put_ordered_extent(ordered);
6786 key.offset += num_bytes;
6787 goto skip;
6788 }
6789 if (ordered)
6790 btrfs_put_ordered_extent(ordered);
6791
Zheng Yan1a40e232008-09-26 10:09:34 -04006792 extent_locked = 1;
6793 continue;
6794 }
6795
6796 if (nr_extents == 1) {
6797 /* update extent pointer in place */
Zheng Yan1a40e232008-09-26 10:09:34 -04006798 btrfs_set_file_extent_disk_bytenr(leaf, fi,
6799 new_extents[0].disk_bytenr);
6800 btrfs_set_file_extent_disk_num_bytes(leaf, fi,
6801 new_extents[0].disk_num_bytes);
Zheng Yan1a40e232008-09-26 10:09:34 -04006802 btrfs_mark_buffer_dirty(leaf);
6803
6804 btrfs_drop_extent_cache(inode, key.offset,
6805 key.offset + num_bytes - 1, 0);
6806
6807 ret = btrfs_inc_extent_ref(trans, root,
6808 new_extents[0].disk_bytenr,
6809 new_extents[0].disk_num_bytes,
6810 leaf->start,
6811 root->root_key.objectid,
6812 trans->transid,
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006813 key.objectid);
Zheng Yan1a40e232008-09-26 10:09:34 -04006814 BUG_ON(ret);
6815
6816 ret = btrfs_free_extent(trans, root,
6817 extent_key->objectid,
6818 extent_key->offset,
6819 leaf->start,
6820 btrfs_header_owner(leaf),
6821 btrfs_header_generation(leaf),
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006822 key.objectid, 0);
Zheng Yan1a40e232008-09-26 10:09:34 -04006823 BUG_ON(ret);
6824
6825 btrfs_release_path(root, path);
6826 key.offset += num_bytes;
6827 } else {
Yan Zhengd899e052008-10-30 14:25:28 -04006828 BUG_ON(1);
6829#if 0
Zheng Yan1a40e232008-09-26 10:09:34 -04006830 u64 alloc_hint;
6831 u64 extent_len;
6832 int i;
6833 /*
6834 * drop old extent pointer at first, then insert the
6835 * new pointers one bye one
6836 */
6837 btrfs_release_path(root, path);
6838 ret = btrfs_drop_extents(trans, root, inode, key.offset,
6839 key.offset + num_bytes,
6840 key.offset, &alloc_hint);
6841 BUG_ON(ret);
6842
6843 for (i = 0; i < nr_extents; i++) {
6844 if (ext_offset >= new_extents[i].num_bytes) {
6845 ext_offset -= new_extents[i].num_bytes;
6846 continue;
6847 }
6848 extent_len = min(new_extents[i].num_bytes -
6849 ext_offset, num_bytes);
6850
6851 ret = btrfs_insert_empty_item(trans, root,
6852 path, &key,
6853 sizeof(*fi));
6854 BUG_ON(ret);
6855
6856 leaf = path->nodes[0];
6857 fi = btrfs_item_ptr(leaf, path->slots[0],
6858 struct btrfs_file_extent_item);
6859 btrfs_set_file_extent_generation(leaf, fi,
6860 trans->transid);
6861 btrfs_set_file_extent_type(leaf, fi,
6862 BTRFS_FILE_EXTENT_REG);
6863 btrfs_set_file_extent_disk_bytenr(leaf, fi,
6864 new_extents[i].disk_bytenr);
6865 btrfs_set_file_extent_disk_num_bytes(leaf, fi,
6866 new_extents[i].disk_num_bytes);
Chris Masonc8b97812008-10-29 14:49:59 -04006867 btrfs_set_file_extent_ram_bytes(leaf, fi,
6868 new_extents[i].ram_bytes);
6869
6870 btrfs_set_file_extent_compression(leaf, fi,
6871 new_extents[i].compression);
6872 btrfs_set_file_extent_encryption(leaf, fi,
6873 new_extents[i].encryption);
6874 btrfs_set_file_extent_other_encoding(leaf, fi,
6875 new_extents[i].other_encoding);
6876
Zheng Yan1a40e232008-09-26 10:09:34 -04006877 btrfs_set_file_extent_num_bytes(leaf, fi,
6878 extent_len);
6879 ext_offset += new_extents[i].offset;
6880 btrfs_set_file_extent_offset(leaf, fi,
6881 ext_offset);
6882 btrfs_mark_buffer_dirty(leaf);
6883
6884 btrfs_drop_extent_cache(inode, key.offset,
6885 key.offset + extent_len - 1, 0);
6886
6887 ret = btrfs_inc_extent_ref(trans, root,
6888 new_extents[i].disk_bytenr,
6889 new_extents[i].disk_num_bytes,
6890 leaf->start,
6891 root->root_key.objectid,
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04006892 trans->transid, key.objectid);
Zheng Yan1a40e232008-09-26 10:09:34 -04006893 BUG_ON(ret);
6894 btrfs_release_path(root, path);
6895
Yan Zhenga76a3cd2008-10-09 11:46:29 -04006896 inode_add_bytes(inode, extent_len);
Zheng Yan1a40e232008-09-26 10:09:34 -04006897
6898 ext_offset = 0;
6899 num_bytes -= extent_len;
6900 key.offset += extent_len;
6901
6902 if (num_bytes == 0)
6903 break;
6904 }
6905 BUG_ON(i >= nr_extents);
Yan Zhengd899e052008-10-30 14:25:28 -04006906#endif
Zheng Yan1a40e232008-09-26 10:09:34 -04006907 }
6908
6909 if (extent_locked) {
Zheng Yan1a40e232008-09-26 10:09:34 -04006910 unlock_extent(&BTRFS_I(inode)->io_tree, lock_start,
6911 lock_end, GFP_NOFS);
6912 extent_locked = 0;
6913 }
6914skip:
6915 if (ref_path->owner_objectid != BTRFS_MULTIPLE_OBJECTIDS &&
Yan Zheng86288a12009-01-21 10:49:16 -05006916 key.offset >= search_end)
Zheng Yan1a40e232008-09-26 10:09:34 -04006917 break;
6918
6919 cond_resched();
6920 }
6921 ret = 0;
6922out:
6923 btrfs_release_path(root, path);
6924 if (inode) {
6925 mutex_unlock(&inode->i_mutex);
6926 if (extent_locked) {
Zheng Yan1a40e232008-09-26 10:09:34 -04006927 unlock_extent(&BTRFS_I(inode)->io_tree, lock_start,
6928 lock_end, GFP_NOFS);
6929 }
6930 iput(inode);
6931 }
6932 return ret;
6933}
6934
Zheng Yan1a40e232008-09-26 10:09:34 -04006935int btrfs_reloc_tree_cache_ref(struct btrfs_trans_handle *trans,
6936 struct btrfs_root *root,
6937 struct extent_buffer *buf, u64 orig_start)
6938{
6939 int level;
6940 int ret;
6941
6942 BUG_ON(btrfs_header_generation(buf) != trans->transid);
6943 BUG_ON(root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID);
6944
6945 level = btrfs_header_level(buf);
6946 if (level == 0) {
6947 struct btrfs_leaf_ref *ref;
6948 struct btrfs_leaf_ref *orig_ref;
6949
6950 orig_ref = btrfs_lookup_leaf_ref(root, orig_start);
6951 if (!orig_ref)
6952 return -ENOENT;
6953
6954 ref = btrfs_alloc_leaf_ref(root, orig_ref->nritems);
6955 if (!ref) {
6956 btrfs_free_leaf_ref(root, orig_ref);
6957 return -ENOMEM;
6958 }
6959
6960 ref->nritems = orig_ref->nritems;
6961 memcpy(ref->extents, orig_ref->extents,
6962 sizeof(ref->extents[0]) * ref->nritems);
6963
6964 btrfs_free_leaf_ref(root, orig_ref);
6965
6966 ref->root_gen = trans->transid;
6967 ref->bytenr = buf->start;
6968 ref->owner = btrfs_header_owner(buf);
6969 ref->generation = btrfs_header_generation(buf);
Chris Masonbd56b302009-02-04 09:27:02 -05006970
Zheng Yan1a40e232008-09-26 10:09:34 -04006971 ret = btrfs_add_leaf_ref(root, ref, 0);
6972 WARN_ON(ret);
6973 btrfs_free_leaf_ref(root, ref);
6974 }
6975 return 0;
6976}
6977
Chris Masond3977122009-01-05 21:25:51 -05006978static noinline int invalidate_extent_cache(struct btrfs_root *root,
Zheng Yan1a40e232008-09-26 10:09:34 -04006979 struct extent_buffer *leaf,
6980 struct btrfs_block_group_cache *group,
6981 struct btrfs_root *target_root)
6982{
6983 struct btrfs_key key;
6984 struct inode *inode = NULL;
6985 struct btrfs_file_extent_item *fi;
Josef Bacik2ac55d42010-02-03 19:33:23 +00006986 struct extent_state *cached_state = NULL;
Zheng Yan1a40e232008-09-26 10:09:34 -04006987 u64 num_bytes;
6988 u64 skip_objectid = 0;
6989 u32 nritems;
6990 u32 i;
6991
6992 nritems = btrfs_header_nritems(leaf);
6993 for (i = 0; i < nritems; i++) {
6994 btrfs_item_key_to_cpu(leaf, &key, i);
6995 if (key.objectid == skip_objectid ||
6996 key.type != BTRFS_EXTENT_DATA_KEY)
6997 continue;
6998 fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
6999 if (btrfs_file_extent_type(leaf, fi) ==
7000 BTRFS_FILE_EXTENT_INLINE)
7001 continue;
7002 if (btrfs_file_extent_disk_bytenr(leaf, fi) == 0)
7003 continue;
7004 if (!inode || inode->i_ino != key.objectid) {
7005 iput(inode);
7006 inode = btrfs_ilookup(target_root->fs_info->sb,
7007 key.objectid, target_root, 1);
7008 }
7009 if (!inode) {
7010 skip_objectid = key.objectid;
7011 continue;
7012 }
7013 num_bytes = btrfs_file_extent_num_bytes(leaf, fi);
7014
Josef Bacik2ac55d42010-02-03 19:33:23 +00007015 lock_extent_bits(&BTRFS_I(inode)->io_tree, key.offset,
7016 key.offset + num_bytes - 1, 0, &cached_state,
7017 GFP_NOFS);
Zheng Yan1a40e232008-09-26 10:09:34 -04007018 btrfs_drop_extent_cache(inode, key.offset,
7019 key.offset + num_bytes - 1, 1);
Josef Bacik2ac55d42010-02-03 19:33:23 +00007020 unlock_extent_cached(&BTRFS_I(inode)->io_tree, key.offset,
7021 key.offset + num_bytes - 1, &cached_state,
7022 GFP_NOFS);
Zheng Yan1a40e232008-09-26 10:09:34 -04007023 cond_resched();
7024 }
7025 iput(inode);
7026 return 0;
7027}
7028
Chris Masond3977122009-01-05 21:25:51 -05007029static noinline int replace_extents_in_leaf(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007030 struct btrfs_root *root,
7031 struct extent_buffer *leaf,
7032 struct btrfs_block_group_cache *group,
7033 struct inode *reloc_inode)
7034{
7035 struct btrfs_key key;
7036 struct btrfs_key extent_key;
7037 struct btrfs_file_extent_item *fi;
7038 struct btrfs_leaf_ref *ref;
7039 struct disk_extent *new_extent;
7040 u64 bytenr;
7041 u64 num_bytes;
7042 u32 nritems;
7043 u32 i;
7044 int ext_index;
7045 int nr_extent;
7046 int ret;
7047
7048 new_extent = kmalloc(sizeof(*new_extent), GFP_NOFS);
7049 BUG_ON(!new_extent);
7050
7051 ref = btrfs_lookup_leaf_ref(root, leaf->start);
7052 BUG_ON(!ref);
7053
7054 ext_index = -1;
7055 nritems = btrfs_header_nritems(leaf);
7056 for (i = 0; i < nritems; i++) {
7057 btrfs_item_key_to_cpu(leaf, &key, i);
7058 if (btrfs_key_type(&key) != BTRFS_EXTENT_DATA_KEY)
7059 continue;
7060 fi = btrfs_item_ptr(leaf, i, struct btrfs_file_extent_item);
7061 if (btrfs_file_extent_type(leaf, fi) ==
7062 BTRFS_FILE_EXTENT_INLINE)
7063 continue;
7064 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
7065 num_bytes = btrfs_file_extent_disk_num_bytes(leaf, fi);
7066 if (bytenr == 0)
7067 continue;
7068
7069 ext_index++;
7070 if (bytenr >= group->key.objectid + group->key.offset ||
7071 bytenr + num_bytes <= group->key.objectid)
7072 continue;
7073
7074 extent_key.objectid = bytenr;
7075 extent_key.offset = num_bytes;
7076 extent_key.type = BTRFS_EXTENT_ITEM_KEY;
7077 nr_extent = 1;
7078 ret = get_new_locations(reloc_inode, &extent_key,
7079 group->key.objectid, 1,
7080 &new_extent, &nr_extent);
7081 if (ret > 0)
7082 continue;
7083 BUG_ON(ret < 0);
7084
7085 BUG_ON(ref->extents[ext_index].bytenr != bytenr);
7086 BUG_ON(ref->extents[ext_index].num_bytes != num_bytes);
7087 ref->extents[ext_index].bytenr = new_extent->disk_bytenr;
7088 ref->extents[ext_index].num_bytes = new_extent->disk_num_bytes;
7089
Zheng Yan1a40e232008-09-26 10:09:34 -04007090 btrfs_set_file_extent_disk_bytenr(leaf, fi,
7091 new_extent->disk_bytenr);
7092 btrfs_set_file_extent_disk_num_bytes(leaf, fi,
7093 new_extent->disk_num_bytes);
Zheng Yan1a40e232008-09-26 10:09:34 -04007094 btrfs_mark_buffer_dirty(leaf);
7095
7096 ret = btrfs_inc_extent_ref(trans, root,
7097 new_extent->disk_bytenr,
7098 new_extent->disk_num_bytes,
7099 leaf->start,
7100 root->root_key.objectid,
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04007101 trans->transid, key.objectid);
Zheng Yan1a40e232008-09-26 10:09:34 -04007102 BUG_ON(ret);
Chris Mason56bec292009-03-13 10:10:06 -04007103
Zheng Yan1a40e232008-09-26 10:09:34 -04007104 ret = btrfs_free_extent(trans, root,
7105 bytenr, num_bytes, leaf->start,
7106 btrfs_header_owner(leaf),
7107 btrfs_header_generation(leaf),
Yan Zheng3bb1a1b2008-10-09 11:46:24 -04007108 key.objectid, 0);
Zheng Yan1a40e232008-09-26 10:09:34 -04007109 BUG_ON(ret);
7110 cond_resched();
7111 }
7112 kfree(new_extent);
7113 BUG_ON(ext_index + 1 != ref->nritems);
7114 btrfs_free_leaf_ref(root, ref);
7115 return 0;
7116}
7117
Yan Zhengf82d02d2008-10-29 14:49:05 -04007118int btrfs_free_reloc_root(struct btrfs_trans_handle *trans,
7119 struct btrfs_root *root)
Zheng Yan1a40e232008-09-26 10:09:34 -04007120{
7121 struct btrfs_root *reloc_root;
Yan Zhengf82d02d2008-10-29 14:49:05 -04007122 int ret;
Zheng Yan1a40e232008-09-26 10:09:34 -04007123
7124 if (root->reloc_root) {
7125 reloc_root = root->reloc_root;
7126 root->reloc_root = NULL;
7127 list_add(&reloc_root->dead_list,
7128 &root->fs_info->dead_reloc_roots);
Yan Zhengf82d02d2008-10-29 14:49:05 -04007129
7130 btrfs_set_root_bytenr(&reloc_root->root_item,
7131 reloc_root->node->start);
7132 btrfs_set_root_level(&root->root_item,
7133 btrfs_header_level(reloc_root->node));
7134 memset(&reloc_root->root_item.drop_progress, 0,
7135 sizeof(struct btrfs_disk_key));
7136 reloc_root->root_item.drop_level = 0;
7137
7138 ret = btrfs_update_root(trans, root->fs_info->tree_root,
7139 &reloc_root->root_key,
7140 &reloc_root->root_item);
7141 BUG_ON(ret);
Zheng Yan1a40e232008-09-26 10:09:34 -04007142 }
7143 return 0;
7144}
7145
7146int btrfs_drop_dead_reloc_roots(struct btrfs_root *root)
7147{
7148 struct btrfs_trans_handle *trans;
7149 struct btrfs_root *reloc_root;
7150 struct btrfs_root *prev_root = NULL;
7151 struct list_head dead_roots;
7152 int ret;
7153 unsigned long nr;
7154
7155 INIT_LIST_HEAD(&dead_roots);
7156 list_splice_init(&root->fs_info->dead_reloc_roots, &dead_roots);
7157
7158 while (!list_empty(&dead_roots)) {
7159 reloc_root = list_entry(dead_roots.prev,
7160 struct btrfs_root, dead_list);
7161 list_del_init(&reloc_root->dead_list);
7162
7163 BUG_ON(reloc_root->commit_root != NULL);
7164 while (1) {
7165 trans = btrfs_join_transaction(root, 1);
7166 BUG_ON(!trans);
7167
7168 mutex_lock(&root->fs_info->drop_mutex);
7169 ret = btrfs_drop_snapshot(trans, reloc_root);
7170 if (ret != -EAGAIN)
7171 break;
7172 mutex_unlock(&root->fs_info->drop_mutex);
7173
7174 nr = trans->blocks_used;
7175 ret = btrfs_end_transaction(trans, root);
7176 BUG_ON(ret);
7177 btrfs_btree_balance_dirty(root, nr);
7178 }
7179
7180 free_extent_buffer(reloc_root->node);
7181
7182 ret = btrfs_del_root(trans, root->fs_info->tree_root,
7183 &reloc_root->root_key);
7184 BUG_ON(ret);
7185 mutex_unlock(&root->fs_info->drop_mutex);
7186
7187 nr = trans->blocks_used;
7188 ret = btrfs_end_transaction(trans, root);
7189 BUG_ON(ret);
7190 btrfs_btree_balance_dirty(root, nr);
7191
7192 kfree(prev_root);
7193 prev_root = reloc_root;
7194 }
7195 if (prev_root) {
7196 btrfs_remove_leaf_refs(prev_root, (u64)-1, 0);
7197 kfree(prev_root);
7198 }
7199 return 0;
7200}
7201
7202int btrfs_add_dead_reloc_root(struct btrfs_root *root)
7203{
7204 list_add(&root->dead_list, &root->fs_info->dead_reloc_roots);
7205 return 0;
7206}
7207
7208int btrfs_cleanup_reloc_trees(struct btrfs_root *root)
7209{
7210 struct btrfs_root *reloc_root;
7211 struct btrfs_trans_handle *trans;
7212 struct btrfs_key location;
7213 int found;
7214 int ret;
7215
7216 mutex_lock(&root->fs_info->tree_reloc_mutex);
7217 ret = btrfs_find_dead_roots(root, BTRFS_TREE_RELOC_OBJECTID, NULL);
7218 BUG_ON(ret);
7219 found = !list_empty(&root->fs_info->dead_reloc_roots);
7220 mutex_unlock(&root->fs_info->tree_reloc_mutex);
7221
7222 if (found) {
7223 trans = btrfs_start_transaction(root, 1);
7224 BUG_ON(!trans);
7225 ret = btrfs_commit_transaction(trans, root);
7226 BUG_ON(ret);
7227 }
7228
7229 location.objectid = BTRFS_DATA_RELOC_TREE_OBJECTID;
7230 location.offset = (u64)-1;
7231 location.type = BTRFS_ROOT_ITEM_KEY;
7232
7233 reloc_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
7234 BUG_ON(!reloc_root);
7235 btrfs_orphan_cleanup(reloc_root);
7236 return 0;
7237}
7238
Chris Masond3977122009-01-05 21:25:51 -05007239static noinline int init_reloc_tree(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007240 struct btrfs_root *root)
7241{
7242 struct btrfs_root *reloc_root;
7243 struct extent_buffer *eb;
7244 struct btrfs_root_item *root_item;
7245 struct btrfs_key root_key;
7246 int ret;
7247
7248 BUG_ON(!root->ref_cows);
7249 if (root->reloc_root)
7250 return 0;
7251
7252 root_item = kmalloc(sizeof(*root_item), GFP_NOFS);
7253 BUG_ON(!root_item);
7254
7255 ret = btrfs_copy_root(trans, root, root->commit_root,
7256 &eb, BTRFS_TREE_RELOC_OBJECTID);
7257 BUG_ON(ret);
7258
7259 root_key.objectid = BTRFS_TREE_RELOC_OBJECTID;
7260 root_key.offset = root->root_key.objectid;
7261 root_key.type = BTRFS_ROOT_ITEM_KEY;
7262
7263 memcpy(root_item, &root->root_item, sizeof(root_item));
7264 btrfs_set_root_refs(root_item, 0);
7265 btrfs_set_root_bytenr(root_item, eb->start);
7266 btrfs_set_root_level(root_item, btrfs_header_level(eb));
Yan Zheng84234f32008-10-29 14:49:05 -04007267 btrfs_set_root_generation(root_item, trans->transid);
Zheng Yan1a40e232008-09-26 10:09:34 -04007268
7269 btrfs_tree_unlock(eb);
7270 free_extent_buffer(eb);
7271
7272 ret = btrfs_insert_root(trans, root->fs_info->tree_root,
7273 &root_key, root_item);
7274 BUG_ON(ret);
7275 kfree(root_item);
7276
7277 reloc_root = btrfs_read_fs_root_no_radix(root->fs_info->tree_root,
7278 &root_key);
7279 BUG_ON(!reloc_root);
7280 reloc_root->last_trans = trans->transid;
7281 reloc_root->commit_root = NULL;
7282 reloc_root->ref_tree = &root->fs_info->reloc_ref_tree;
7283
7284 root->reloc_root = reloc_root;
7285 return 0;
7286}
7287
7288/*
7289 * Core function of space balance.
7290 *
7291 * The idea is using reloc trees to relocate tree blocks in reference
Yan Zhengf82d02d2008-10-29 14:49:05 -04007292 * counted roots. There is one reloc tree for each subvol, and all
7293 * reloc trees share same root key objectid. Reloc trees are snapshots
7294 * of the latest committed roots of subvols (root->commit_root).
7295 *
7296 * To relocate a tree block referenced by a subvol, there are two steps.
7297 * COW the block through subvol's reloc tree, then update block pointer
7298 * in the subvol to point to the new block. Since all reloc trees share
7299 * same root key objectid, doing special handing for tree blocks owned
7300 * by them is easy. Once a tree block has been COWed in one reloc tree,
7301 * we can use the resulting new block directly when the same block is
7302 * required to COW again through other reloc trees. By this way, relocated
7303 * tree blocks are shared between reloc trees, so they are also shared
7304 * between subvols.
Zheng Yan1a40e232008-09-26 10:09:34 -04007305 */
Chris Masond3977122009-01-05 21:25:51 -05007306static noinline int relocate_one_path(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007307 struct btrfs_root *root,
7308 struct btrfs_path *path,
7309 struct btrfs_key *first_key,
7310 struct btrfs_ref_path *ref_path,
7311 struct btrfs_block_group_cache *group,
7312 struct inode *reloc_inode)
7313{
7314 struct btrfs_root *reloc_root;
7315 struct extent_buffer *eb = NULL;
7316 struct btrfs_key *keys;
7317 u64 *nodes;
7318 int level;
Yan Zhengf82d02d2008-10-29 14:49:05 -04007319 int shared_level;
Zheng Yan1a40e232008-09-26 10:09:34 -04007320 int lowest_level = 0;
Zheng Yan1a40e232008-09-26 10:09:34 -04007321 int ret;
7322
7323 if (ref_path->owner_objectid < BTRFS_FIRST_FREE_OBJECTID)
7324 lowest_level = ref_path->owner_objectid;
7325
Yan Zhengf82d02d2008-10-29 14:49:05 -04007326 if (!root->ref_cows) {
Zheng Yan1a40e232008-09-26 10:09:34 -04007327 path->lowest_level = lowest_level;
7328 ret = btrfs_search_slot(trans, root, first_key, path, 0, 1);
7329 BUG_ON(ret < 0);
7330 path->lowest_level = 0;
7331 btrfs_release_path(root, path);
7332 return 0;
7333 }
7334
Zheng Yan1a40e232008-09-26 10:09:34 -04007335 mutex_lock(&root->fs_info->tree_reloc_mutex);
7336 ret = init_reloc_tree(trans, root);
7337 BUG_ON(ret);
7338 reloc_root = root->reloc_root;
7339
Yan Zhengf82d02d2008-10-29 14:49:05 -04007340 shared_level = ref_path->shared_level;
7341 ref_path->shared_level = BTRFS_MAX_LEVEL - 1;
Zheng Yan1a40e232008-09-26 10:09:34 -04007342
Yan Zhengf82d02d2008-10-29 14:49:05 -04007343 keys = ref_path->node_keys;
7344 nodes = ref_path->new_nodes;
7345 memset(&keys[shared_level + 1], 0,
7346 sizeof(*keys) * (BTRFS_MAX_LEVEL - shared_level - 1));
7347 memset(&nodes[shared_level + 1], 0,
7348 sizeof(*nodes) * (BTRFS_MAX_LEVEL - shared_level - 1));
Zheng Yan1a40e232008-09-26 10:09:34 -04007349
Yan Zhengf82d02d2008-10-29 14:49:05 -04007350 if (nodes[lowest_level] == 0) {
7351 path->lowest_level = lowest_level;
7352 ret = btrfs_search_slot(trans, reloc_root, first_key, path,
7353 0, 1);
7354 BUG_ON(ret);
7355 for (level = lowest_level; level < BTRFS_MAX_LEVEL; level++) {
7356 eb = path->nodes[level];
7357 if (!eb || eb == reloc_root->node)
7358 break;
7359 nodes[level] = eb->start;
7360 if (level == 0)
7361 btrfs_item_key_to_cpu(eb, &keys[level], 0);
7362 else
7363 btrfs_node_key_to_cpu(eb, &keys[level], 0);
7364 }
Yan Zheng2b820322008-11-17 21:11:30 -05007365 if (nodes[0] &&
7366 ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
Yan Zhengf82d02d2008-10-29 14:49:05 -04007367 eb = path->nodes[0];
7368 ret = replace_extents_in_leaf(trans, reloc_root, eb,
7369 group, reloc_inode);
7370 BUG_ON(ret);
7371 }
7372 btrfs_release_path(reloc_root, path);
7373 } else {
Zheng Yan1a40e232008-09-26 10:09:34 -04007374 ret = btrfs_merge_path(trans, reloc_root, keys, nodes,
Yan Zhengf82d02d2008-10-29 14:49:05 -04007375 lowest_level);
Zheng Yan1a40e232008-09-26 10:09:34 -04007376 BUG_ON(ret);
7377 }
7378
Zheng Yan1a40e232008-09-26 10:09:34 -04007379 /*
7380 * replace tree blocks in the fs tree with tree blocks in
7381 * the reloc tree.
7382 */
7383 ret = btrfs_merge_path(trans, root, keys, nodes, lowest_level);
7384 BUG_ON(ret < 0);
7385
7386 if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
Yan Zhengf82d02d2008-10-29 14:49:05 -04007387 ret = btrfs_search_slot(trans, reloc_root, first_key, path,
7388 0, 0);
7389 BUG_ON(ret);
7390 extent_buffer_get(path->nodes[0]);
7391 eb = path->nodes[0];
7392 btrfs_release_path(reloc_root, path);
Zheng Yan1a40e232008-09-26 10:09:34 -04007393 ret = invalidate_extent_cache(reloc_root, eb, group, root);
7394 BUG_ON(ret);
7395 free_extent_buffer(eb);
7396 }
Zheng Yan1a40e232008-09-26 10:09:34 -04007397
Yan Zhengf82d02d2008-10-29 14:49:05 -04007398 mutex_unlock(&root->fs_info->tree_reloc_mutex);
Zheng Yan1a40e232008-09-26 10:09:34 -04007399 path->lowest_level = 0;
Zheng Yan1a40e232008-09-26 10:09:34 -04007400 return 0;
7401}
7402
Chris Masond3977122009-01-05 21:25:51 -05007403static noinline int relocate_tree_block(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007404 struct btrfs_root *root,
7405 struct btrfs_path *path,
7406 struct btrfs_key *first_key,
7407 struct btrfs_ref_path *ref_path)
7408{
7409 int ret;
Zheng Yan1a40e232008-09-26 10:09:34 -04007410
7411 ret = relocate_one_path(trans, root, path, first_key,
7412 ref_path, NULL, NULL);
7413 BUG_ON(ret);
7414
Zheng Yan1a40e232008-09-26 10:09:34 -04007415 return 0;
7416}
7417
Chris Masond3977122009-01-05 21:25:51 -05007418static noinline int del_extent_zero(struct btrfs_trans_handle *trans,
Zheng Yan1a40e232008-09-26 10:09:34 -04007419 struct btrfs_root *extent_root,
7420 struct btrfs_path *path,
7421 struct btrfs_key *extent_key)
7422{
7423 int ret;
7424
Zheng Yan1a40e232008-09-26 10:09:34 -04007425 ret = btrfs_search_slot(trans, extent_root, extent_key, path, -1, 1);
7426 if (ret)
7427 goto out;
7428 ret = btrfs_del_item(trans, extent_root, path);
7429out:
Chris Masonedbd8d42007-12-21 16:27:24 -05007430 btrfs_release_path(extent_root, path);
Zheng Yan1a40e232008-09-26 10:09:34 -04007431 return ret;
7432}
7433
Chris Masond3977122009-01-05 21:25:51 -05007434static noinline struct btrfs_root *read_ref_root(struct btrfs_fs_info *fs_info,
Zheng Yan1a40e232008-09-26 10:09:34 -04007435 struct btrfs_ref_path *ref_path)
7436{
7437 struct btrfs_key root_key;
7438
7439 root_key.objectid = ref_path->root_objectid;
7440 root_key.type = BTRFS_ROOT_ITEM_KEY;
7441 if (is_cowonly_root(ref_path->root_objectid))
7442 root_key.offset = 0;
7443 else
7444 root_key.offset = (u64)-1;
7445
7446 return btrfs_read_fs_root_no_name(fs_info, &root_key);
7447}
7448
Chris Masond3977122009-01-05 21:25:51 -05007449static noinline int relocate_one_extent(struct btrfs_root *extent_root,
Zheng Yan1a40e232008-09-26 10:09:34 -04007450 struct btrfs_path *path,
7451 struct btrfs_key *extent_key,
7452 struct btrfs_block_group_cache *group,
7453 struct inode *reloc_inode, int pass)
7454{
7455 struct btrfs_trans_handle *trans;
7456 struct btrfs_root *found_root;
7457 struct btrfs_ref_path *ref_path = NULL;
7458 struct disk_extent *new_extents = NULL;
7459 int nr_extents = 0;
7460 int loops;
7461 int ret;
7462 int level;
7463 struct btrfs_key first_key;
7464 u64 prev_block = 0;
7465
Zheng Yan1a40e232008-09-26 10:09:34 -04007466
7467 trans = btrfs_start_transaction(extent_root, 1);
7468 BUG_ON(!trans);
7469
7470 if (extent_key->objectid == 0) {
7471 ret = del_extent_zero(trans, extent_root, path, extent_key);
7472 goto out;
7473 }
7474
7475 ref_path = kmalloc(sizeof(*ref_path), GFP_NOFS);
7476 if (!ref_path) {
Chris Masond3977122009-01-05 21:25:51 -05007477 ret = -ENOMEM;
7478 goto out;
Zheng Yan1a40e232008-09-26 10:09:34 -04007479 }
7480
7481 for (loops = 0; ; loops++) {
7482 if (loops == 0) {
7483 ret = btrfs_first_ref_path(trans, extent_root, ref_path,
7484 extent_key->objectid);
7485 } else {
7486 ret = btrfs_next_ref_path(trans, extent_root, ref_path);
7487 }
7488 if (ret < 0)
7489 goto out;
7490 if (ret > 0)
7491 break;
7492
7493 if (ref_path->root_objectid == BTRFS_TREE_LOG_OBJECTID ||
7494 ref_path->root_objectid == BTRFS_TREE_RELOC_OBJECTID)
7495 continue;
7496
7497 found_root = read_ref_root(extent_root->fs_info, ref_path);
7498 BUG_ON(!found_root);
7499 /*
7500 * for reference counted tree, only process reference paths
7501 * rooted at the latest committed root.
7502 */
7503 if (found_root->ref_cows &&
7504 ref_path->root_generation != found_root->root_key.offset)
7505 continue;
7506
7507 if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
7508 if (pass == 0) {
7509 /*
7510 * copy data extents to new locations
7511 */
7512 u64 group_start = group->key.objectid;
7513 ret = relocate_data_extent(reloc_inode,
7514 extent_key,
7515 group_start);
7516 if (ret < 0)
7517 goto out;
7518 break;
7519 }
7520 level = 0;
7521 } else {
7522 level = ref_path->owner_objectid;
7523 }
7524
7525 if (prev_block != ref_path->nodes[level]) {
7526 struct extent_buffer *eb;
7527 u64 block_start = ref_path->nodes[level];
7528 u64 block_size = btrfs_level_size(found_root, level);
7529
7530 eb = read_tree_block(found_root, block_start,
7531 block_size, 0);
7532 btrfs_tree_lock(eb);
7533 BUG_ON(level != btrfs_header_level(eb));
7534
7535 if (level == 0)
7536 btrfs_item_key_to_cpu(eb, &first_key, 0);
7537 else
7538 btrfs_node_key_to_cpu(eb, &first_key, 0);
7539
7540 btrfs_tree_unlock(eb);
7541 free_extent_buffer(eb);
7542 prev_block = block_start;
7543 }
7544
Yan Zheng24562422009-02-12 14:14:53 -05007545 mutex_lock(&extent_root->fs_info->trans_mutex);
Yan Zhenge4404d62008-12-12 10:03:26 -05007546 btrfs_record_root_in_trans(found_root);
Yan Zheng24562422009-02-12 14:14:53 -05007547 mutex_unlock(&extent_root->fs_info->trans_mutex);
Yan Zhenge4404d62008-12-12 10:03:26 -05007548 if (ref_path->owner_objectid >= BTRFS_FIRST_FREE_OBJECTID) {
7549 /*
7550 * try to update data extent references while
7551 * keeping metadata shared between snapshots.
7552 */
7553 if (pass == 1) {
7554 ret = relocate_one_path(trans, found_root,
7555 path, &first_key, ref_path,
7556 group, reloc_inode);
7557 if (ret < 0)
7558 goto out;
7559 continue;
7560 }
Zheng Yan1a40e232008-09-26 10:09:34 -04007561 /*
7562 * use fallback method to process the remaining
7563 * references.
7564 */
7565 if (!new_extents) {
7566 u64 group_start = group->key.objectid;
Yan Zhengd899e052008-10-30 14:25:28 -04007567 new_extents = kmalloc(sizeof(*new_extents),
7568 GFP_NOFS);
7569 nr_extents = 1;
Zheng Yan1a40e232008-09-26 10:09:34 -04007570 ret = get_new_locations(reloc_inode,
7571 extent_key,
Yan Zhengd899e052008-10-30 14:25:28 -04007572 group_start, 1,
Zheng Yan1a40e232008-09-26 10:09:34 -04007573 &new_extents,
7574 &nr_extents);
Yan Zhengd899e052008-10-30 14:25:28 -04007575 if (ret)
Zheng Yan1a40e232008-09-26 10:09:34 -04007576 goto out;
7577 }
Zheng Yan1a40e232008-09-26 10:09:34 -04007578 ret = replace_one_extent(trans, found_root,
7579 path, extent_key,
7580 &first_key, ref_path,
7581 new_extents, nr_extents);
Yan Zhenge4404d62008-12-12 10:03:26 -05007582 } else {
Zheng Yan1a40e232008-09-26 10:09:34 -04007583 ret = relocate_tree_block(trans, found_root, path,
7584 &first_key, ref_path);
Zheng Yan1a40e232008-09-26 10:09:34 -04007585 }
7586 if (ret < 0)
7587 goto out;
7588 }
7589 ret = 0;
7590out:
7591 btrfs_end_transaction(trans, extent_root);
7592 kfree(new_extents);
7593 kfree(ref_path);
Chris Masonedbd8d42007-12-21 16:27:24 -05007594 return ret;
7595}
Yan Zheng5d4f98a2009-06-10 10:45:14 -04007596#endif
Chris Masonedbd8d42007-12-21 16:27:24 -05007597
Chris Masonec44a352008-04-28 15:29:52 -04007598static u64 update_block_group_flags(struct btrfs_root *root, u64 flags)
7599{
7600 u64 num_devices;
7601 u64 stripped = BTRFS_BLOCK_GROUP_RAID0 |
7602 BTRFS_BLOCK_GROUP_RAID1 | BTRFS_BLOCK_GROUP_RAID10;
7603
Yan Zheng2b820322008-11-17 21:11:30 -05007604 num_devices = root->fs_info->fs_devices->rw_devices;
Chris Masonec44a352008-04-28 15:29:52 -04007605 if (num_devices == 1) {
7606 stripped |= BTRFS_BLOCK_GROUP_DUP;
7607 stripped = flags & ~stripped;
7608
7609 /* turn raid0 into single device chunks */
7610 if (flags & BTRFS_BLOCK_GROUP_RAID0)
7611 return stripped;
7612
7613 /* turn mirroring into duplication */
7614 if (flags & (BTRFS_BLOCK_GROUP_RAID1 |
7615 BTRFS_BLOCK_GROUP_RAID10))
7616 return stripped | BTRFS_BLOCK_GROUP_DUP;
7617 return flags;
7618 } else {
7619 /* they already had raid on here, just return */
Chris Masonec44a352008-04-28 15:29:52 -04007620 if (flags & stripped)
7621 return flags;
7622
7623 stripped |= BTRFS_BLOCK_GROUP_DUP;
7624 stripped = flags & ~stripped;
7625
7626 /* switch duplicated blocks with raid1 */
7627 if (flags & BTRFS_BLOCK_GROUP_DUP)
7628 return stripped | BTRFS_BLOCK_GROUP_RAID1;
7629
7630 /* turn single device chunks into raid0 */
7631 return stripped | BTRFS_BLOCK_GROUP_RAID0;
7632 }
7633 return flags;
7634}
7635
Yan, Zhengf0486c62010-05-16 10:46:25 -04007636static int set_block_group_ro(struct btrfs_block_group_cache *cache)
Chris Mason0ef3e662008-05-24 14:04:53 -04007637{
Yan, Zhengf0486c62010-05-16 10:46:25 -04007638 struct btrfs_space_info *sinfo = cache->space_info;
7639 u64 num_bytes;
7640 int ret = -ENOSPC;
Chris Mason0ef3e662008-05-24 14:04:53 -04007641
Yan, Zhengf0486c62010-05-16 10:46:25 -04007642 if (cache->ro)
7643 return 0;
Chris Masonc286ac42008-07-22 23:06:41 -04007644
Yan, Zhengf0486c62010-05-16 10:46:25 -04007645 spin_lock(&sinfo->lock);
7646 spin_lock(&cache->lock);
7647 num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7648 cache->bytes_super - btrfs_block_group_used(&cache->item);
Chris Mason7d9eb122008-07-08 14:19:17 -04007649
Yan, Zhengf0486c62010-05-16 10:46:25 -04007650 if (sinfo->bytes_used + sinfo->bytes_reserved + sinfo->bytes_pinned +
7651 sinfo->bytes_may_use + sinfo->bytes_readonly +
7652 cache->reserved_pinned + num_bytes < sinfo->total_bytes) {
7653 sinfo->bytes_readonly += num_bytes;
7654 sinfo->bytes_reserved += cache->reserved_pinned;
7655 cache->reserved_pinned = 0;
7656 cache->ro = 1;
7657 ret = 0;
7658 }
7659 spin_unlock(&cache->lock);
7660 spin_unlock(&sinfo->lock);
7661 return ret;
Chris Mason0ef3e662008-05-24 14:04:53 -04007662}
7663
Yan, Zhengf0486c62010-05-16 10:46:25 -04007664int btrfs_set_block_group_ro(struct btrfs_root *root,
7665 struct btrfs_block_group_cache *cache)
Yan Zheng5d4f98a2009-06-10 10:45:14 -04007666
7667{
Yan, Zhengf0486c62010-05-16 10:46:25 -04007668 struct btrfs_trans_handle *trans;
7669 u64 alloc_flags;
7670 int ret;
7671
7672 BUG_ON(cache->ro);
7673
7674 trans = btrfs_join_transaction(root, 1);
7675 BUG_ON(IS_ERR(trans));
7676
7677 alloc_flags = update_block_group_flags(root, cache->flags);
7678 if (alloc_flags != cache->flags)
7679 do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags, 1);
7680
7681 ret = set_block_group_ro(cache);
7682 if (!ret)
7683 goto out;
7684 alloc_flags = get_alloc_profile(root, cache->space_info->flags);
7685 ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags, 1);
7686 if (ret < 0)
7687 goto out;
7688 ret = set_block_group_ro(cache);
7689out:
7690 btrfs_end_transaction(trans, root);
7691 return ret;
7692}
7693
7694int btrfs_set_block_group_rw(struct btrfs_root *root,
7695 struct btrfs_block_group_cache *cache)
7696{
7697 struct btrfs_space_info *sinfo = cache->space_info;
7698 u64 num_bytes;
7699
7700 BUG_ON(!cache->ro);
7701
7702 spin_lock(&sinfo->lock);
7703 spin_lock(&cache->lock);
7704 num_bytes = cache->key.offset - cache->reserved - cache->pinned -
7705 cache->bytes_super - btrfs_block_group_used(&cache->item);
7706 sinfo->bytes_readonly -= num_bytes;
7707 cache->ro = 0;
7708 spin_unlock(&cache->lock);
7709 spin_unlock(&sinfo->lock);
Yan Zheng5d4f98a2009-06-10 10:45:14 -04007710 return 0;
7711}
7712
Josef Bacikba1bf482009-09-11 16:11:19 -04007713/*
7714 * checks to see if its even possible to relocate this block group.
7715 *
7716 * @return - -1 if it's not a good idea to relocate this block group, 0 if its
7717 * ok to go ahead and try.
7718 */
7719int btrfs_can_relocate(struct btrfs_root *root, u64 bytenr)
Zheng Yan1a40e232008-09-26 10:09:34 -04007720{
Zheng Yan1a40e232008-09-26 10:09:34 -04007721 struct btrfs_block_group_cache *block_group;
Josef Bacikba1bf482009-09-11 16:11:19 -04007722 struct btrfs_space_info *space_info;
7723 struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
7724 struct btrfs_device *device;
7725 int full = 0;
7726 int ret = 0;
Chris Masonedbd8d42007-12-21 16:27:24 -05007727
Josef Bacikba1bf482009-09-11 16:11:19 -04007728 block_group = btrfs_lookup_block_group(root->fs_info, bytenr);
Zheng Yan1a40e232008-09-26 10:09:34 -04007729
Josef Bacikba1bf482009-09-11 16:11:19 -04007730 /* odd, couldn't find the block group, leave it alone */
7731 if (!block_group)
7732 return -1;
Chris Masonedbd8d42007-12-21 16:27:24 -05007733
Josef Bacikba1bf482009-09-11 16:11:19 -04007734 /* no bytes used, we're good */
7735 if (!btrfs_block_group_used(&block_group->item))
7736 goto out;
Chris Mason323da792008-05-09 11:46:48 -04007737
Josef Bacikba1bf482009-09-11 16:11:19 -04007738 space_info = block_group->space_info;
7739 spin_lock(&space_info->lock);
Chris Mason323da792008-05-09 11:46:48 -04007740
Josef Bacikba1bf482009-09-11 16:11:19 -04007741 full = space_info->full;
Zheng Yan1a40e232008-09-26 10:09:34 -04007742
Josef Bacikba1bf482009-09-11 16:11:19 -04007743 /*
7744 * if this is the last block group we have in this space, we can't
Chris Mason7ce618d2009-09-22 14:48:44 -04007745 * relocate it unless we're able to allocate a new chunk below.
7746 *
7747 * Otherwise, we need to make sure we have room in the space to handle
7748 * all of the extents from this block group. If we can, we're good
Josef Bacikba1bf482009-09-11 16:11:19 -04007749 */
Chris Mason7ce618d2009-09-22 14:48:44 -04007750 if ((space_info->total_bytes != block_group->key.offset) &&
7751 (space_info->bytes_used + space_info->bytes_reserved +
Josef Bacikba1bf482009-09-11 16:11:19 -04007752 space_info->bytes_pinned + space_info->bytes_readonly +
7753 btrfs_block_group_used(&block_group->item) <
Chris Mason7ce618d2009-09-22 14:48:44 -04007754 space_info->total_bytes)) {
Josef Bacikba1bf482009-09-11 16:11:19 -04007755 spin_unlock(&space_info->lock);
7756 goto out;
7757 }
7758 spin_unlock(&space_info->lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04007759
Josef Bacikba1bf482009-09-11 16:11:19 -04007760 /*
7761 * ok we don't have enough space, but maybe we have free space on our
7762 * devices to allocate new chunks for relocation, so loop through our
7763 * alloc devices and guess if we have enough space. However, if we
7764 * were marked as full, then we know there aren't enough chunks, and we
7765 * can just return.
7766 */
7767 ret = -1;
7768 if (full)
7769 goto out;
Chris Mason4313b392008-01-03 09:08:48 -05007770
Josef Bacikba1bf482009-09-11 16:11:19 -04007771 mutex_lock(&root->fs_info->chunk_mutex);
7772 list_for_each_entry(device, &fs_devices->alloc_list, dev_alloc_list) {
7773 u64 min_free = btrfs_block_group_used(&block_group->item);
7774 u64 dev_offset, max_avail;
Chris Masonea8c2812008-08-04 23:17:27 -04007775
Josef Bacikba1bf482009-09-11 16:11:19 -04007776 /*
7777 * check to make sure we can actually find a chunk with enough
7778 * space to fit our block group in.
7779 */
7780 if (device->total_bytes > device->bytes_used + min_free) {
7781 ret = find_free_dev_extent(NULL, device, min_free,
7782 &dev_offset, &max_avail);
7783 if (!ret)
Yan73e48b22008-01-03 14:14:39 -05007784 break;
Josef Bacikba1bf482009-09-11 16:11:19 -04007785 ret = -1;
Yan73e48b22008-01-03 14:14:39 -05007786 }
Chris Masonedbd8d42007-12-21 16:27:24 -05007787 }
Josef Bacikba1bf482009-09-11 16:11:19 -04007788 mutex_unlock(&root->fs_info->chunk_mutex);
Chris Masonedbd8d42007-12-21 16:27:24 -05007789out:
Josef Bacikba1bf482009-09-11 16:11:19 -04007790 btrfs_put_block_group(block_group);
Chris Masonedbd8d42007-12-21 16:27:24 -05007791 return ret;
7792}
7793
Christoph Hellwigb2950862008-12-02 09:54:17 -05007794static int find_first_block_group(struct btrfs_root *root,
7795 struct btrfs_path *path, struct btrfs_key *key)
Chris Mason0b86a832008-03-24 15:01:56 -04007796{
Chris Mason925baed2008-06-25 16:01:30 -04007797 int ret = 0;
Chris Mason0b86a832008-03-24 15:01:56 -04007798 struct btrfs_key found_key;
7799 struct extent_buffer *leaf;
7800 int slot;
7801
7802 ret = btrfs_search_slot(NULL, root, key, path, 0, 0);
7803 if (ret < 0)
Chris Mason925baed2008-06-25 16:01:30 -04007804 goto out;
7805
Chris Masond3977122009-01-05 21:25:51 -05007806 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -04007807 slot = path->slots[0];
7808 leaf = path->nodes[0];
7809 if (slot >= btrfs_header_nritems(leaf)) {
7810 ret = btrfs_next_leaf(root, path);
7811 if (ret == 0)
7812 continue;
7813 if (ret < 0)
Chris Mason925baed2008-06-25 16:01:30 -04007814 goto out;
Chris Mason0b86a832008-03-24 15:01:56 -04007815 break;
7816 }
7817 btrfs_item_key_to_cpu(leaf, &found_key, slot);
7818
7819 if (found_key.objectid >= key->objectid &&
Chris Mason925baed2008-06-25 16:01:30 -04007820 found_key.type == BTRFS_BLOCK_GROUP_ITEM_KEY) {
7821 ret = 0;
7822 goto out;
7823 }
Chris Mason0b86a832008-03-24 15:01:56 -04007824 path->slots[0]++;
7825 }
Chris Mason925baed2008-06-25 16:01:30 -04007826out:
Chris Mason0b86a832008-03-24 15:01:56 -04007827 return ret;
7828}
7829
Zheng Yan1a40e232008-09-26 10:09:34 -04007830int btrfs_free_block_groups(struct btrfs_fs_info *info)
7831{
7832 struct btrfs_block_group_cache *block_group;
Chris Mason4184ea72009-03-10 12:39:20 -04007833 struct btrfs_space_info *space_info;
Yan Zheng11833d62009-09-11 16:11:19 -04007834 struct btrfs_caching_control *caching_ctl;
Zheng Yan1a40e232008-09-26 10:09:34 -04007835 struct rb_node *n;
7836
Yan Zheng11833d62009-09-11 16:11:19 -04007837 down_write(&info->extent_commit_sem);
7838 while (!list_empty(&info->caching_block_groups)) {
7839 caching_ctl = list_entry(info->caching_block_groups.next,
7840 struct btrfs_caching_control, list);
7841 list_del(&caching_ctl->list);
7842 put_caching_control(caching_ctl);
7843 }
7844 up_write(&info->extent_commit_sem);
7845
Zheng Yan1a40e232008-09-26 10:09:34 -04007846 spin_lock(&info->block_group_cache_lock);
7847 while ((n = rb_last(&info->block_group_cache_tree)) != NULL) {
7848 block_group = rb_entry(n, struct btrfs_block_group_cache,
7849 cache_node);
Zheng Yan1a40e232008-09-26 10:09:34 -04007850 rb_erase(&block_group->cache_node,
7851 &info->block_group_cache_tree);
Yan Zhengd899e052008-10-30 14:25:28 -04007852 spin_unlock(&info->block_group_cache_lock);
7853
Josef Bacik80eb2342008-10-29 14:49:05 -04007854 down_write(&block_group->space_info->groups_sem);
Zheng Yan1a40e232008-09-26 10:09:34 -04007855 list_del(&block_group->list);
Josef Bacik80eb2342008-10-29 14:49:05 -04007856 up_write(&block_group->space_info->groups_sem);
Yan Zhengd2fb3432008-12-11 16:30:39 -05007857
Josef Bacik817d52f2009-07-13 21:29:25 -04007858 if (block_group->cached == BTRFS_CACHE_STARTED)
Yan Zheng11833d62009-09-11 16:11:19 -04007859 wait_block_group_cache_done(block_group);
Josef Bacik817d52f2009-07-13 21:29:25 -04007860
7861 btrfs_remove_free_space_cache(block_group);
Josef Bacik11dfe352009-11-13 20:12:59 +00007862 btrfs_put_block_group(block_group);
Yan Zhengd899e052008-10-30 14:25:28 -04007863
7864 spin_lock(&info->block_group_cache_lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04007865 }
7866 spin_unlock(&info->block_group_cache_lock);
Chris Mason4184ea72009-03-10 12:39:20 -04007867
7868 /* now that all the block groups are freed, go through and
7869 * free all the space_info structs. This is only called during
7870 * the final stages of unmount, and so we know nobody is
7871 * using them. We call synchronize_rcu() once before we start,
7872 * just to be on the safe side.
7873 */
7874 synchronize_rcu();
7875
Yan, Zheng8929ecfa2010-05-16 10:49:58 -04007876 release_global_block_rsv(info);
7877
Chris Mason4184ea72009-03-10 12:39:20 -04007878 while(!list_empty(&info->space_info)) {
7879 space_info = list_entry(info->space_info.next,
7880 struct btrfs_space_info,
7881 list);
Yan, Zhengf0486c62010-05-16 10:46:25 -04007882 if (space_info->bytes_pinned > 0 ||
7883 space_info->bytes_reserved > 0) {
7884 WARN_ON(1);
7885 dump_space_info(space_info, 0, 0);
7886 }
Chris Mason4184ea72009-03-10 12:39:20 -04007887 list_del(&space_info->list);
7888 kfree(space_info);
7889 }
Zheng Yan1a40e232008-09-26 10:09:34 -04007890 return 0;
7891}
7892
Yan, Zhengb742bb82010-05-16 10:46:24 -04007893static void __link_block_group(struct btrfs_space_info *space_info,
7894 struct btrfs_block_group_cache *cache)
7895{
7896 int index = get_block_group_index(cache);
7897
7898 down_write(&space_info->groups_sem);
7899 list_add_tail(&cache->list, &space_info->block_groups[index]);
7900 up_write(&space_info->groups_sem);
7901}
7902
Chris Mason9078a3e2007-04-26 16:46:15 -04007903int btrfs_read_block_groups(struct btrfs_root *root)
7904{
7905 struct btrfs_path *path;
7906 int ret;
Chris Mason9078a3e2007-04-26 16:46:15 -04007907 struct btrfs_block_group_cache *cache;
Chris Masonbe744172007-05-06 10:15:01 -04007908 struct btrfs_fs_info *info = root->fs_info;
Chris Mason6324fbf2008-03-24 15:01:59 -04007909 struct btrfs_space_info *space_info;
Chris Mason9078a3e2007-04-26 16:46:15 -04007910 struct btrfs_key key;
7911 struct btrfs_key found_key;
Chris Mason5f39d392007-10-15 16:14:19 -04007912 struct extent_buffer *leaf;
Chris Mason96b51792007-10-15 16:15:19 -04007913
Chris Masonbe744172007-05-06 10:15:01 -04007914 root = info->extent_root;
Chris Mason9078a3e2007-04-26 16:46:15 -04007915 key.objectid = 0;
Chris Mason0b86a832008-03-24 15:01:56 -04007916 key.offset = 0;
Chris Mason9078a3e2007-04-26 16:46:15 -04007917 btrfs_set_key_type(&key, BTRFS_BLOCK_GROUP_ITEM_KEY);
Chris Mason9078a3e2007-04-26 16:46:15 -04007918 path = btrfs_alloc_path();
7919 if (!path)
7920 return -ENOMEM;
7921
Chris Masond3977122009-01-05 21:25:51 -05007922 while (1) {
Chris Mason0b86a832008-03-24 15:01:56 -04007923 ret = find_first_block_group(root, path, &key);
Yan, Zhengb742bb82010-05-16 10:46:24 -04007924 if (ret > 0)
7925 break;
Chris Mason0b86a832008-03-24 15:01:56 -04007926 if (ret != 0)
7927 goto error;
7928
Chris Mason5f39d392007-10-15 16:14:19 -04007929 leaf = path->nodes[0];
7930 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
Chris Mason8f18cf12008-04-25 16:53:30 -04007931 cache = kzalloc(sizeof(*cache), GFP_NOFS);
Chris Mason9078a3e2007-04-26 16:46:15 -04007932 if (!cache) {
Chris Mason0b86a832008-03-24 15:01:56 -04007933 ret = -ENOMEM;
Yan, Zhengf0486c62010-05-16 10:46:25 -04007934 goto error;
Chris Mason9078a3e2007-04-26 16:46:15 -04007935 }
Chris Mason3e1ad542007-05-07 20:03:49 -04007936
Yan Zhengd2fb3432008-12-11 16:30:39 -05007937 atomic_set(&cache->count, 1);
Chris Masonc286ac42008-07-22 23:06:41 -04007938 spin_lock_init(&cache->lock);
Josef Bacik6226cb02009-04-03 10:14:18 -04007939 spin_lock_init(&cache->tree_lock);
Josef Bacik817d52f2009-07-13 21:29:25 -04007940 cache->fs_info = info;
Josef Bacik0f9dd462008-09-23 13:14:11 -04007941 INIT_LIST_HEAD(&cache->list);
Chris Masonfa9c0d72009-04-03 09:47:43 -04007942 INIT_LIST_HEAD(&cache->cluster_list);
Josef Bacik96303082009-07-13 21:29:25 -04007943
7944 /*
7945 * we only want to have 32k of ram per block group for keeping
7946 * track of free space, and if we pass 1/2 of that we want to
7947 * start converting things over to using bitmaps
7948 */
7949 cache->extents_thresh = ((1024 * 32) / 2) /
7950 sizeof(struct btrfs_free_space);
7951
Chris Mason5f39d392007-10-15 16:14:19 -04007952 read_extent_buffer(leaf, &cache->item,
7953 btrfs_item_ptr_offset(leaf, path->slots[0]),
7954 sizeof(cache->item));
Chris Mason9078a3e2007-04-26 16:46:15 -04007955 memcpy(&cache->key, &found_key, sizeof(found_key));
Chris Mason0b86a832008-03-24 15:01:56 -04007956
Chris Mason9078a3e2007-04-26 16:46:15 -04007957 key.objectid = found_key.objectid + found_key.offset;
7958 btrfs_release_path(root, path);
Chris Mason0b86a832008-03-24 15:01:56 -04007959 cache->flags = btrfs_block_group_flags(&cache->item);
Josef Bacik817d52f2009-07-13 21:29:25 -04007960 cache->sectorsize = root->sectorsize;
7961
Josef Bacik817d52f2009-07-13 21:29:25 -04007962 /*
7963 * check for two cases, either we are full, and therefore
7964 * don't need to bother with the caching work since we won't
7965 * find any space, or we are empty, and we can just add all
7966 * the space in and be done with it. This saves us _alot_ of
7967 * time, particularly in the full case.
7968 */
7969 if (found_key.offset == btrfs_block_group_used(&cache->item)) {
Josef Bacik1b2da372009-09-11 16:11:20 -04007970 exclude_super_stripes(root, cache);
Yan Zheng11833d62009-09-11 16:11:19 -04007971 cache->last_byte_to_unpin = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -04007972 cache->cached = BTRFS_CACHE_FINISHED;
Josef Bacik1b2da372009-09-11 16:11:20 -04007973 free_excluded_extents(root, cache);
Josef Bacik817d52f2009-07-13 21:29:25 -04007974 } else if (btrfs_block_group_used(&cache->item) == 0) {
Yan Zheng11833d62009-09-11 16:11:19 -04007975 exclude_super_stripes(root, cache);
7976 cache->last_byte_to_unpin = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -04007977 cache->cached = BTRFS_CACHE_FINISHED;
7978 add_new_free_space(cache, root->fs_info,
7979 found_key.objectid,
7980 found_key.objectid +
7981 found_key.offset);
Yan Zheng11833d62009-09-11 16:11:19 -04007982 free_excluded_extents(root, cache);
Josef Bacik817d52f2009-07-13 21:29:25 -04007983 }
Chris Mason96b51792007-10-15 16:15:19 -04007984
Chris Mason6324fbf2008-03-24 15:01:59 -04007985 ret = update_space_info(info, cache->flags, found_key.offset,
7986 btrfs_block_group_used(&cache->item),
7987 &space_info);
7988 BUG_ON(ret);
7989 cache->space_info = space_info;
Josef Bacik1b2da372009-09-11 16:11:20 -04007990 spin_lock(&cache->space_info->lock);
Yan, Zhengf0486c62010-05-16 10:46:25 -04007991 cache->space_info->bytes_readonly += cache->bytes_super;
Josef Bacik1b2da372009-09-11 16:11:20 -04007992 spin_unlock(&cache->space_info->lock);
7993
Yan, Zhengb742bb82010-05-16 10:46:24 -04007994 __link_block_group(space_info, cache);
Chris Mason6324fbf2008-03-24 15:01:59 -04007995
Josef Bacik0f9dd462008-09-23 13:14:11 -04007996 ret = btrfs_add_block_group_cache(root->fs_info, cache);
7997 BUG_ON(ret);
Chris Mason75ccf472008-09-30 19:24:06 -04007998
7999 set_avail_alloc_bits(root->fs_info, cache->flags);
Yan Zheng2b820322008-11-17 21:11:30 -05008000 if (btrfs_chunk_readonly(root, cache->key.objectid))
Yan, Zhengf0486c62010-05-16 10:46:25 -04008001 set_block_group_ro(cache);
Chris Mason9078a3e2007-04-26 16:46:15 -04008002 }
Yan, Zhengb742bb82010-05-16 10:46:24 -04008003
8004 list_for_each_entry_rcu(space_info, &root->fs_info->space_info, list) {
8005 if (!(get_alloc_profile(root, space_info->flags) &
8006 (BTRFS_BLOCK_GROUP_RAID10 |
8007 BTRFS_BLOCK_GROUP_RAID1 |
8008 BTRFS_BLOCK_GROUP_DUP)))
8009 continue;
8010 /*
8011 * avoid allocating from un-mirrored block group if there are
8012 * mirrored block groups.
8013 */
8014 list_for_each_entry(cache, &space_info->block_groups[3], list)
Yan, Zhengf0486c62010-05-16 10:46:25 -04008015 set_block_group_ro(cache);
Yan, Zhengb742bb82010-05-16 10:46:24 -04008016 list_for_each_entry(cache, &space_info->block_groups[4], list)
Yan, Zhengf0486c62010-05-16 10:46:25 -04008017 set_block_group_ro(cache);
Yan, Zhengb742bb82010-05-16 10:46:24 -04008018 }
Yan, Zhengf0486c62010-05-16 10:46:25 -04008019
8020 init_global_block_rsv(info);
Chris Mason0b86a832008-03-24 15:01:56 -04008021 ret = 0;
8022error:
Chris Mason9078a3e2007-04-26 16:46:15 -04008023 btrfs_free_path(path);
Chris Mason0b86a832008-03-24 15:01:56 -04008024 return ret;
Chris Mason9078a3e2007-04-26 16:46:15 -04008025}
Chris Mason6324fbf2008-03-24 15:01:59 -04008026
8027int btrfs_make_block_group(struct btrfs_trans_handle *trans,
8028 struct btrfs_root *root, u64 bytes_used,
Chris Masone17cade2008-04-15 15:41:47 -04008029 u64 type, u64 chunk_objectid, u64 chunk_offset,
Chris Mason6324fbf2008-03-24 15:01:59 -04008030 u64 size)
8031{
8032 int ret;
Chris Mason6324fbf2008-03-24 15:01:59 -04008033 struct btrfs_root *extent_root;
8034 struct btrfs_block_group_cache *cache;
Chris Mason6324fbf2008-03-24 15:01:59 -04008035
8036 extent_root = root->fs_info->extent_root;
Chris Mason6324fbf2008-03-24 15:01:59 -04008037
Chris Mason12fcfd22009-03-24 10:24:20 -04008038 root->fs_info->last_trans_log_full_commit = trans->transid;
Chris Masone02119d2008-09-05 16:13:11 -04008039
Chris Mason8f18cf12008-04-25 16:53:30 -04008040 cache = kzalloc(sizeof(*cache), GFP_NOFS);
Josef Bacik0f9dd462008-09-23 13:14:11 -04008041 if (!cache)
8042 return -ENOMEM;
8043
Chris Masone17cade2008-04-15 15:41:47 -04008044 cache->key.objectid = chunk_offset;
Chris Mason6324fbf2008-03-24 15:01:59 -04008045 cache->key.offset = size;
Yan Zhengd2fb3432008-12-11 16:30:39 -05008046 cache->key.type = BTRFS_BLOCK_GROUP_ITEM_KEY;
Josef Bacik96303082009-07-13 21:29:25 -04008047 cache->sectorsize = root->sectorsize;
8048
8049 /*
8050 * we only want to have 32k of ram per block group for keeping track
8051 * of free space, and if we pass 1/2 of that we want to start
8052 * converting things over to using bitmaps
8053 */
8054 cache->extents_thresh = ((1024 * 32) / 2) /
8055 sizeof(struct btrfs_free_space);
Yan Zhengd2fb3432008-12-11 16:30:39 -05008056 atomic_set(&cache->count, 1);
Chris Masonc286ac42008-07-22 23:06:41 -04008057 spin_lock_init(&cache->lock);
Josef Bacik6226cb02009-04-03 10:14:18 -04008058 spin_lock_init(&cache->tree_lock);
Josef Bacik0f9dd462008-09-23 13:14:11 -04008059 INIT_LIST_HEAD(&cache->list);
Chris Masonfa9c0d72009-04-03 09:47:43 -04008060 INIT_LIST_HEAD(&cache->cluster_list);
Chris Mason0ef3e662008-05-24 14:04:53 -04008061
Chris Mason6324fbf2008-03-24 15:01:59 -04008062 btrfs_set_block_group_used(&cache->item, bytes_used);
Chris Mason6324fbf2008-03-24 15:01:59 -04008063 btrfs_set_block_group_chunk_objectid(&cache->item, chunk_objectid);
8064 cache->flags = type;
8065 btrfs_set_block_group_flags(&cache->item, type);
8066
Yan Zheng11833d62009-09-11 16:11:19 -04008067 cache->last_byte_to_unpin = (u64)-1;
Josef Bacik817d52f2009-07-13 21:29:25 -04008068 cache->cached = BTRFS_CACHE_FINISHED;
Yan Zheng11833d62009-09-11 16:11:19 -04008069 exclude_super_stripes(root, cache);
Josef Bacik96303082009-07-13 21:29:25 -04008070
Josef Bacik817d52f2009-07-13 21:29:25 -04008071 add_new_free_space(cache, root->fs_info, chunk_offset,
8072 chunk_offset + size);
8073
Yan Zheng11833d62009-09-11 16:11:19 -04008074 free_excluded_extents(root, cache);
8075
Chris Mason6324fbf2008-03-24 15:01:59 -04008076 ret = update_space_info(root->fs_info, cache->flags, size, bytes_used,
8077 &cache->space_info);
8078 BUG_ON(ret);
Josef Bacik1b2da372009-09-11 16:11:20 -04008079
8080 spin_lock(&cache->space_info->lock);
Yan, Zhengf0486c62010-05-16 10:46:25 -04008081 cache->space_info->bytes_readonly += cache->bytes_super;
Josef Bacik1b2da372009-09-11 16:11:20 -04008082 spin_unlock(&cache->space_info->lock);
8083
Yan, Zhengb742bb82010-05-16 10:46:24 -04008084 __link_block_group(cache->space_info, cache);
Chris Mason6324fbf2008-03-24 15:01:59 -04008085
Josef Bacik0f9dd462008-09-23 13:14:11 -04008086 ret = btrfs_add_block_group_cache(root->fs_info, cache);
8087 BUG_ON(ret);
Chris Masonc286ac42008-07-22 23:06:41 -04008088
Chris Mason6324fbf2008-03-24 15:01:59 -04008089 ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item,
8090 sizeof(cache->item));
8091 BUG_ON(ret);
8092
Chris Masond18a2c42008-04-04 15:40:00 -04008093 set_avail_alloc_bits(extent_root->fs_info, type);
Chris Mason925baed2008-06-25 16:01:30 -04008094
Chris Mason6324fbf2008-03-24 15:01:59 -04008095 return 0;
8096}
Zheng Yan1a40e232008-09-26 10:09:34 -04008097
8098int btrfs_remove_block_group(struct btrfs_trans_handle *trans,
8099 struct btrfs_root *root, u64 group_start)
8100{
8101 struct btrfs_path *path;
8102 struct btrfs_block_group_cache *block_group;
Chris Mason44fb5512009-06-04 15:34:51 -04008103 struct btrfs_free_cluster *cluster;
Zheng Yan1a40e232008-09-26 10:09:34 -04008104 struct btrfs_key key;
8105 int ret;
Josef Bacik89a55892010-10-14 14:52:27 -04008106 int factor;
Zheng Yan1a40e232008-09-26 10:09:34 -04008107
Zheng Yan1a40e232008-09-26 10:09:34 -04008108 root = root->fs_info->extent_root;
8109
8110 block_group = btrfs_lookup_block_group(root->fs_info, group_start);
8111 BUG_ON(!block_group);
Yan Zhengc146afa2008-11-12 14:34:12 -05008112 BUG_ON(!block_group->ro);
Zheng Yan1a40e232008-09-26 10:09:34 -04008113
8114 memcpy(&key, &block_group->key, sizeof(key));
Josef Bacik89a55892010-10-14 14:52:27 -04008115 if (block_group->flags & (BTRFS_BLOCK_GROUP_DUP |
8116 BTRFS_BLOCK_GROUP_RAID1 |
8117 BTRFS_BLOCK_GROUP_RAID10))
8118 factor = 2;
8119 else
8120 factor = 1;
Zheng Yan1a40e232008-09-26 10:09:34 -04008121
Chris Mason44fb5512009-06-04 15:34:51 -04008122 /* make sure this block group isn't part of an allocation cluster */
8123 cluster = &root->fs_info->data_alloc_cluster;
8124 spin_lock(&cluster->refill_lock);
8125 btrfs_return_cluster_to_free_space(block_group, cluster);
8126 spin_unlock(&cluster->refill_lock);
8127
8128 /*
8129 * make sure this block group isn't part of a metadata
8130 * allocation cluster
8131 */
8132 cluster = &root->fs_info->meta_alloc_cluster;
8133 spin_lock(&cluster->refill_lock);
8134 btrfs_return_cluster_to_free_space(block_group, cluster);
8135 spin_unlock(&cluster->refill_lock);
8136
Zheng Yan1a40e232008-09-26 10:09:34 -04008137 path = btrfs_alloc_path();
8138 BUG_ON(!path);
8139
Yan Zheng3dfdb932009-01-21 10:49:16 -05008140 spin_lock(&root->fs_info->block_group_cache_lock);
Zheng Yan1a40e232008-09-26 10:09:34 -04008141 rb_erase(&block_group->cache_node,
8142 &root->fs_info->block_group_cache_tree);
Yan Zheng3dfdb932009-01-21 10:49:16 -05008143 spin_unlock(&root->fs_info->block_group_cache_lock);
Josef Bacik817d52f2009-07-13 21:29:25 -04008144
Josef Bacik80eb2342008-10-29 14:49:05 -04008145 down_write(&block_group->space_info->groups_sem);
Chris Mason44fb5512009-06-04 15:34:51 -04008146 /*
8147 * we must use list_del_init so people can check to see if they
8148 * are still on the list after taking the semaphore
8149 */
8150 list_del_init(&block_group->list);
Josef Bacik80eb2342008-10-29 14:49:05 -04008151 up_write(&block_group->space_info->groups_sem);
Zheng Yan1a40e232008-09-26 10:09:34 -04008152
Josef Bacik817d52f2009-07-13 21:29:25 -04008153 if (block_group->cached == BTRFS_CACHE_STARTED)
Yan Zheng11833d62009-09-11 16:11:19 -04008154 wait_block_group_cache_done(block_group);
Josef Bacik817d52f2009-07-13 21:29:25 -04008155
8156 btrfs_remove_free_space_cache(block_group);
8157
Yan Zhengc146afa2008-11-12 14:34:12 -05008158 spin_lock(&block_group->space_info->lock);
8159 block_group->space_info->total_bytes -= block_group->key.offset;
8160 block_group->space_info->bytes_readonly -= block_group->key.offset;
Josef Bacik89a55892010-10-14 14:52:27 -04008161 block_group->space_info->disk_total -= block_group->key.offset * factor;
Yan Zhengc146afa2008-11-12 14:34:12 -05008162 spin_unlock(&block_group->space_info->lock);
Chris Mason283bb192009-07-24 16:30:55 -04008163
8164 btrfs_clear_space_info_full(root->fs_info);
Yan Zhengc146afa2008-11-12 14:34:12 -05008165
Chris Masonfa9c0d72009-04-03 09:47:43 -04008166 btrfs_put_block_group(block_group);
8167 btrfs_put_block_group(block_group);
Zheng Yan1a40e232008-09-26 10:09:34 -04008168
8169 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
8170 if (ret > 0)
8171 ret = -EIO;
8172 if (ret < 0)
8173 goto out;
8174
8175 ret = btrfs_del_item(trans, root, path);
8176out:
8177 btrfs_free_path(path);
8178 return ret;
8179}