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