Commit | Line | Data |
---|---|---|
2e635a27 | 1 | #include <linux/module.h> |
fec577fb CM |
2 | #include "ctree.h" |
3 | #include "disk-io.h" | |
4 | #include "print-tree.h" | |
e089f05c | 5 | #include "transaction.h" |
fec577fb | 6 | |
e089f05c CM |
7 | static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root |
8 | *orig_root, u64 num_blocks, u64 search_start, u64 | |
9 | search_end, struct btrfs_key *ins); | |
10 | static int finish_current_insert(struct btrfs_trans_handle *trans, struct | |
11 | btrfs_root *extent_root); | |
e20d96d6 CM |
12 | static int del_pending_extents(struct btrfs_trans_handle *trans, struct |
13 | btrfs_root *extent_root); | |
fec577fb | 14 | |
e089f05c CM |
15 | static int inc_block_ref(struct btrfs_trans_handle *trans, struct btrfs_root |
16 | *root, u64 blocknr) | |
02217ed2 | 17 | { |
234b63a0 | 18 | struct btrfs_path path; |
02217ed2 | 19 | int ret; |
e2fa7227 | 20 | struct btrfs_key key; |
234b63a0 CM |
21 | struct btrfs_leaf *l; |
22 | struct btrfs_extent_item *item; | |
e2fa7227 | 23 | struct btrfs_key ins; |
cf27e1ee | 24 | u32 refs; |
037e6390 | 25 | |
9f5fae2f CM |
26 | find_free_extent(trans, root->fs_info->extent_root, 0, 0, (u64)-1, |
27 | &ins); | |
234b63a0 | 28 | btrfs_init_path(&path); |
02217ed2 CM |
29 | key.objectid = blocknr; |
30 | key.flags = 0; | |
62e2749e | 31 | btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY); |
02217ed2 | 32 | key.offset = 1; |
9f5fae2f CM |
33 | ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key, &path, |
34 | 0, 1); | |
a28ec197 CM |
35 | if (ret != 0) |
36 | BUG(); | |
02217ed2 | 37 | BUG_ON(ret != 0); |
e20d96d6 | 38 | l = btrfs_buffer_leaf(path.nodes[0]); |
4beb1b8b | 39 | item = btrfs_item_ptr(l, path.slots[0], struct btrfs_extent_item); |
cf27e1ee CM |
40 | refs = btrfs_extent_refs(item); |
41 | btrfs_set_extent_refs(item, refs + 1); | |
d5719762 | 42 | mark_buffer_dirty(path.nodes[0]); |
a28ec197 | 43 | |
9f5fae2f CM |
44 | btrfs_release_path(root->fs_info->extent_root, &path); |
45 | finish_current_insert(trans, root->fs_info->extent_root); | |
e20d96d6 | 46 | del_pending_extents(trans, root->fs_info->extent_root); |
02217ed2 CM |
47 | return 0; |
48 | } | |
49 | ||
e089f05c CM |
50 | static int lookup_block_ref(struct btrfs_trans_handle *trans, struct btrfs_root |
51 | *root, u64 blocknr, u32 *refs) | |
a28ec197 | 52 | { |
234b63a0 | 53 | struct btrfs_path path; |
a28ec197 | 54 | int ret; |
e2fa7227 | 55 | struct btrfs_key key; |
234b63a0 CM |
56 | struct btrfs_leaf *l; |
57 | struct btrfs_extent_item *item; | |
58 | btrfs_init_path(&path); | |
a28ec197 | 59 | key.objectid = blocknr; |
a28ec197 | 60 | key.offset = 1; |
62e2749e CM |
61 | key.flags = 0; |
62 | btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY); | |
9f5fae2f CM |
63 | ret = btrfs_search_slot(trans, root->fs_info->extent_root, &key, &path, |
64 | 0, 0); | |
a28ec197 CM |
65 | if (ret != 0) |
66 | BUG(); | |
e20d96d6 | 67 | l = btrfs_buffer_leaf(path.nodes[0]); |
4beb1b8b | 68 | item = btrfs_item_ptr(l, path.slots[0], struct btrfs_extent_item); |
cf27e1ee | 69 | *refs = btrfs_extent_refs(item); |
9f5fae2f | 70 | btrfs_release_path(root->fs_info->extent_root, &path); |
a28ec197 CM |
71 | return 0; |
72 | } | |
73 | ||
e089f05c | 74 | int btrfs_inc_ref(struct btrfs_trans_handle *trans, struct btrfs_root *root, |
e20d96d6 | 75 | struct buffer_head *buf) |
02217ed2 CM |
76 | { |
77 | u64 blocknr; | |
e20d96d6 | 78 | struct btrfs_node *buf_node; |
02217ed2 | 79 | int i; |
a28ec197 | 80 | |
3768f368 | 81 | if (!root->ref_cows) |
a28ec197 | 82 | return 0; |
e20d96d6 CM |
83 | buf_node = btrfs_buffer_node(buf); |
84 | if (btrfs_is_leaf(buf_node)) | |
a28ec197 CM |
85 | return 0; |
86 | ||
e20d96d6 CM |
87 | for (i = 0; i < btrfs_header_nritems(&buf_node->header); i++) { |
88 | blocknr = btrfs_node_blockptr(buf_node, i); | |
e089f05c | 89 | inc_block_ref(trans, root, blocknr); |
02217ed2 CM |
90 | } |
91 | return 0; | |
92 | } | |
93 | ||
e089f05c CM |
94 | int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, struct |
95 | btrfs_root *root) | |
a28ec197 | 96 | { |
8ef97622 | 97 | unsigned long gang[8]; |
88fd146c | 98 | u64 first = 0; |
a28ec197 CM |
99 | int ret; |
100 | int i; | |
8ef97622 | 101 | struct radix_tree_root *pinned_radix = &root->fs_info->pinned_radix; |
a28ec197 CM |
102 | |
103 | while(1) { | |
8ef97622 CM |
104 | ret = find_first_radix_bit(pinned_radix, gang, |
105 | ARRAY_SIZE(gang)); | |
a28ec197 CM |
106 | if (!ret) |
107 | break; | |
88fd146c | 108 | if (!first) |
8ef97622 | 109 | first = gang[0]; |
0579da42 | 110 | for (i = 0; i < ret; i++) { |
8ef97622 | 111 | clear_radix_bit(pinned_radix, gang[i]); |
0579da42 | 112 | } |
a28ec197 | 113 | } |
d5719762 CM |
114 | if (root->fs_info->last_insert.objectid > first) |
115 | root->fs_info->last_insert.objectid = first; | |
9f5fae2f | 116 | root->fs_info->last_insert.offset = 0; |
a28ec197 CM |
117 | return 0; |
118 | } | |
119 | ||
e089f05c CM |
120 | static int finish_current_insert(struct btrfs_trans_handle *trans, struct |
121 | btrfs_root *extent_root) | |
037e6390 | 122 | { |
e2fa7227 | 123 | struct btrfs_key ins; |
234b63a0 | 124 | struct btrfs_extent_item extent_item; |
037e6390 CM |
125 | int i; |
126 | int ret; | |
1261ec42 CM |
127 | u64 super_blocks_used; |
128 | struct btrfs_fs_info *info = extent_root->fs_info; | |
037e6390 | 129 | |
cf27e1ee CM |
130 | btrfs_set_extent_refs(&extent_item, 1); |
131 | btrfs_set_extent_owner(&extent_item, | |
e20d96d6 | 132 | btrfs_header_parentid(btrfs_buffer_header(extent_root->node))); |
037e6390 CM |
133 | ins.offset = 1; |
134 | ins.flags = 0; | |
62e2749e | 135 | btrfs_set_key_type(&ins, BTRFS_EXTENT_ITEM_KEY); |
037e6390 | 136 | |
9f5fae2f CM |
137 | for (i = 0; i < extent_root->fs_info->current_insert.flags; i++) { |
138 | ins.objectid = extent_root->fs_info->current_insert.objectid + | |
139 | i; | |
1261ec42 CM |
140 | super_blocks_used = btrfs_super_blocks_used(info->disk_super); |
141 | btrfs_set_super_blocks_used(info->disk_super, | |
142 | super_blocks_used + 1); | |
e089f05c CM |
143 | ret = btrfs_insert_item(trans, extent_root, &ins, &extent_item, |
144 | sizeof(extent_item)); | |
037e6390 CM |
145 | BUG_ON(ret); |
146 | } | |
9f5fae2f | 147 | extent_root->fs_info->current_insert.offset = 0; |
037e6390 CM |
148 | return 0; |
149 | } | |
150 | ||
8ef97622 | 151 | static int pin_down_block(struct btrfs_root *root, u64 blocknr, int pending) |
e20d96d6 CM |
152 | { |
153 | int err; | |
78fae27e | 154 | struct btrfs_header *header; |
8ef97622 CM |
155 | struct buffer_head *bh; |
156 | ||
157 | bh = sb_find_get_block(root->fs_info->sb, blocknr); | |
158 | if (bh) { | |
159 | header = btrfs_buffer_header(bh); | |
160 | if (btrfs_header_generation(header) == | |
161 | root->fs_info->running_transaction->transid) { | |
162 | brelse(bh); | |
163 | return 0; | |
164 | } | |
78fae27e | 165 | brelse(bh); |
8ef97622 CM |
166 | } |
167 | if (pending) | |
168 | err = set_radix_bit(&root->fs_info->pending_del_radix, blocknr); | |
169 | else | |
170 | err = set_radix_bit(&root->fs_info->pinned_radix, blocknr); | |
171 | BUG_ON(err); | |
e20d96d6 CM |
172 | return 0; |
173 | } | |
174 | ||
fec577fb | 175 | /* |
a28ec197 | 176 | * remove an extent from the root, returns 0 on success |
fec577fb | 177 | */ |
e089f05c | 178 | static int __free_extent(struct btrfs_trans_handle *trans, struct btrfs_root |
78fae27e | 179 | *root, u64 blocknr, u64 num_blocks, int pin) |
a28ec197 | 180 | { |
234b63a0 | 181 | struct btrfs_path path; |
e2fa7227 | 182 | struct btrfs_key key; |
1261ec42 CM |
183 | struct btrfs_fs_info *info = root->fs_info; |
184 | struct btrfs_root *extent_root = info->extent_root; | |
a28ec197 | 185 | int ret; |
234b63a0 | 186 | struct btrfs_extent_item *ei; |
e2fa7227 | 187 | struct btrfs_key ins; |
cf27e1ee | 188 | u32 refs; |
037e6390 | 189 | |
a28ec197 CM |
190 | key.objectid = blocknr; |
191 | key.flags = 0; | |
62e2749e | 192 | btrfs_set_key_type(&key, BTRFS_EXTENT_ITEM_KEY); |
a28ec197 CM |
193 | key.offset = num_blocks; |
194 | ||
e089f05c | 195 | find_free_extent(trans, root, 0, 0, (u64)-1, &ins); |
234b63a0 | 196 | btrfs_init_path(&path); |
e089f05c | 197 | ret = btrfs_search_slot(trans, extent_root, &key, &path, -1, 1); |
a28ec197 | 198 | if (ret) { |
2e635a27 | 199 | printk("failed to find %Lu\n", key.objectid); |
234b63a0 | 200 | btrfs_print_tree(extent_root, extent_root->node); |
2e635a27 | 201 | printk("failed to find %Lu\n", key.objectid); |
a28ec197 CM |
202 | BUG(); |
203 | } | |
e20d96d6 | 204 | ei = btrfs_item_ptr(btrfs_buffer_leaf(path.nodes[0]), path.slots[0], |
123abc88 | 205 | struct btrfs_extent_item); |
a28ec197 | 206 | BUG_ON(ei->refs == 0); |
cf27e1ee CM |
207 | refs = btrfs_extent_refs(ei) - 1; |
208 | btrfs_set_extent_refs(ei, refs); | |
209 | if (refs == 0) { | |
1261ec42 | 210 | u64 super_blocks_used; |
78fae27e CM |
211 | |
212 | if (pin) { | |
8ef97622 | 213 | ret = pin_down_block(root, blocknr, 0); |
78fae27e CM |
214 | BUG_ON(ret); |
215 | } | |
216 | ||
1261ec42 CM |
217 | super_blocks_used = btrfs_super_blocks_used(info->disk_super); |
218 | btrfs_set_super_blocks_used(info->disk_super, | |
219 | super_blocks_used - num_blocks); | |
e089f05c | 220 | ret = btrfs_del_item(trans, extent_root, &path); |
78fae27e | 221 | if (extent_root->fs_info->last_insert.objectid > blocknr) |
9f5fae2f | 222 | extent_root->fs_info->last_insert.objectid = blocknr; |
a28ec197 CM |
223 | if (ret) |
224 | BUG(); | |
225 | } | |
d5719762 | 226 | mark_buffer_dirty(path.nodes[0]); |
234b63a0 | 227 | btrfs_release_path(extent_root, &path); |
e089f05c | 228 | finish_current_insert(trans, extent_root); |
a28ec197 CM |
229 | return ret; |
230 | } | |
231 | ||
a28ec197 CM |
232 | /* |
233 | * find all the blocks marked as pending in the radix tree and remove | |
234 | * them from the extent map | |
235 | */ | |
e089f05c CM |
236 | static int del_pending_extents(struct btrfs_trans_handle *trans, struct |
237 | btrfs_root *extent_root) | |
a28ec197 CM |
238 | { |
239 | int ret; | |
e20d96d6 CM |
240 | int wret; |
241 | int err = 0; | |
8ef97622 | 242 | unsigned long gang[4]; |
a28ec197 | 243 | int i; |
8ef97622 CM |
244 | struct radix_tree_root *pending_radix; |
245 | struct radix_tree_root *pinned_radix; | |
246 | ||
247 | pending_radix = &extent_root->fs_info->pending_del_radix; | |
248 | pinned_radix = &extent_root->fs_info->pinned_radix; | |
a28ec197 CM |
249 | |
250 | while(1) { | |
8ef97622 CM |
251 | ret = find_first_radix_bit(pending_radix, gang, |
252 | ARRAY_SIZE(gang)); | |
a28ec197 CM |
253 | if (!ret) |
254 | break; | |
255 | for (i = 0; i < ret; i++) { | |
8ef97622 CM |
256 | wret = set_radix_bit(pinned_radix, gang[i]); |
257 | BUG_ON(wret); | |
258 | wret = clear_radix_bit(pending_radix, gang[i]); | |
259 | BUG_ON(wret); | |
d5719762 | 260 | wret = __free_extent(trans, extent_root, |
8ef97622 | 261 | gang[i], 1, 0); |
e20d96d6 CM |
262 | if (wret) |
263 | err = wret; | |
fec577fb CM |
264 | } |
265 | } | |
e20d96d6 | 266 | return err; |
fec577fb CM |
267 | } |
268 | ||
269 | /* | |
270 | * remove an extent from the root, returns 0 on success | |
271 | */ | |
e089f05c CM |
272 | int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root |
273 | *root, u64 blocknr, u64 num_blocks, int pin) | |
fec577fb | 274 | { |
9f5fae2f | 275 | struct btrfs_root *extent_root = root->fs_info->extent_root; |
e20d96d6 | 276 | struct buffer_head *t; |
fec577fb CM |
277 | int pending_ret; |
278 | int ret; | |
a28ec197 | 279 | |
fec577fb | 280 | if (root == extent_root) { |
a28ec197 | 281 | t = find_tree_block(root, blocknr); |
8ef97622 | 282 | pin_down_block(root, blocknr, 1); |
fec577fb CM |
283 | return 0; |
284 | } | |
78fae27e | 285 | ret = __free_extent(trans, root, blocknr, num_blocks, pin); |
e20d96d6 | 286 | pending_ret = del_pending_extents(trans, root->fs_info->extent_root); |
fec577fb CM |
287 | return ret ? ret : pending_ret; |
288 | } | |
289 | ||
290 | /* | |
291 | * walks the btree of allocated extents and find a hole of a given size. | |
292 | * The key ins is changed to record the hole: | |
293 | * ins->objectid == block start | |
62e2749e | 294 | * ins->flags = BTRFS_EXTENT_ITEM_KEY |
fec577fb CM |
295 | * ins->offset == number of blocks |
296 | * Any available blocks before search_start are skipped. | |
297 | */ | |
e089f05c CM |
298 | static int find_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root |
299 | *orig_root, u64 num_blocks, u64 search_start, u64 | |
300 | search_end, struct btrfs_key *ins) | |
fec577fb | 301 | { |
234b63a0 | 302 | struct btrfs_path path; |
e2fa7227 | 303 | struct btrfs_key key; |
fec577fb CM |
304 | int ret; |
305 | u64 hole_size = 0; | |
306 | int slot = 0; | |
e20d96d6 | 307 | u64 last_block = 0; |
037e6390 | 308 | u64 test_block; |
fec577fb | 309 | int start_found; |
234b63a0 | 310 | struct btrfs_leaf *l; |
9f5fae2f | 311 | struct btrfs_root * root = orig_root->fs_info->extent_root; |
0579da42 | 312 | int total_needed = num_blocks; |
e20d96d6 | 313 | int level; |
fec577fb | 314 | |
e20d96d6 CM |
315 | level = btrfs_header_level(btrfs_buffer_header(root->node)); |
316 | total_needed += (level + 1) * 3; | |
9f5fae2f CM |
317 | if (root->fs_info->last_insert.objectid > search_start) |
318 | search_start = root->fs_info->last_insert.objectid; | |
62e2749e CM |
319 | |
320 | ins->flags = 0; | |
321 | btrfs_set_key_type(ins, BTRFS_EXTENT_ITEM_KEY); | |
322 | ||
fec577fb | 323 | check_failed: |
234b63a0 | 324 | btrfs_init_path(&path); |
fec577fb CM |
325 | ins->objectid = search_start; |
326 | ins->offset = 0; | |
fec577fb | 327 | start_found = 0; |
e089f05c | 328 | ret = btrfs_search_slot(trans, root, ins, &path, 0, 0); |
0f70abe2 CM |
329 | if (ret < 0) |
330 | goto error; | |
aa5d6bed | 331 | |
0579da42 CM |
332 | if (path.slots[0] > 0) |
333 | path.slots[0]--; | |
334 | ||
fec577fb | 335 | while (1) { |
e20d96d6 | 336 | l = btrfs_buffer_leaf(path.nodes[0]); |
fec577fb | 337 | slot = path.slots[0]; |
7518a238 | 338 | if (slot >= btrfs_header_nritems(&l->header)) { |
234b63a0 | 339 | ret = btrfs_next_leaf(root, &path); |
fec577fb CM |
340 | if (ret == 0) |
341 | continue; | |
0f70abe2 CM |
342 | if (ret < 0) |
343 | goto error; | |
fec577fb CM |
344 | if (!start_found) { |
345 | ins->objectid = search_start; | |
037e6390 | 346 | ins->offset = (u64)-1; |
fec577fb CM |
347 | start_found = 1; |
348 | goto check_pending; | |
349 | } | |
350 | ins->objectid = last_block > search_start ? | |
351 | last_block : search_start; | |
037e6390 | 352 | ins->offset = (u64)-1; |
fec577fb CM |
353 | goto check_pending; |
354 | } | |
e2fa7227 CM |
355 | btrfs_disk_key_to_cpu(&key, &l->items[slot].key); |
356 | if (key.objectid >= search_start) { | |
fec577fb | 357 | if (start_found) { |
0579da42 CM |
358 | if (last_block < search_start) |
359 | last_block = search_start; | |
e2fa7227 | 360 | hole_size = key.objectid - last_block; |
037e6390 | 361 | if (hole_size > total_needed) { |
fec577fb | 362 | ins->objectid = last_block; |
037e6390 | 363 | ins->offset = hole_size; |
fec577fb CM |
364 | goto check_pending; |
365 | } | |
0579da42 | 366 | } |
fec577fb | 367 | } |
0579da42 | 368 | start_found = 1; |
e2fa7227 | 369 | last_block = key.objectid + key.offset; |
fec577fb CM |
370 | path.slots[0]++; |
371 | } | |
372 | // FIXME -ENOSPC | |
373 | check_pending: | |
374 | /* we have to make sure we didn't find an extent that has already | |
375 | * been allocated by the map tree or the original allocation | |
376 | */ | |
234b63a0 | 377 | btrfs_release_path(root, &path); |
fec577fb | 378 | BUG_ON(ins->objectid < search_start); |
037e6390 CM |
379 | for (test_block = ins->objectid; |
380 | test_block < ins->objectid + total_needed; test_block++) { | |
8ef97622 | 381 | if (test_radix_bit(&root->fs_info->pinned_radix, |
9f5fae2f | 382 | test_block)) { |
037e6390 | 383 | search_start = test_block + 1; |
fec577fb CM |
384 | goto check_failed; |
385 | } | |
386 | } | |
9f5fae2f CM |
387 | BUG_ON(root->fs_info->current_insert.offset); |
388 | root->fs_info->current_insert.offset = total_needed - num_blocks; | |
389 | root->fs_info->current_insert.objectid = ins->objectid + num_blocks; | |
390 | root->fs_info->current_insert.flags = 0; | |
391 | root->fs_info->last_insert.objectid = ins->objectid; | |
037e6390 | 392 | ins->offset = num_blocks; |
fec577fb | 393 | return 0; |
0f70abe2 | 394 | error: |
234b63a0 | 395 | btrfs_release_path(root, &path); |
0f70abe2 | 396 | return ret; |
fec577fb CM |
397 | } |
398 | ||
fec577fb CM |
399 | /* |
400 | * finds a free extent and does all the dirty work required for allocation | |
401 | * returns the key for the extent through ins, and a tree buffer for | |
402 | * the first block of the extent through buf. | |
403 | * | |
404 | * returns 0 if everything worked, non-zero otherwise. | |
405 | */ | |
e089f05c CM |
406 | static int alloc_extent(struct btrfs_trans_handle *trans, struct btrfs_root |
407 | *root, u64 num_blocks, u64 search_start, u64 | |
408 | search_end, u64 owner, struct btrfs_key *ins) | |
fec577fb CM |
409 | { |
410 | int ret; | |
411 | int pending_ret; | |
1261ec42 CM |
412 | u64 super_blocks_used; |
413 | struct btrfs_fs_info *info = root->fs_info; | |
414 | struct btrfs_root *extent_root = info->extent_root; | |
234b63a0 | 415 | struct btrfs_extent_item extent_item; |
037e6390 | 416 | |
cf27e1ee CM |
417 | btrfs_set_extent_refs(&extent_item, 1); |
418 | btrfs_set_extent_owner(&extent_item, owner); | |
fec577fb | 419 | |
037e6390 | 420 | if (root == extent_root) { |
9f5fae2f | 421 | BUG_ON(extent_root->fs_info->current_insert.offset == 0); |
037e6390 | 422 | BUG_ON(num_blocks != 1); |
9f5fae2f CM |
423 | BUG_ON(extent_root->fs_info->current_insert.flags == |
424 | extent_root->fs_info->current_insert.offset); | |
037e6390 | 425 | ins->offset = 1; |
9f5fae2f CM |
426 | ins->objectid = extent_root->fs_info->current_insert.objectid + |
427 | extent_root->fs_info->current_insert.flags++; | |
fec577fb CM |
428 | return 0; |
429 | } | |
e089f05c | 430 | ret = find_free_extent(trans, root, num_blocks, search_start, |
037e6390 CM |
431 | search_end, ins); |
432 | if (ret) | |
433 | return ret; | |
fec577fb | 434 | |
1261ec42 CM |
435 | super_blocks_used = btrfs_super_blocks_used(info->disk_super); |
436 | btrfs_set_super_blocks_used(info->disk_super, super_blocks_used + | |
437 | num_blocks); | |
e089f05c CM |
438 | ret = btrfs_insert_item(trans, extent_root, ins, &extent_item, |
439 | sizeof(extent_item)); | |
037e6390 | 440 | |
e089f05c | 441 | finish_current_insert(trans, extent_root); |
e20d96d6 | 442 | pending_ret = del_pending_extents(trans, extent_root); |
037e6390 CM |
443 | if (ret) |
444 | return ret; | |
445 | if (pending_ret) | |
446 | return pending_ret; | |
447 | return 0; | |
fec577fb CM |
448 | } |
449 | ||
450 | /* | |
451 | * helper function to allocate a block for a given tree | |
452 | * returns the tree buffer or NULL. | |
453 | */ | |
e20d96d6 | 454 | struct buffer_head *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, |
e089f05c | 455 | struct btrfs_root *root) |
fec577fb | 456 | { |
e2fa7227 | 457 | struct btrfs_key ins; |
fec577fb | 458 | int ret; |
e20d96d6 | 459 | struct buffer_head *buf; |
fec577fb | 460 | |
e089f05c | 461 | ret = alloc_extent(trans, root, 1, 0, (unsigned long)-1, |
e20d96d6 | 462 | btrfs_header_parentid(btrfs_buffer_header(root->node)), &ins); |
fec577fb CM |
463 | if (ret) { |
464 | BUG(); | |
465 | return NULL; | |
466 | } | |
037e6390 | 467 | buf = find_tree_block(root, ins.objectid); |
df2ce34c | 468 | set_buffer_uptodate(buf); |
fec577fb CM |
469 | return buf; |
470 | } | |
a28ec197 | 471 | |
9aca1d51 CM |
472 | /* |
473 | * helper function for drop_snapshot, this walks down the tree dropping ref | |
474 | * counts as it goes. | |
475 | */ | |
e089f05c CM |
476 | static int walk_down_tree(struct btrfs_trans_handle *trans, struct btrfs_root |
477 | *root, struct btrfs_path *path, int *level) | |
20524f02 | 478 | { |
e20d96d6 CM |
479 | struct buffer_head *next; |
480 | struct buffer_head *cur; | |
20524f02 CM |
481 | u64 blocknr; |
482 | int ret; | |
483 | u32 refs; | |
484 | ||
e20d96d6 | 485 | ret = lookup_block_ref(trans, root, path->nodes[*level]->b_blocknr, |
e089f05c | 486 | &refs); |
20524f02 CM |
487 | BUG_ON(ret); |
488 | if (refs > 1) | |
489 | goto out; | |
9aca1d51 CM |
490 | /* |
491 | * walk down to the last node level and free all the leaves | |
492 | */ | |
20524f02 CM |
493 | while(*level > 0) { |
494 | cur = path->nodes[*level]; | |
7518a238 | 495 | if (path->slots[*level] >= |
e20d96d6 | 496 | btrfs_header_nritems(btrfs_buffer_header(cur))) |
20524f02 | 497 | break; |
e20d96d6 CM |
498 | blocknr = btrfs_node_blockptr(btrfs_buffer_node(cur), |
499 | path->slots[*level]); | |
e089f05c | 500 | ret = lookup_block_ref(trans, root, blocknr, &refs); |
20524f02 CM |
501 | if (refs != 1 || *level == 1) { |
502 | path->slots[*level]++; | |
e089f05c | 503 | ret = btrfs_free_extent(trans, root, blocknr, 1, 1); |
20524f02 CM |
504 | BUG_ON(ret); |
505 | continue; | |
506 | } | |
507 | BUG_ON(ret); | |
508 | next = read_tree_block(root, blocknr); | |
83e15a28 | 509 | if (path->nodes[*level-1]) |
234b63a0 | 510 | btrfs_block_release(root, path->nodes[*level-1]); |
20524f02 | 511 | path->nodes[*level-1] = next; |
e20d96d6 | 512 | *level = btrfs_header_level(btrfs_buffer_header(next)); |
20524f02 CM |
513 | path->slots[*level] = 0; |
514 | } | |
515 | out: | |
e20d96d6 CM |
516 | ret = btrfs_free_extent(trans, root, path->nodes[*level]->b_blocknr, |
517 | 1, 1); | |
234b63a0 | 518 | btrfs_block_release(root, path->nodes[*level]); |
20524f02 CM |
519 | path->nodes[*level] = NULL; |
520 | *level += 1; | |
521 | BUG_ON(ret); | |
522 | return 0; | |
523 | } | |
524 | ||
9aca1d51 CM |
525 | /* |
526 | * helper for dropping snapshots. This walks back up the tree in the path | |
527 | * to find the first node higher up where we haven't yet gone through | |
528 | * all the slots | |
529 | */ | |
e089f05c CM |
530 | static int walk_up_tree(struct btrfs_trans_handle *trans, struct btrfs_root |
531 | *root, struct btrfs_path *path, int *level) | |
20524f02 CM |
532 | { |
533 | int i; | |
534 | int slot; | |
535 | int ret; | |
234b63a0 | 536 | for(i = *level; i < BTRFS_MAX_LEVEL - 1 && path->nodes[i]; i++) { |
20524f02 | 537 | slot = path->slots[i]; |
e20d96d6 CM |
538 | if (slot < btrfs_header_nritems( |
539 | btrfs_buffer_header(path->nodes[i])) - 1) { | |
20524f02 CM |
540 | path->slots[i]++; |
541 | *level = i; | |
542 | return 0; | |
543 | } else { | |
e089f05c | 544 | ret = btrfs_free_extent(trans, root, |
e20d96d6 | 545 | path->nodes[*level]->b_blocknr, |
e089f05c | 546 | 1, 1); |
234b63a0 | 547 | btrfs_block_release(root, path->nodes[*level]); |
83e15a28 | 548 | path->nodes[*level] = NULL; |
20524f02 CM |
549 | *level = i + 1; |
550 | BUG_ON(ret); | |
551 | } | |
552 | } | |
553 | return 1; | |
554 | } | |
555 | ||
9aca1d51 CM |
556 | /* |
557 | * drop the reference count on the tree rooted at 'snap'. This traverses | |
558 | * the tree freeing any blocks that have a ref count of zero after being | |
559 | * decremented. | |
560 | */ | |
e089f05c | 561 | int btrfs_drop_snapshot(struct btrfs_trans_handle *trans, struct btrfs_root |
e20d96d6 | 562 | *root, struct buffer_head *snap) |
20524f02 | 563 | { |
3768f368 | 564 | int ret = 0; |
9aca1d51 | 565 | int wret; |
20524f02 | 566 | int level; |
234b63a0 | 567 | struct btrfs_path path; |
20524f02 CM |
568 | int i; |
569 | int orig_level; | |
570 | ||
234b63a0 | 571 | btrfs_init_path(&path); |
20524f02 | 572 | |
e20d96d6 | 573 | level = btrfs_header_level(btrfs_buffer_header(snap)); |
20524f02 CM |
574 | orig_level = level; |
575 | path.nodes[level] = snap; | |
576 | path.slots[level] = 0; | |
577 | while(1) { | |
e089f05c | 578 | wret = walk_down_tree(trans, root, &path, &level); |
9aca1d51 | 579 | if (wret > 0) |
20524f02 | 580 | break; |
9aca1d51 CM |
581 | if (wret < 0) |
582 | ret = wret; | |
583 | ||
e089f05c | 584 | wret = walk_up_tree(trans, root, &path, &level); |
9aca1d51 | 585 | if (wret > 0) |
20524f02 | 586 | break; |
9aca1d51 CM |
587 | if (wret < 0) |
588 | ret = wret; | |
20524f02 | 589 | } |
83e15a28 CM |
590 | for (i = 0; i <= orig_level; i++) { |
591 | if (path.nodes[i]) { | |
234b63a0 | 592 | btrfs_block_release(root, path.nodes[i]); |
83e15a28 | 593 | } |
20524f02 | 594 | } |
9aca1d51 | 595 | return ret; |
20524f02 | 596 | } |