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