diff options
author | Chris Mason <chris.mason@oracle.com> | 2012-03-28 20:31:37 -0400 |
---|---|---|
committer | Chris Mason <chris.mason@oracle.com> | 2012-03-28 20:31:37 -0400 |
commit | 1d4284bd6e8d7dd1d5521a6747bdb6dc1caf0225 (patch) | |
tree | a7dde6312ec24eb6368cad7a3efedbf368a5a70c /fs/btrfs | |
parent | b5d67f64f9bc656970dacba245410f0faedad18e (diff) | |
parent | 65139ed99234d8505948cdb7a835452eb5c191f9 (diff) |
Merge branch 'error-handling' into for-linus
Conflicts:
fs/btrfs/ctree.c
fs/btrfs/disk-io.c
fs/btrfs/extent-tree.c
fs/btrfs/extent_io.c
fs/btrfs/extent_io.h
fs/btrfs/inode.c
fs/btrfs/scrub.c
Signed-off-by: Chris Mason <chris.mason@oracle.com>
Diffstat (limited to 'fs/btrfs')
37 files changed, 1973 insertions, 1018 deletions
diff --git a/fs/btrfs/async-thread.c b/fs/btrfs/async-thread.c index 0cc20b35c1c4..42704149b723 100644 --- a/fs/btrfs/async-thread.c +++ b/fs/btrfs/async-thread.c | |||
@@ -171,11 +171,11 @@ out: | |||
171 | spin_unlock_irqrestore(&workers->lock, flags); | 171 | spin_unlock_irqrestore(&workers->lock, flags); |
172 | } | 172 | } |
173 | 173 | ||
174 | static noinline int run_ordered_completions(struct btrfs_workers *workers, | 174 | static noinline void run_ordered_completions(struct btrfs_workers *workers, |
175 | struct btrfs_work *work) | 175 | struct btrfs_work *work) |
176 | { | 176 | { |
177 | if (!workers->ordered) | 177 | if (!workers->ordered) |
178 | return 0; | 178 | return; |
179 | 179 | ||
180 | set_bit(WORK_DONE_BIT, &work->flags); | 180 | set_bit(WORK_DONE_BIT, &work->flags); |
181 | 181 | ||
@@ -213,7 +213,6 @@ static noinline int run_ordered_completions(struct btrfs_workers *workers, | |||
213 | } | 213 | } |
214 | 214 | ||
215 | spin_unlock(&workers->order_lock); | 215 | spin_unlock(&workers->order_lock); |
216 | return 0; | ||
217 | } | 216 | } |
218 | 217 | ||
219 | static void put_worker(struct btrfs_worker_thread *worker) | 218 | static void put_worker(struct btrfs_worker_thread *worker) |
@@ -399,7 +398,7 @@ again: | |||
399 | /* | 398 | /* |
400 | * this will wait for all the worker threads to shutdown | 399 | * this will wait for all the worker threads to shutdown |
401 | */ | 400 | */ |
402 | int btrfs_stop_workers(struct btrfs_workers *workers) | 401 | void btrfs_stop_workers(struct btrfs_workers *workers) |
403 | { | 402 | { |
404 | struct list_head *cur; | 403 | struct list_head *cur; |
405 | struct btrfs_worker_thread *worker; | 404 | struct btrfs_worker_thread *worker; |
@@ -427,7 +426,6 @@ int btrfs_stop_workers(struct btrfs_workers *workers) | |||
427 | put_worker(worker); | 426 | put_worker(worker); |
428 | } | 427 | } |
429 | spin_unlock_irq(&workers->lock); | 428 | spin_unlock_irq(&workers->lock); |
430 | return 0; | ||
431 | } | 429 | } |
432 | 430 | ||
433 | /* | 431 | /* |
@@ -615,14 +613,14 @@ found: | |||
615 | * it was taken from. It is intended for use with long running work functions | 613 | * it was taken from. It is intended for use with long running work functions |
616 | * that make some progress and want to give the cpu up for others. | 614 | * that make some progress and want to give the cpu up for others. |
617 | */ | 615 | */ |
618 | int btrfs_requeue_work(struct btrfs_work *work) | 616 | void btrfs_requeue_work(struct btrfs_work *work) |
619 | { | 617 | { |
620 | struct btrfs_worker_thread *worker = work->worker; | 618 | struct btrfs_worker_thread *worker = work->worker; |
621 | unsigned long flags; | 619 | unsigned long flags; |
622 | int wake = 0; | 620 | int wake = 0; |
623 | 621 | ||
624 | if (test_and_set_bit(WORK_QUEUED_BIT, &work->flags)) | 622 | if (test_and_set_bit(WORK_QUEUED_BIT, &work->flags)) |
625 | goto out; | 623 | return; |
626 | 624 | ||
627 | spin_lock_irqsave(&worker->lock, flags); | 625 | spin_lock_irqsave(&worker->lock, flags); |
628 | if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags)) | 626 | if (test_bit(WORK_HIGH_PRIO_BIT, &work->flags)) |
@@ -649,9 +647,6 @@ int btrfs_requeue_work(struct btrfs_work *work) | |||
649 | if (wake) | 647 | if (wake) |
650 | wake_up_process(worker->task); | 648 | wake_up_process(worker->task); |
651 | spin_unlock_irqrestore(&worker->lock, flags); | 649 | spin_unlock_irqrestore(&worker->lock, flags); |
652 | out: | ||
653 | |||
654 | return 0; | ||
655 | } | 650 | } |
656 | 651 | ||
657 | void btrfs_set_work_high_prio(struct btrfs_work *work) | 652 | void btrfs_set_work_high_prio(struct btrfs_work *work) |
diff --git a/fs/btrfs/async-thread.h b/fs/btrfs/async-thread.h index f34cc31fa3c9..063698b90ce2 100644 --- a/fs/btrfs/async-thread.h +++ b/fs/btrfs/async-thread.h | |||
@@ -111,9 +111,9 @@ struct btrfs_workers { | |||
111 | 111 | ||
112 | void btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work); | 112 | void btrfs_queue_worker(struct btrfs_workers *workers, struct btrfs_work *work); |
113 | int btrfs_start_workers(struct btrfs_workers *workers); | 113 | int btrfs_start_workers(struct btrfs_workers *workers); |
114 | int btrfs_stop_workers(struct btrfs_workers *workers); | 114 | void btrfs_stop_workers(struct btrfs_workers *workers); |
115 | void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max, | 115 | void btrfs_init_workers(struct btrfs_workers *workers, char *name, int max, |
116 | struct btrfs_workers *async_starter); | 116 | struct btrfs_workers *async_starter); |
117 | int btrfs_requeue_work(struct btrfs_work *work); | 117 | void btrfs_requeue_work(struct btrfs_work *work); |
118 | void btrfs_set_work_high_prio(struct btrfs_work *work); | 118 | void btrfs_set_work_high_prio(struct btrfs_work *work); |
119 | #endif | 119 | #endif |
diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c index d02c27cd14c7..d11afa67c7d8 100644 --- a/fs/btrfs/compression.c +++ b/fs/btrfs/compression.c | |||
@@ -226,8 +226,8 @@ out: | |||
226 | * Clear the writeback bits on all of the file | 226 | * Clear the writeback bits on all of the file |
227 | * pages for a compressed write | 227 | * pages for a compressed write |
228 | */ | 228 | */ |
229 | static noinline int end_compressed_writeback(struct inode *inode, u64 start, | 229 | static noinline void end_compressed_writeback(struct inode *inode, u64 start, |
230 | unsigned long ram_size) | 230 | unsigned long ram_size) |
231 | { | 231 | { |
232 | unsigned long index = start >> PAGE_CACHE_SHIFT; | 232 | unsigned long index = start >> PAGE_CACHE_SHIFT; |
233 | unsigned long end_index = (start + ram_size - 1) >> PAGE_CACHE_SHIFT; | 233 | unsigned long end_index = (start + ram_size - 1) >> PAGE_CACHE_SHIFT; |
@@ -253,7 +253,6 @@ static noinline int end_compressed_writeback(struct inode *inode, u64 start, | |||
253 | index += ret; | 253 | index += ret; |
254 | } | 254 | } |
255 | /* the inode may be gone now */ | 255 | /* the inode may be gone now */ |
256 | return 0; | ||
257 | } | 256 | } |
258 | 257 | ||
259 | /* | 258 | /* |
@@ -392,16 +391,16 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start, | |||
392 | */ | 391 | */ |
393 | atomic_inc(&cb->pending_bios); | 392 | atomic_inc(&cb->pending_bios); |
394 | ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0); | 393 | ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0); |
395 | BUG_ON(ret); | 394 | BUG_ON(ret); /* -ENOMEM */ |
396 | 395 | ||
397 | if (!skip_sum) { | 396 | if (!skip_sum) { |
398 | ret = btrfs_csum_one_bio(root, inode, bio, | 397 | ret = btrfs_csum_one_bio(root, inode, bio, |
399 | start, 1); | 398 | start, 1); |
400 | BUG_ON(ret); | 399 | BUG_ON(ret); /* -ENOMEM */ |
401 | } | 400 | } |
402 | 401 | ||
403 | ret = btrfs_map_bio(root, WRITE, bio, 0, 1); | 402 | ret = btrfs_map_bio(root, WRITE, bio, 0, 1); |
404 | BUG_ON(ret); | 403 | BUG_ON(ret); /* -ENOMEM */ |
405 | 404 | ||
406 | bio_put(bio); | 405 | bio_put(bio); |
407 | 406 | ||
@@ -421,15 +420,15 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start, | |||
421 | bio_get(bio); | 420 | bio_get(bio); |
422 | 421 | ||
423 | ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0); | 422 | ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0); |
424 | BUG_ON(ret); | 423 | BUG_ON(ret); /* -ENOMEM */ |
425 | 424 | ||
426 | if (!skip_sum) { | 425 | if (!skip_sum) { |
427 | ret = btrfs_csum_one_bio(root, inode, bio, start, 1); | 426 | ret = btrfs_csum_one_bio(root, inode, bio, start, 1); |
428 | BUG_ON(ret); | 427 | BUG_ON(ret); /* -ENOMEM */ |
429 | } | 428 | } |
430 | 429 | ||
431 | ret = btrfs_map_bio(root, WRITE, bio, 0, 1); | 430 | ret = btrfs_map_bio(root, WRITE, bio, 0, 1); |
432 | BUG_ON(ret); | 431 | BUG_ON(ret); /* -ENOMEM */ |
433 | 432 | ||
434 | bio_put(bio); | 433 | bio_put(bio); |
435 | return 0; | 434 | return 0; |
@@ -497,7 +496,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, | |||
497 | * sure they map to this compressed extent on disk. | 496 | * sure they map to this compressed extent on disk. |
498 | */ | 497 | */ |
499 | set_page_extent_mapped(page); | 498 | set_page_extent_mapped(page); |
500 | lock_extent(tree, last_offset, end, GFP_NOFS); | 499 | lock_extent(tree, last_offset, end); |
501 | read_lock(&em_tree->lock); | 500 | read_lock(&em_tree->lock); |
502 | em = lookup_extent_mapping(em_tree, last_offset, | 501 | em = lookup_extent_mapping(em_tree, last_offset, |
503 | PAGE_CACHE_SIZE); | 502 | PAGE_CACHE_SIZE); |
@@ -507,7 +506,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, | |||
507 | (last_offset + PAGE_CACHE_SIZE > extent_map_end(em)) || | 506 | (last_offset + PAGE_CACHE_SIZE > extent_map_end(em)) || |
508 | (em->block_start >> 9) != cb->orig_bio->bi_sector) { | 507 | (em->block_start >> 9) != cb->orig_bio->bi_sector) { |
509 | free_extent_map(em); | 508 | free_extent_map(em); |
510 | unlock_extent(tree, last_offset, end, GFP_NOFS); | 509 | unlock_extent(tree, last_offset, end); |
511 | unlock_page(page); | 510 | unlock_page(page); |
512 | page_cache_release(page); | 511 | page_cache_release(page); |
513 | break; | 512 | break; |
@@ -535,7 +534,7 @@ static noinline int add_ra_bio_pages(struct inode *inode, | |||
535 | nr_pages++; | 534 | nr_pages++; |
536 | page_cache_release(page); | 535 | page_cache_release(page); |
537 | } else { | 536 | } else { |
538 | unlock_extent(tree, last_offset, end, GFP_NOFS); | 537 | unlock_extent(tree, last_offset, end); |
539 | unlock_page(page); | 538 | unlock_page(page); |
540 | page_cache_release(page); | 539 | page_cache_release(page); |
541 | break; | 540 | break; |
@@ -662,7 +661,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, | |||
662 | bio_get(comp_bio); | 661 | bio_get(comp_bio); |
663 | 662 | ||
664 | ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0); | 663 | ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0); |
665 | BUG_ON(ret); | 664 | BUG_ON(ret); /* -ENOMEM */ |
666 | 665 | ||
667 | /* | 666 | /* |
668 | * inc the count before we submit the bio so | 667 | * inc the count before we submit the bio so |
@@ -675,14 +674,14 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, | |||
675 | if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { | 674 | if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { |
676 | ret = btrfs_lookup_bio_sums(root, inode, | 675 | ret = btrfs_lookup_bio_sums(root, inode, |
677 | comp_bio, sums); | 676 | comp_bio, sums); |
678 | BUG_ON(ret); | 677 | BUG_ON(ret); /* -ENOMEM */ |
679 | } | 678 | } |
680 | sums += (comp_bio->bi_size + root->sectorsize - 1) / | 679 | sums += (comp_bio->bi_size + root->sectorsize - 1) / |
681 | root->sectorsize; | 680 | root->sectorsize; |
682 | 681 | ||
683 | ret = btrfs_map_bio(root, READ, comp_bio, | 682 | ret = btrfs_map_bio(root, READ, comp_bio, |
684 | mirror_num, 0); | 683 | mirror_num, 0); |
685 | BUG_ON(ret); | 684 | BUG_ON(ret); /* -ENOMEM */ |
686 | 685 | ||
687 | bio_put(comp_bio); | 686 | bio_put(comp_bio); |
688 | 687 | ||
@@ -698,15 +697,15 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio, | |||
698 | bio_get(comp_bio); | 697 | bio_get(comp_bio); |
699 | 698 | ||
700 | ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0); | 699 | ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0); |
701 | BUG_ON(ret); | 700 | BUG_ON(ret); /* -ENOMEM */ |
702 | 701 | ||
703 | if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { | 702 | if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) { |
704 | ret = btrfs_lookup_bio_sums(root, inode, comp_bio, sums); | 703 | ret = btrfs_lookup_bio_sums(root, inode, comp_bio, sums); |
705 | BUG_ON(ret); | 704 | BUG_ON(ret); /* -ENOMEM */ |
706 | } | 705 | } |
707 | 706 | ||
708 | ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0); | 707 | ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0); |
709 | BUG_ON(ret); | 708 | BUG_ON(ret); /* -ENOMEM */ |
710 | 709 | ||
711 | bio_put(comp_bio); | 710 | bio_put(comp_bio); |
712 | return 0; | 711 | return 0; |
@@ -734,7 +733,7 @@ struct btrfs_compress_op *btrfs_compress_op[] = { | |||
734 | &btrfs_lzo_compress, | 733 | &btrfs_lzo_compress, |
735 | }; | 734 | }; |
736 | 735 | ||
737 | int __init btrfs_init_compress(void) | 736 | void __init btrfs_init_compress(void) |
738 | { | 737 | { |
739 | int i; | 738 | int i; |
740 | 739 | ||
@@ -744,7 +743,6 @@ int __init btrfs_init_compress(void) | |||
744 | atomic_set(&comp_alloc_workspace[i], 0); | 743 | atomic_set(&comp_alloc_workspace[i], 0); |
745 | init_waitqueue_head(&comp_workspace_wait[i]); | 744 | init_waitqueue_head(&comp_workspace_wait[i]); |
746 | } | 745 | } |
747 | return 0; | ||
748 | } | 746 | } |
749 | 747 | ||
750 | /* | 748 | /* |
diff --git a/fs/btrfs/compression.h b/fs/btrfs/compression.h index a12059f4f0fd..9afb0a62ae82 100644 --- a/fs/btrfs/compression.h +++ b/fs/btrfs/compression.h | |||
@@ -19,7 +19,7 @@ | |||
19 | #ifndef __BTRFS_COMPRESSION_ | 19 | #ifndef __BTRFS_COMPRESSION_ |
20 | #define __BTRFS_COMPRESSION_ | 20 | #define __BTRFS_COMPRESSION_ |
21 | 21 | ||
22 | int btrfs_init_compress(void); | 22 | void btrfs_init_compress(void); |
23 | void btrfs_exit_compress(void); | 23 | void btrfs_exit_compress(void); |
24 | 24 | ||
25 | int btrfs_compress_pages(int type, struct address_space *mapping, | 25 | int btrfs_compress_pages(int type, struct address_space *mapping, |
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c index 270655da11d1..e801f226d7e0 100644 --- a/fs/btrfs/ctree.c +++ b/fs/btrfs/ctree.c | |||
@@ -36,7 +36,7 @@ static int balance_node_right(struct btrfs_trans_handle *trans, | |||
36 | struct btrfs_root *root, | 36 | struct btrfs_root *root, |
37 | struct extent_buffer *dst_buf, | 37 | struct extent_buffer *dst_buf, |
38 | struct extent_buffer *src_buf); | 38 | struct extent_buffer *src_buf); |
39 | static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, | 39 | static void del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, |
40 | struct btrfs_path *path, int level, int slot); | 40 | struct btrfs_path *path, int level, int slot); |
41 | 41 | ||
42 | struct btrfs_path *btrfs_alloc_path(void) | 42 | struct btrfs_path *btrfs_alloc_path(void) |
@@ -344,8 +344,13 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, | |||
344 | if (btrfs_block_can_be_shared(root, buf)) { | 344 | if (btrfs_block_can_be_shared(root, buf)) { |
345 | ret = btrfs_lookup_extent_info(trans, root, buf->start, | 345 | ret = btrfs_lookup_extent_info(trans, root, buf->start, |
346 | buf->len, &refs, &flags); | 346 | buf->len, &refs, &flags); |
347 | BUG_ON(ret); | 347 | if (ret) |
348 | BUG_ON(refs == 0); | 348 | return ret; |
349 | if (refs == 0) { | ||
350 | ret = -EROFS; | ||
351 | btrfs_std_error(root->fs_info, ret); | ||
352 | return ret; | ||
353 | } | ||
349 | } else { | 354 | } else { |
350 | refs = 1; | 355 | refs = 1; |
351 | if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || | 356 | if (root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || |
@@ -364,14 +369,14 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, | |||
364 | root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) && | 369 | root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID) && |
365 | !(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)) { | 370 | !(flags & BTRFS_BLOCK_FLAG_FULL_BACKREF)) { |
366 | ret = btrfs_inc_ref(trans, root, buf, 1, 1); | 371 | ret = btrfs_inc_ref(trans, root, buf, 1, 1); |
367 | BUG_ON(ret); | 372 | BUG_ON(ret); /* -ENOMEM */ |
368 | 373 | ||
369 | if (root->root_key.objectid == | 374 | if (root->root_key.objectid == |
370 | BTRFS_TREE_RELOC_OBJECTID) { | 375 | BTRFS_TREE_RELOC_OBJECTID) { |
371 | ret = btrfs_dec_ref(trans, root, buf, 0, 1); | 376 | ret = btrfs_dec_ref(trans, root, buf, 0, 1); |
372 | BUG_ON(ret); | 377 | BUG_ON(ret); /* -ENOMEM */ |
373 | ret = btrfs_inc_ref(trans, root, cow, 1, 1); | 378 | ret = btrfs_inc_ref(trans, root, cow, 1, 1); |
374 | BUG_ON(ret); | 379 | BUG_ON(ret); /* -ENOMEM */ |
375 | } | 380 | } |
376 | new_flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF; | 381 | new_flags |= BTRFS_BLOCK_FLAG_FULL_BACKREF; |
377 | } else { | 382 | } else { |
@@ -381,14 +386,15 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, | |||
381 | ret = btrfs_inc_ref(trans, root, cow, 1, 1); | 386 | ret = btrfs_inc_ref(trans, root, cow, 1, 1); |
382 | else | 387 | else |
383 | ret = btrfs_inc_ref(trans, root, cow, 0, 1); | 388 | ret = btrfs_inc_ref(trans, root, cow, 0, 1); |
384 | BUG_ON(ret); | 389 | BUG_ON(ret); /* -ENOMEM */ |
385 | } | 390 | } |
386 | if (new_flags != 0) { | 391 | if (new_flags != 0) { |
387 | ret = btrfs_set_disk_extent_flags(trans, root, | 392 | ret = btrfs_set_disk_extent_flags(trans, root, |
388 | buf->start, | 393 | buf->start, |
389 | buf->len, | 394 | buf->len, |
390 | new_flags, 0); | 395 | new_flags, 0); |
391 | BUG_ON(ret); | 396 | if (ret) |
397 | return ret; | ||
392 | } | 398 | } |
393 | } else { | 399 | } else { |
394 | if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) { | 400 | if (flags & BTRFS_BLOCK_FLAG_FULL_BACKREF) { |
@@ -397,9 +403,9 @@ static noinline int update_ref_for_cow(struct btrfs_trans_handle *trans, | |||
397 | ret = btrfs_inc_ref(trans, root, cow, 1, 1); | 403 | ret = btrfs_inc_ref(trans, root, cow, 1, 1); |
398 | else | 404 | else |
399 | ret = btrfs_inc_ref(trans, root, cow, 0, 1); | 405 | ret = btrfs_inc_ref(trans, root, cow, 0, 1); |
400 | BUG_ON(ret); | 406 | BUG_ON(ret); /* -ENOMEM */ |
401 | ret = btrfs_dec_ref(trans, root, buf, 1, 1); | 407 | ret = btrfs_dec_ref(trans, root, buf, 1, 1); |
402 | BUG_ON(ret); | 408 | BUG_ON(ret); /* -ENOMEM */ |
403 | } | 409 | } |
404 | clean_tree_block(trans, root, buf); | 410 | clean_tree_block(trans, root, buf); |
405 | *last_ref = 1; | 411 | *last_ref = 1; |
@@ -428,7 +434,7 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans, | |||
428 | { | 434 | { |
429 | struct btrfs_disk_key disk_key; | 435 | struct btrfs_disk_key disk_key; |
430 | struct extent_buffer *cow; | 436 | struct extent_buffer *cow; |
431 | int level; | 437 | int level, ret; |
432 | int last_ref = 0; | 438 | int last_ref = 0; |
433 | int unlock_orig = 0; | 439 | int unlock_orig = 0; |
434 | u64 parent_start; | 440 | u64 parent_start; |
@@ -480,7 +486,11 @@ static noinline int __btrfs_cow_block(struct btrfs_trans_handle *trans, | |||
480 | (unsigned long)btrfs_header_fsid(cow), | 486 | (unsigned long)btrfs_header_fsid(cow), |
481 | BTRFS_FSID_SIZE); | 487 | BTRFS_FSID_SIZE); |
482 | 488 | ||
483 | update_ref_for_cow(trans, root, buf, cow, &last_ref); | 489 | ret = update_ref_for_cow(trans, root, buf, cow, &last_ref); |
490 | if (ret) { | ||
491 | btrfs_abort_transaction(trans, root, ret); | ||
492 | return ret; | ||
493 | } | ||
484 | 494 | ||
485 | if (root->ref_cows) | 495 | if (root->ref_cows) |
486 | btrfs_reloc_cow_block(trans, root, buf, cow); | 496 | btrfs_reloc_cow_block(trans, root, buf, cow); |
@@ -947,7 +957,12 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, | |||
947 | 957 | ||
948 | /* promote the child to a root */ | 958 | /* promote the child to a root */ |
949 | child = read_node_slot(root, mid, 0); | 959 | child = read_node_slot(root, mid, 0); |
950 | BUG_ON(!child); | 960 | if (!child) { |
961 | ret = -EROFS; | ||
962 | btrfs_std_error(root->fs_info, ret); | ||
963 | goto enospc; | ||
964 | } | ||
965 | |||
951 | btrfs_tree_lock(child); | 966 | btrfs_tree_lock(child); |
952 | btrfs_set_lock_blocking(child); | 967 | btrfs_set_lock_blocking(child); |
953 | ret = btrfs_cow_block(trans, root, child, mid, 0, &child); | 968 | ret = btrfs_cow_block(trans, root, child, mid, 0, &child); |
@@ -1023,10 +1038,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, | |||
1023 | if (btrfs_header_nritems(right) == 0) { | 1038 | if (btrfs_header_nritems(right) == 0) { |
1024 | clean_tree_block(trans, root, right); | 1039 | clean_tree_block(trans, root, right); |
1025 | btrfs_tree_unlock(right); | 1040 | btrfs_tree_unlock(right); |
1026 | wret = del_ptr(trans, root, path, level + 1, pslot + | 1041 | del_ptr(trans, root, path, level + 1, pslot + 1); |
1027 | 1); | ||
1028 | if (wret) | ||
1029 | ret = wret; | ||
1030 | root_sub_used(root, right->len); | 1042 | root_sub_used(root, right->len); |
1031 | btrfs_free_tree_block(trans, root, right, 0, 1, 0); | 1043 | btrfs_free_tree_block(trans, root, right, 0, 1, 0); |
1032 | free_extent_buffer_stale(right); | 1044 | free_extent_buffer_stale(right); |
@@ -1048,7 +1060,11 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, | |||
1048 | * otherwise we would have pulled some pointers from the | 1060 | * otherwise we would have pulled some pointers from the |
1049 | * right | 1061 | * right |
1050 | */ | 1062 | */ |
1051 | BUG_ON(!left); | 1063 | if (!left) { |
1064 | ret = -EROFS; | ||
1065 | btrfs_std_error(root->fs_info, ret); | ||
1066 | goto enospc; | ||
1067 | } | ||
1052 | wret = balance_node_right(trans, root, mid, left); | 1068 | wret = balance_node_right(trans, root, mid, left); |
1053 | if (wret < 0) { | 1069 | if (wret < 0) { |
1054 | ret = wret; | 1070 | ret = wret; |
@@ -1064,9 +1080,7 @@ static noinline int balance_level(struct btrfs_trans_handle *trans, | |||
1064 | if (btrfs_header_nritems(mid) == 0) { | 1080 | if (btrfs_header_nritems(mid) == 0) { |
1065 | clean_tree_block(trans, root, mid); | 1081 | clean_tree_block(trans, root, mid); |
1066 | btrfs_tree_unlock(mid); | 1082 | btrfs_tree_unlock(mid); |
1067 | wret = del_ptr(trans, root, path, level + 1, pslot); | 1083 | del_ptr(trans, root, path, level + 1, pslot); |
1068 | if (wret) | ||
1069 | ret = wret; | ||
1070 | root_sub_used(root, mid->len); | 1084 | root_sub_used(root, mid->len); |
1071 | btrfs_free_tree_block(trans, root, mid, 0, 1, 0); | 1085 | btrfs_free_tree_block(trans, root, mid, 0, 1, 0); |
1072 | free_extent_buffer_stale(mid); | 1086 | free_extent_buffer_stale(mid); |
@@ -1905,15 +1919,12 @@ done: | |||
1905 | * fixing up pointers when a given leaf/node is not in slot 0 of the | 1919 | * fixing up pointers when a given leaf/node is not in slot 0 of the |
1906 | * higher levels | 1920 | * higher levels |
1907 | * | 1921 | * |
1908 | * If this fails to write a tree block, it returns -1, but continues | ||
1909 | * fixing up the blocks in ram so the tree is consistent. | ||
1910 | */ | 1922 | */ |
1911 | static int fixup_low_keys(struct btrfs_trans_handle *trans, | 1923 | static void fixup_low_keys(struct btrfs_trans_handle *trans, |
1912 | struct btrfs_root *root, struct btrfs_path *path, | 1924 | struct btrfs_root *root, struct btrfs_path *path, |
1913 | struct btrfs_disk_key *key, int level) | 1925 | struct btrfs_disk_key *key, int level) |
1914 | { | 1926 | { |
1915 | int i; | 1927 | int i; |
1916 | int ret = 0; | ||
1917 | struct extent_buffer *t; | 1928 | struct extent_buffer *t; |
1918 | 1929 | ||
1919 | for (i = level; i < BTRFS_MAX_LEVEL; i++) { | 1930 | for (i = level; i < BTRFS_MAX_LEVEL; i++) { |
@@ -1926,7 +1937,6 @@ static int fixup_low_keys(struct btrfs_trans_handle *trans, | |||
1926 | if (tslot != 0) | 1937 | if (tslot != 0) |
1927 | break; | 1938 | break; |
1928 | } | 1939 | } |
1929 | return ret; | ||
1930 | } | 1940 | } |
1931 | 1941 | ||
1932 | /* | 1942 | /* |
@@ -1935,9 +1945,9 @@ static int fixup_low_keys(struct btrfs_trans_handle *trans, | |||
1935 | * This function isn't completely safe. It's the caller's responsibility | 1945 | * This function isn't completely safe. It's the caller's responsibility |
1936 | * that the new key won't break the order | 1946 | * that the new key won't break the order |
1937 | */ | 1947 | */ |
1938 | int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans, | 1948 | void btrfs_set_item_key_safe(struct btrfs_trans_handle *trans, |
1939 | struct btrfs_root *root, struct btrfs_path *path, | 1949 | struct btrfs_root *root, struct btrfs_path *path, |
1940 | struct btrfs_key *new_key) | 1950 | struct btrfs_key *new_key) |
1941 | { | 1951 | { |
1942 | struct btrfs_disk_key disk_key; | 1952 | struct btrfs_disk_key disk_key; |
1943 | struct extent_buffer *eb; | 1953 | struct extent_buffer *eb; |
@@ -1947,13 +1957,11 @@ int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans, | |||
1947 | slot = path->slots[0]; | 1957 | slot = path->slots[0]; |
1948 | if (slot > 0) { | 1958 | if (slot > 0) { |
1949 | btrfs_item_key(eb, &disk_key, slot - 1); | 1959 | btrfs_item_key(eb, &disk_key, slot - 1); |
1950 | if (comp_keys(&disk_key, new_key) >= 0) | 1960 | BUG_ON(comp_keys(&disk_key, new_key) >= 0); |
1951 | return -1; | ||
1952 | } | 1961 | } |
1953 | if (slot < btrfs_header_nritems(eb) - 1) { | 1962 | if (slot < btrfs_header_nritems(eb) - 1) { |
1954 | btrfs_item_key(eb, &disk_key, slot + 1); | 1963 | btrfs_item_key(eb, &disk_key, slot + 1); |
1955 | if (comp_keys(&disk_key, new_key) <= 0) | 1964 | BUG_ON(comp_keys(&disk_key, new_key) <= 0); |
1956 | return -1; | ||
1957 | } | 1965 | } |
1958 | 1966 | ||
1959 | btrfs_cpu_key_to_disk(&disk_key, new_key); | 1967 | btrfs_cpu_key_to_disk(&disk_key, new_key); |
@@ -1961,7 +1969,6 @@ int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans, | |||
1961 | btrfs_mark_buffer_dirty(eb); | 1969 | btrfs_mark_buffer_dirty(eb); |
1962 | if (slot == 0) | 1970 | if (slot == 0) |
1963 | fixup_low_keys(trans, root, path, &disk_key, 1); | 1971 | fixup_low_keys(trans, root, path, &disk_key, 1); |
1964 | return 0; | ||
1965 | } | 1972 | } |
1966 | 1973 | ||
1967 | /* | 1974 | /* |
@@ -2164,12 +2171,11 @@ static noinline int insert_new_root(struct btrfs_trans_handle *trans, | |||
2164 | * | 2171 | * |
2165 | * slot and level indicate where you want the key to go, and | 2172 | * slot and level indicate where you want the key to go, and |
2166 | * blocknr is the block the key points to. | 2173 | * blocknr is the block the key points to. |
2167 | * | ||
2168 | * returns zero on success and < 0 on any error | ||
2169 | */ | 2174 | */ |
2170 | static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root | 2175 | static void insert_ptr(struct btrfs_trans_handle *trans, |
2171 | *root, struct btrfs_path *path, struct btrfs_disk_key | 2176 | struct btrfs_root *root, struct btrfs_path *path, |
2172 | *key, u64 bytenr, int slot, int level) | 2177 | struct btrfs_disk_key *key, u64 bytenr, |
2178 | int slot, int level) | ||
2173 | { | 2179 | { |
2174 | struct extent_buffer *lower; | 2180 | struct extent_buffer *lower; |
2175 | int nritems; | 2181 | int nritems; |
@@ -2179,8 +2185,7 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root | |||
2179 | lower = path->nodes[level]; | 2185 | lower = path->nodes[level]; |
2180 | nritems = btrfs_header_nritems(lower); | 2186 | nritems = btrfs_header_nritems(lower); |
2181 | BUG_ON(slot > nritems); | 2187 | BUG_ON(slot > nritems); |
2182 | if (nritems == BTRFS_NODEPTRS_PER_BLOCK(root)) | 2188 | BUG_ON(nritems == BTRFS_NODEPTRS_PER_BLOCK(root)); |
2183 | BUG(); | ||
2184 | if (slot != nritems) { | 2189 | if (slot != nritems) { |
2185 | memmove_extent_buffer(lower, | 2190 | memmove_extent_buffer(lower, |
2186 | btrfs_node_key_ptr_offset(slot + 1), | 2191 | btrfs_node_key_ptr_offset(slot + 1), |
@@ -2193,7 +2198,6 @@ static int insert_ptr(struct btrfs_trans_handle *trans, struct btrfs_root | |||
2193 | btrfs_set_node_ptr_generation(lower, slot, trans->transid); | 2198 | btrfs_set_node_ptr_generation(lower, slot, trans->transid); |
2194 | btrfs_set_header_nritems(lower, nritems + 1); | 2199 | btrfs_set_header_nritems(lower, nritems + 1); |
2195 | btrfs_mark_buffer_dirty(lower); | 2200 | btrfs_mark_buffer_dirty(lower); |
2196 | return 0; | ||
2197 | } | 2201 | } |
2198 | 2202 | ||
2199 | /* | 2203 | /* |
@@ -2214,7 +2218,6 @@ static noinline int split_node(struct btrfs_trans_handle *trans, | |||
2214 | struct btrfs_disk_key disk_key; | 2218 | struct btrfs_disk_key disk_key; |
2215 | int mid; | 2219 | int mid; |
2216 | int ret; | 2220 | int ret; |
2217 | int wret; | ||
2218 | u32 c_nritems; | 2221 | u32 c_nritems; |
2219 | 2222 | ||
2220 | c = path->nodes[level]; | 2223 | c = path->nodes[level]; |
@@ -2271,11 +2274,8 @@ static noinline int split_node(struct btrfs_trans_handle *trans, | |||
2271 | btrfs_mark_buffer_dirty(c); | 2274 | btrfs_mark_buffer_dirty(c); |
2272 | btrfs_mark_buffer_dirty(split); | 2275 | btrfs_mark_buffer_dirty(split); |
2273 | 2276 | ||
2274 | wret = insert_ptr(trans, root, path, &disk_key, split->start, | 2277 | insert_ptr(trans, root, path, &disk_key, split->start, |
2275 | path->slots[level + 1] + 1, | 2278 | path->slots[level + 1] + 1, level + 1); |
2276 | level + 1); | ||
2277 | if (wret) | ||
2278 | ret = wret; | ||
2279 | 2279 | ||
2280 | if (path->slots[level] >= mid) { | 2280 | if (path->slots[level] >= mid) { |
2281 | path->slots[level] -= mid; | 2281 | path->slots[level] -= mid; |
@@ -2564,7 +2564,6 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans, | |||
2564 | u32 old_left_nritems; | 2564 | u32 old_left_nritems; |
2565 | u32 nr; | 2565 | u32 nr; |
2566 | int ret = 0; | 2566 | int ret = 0; |
2567 | int wret; | ||
2568 | u32 this_item_size; | 2567 | u32 this_item_size; |
2569 | u32 old_left_item_size; | 2568 | u32 old_left_item_size; |
2570 | struct btrfs_map_token token; | 2569 | struct btrfs_map_token token; |
@@ -2675,9 +2674,7 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans, | |||
2675 | clean_tree_block(trans, root, right); | 2674 | clean_tree_block(trans, root, right); |
2676 | 2675 | ||
2677 | btrfs_item_key(right, &disk_key, 0); | 2676 | btrfs_item_key(right, &disk_key, 0); |
2678 | wret = fixup_low_keys(trans, root, path, &disk_key, 1); | 2677 | fixup_low_keys(trans, root, path, &disk_key, 1); |
2679 | if (wret) | ||
2680 | ret = wret; | ||
2681 | 2678 | ||
2682 | /* then fixup the leaf pointer in the path */ | 2679 | /* then fixup the leaf pointer in the path */ |
2683 | if (path->slots[0] < push_items) { | 2680 | if (path->slots[0] < push_items) { |
@@ -2748,7 +2745,8 @@ static int push_leaf_left(struct btrfs_trans_handle *trans, struct btrfs_root | |||
2748 | path->nodes[1], slot - 1, &left); | 2745 | path->nodes[1], slot - 1, &left); |
2749 | if (ret) { | 2746 | if (ret) { |
2750 | /* we hit -ENOSPC, but it isn't fatal here */ | 2747 | /* we hit -ENOSPC, but it isn't fatal here */ |
2751 | ret = 1; | 2748 | if (ret == -ENOSPC) |
2749 | ret = 1; | ||
2752 | goto out; | 2750 | goto out; |
2753 | } | 2751 | } |
2754 | 2752 | ||
@@ -2770,21 +2768,17 @@ out: | |||
2770 | /* | 2768 | /* |
2771 | * split the path's leaf in two, making sure there is at least data_size | 2769 | * split the path's leaf in two, making sure there is at least data_size |
2772 | * available for the resulting leaf level of the path. | 2770 | * available for the resulting leaf level of the path. |
2773 | * | ||
2774 | * returns 0 if all went well and < 0 on failure. | ||
2775 | */ | 2771 | */ |
2776 | static noinline int copy_for_split(struct btrfs_trans_handle *trans, | 2772 | static noinline void copy_for_split(struct btrfs_trans_handle *trans, |
2777 | struct btrfs_root *root, | 2773 | struct btrfs_root *root, |
2778 | struct btrfs_path *path, | 2774 | struct btrfs_path *path, |
2779 | struct extent_buffer *l, | 2775 | struct extent_buffer *l, |
2780 | struct extent_buffer *right, | 2776 | struct extent_buffer *right, |
2781 | int slot, int mid, int nritems) | 2777 | int slot, int mid, int nritems) |
2782 | { | 2778 | { |
2783 | int data_copy_size; | 2779 | int data_copy_size; |
2784 | int rt_data_off; | 2780 | int rt_data_off; |
2785 | int i; | 2781 | int i; |
2786 | int ret = 0; | ||
2787 | int wret; | ||
2788 | struct btrfs_disk_key disk_key; | 2782 | struct btrfs_disk_key disk_key; |
2789 | struct btrfs_map_token token; | 2783 | struct btrfs_map_token token; |
2790 | 2784 | ||
@@ -2816,12 +2810,9 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, | |||
2816 | } | 2810 | } |
2817 | 2811 | ||
2818 | btrfs_set_header_nritems(l, mid); | 2812 | btrfs_set_header_nritems(l, mid); |
2819 | ret = 0; | ||
2820 | btrfs_item_key(right, &disk_key, 0); | 2813 | btrfs_item_key(right, &disk_key, 0); |
2821 | wret = insert_ptr(trans, root, path, &disk_key, right->start, | 2814 | insert_ptr(trans, root, path, &disk_key, right->start, |
2822 | path->slots[1] + 1, 1); | 2815 | path->slots[1] + 1, 1); |
2823 | if (wret) | ||
2824 | ret = wret; | ||
2825 | 2816 | ||
2826 | btrfs_mark_buffer_dirty(right); | 2817 | btrfs_mark_buffer_dirty(right); |
2827 | btrfs_mark_buffer_dirty(l); | 2818 | btrfs_mark_buffer_dirty(l); |
@@ -2839,8 +2830,6 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans, | |||
2839 | } | 2830 | } |
2840 | 2831 | ||
2841 | BUG_ON(path->slots[0] < 0); | 2832 | BUG_ON(path->slots[0] < 0); |
2842 | |||
2843 | return ret; | ||
2844 | } | 2833 | } |
2845 | 2834 | ||
2846 | /* | 2835 | /* |
@@ -3029,12 +3018,8 @@ again: | |||
3029 | if (split == 0) { | 3018 | if (split == 0) { |
3030 | if (mid <= slot) { | 3019 | if (mid <= slot) { |
3031 | btrfs_set_header_nritems(right, 0); | 3020 | btrfs_set_header_nritems(right, 0); |
3032 | wret = insert_ptr(trans, root, path, | 3021 | insert_ptr(trans, root, path, &disk_key, right->start, |
3033 | &disk_key, right->start, | 3022 | path->slots[1] + 1, 1); |
3034 | path->slots[1] + 1, 1); | ||
3035 | if (wret) | ||
3036 | ret = wret; | ||
3037 | |||
3038 | btrfs_tree_unlock(path->nodes[0]); | 3023 | btrfs_tree_unlock(path->nodes[0]); |
3039 | free_extent_buffer(path->nodes[0]); | 3024 | free_extent_buffer(path->nodes[0]); |
3040 | path->nodes[0] = right; | 3025 | path->nodes[0] = right; |
@@ -3042,29 +3027,21 @@ again: | |||
3042 | path->slots[1] += 1; | 3027 | path->slots[1] += 1; |
3043 | } else { | 3028 | } else { |
3044 | btrfs_set_header_nritems(right, 0); | 3029 | btrfs_set_header_nritems(right, 0); |
3045 | wret = insert_ptr(trans, root, path, | 3030 | insert_ptr(trans, root, path, &disk_key, right->start, |
3046 | &disk_key, | ||
3047 | right->start, | ||
3048 | path->slots[1], 1); | 3031 | path->slots[1], 1); |
3049 | if (wret) | ||
3050 | ret = wret; | ||
3051 | btrfs_tree_unlock(path->nodes[0]); | 3032 | btrfs_tree_unlock(path->nodes[0]); |
3052 | free_extent_buffer(path->nodes[0]); | 3033 | free_extent_buffer(path->nodes[0]); |
3053 | path->nodes[0] = right; | 3034 | path->nodes[0] = right; |
3054 | path->slots[0] = 0; | 3035 | path->slots[0] = 0; |
3055 | if (path->slots[1] == 0) { | 3036 | if (path->slots[1] == 0) |
3056 | wret = fixup_low_keys(trans, root, | 3037 | fixup_low_keys(trans, root, path, |
3057 | path, &disk_key, 1); | 3038 | &disk_key, 1); |
3058 | if (wret) | ||
3059 | ret = wret; | ||
3060 | } | ||
3061 | } | 3039 | } |
3062 | btrfs_mark_buffer_dirty(right); | 3040 | btrfs_mark_buffer_dirty(right); |
3063 | return ret; | 3041 | return ret; |
3064 | } | 3042 | } |
3065 | 3043 | ||
3066 | ret = copy_for_split(trans, root, path, l, right, slot, mid, nritems); | 3044 | copy_for_split(trans, root, path, l, right, slot, mid, nritems); |
3067 | BUG_ON(ret); | ||
3068 | 3045 | ||
3069 | if (split == 2) { | 3046 | if (split == 2) { |
3070 | BUG_ON(num_doubles != 0); | 3047 | BUG_ON(num_doubles != 0); |
@@ -3072,7 +3049,7 @@ again: | |||
3072 | goto again; | 3049 | goto again; |
3073 | } | 3050 | } |
3074 | 3051 | ||
3075 | return ret; | 3052 | return 0; |
3076 | 3053 | ||
3077 | push_for_double: | 3054 | push_for_double: |
3078 | push_for_double_split(trans, root, path, data_size); | 3055 | push_for_double_split(trans, root, path, data_size); |
@@ -3274,11 +3251,9 @@ int btrfs_duplicate_item(struct btrfs_trans_handle *trans, | |||
3274 | return ret; | 3251 | return ret; |
3275 | 3252 | ||
3276 | path->slots[0]++; | 3253 | path->slots[0]++; |
3277 | ret = setup_items_for_insert(trans, root, path, new_key, &item_size, | 3254 | setup_items_for_insert(trans, root, path, new_key, &item_size, |
3278 | item_size, item_size + | 3255 | item_size, item_size + |
3279 | sizeof(struct btrfs_item), 1); | 3256 | sizeof(struct btrfs_item), 1); |
3280 | BUG_ON(ret); | ||
3281 | |||
3282 | leaf = path->nodes[0]; | 3257 | leaf = path->nodes[0]; |
3283 | memcpy_extent_buffer(leaf, | 3258 | memcpy_extent_buffer(leaf, |
3284 | btrfs_item_ptr_offset(leaf, path->slots[0]), | 3259 | btrfs_item_ptr_offset(leaf, path->slots[0]), |
@@ -3293,10 +3268,10 @@ int btrfs_duplicate_item(struct btrfs_trans_handle *trans, | |||
3293 | * off the end of the item or if we shift the item to chop bytes off | 3268 | * off the end of the item or if we shift the item to chop bytes off |
3294 | * the front. | 3269 | * the front. |
3295 | */ | 3270 | */ |
3296 | int btrfs_truncate_item(struct btrfs_trans_handle *trans, | 3271 | void btrfs_truncate_item(struct btrfs_trans_handle *trans, |
3297 | struct btrfs_root *root, | 3272 | struct btrfs_root *root, |
3298 | struct btrfs_path *path, | 3273 | struct btrfs_path *path, |
3299 | u32 new_size, int from_end) | 3274 | u32 new_size, int from_end) |
3300 | { | 3275 | { |
3301 | int slot; | 3276 | int slot; |
3302 | struct extent_buffer *leaf; | 3277 | struct extent_buffer *leaf; |
@@ -3316,7 +3291,7 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans, | |||
3316 | 3291 | ||
3317 | old_size = btrfs_item_size_nr(leaf, slot); | 3292 | old_size = btrfs_item_size_nr(leaf, slot); |
3318 | if (old_size == new_size) | 3293 | if (old_size == new_size) |
3319 | return 0; | 3294 | return; |
3320 | 3295 | ||
3321 | nritems = btrfs_header_nritems(leaf); | 3296 | nritems = btrfs_header_nritems(leaf); |
3322 | data_end = leaf_data_end(root, leaf); | 3297 | data_end = leaf_data_end(root, leaf); |
@@ -3390,15 +3365,14 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans, | |||
3390 | btrfs_print_leaf(root, leaf); | 3365 | btrfs_print_leaf(root, leaf); |
3391 | BUG(); | 3366 | BUG(); |
3392 | } | 3367 | } |
3393 | return 0; | ||
3394 | } | 3368 | } |
3395 | 3369 | ||
3396 | /* | 3370 | /* |
3397 | * make the item pointed to by the path bigger, data_size is the new size. | 3371 | * make the item pointed to by the path bigger, data_size is the new size. |
3398 | */ | 3372 | */ |
3399 | int btrfs_extend_item(struct btrfs_trans_handle *trans, | 3373 | void btrfs_extend_item(struct btrfs_trans_handle *trans, |
3400 | struct btrfs_root *root, struct btrfs_path *path, | 3374 | struct btrfs_root *root, struct btrfs_path *path, |
3401 | u32 data_size) | 3375 | u32 data_size) |
3402 | { | 3376 | { |
3403 | int slot; | 3377 | int slot; |
3404 | struct extent_buffer *leaf; | 3378 | struct extent_buffer *leaf; |
@@ -3460,7 +3434,6 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans, | |||
3460 | btrfs_print_leaf(root, leaf); | 3434 | btrfs_print_leaf(root, leaf); |
3461 | BUG(); | 3435 | BUG(); |
3462 | } | 3436 | } |
3463 | return 0; | ||
3464 | } | 3437 | } |
3465 | 3438 | ||
3466 | /* | 3439 | /* |
@@ -3593,7 +3566,7 @@ int btrfs_insert_some_items(struct btrfs_trans_handle *trans, | |||
3593 | ret = 0; | 3566 | ret = 0; |
3594 | if (slot == 0) { | 3567 | if (slot == 0) { |
3595 | btrfs_cpu_key_to_disk(&disk_key, cpu_key); | 3568 | btrfs_cpu_key_to_disk(&disk_key, cpu_key); |
3596 | ret = fixup_low_keys(trans, root, path, &disk_key, 1); | 3569 | fixup_low_keys(trans, root, path, &disk_key, 1); |
3597 | } | 3570 | } |
3598 | 3571 | ||
3599 | if (btrfs_leaf_free_space(root, leaf) < 0) { | 3572 | if (btrfs_leaf_free_space(root, leaf) < 0) { |
@@ -3611,17 +3584,16 @@ out: | |||
3611 | * to save stack depth by doing the bulk of the work in a function | 3584 | * to save stack depth by doing the bulk of the work in a function |
3612 | * that doesn't call btrfs_search_slot | 3585 | * that doesn't call btrfs_search_slot |
3613 | */ | 3586 | */ |
3614 | int setup_items_for_insert(struct btrfs_trans_handle *trans, | 3587 | void setup_items_for_insert(struct btrfs_trans_handle *trans, |
3615 | struct btrfs_root *root, struct btrfs_path *path, | 3588 | struct btrfs_root *root, struct btrfs_path *path, |
3616 | struct btrfs_key *cpu_key, u32 *data_size, | 3589 | struct btrfs_key *cpu_key, u32 *data_size, |
3617 | u32 total_data, u32 total_size, int nr) | 3590 | u32 total_data, u32 total_size, int nr) |
3618 | { | 3591 | { |
3619 | struct btrfs_item *item; | 3592 | struct btrfs_item *item; |
3620 | int i; | 3593 | int i; |
3621 | u32 nritems; | 3594 | u32 nritems; |
3622 | unsigned int data_end; | 3595 | unsigned int data_end; |
3623 | struct btrfs_disk_key disk_key; | 3596 | struct btrfs_disk_key disk_key; |
3624 | int ret; | ||
3625 | struct extent_buffer *leaf; | 3597 | struct extent_buffer *leaf; |
3626 | int slot; | 3598 | int slot; |
3627 | struct btrfs_map_token token; | 3599 | struct btrfs_map_token token; |
@@ -3687,10 +3659,9 @@ int setup_items_for_insert(struct btrfs_trans_handle *trans, | |||
3687 | 3659 | ||
3688 | btrfs_set_header_nritems(leaf, nritems + nr); | 3660 | btrfs_set_header_nritems(leaf, nritems + nr); |
3689 | 3661 | ||
3690 | ret = 0; | ||
3691 | if (slot == 0) { | 3662 | if (slot == 0) { |
3692 | btrfs_cpu_key_to_disk(&disk_key, cpu_key); | 3663 | btrfs_cpu_key_to_disk(&disk_key, cpu_key); |
3693 | ret = fixup_low_keys(trans, root, path, &disk_key, 1); | 3664 | fixup_low_keys(trans, root, path, &disk_key, 1); |
3694 | } | 3665 | } |
3695 | btrfs_unlock_up_safe(path, 1); | 3666 | btrfs_unlock_up_safe(path, 1); |
3696 | btrfs_mark_buffer_dirty(leaf); | 3667 | btrfs_mark_buffer_dirty(leaf); |
@@ -3699,7 +3670,6 @@ int setup_items_for_insert(struct btrfs_trans_handle *trans, | |||
3699 | btrfs_print_leaf(root, leaf); | 3670 | btrfs_print_leaf(root, leaf); |
3700 | BUG(); | 3671 | BUG(); |
3701 | } | 3672 | } |
3702 | return ret; | ||
3703 | } | 3673 | } |
3704 | 3674 | ||
3705 | /* | 3675 | /* |
@@ -3726,16 +3696,14 @@ int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, | |||
3726 | if (ret == 0) | 3696 | if (ret == 0) |
3727 | return -EEXIST; | 3697 | return -EEXIST; |
3728 | if (ret < 0) | 3698 | if (ret < 0) |
3729 | goto out; | 3699 | return ret; |
3730 | 3700 | ||
3731 | slot = path->slots[0]; | 3701 | slot = path->slots[0]; |
3732 | BUG_ON(slot < 0); | 3702 | BUG_ON(slot < 0); |
3733 | 3703 | ||
3734 | ret = setup_items_for_insert(trans, root, path, cpu_key, data_size, | 3704 | setup_items_for_insert(trans, root, path, cpu_key, data_size, |
3735 | total_data, total_size, nr); | 3705 | total_data, total_size, nr); |
3736 | 3706 | return 0; | |
3737 | out: | ||
3738 | return ret; | ||
3739 | } | 3707 | } |
3740 | 3708 | ||
3741 | /* | 3709 | /* |
@@ -3771,13 +3739,11 @@ int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root | |||
3771 | * the tree should have been previously balanced so the deletion does not | 3739 | * the tree should have been previously balanced so the deletion does not |
3772 | * empty a node. | 3740 | * empty a node. |
3773 | */ | 3741 | */ |
3774 | static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, | 3742 | static void del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, |
3775 | struct btrfs_path *path, int level, int slot) | 3743 | struct btrfs_path *path, int level, int slot) |
3776 | { | 3744 | { |
3777 | struct extent_buffer *parent = path->nodes[level]; | 3745 | struct extent_buffer *parent = path->nodes[level]; |
3778 | u32 nritems; | 3746 | u32 nritems; |
3779 | int ret = 0; | ||
3780 | int wret; | ||
3781 | 3747 | ||
3782 | nritems = btrfs_header_nritems(parent); | 3748 | nritems = btrfs_header_nritems(parent); |
3783 | if (slot != nritems - 1) { | 3749 | if (slot != nritems - 1) { |
@@ -3797,12 +3763,9 @@ static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, | |||
3797 | struct btrfs_disk_key disk_key; | 3763 | struct btrfs_disk_key disk_key; |
3798 | 3764 | ||
3799 | btrfs_node_key(parent, &disk_key, 0); | 3765 | btrfs_node_key(parent, &disk_key, 0); |
3800 | wret = fixup_low_keys(trans, root, path, &disk_key, level + 1); | 3766 | fixup_low_keys(trans, root, path, &disk_key, level + 1); |
3801 | if (wret) | ||
3802 | ret = wret; | ||
3803 | } | 3767 | } |
3804 | btrfs_mark_buffer_dirty(parent); | 3768 | btrfs_mark_buffer_dirty(parent); |
3805 | return ret; | ||
3806 | } | 3769 | } |
3807 | 3770 | ||
3808 | /* | 3771 | /* |
@@ -3815,17 +3778,13 @@ static int del_ptr(struct btrfs_trans_handle *trans, struct btrfs_root *root, | |||
3815 | * The path must have already been setup for deleting the leaf, including | 3778 | * The path must have already been setup for deleting the leaf, including |
3816 | * all the proper balancing. path->nodes[1] must be locked. | 3779 | * all the proper balancing. path->nodes[1] must be locked. |
3817 | */ | 3780 | */ |
3818 | static noinline int btrfs_del_leaf(struct btrfs_trans_handle *trans, | 3781 | static noinline void btrfs_del_leaf(struct btrfs_trans_handle *trans, |
3819 | struct btrfs_root *root, | 3782 | struct btrfs_root *root, |
3820 | struct btrfs_path *path, | 3783 | struct btrfs_path *path, |
3821 | struct extent_buffer *leaf) | 3784 | struct extent_buffer *leaf) |
3822 | { | 3785 | { |
3823 | int ret; | ||
3824 | |||
3825 | WARN_ON(btrfs_header_generation(leaf) != trans->transid); | 3786 | WARN_ON(btrfs_header_generation(leaf) != trans->transid); |
3826 | ret = del_ptr(trans, root, path, 1, path->slots[1]); | 3787 | del_ptr(trans, root, path, 1, path->slots[1]); |
3827 | if (ret) | ||
3828 | return ret; | ||
3829 | 3788 | ||
3830 | /* | 3789 | /* |
3831 | * btrfs_free_extent is expensive, we want to make sure we | 3790 | * btrfs_free_extent is expensive, we want to make sure we |
@@ -3838,7 +3797,6 @@ static noinline int btrfs_del_leaf(struct btrfs_trans_handle *trans, | |||
3838 | extent_buffer_get(leaf); | 3797 | extent_buffer_get(leaf); |
3839 | btrfs_free_tree_block(trans, root, leaf, 0, 1, 0); | 3798 | btrfs_free_tree_block(trans, root, leaf, 0, 1, 0); |
3840 | free_extent_buffer_stale(leaf); | 3799 | free_extent_buffer_stale(leaf); |
3841 | return 0; | ||
3842 | } | 3800 | } |
3843 | /* | 3801 | /* |
3844 | * delete the item at the leaf level in path. If that empties | 3802 | * delete the item at the leaf level in path. If that empties |
@@ -3899,8 +3857,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, | |||
3899 | } else { | 3857 | } else { |
3900 | btrfs_set_path_blocking(path); | 3858 | btrfs_set_path_blocking(path); |
3901 | clean_tree_block(trans, root, leaf); | 3859 | clean_tree_block(trans, root, leaf); |
3902 | ret = btrfs_del_leaf(trans, root, path, leaf); | 3860 | btrfs_del_leaf(trans, root, path, leaf); |
3903 | BUG_ON(ret); | ||
3904 | } | 3861 | } |
3905 | } else { | 3862 | } else { |
3906 | int used = leaf_space_used(leaf, 0, nritems); | 3863 | int used = leaf_space_used(leaf, 0, nritems); |
@@ -3908,10 +3865,7 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, | |||
3908 | struct btrfs_disk_key disk_key; | 3865 | struct btrfs_disk_key disk_key; |
3909 | 3866 | ||
3910 | btrfs_item_key(leaf, &disk_key, 0); | 3867 | btrfs_item_key(leaf, &disk_key, 0); |
3911 | wret = fixup_low_keys(trans, root, path, | 3868 | fixup_low_keys(trans, root, path, &disk_key, 1); |
3912 | &disk_key, 1); | ||
3913 | if (wret) | ||
3914 | ret = wret; | ||
3915 | } | 3869 | } |
3916 | 3870 | ||
3917 | /* delete the leaf if it is mostly empty */ | 3871 | /* delete the leaf if it is mostly empty */ |
@@ -3939,9 +3893,9 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root, | |||
3939 | 3893 | ||
3940 | if (btrfs_header_nritems(leaf) == 0) { | 3894 | if (btrfs_header_nritems(leaf) == 0) { |
3941 | path->slots[1] = slot; | 3895 | path->slots[1] = slot; |
3942 | ret = btrfs_del_leaf(trans, root, path, leaf); | 3896 | btrfs_del_leaf(trans, root, path, leaf); |
3943 | BUG_ON(ret); | ||
3944 | free_extent_buffer(leaf); | 3897 | free_extent_buffer(leaf); |
3898 | ret = 0; | ||
3945 | } else { | 3899 | } else { |
3946 | /* if we're still in the path, make sure | 3900 | /* if we're still in the path, make sure |
3947 | * we're dirty. Otherwise, one of the | 3901 | * we're dirty. Otherwise, one of the |
@@ -4124,7 +4078,7 @@ find_next_key: | |||
4124 | } | 4078 | } |
4125 | btrfs_set_path_blocking(path); | 4079 | btrfs_set_path_blocking(path); |
4126 | cur = read_node_slot(root, cur, slot); | 4080 | cur = read_node_slot(root, cur, slot); |
4127 | BUG_ON(!cur); | 4081 | BUG_ON(!cur); /* -ENOMEM */ |
4128 | 4082 | ||
4129 | btrfs_tree_read_lock(cur); | 4083 | btrfs_tree_read_lock(cur); |
4130 | 4084 | ||
diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h index f7da8a8d13c1..ed2d196f7a84 100644 --- a/fs/btrfs/ctree.h +++ b/fs/btrfs/ctree.h | |||
@@ -1525,6 +1525,7 @@ struct btrfs_ioctl_defrag_range_args { | |||
1525 | #define BTRFS_MOUNT_SKIP_BALANCE (1 << 19) | 1525 | #define BTRFS_MOUNT_SKIP_BALANCE (1 << 19) |
1526 | #define BTRFS_MOUNT_CHECK_INTEGRITY (1 << 20) | 1526 | #define BTRFS_MOUNT_CHECK_INTEGRITY (1 << 20) |
1527 | #define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21) | 1527 | #define BTRFS_MOUNT_CHECK_INTEGRITY_INCLUDING_EXTENT_DATA (1 << 21) |
1528 | #define BTRFS_MOUNT_PANIC_ON_FATAL_ERROR (1 << 22) | ||
1528 | 1529 | ||
1529 | #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt) | 1530 | #define btrfs_clear_opt(o, opt) ((o) &= ~BTRFS_MOUNT_##opt) |
1530 | #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt) | 1531 | #define btrfs_set_opt(o, opt) ((o) |= BTRFS_MOUNT_##opt) |
@@ -2518,8 +2519,8 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, | |||
2518 | int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len); | 2519 | int btrfs_free_reserved_extent(struct btrfs_root *root, u64 start, u64 len); |
2519 | int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root, | 2520 | int btrfs_free_and_pin_reserved_extent(struct btrfs_root *root, |
2520 | u64 start, u64 len); | 2521 | u64 start, u64 len); |
2521 | int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans, | 2522 | void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans, |
2522 | struct btrfs_root *root); | 2523 | struct btrfs_root *root); |
2523 | int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, | 2524 | int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, |
2524 | struct btrfs_root *root); | 2525 | struct btrfs_root *root); |
2525 | int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, | 2526 | int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, |
@@ -2582,8 +2583,8 @@ void btrfs_block_rsv_release(struct btrfs_root *root, | |||
2582 | u64 num_bytes); | 2583 | u64 num_bytes); |
2583 | int btrfs_set_block_group_ro(struct btrfs_root *root, | 2584 | int btrfs_set_block_group_ro(struct btrfs_root *root, |
2584 | struct btrfs_block_group_cache *cache); | 2585 | struct btrfs_block_group_cache *cache); |
2585 | int btrfs_set_block_group_rw(struct btrfs_root *root, | 2586 | void btrfs_set_block_group_rw(struct btrfs_root *root, |
2586 | struct btrfs_block_group_cache *cache); | 2587 | struct btrfs_block_group_cache *cache); |
2587 | void btrfs_put_block_group_cache(struct btrfs_fs_info *info); | 2588 | void btrfs_put_block_group_cache(struct btrfs_fs_info *info); |
2588 | u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo); | 2589 | u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo); |
2589 | int btrfs_error_unpin_extent_range(struct btrfs_root *root, | 2590 | int btrfs_error_unpin_extent_range(struct btrfs_root *root, |
@@ -2602,9 +2603,9 @@ int btrfs_comp_cpu_keys(struct btrfs_key *k1, struct btrfs_key *k2); | |||
2602 | int btrfs_previous_item(struct btrfs_root *root, | 2603 | int btrfs_previous_item(struct btrfs_root *root, |
2603 | struct btrfs_path *path, u64 min_objectid, | 2604 | struct btrfs_path *path, u64 min_objectid, |
2604 | int type); | 2605 | int type); |
2605 | int btrfs_set_item_key_safe(struct btrfs_trans_handle *trans, | 2606 | void btrfs_set_item_key_safe(struct btrfs_trans_handle *trans, |
2606 | struct btrfs_root *root, struct btrfs_path *path, | 2607 | struct btrfs_root *root, struct btrfs_path *path, |
2607 | struct btrfs_key *new_key); | 2608 | struct btrfs_key *new_key); |
2608 | struct extent_buffer *btrfs_root_node(struct btrfs_root *root); | 2609 | struct extent_buffer *btrfs_root_node(struct btrfs_root *root); |
2609 | struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root); | 2610 | struct extent_buffer *btrfs_lock_root_node(struct btrfs_root *root); |
2610 | int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path, | 2611 | int btrfs_find_next_key(struct btrfs_root *root, struct btrfs_path *path, |
@@ -2624,12 +2625,13 @@ int btrfs_copy_root(struct btrfs_trans_handle *trans, | |||
2624 | struct extent_buffer **cow_ret, u64 new_root_objectid); | 2625 | struct extent_buffer **cow_ret, u64 new_root_objectid); |
2625 | int btrfs_block_can_be_shared(struct btrfs_root *root, | 2626 | int btrfs_block_can_be_shared(struct btrfs_root *root, |
2626 | struct extent_buffer *buf); | 2627 | struct extent_buffer *buf); |
2627 | int btrfs_extend_item(struct btrfs_trans_handle *trans, struct btrfs_root | 2628 | void btrfs_extend_item(struct btrfs_trans_handle *trans, |
2628 | *root, struct btrfs_path *path, u32 data_size); | 2629 | struct btrfs_root *root, struct btrfs_path *path, |
2629 | int btrfs_truncate_item(struct btrfs_trans_handle *trans, | 2630 | u32 data_size); |
2630 | struct btrfs_root *root, | 2631 | void btrfs_truncate_item(struct btrfs_trans_handle *trans, |
2631 | struct btrfs_path *path, | 2632 | struct btrfs_root *root, |
2632 | u32 new_size, int from_end); | 2633 | struct btrfs_path *path, |
2634 | u32 new_size, int from_end); | ||
2633 | int btrfs_split_item(struct btrfs_trans_handle *trans, | 2635 | int btrfs_split_item(struct btrfs_trans_handle *trans, |
2634 | struct btrfs_root *root, | 2636 | struct btrfs_root *root, |
2635 | struct btrfs_path *path, | 2637 | struct btrfs_path *path, |
@@ -2663,10 +2665,10 @@ static inline int btrfs_del_item(struct btrfs_trans_handle *trans, | |||
2663 | return btrfs_del_items(trans, root, path, path->slots[0], 1); | 2665 | return btrfs_del_items(trans, root, path, path->slots[0], 1); |
2664 | } | 2666 | } |
2665 | 2667 | ||
2666 | int setup_items_for_insert(struct btrfs_trans_handle *trans, | 2668 | void setup_items_for_insert(struct btrfs_trans_handle *trans, |
2667 | struct btrfs_root *root, struct btrfs_path *path, | 2669 | struct btrfs_root *root, struct btrfs_path *path, |
2668 | struct btrfs_key *cpu_key, u32 *data_size, | 2670 | struct btrfs_key *cpu_key, u32 *data_size, |
2669 | u32 total_data, u32 total_size, int nr); | 2671 | u32 total_data, u32 total_size, int nr); |
2670 | int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root | 2672 | int btrfs_insert_item(struct btrfs_trans_handle *trans, struct btrfs_root |
2671 | *root, struct btrfs_key *key, void *data, u32 data_size); | 2673 | *root, struct btrfs_key *key, void *data, u32 data_size); |
2672 | int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, | 2674 | int btrfs_insert_empty_items(struct btrfs_trans_handle *trans, |
@@ -2693,9 +2695,9 @@ static inline int btrfs_next_item(struct btrfs_root *root, struct btrfs_path *p) | |||
2693 | } | 2695 | } |
2694 | int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path); | 2696 | int btrfs_prev_leaf(struct btrfs_root *root, struct btrfs_path *path); |
2695 | int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf); | 2697 | int btrfs_leaf_free_space(struct btrfs_root *root, struct extent_buffer *leaf); |
2696 | void btrfs_drop_snapshot(struct btrfs_root *root, | 2698 | int __must_check btrfs_drop_snapshot(struct btrfs_root *root, |
2697 | struct btrfs_block_rsv *block_rsv, int update_ref, | 2699 | struct btrfs_block_rsv *block_rsv, |
2698 | int for_reloc); | 2700 | int update_ref, int for_reloc); |
2699 | int btrfs_drop_subtree(struct btrfs_trans_handle *trans, | 2701 | int btrfs_drop_subtree(struct btrfs_trans_handle *trans, |
2700 | struct btrfs_root *root, | 2702 | struct btrfs_root *root, |
2701 | struct extent_buffer *node, | 2703 | struct extent_buffer *node, |
@@ -2757,9 +2759,10 @@ int btrfs_del_root(struct btrfs_trans_handle *trans, struct btrfs_root *root, | |||
2757 | int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root | 2759 | int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root |
2758 | *root, struct btrfs_key *key, struct btrfs_root_item | 2760 | *root, struct btrfs_key *key, struct btrfs_root_item |
2759 | *item); | 2761 | *item); |
2760 | int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root | 2762 | int __must_check btrfs_update_root(struct btrfs_trans_handle *trans, |
2761 | *root, struct btrfs_key *key, struct btrfs_root_item | 2763 | struct btrfs_root *root, |
2762 | *item); | 2764 | struct btrfs_key *key, |
2765 | struct btrfs_root_item *item); | ||
2763 | int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct | 2766 | int btrfs_find_last_root(struct btrfs_root *root, u64 objectid, struct |
2764 | btrfs_root_item *item, struct btrfs_key *key); | 2767 | btrfs_root_item *item, struct btrfs_key *key); |
2765 | int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid); | 2768 | int btrfs_find_dead_roots(struct btrfs_root *root, u64 objectid); |
@@ -2943,7 +2946,7 @@ int btrfs_orphan_cleanup(struct btrfs_root *root); | |||
2943 | void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans, | 2946 | void btrfs_orphan_commit_root(struct btrfs_trans_handle *trans, |
2944 | struct btrfs_root *root); | 2947 | struct btrfs_root *root); |
2945 | int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size); | 2948 | int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size); |
2946 | int btrfs_invalidate_inodes(struct btrfs_root *root); | 2949 | void btrfs_invalidate_inodes(struct btrfs_root *root); |
2947 | void btrfs_add_delayed_iput(struct inode *inode); | 2950 | void btrfs_add_delayed_iput(struct inode *inode); |
2948 | void btrfs_run_delayed_iputs(struct btrfs_root *root); | 2951 | void btrfs_run_delayed_iputs(struct btrfs_root *root); |
2949 | int btrfs_prealloc_file_range(struct inode *inode, int mode, | 2952 | int btrfs_prealloc_file_range(struct inode *inode, int mode, |
@@ -2995,13 +2998,41 @@ ssize_t btrfs_listxattr(struct dentry *dentry, char *buffer, size_t size); | |||
2995 | /* super.c */ | 2998 | /* super.c */ |
2996 | int btrfs_parse_options(struct btrfs_root *root, char *options); | 2999 | int btrfs_parse_options(struct btrfs_root *root, char *options); |
2997 | int btrfs_sync_fs(struct super_block *sb, int wait); | 3000 | int btrfs_sync_fs(struct super_block *sb, int wait); |
3001 | void btrfs_printk(struct btrfs_fs_info *fs_info, const char *fmt, ...); | ||
2998 | void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function, | 3002 | void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function, |
2999 | unsigned int line, int errno); | 3003 | unsigned int line, int errno, const char *fmt, ...); |
3004 | |||
3005 | void __btrfs_abort_transaction(struct btrfs_trans_handle *trans, | ||
3006 | struct btrfs_root *root, const char *function, | ||
3007 | unsigned int line, int errno); | ||
3008 | |||
3009 | #define btrfs_abort_transaction(trans, root, errno) \ | ||
3010 | do { \ | ||
3011 | __btrfs_abort_transaction(trans, root, __func__, \ | ||
3012 | __LINE__, errno); \ | ||
3013 | } while (0) | ||
3000 | 3014 | ||
3001 | #define btrfs_std_error(fs_info, errno) \ | 3015 | #define btrfs_std_error(fs_info, errno) \ |
3002 | do { \ | 3016 | do { \ |
3003 | if ((errno)) \ | 3017 | if ((errno)) \ |
3004 | __btrfs_std_error((fs_info), __func__, __LINE__, (errno));\ | 3018 | __btrfs_std_error((fs_info), __func__, \ |
3019 | __LINE__, (errno), NULL); \ | ||
3020 | } while (0) | ||
3021 | |||
3022 | #define btrfs_error(fs_info, errno, fmt, args...) \ | ||
3023 | do { \ | ||
3024 | __btrfs_std_error((fs_info), __func__, __LINE__, \ | ||
3025 | (errno), fmt, ##args); \ | ||
3026 | } while (0) | ||
3027 | |||
3028 | void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function, | ||
3029 | unsigned int line, int errno, const char *fmt, ...); | ||
3030 | |||
3031 | #define btrfs_panic(fs_info, errno, fmt, args...) \ | ||
3032 | do { \ | ||
3033 | struct btrfs_fs_info *_i = (fs_info); \ | ||
3034 | __btrfs_panic(_i, __func__, __LINE__, errno, fmt, ##args); \ | ||
3035 | BUG_ON(!(_i->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR)); \ | ||
3005 | } while (0) | 3036 | } while (0) |
3006 | 3037 | ||
3007 | /* acl.c */ | 3038 | /* acl.c */ |
@@ -3037,16 +3068,17 @@ void btrfs_reloc_cow_block(struct btrfs_trans_handle *trans, | |||
3037 | void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans, | 3068 | void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans, |
3038 | struct btrfs_pending_snapshot *pending, | 3069 | struct btrfs_pending_snapshot *pending, |
3039 | u64 *bytes_to_reserve); | 3070 | u64 *bytes_to_reserve); |
3040 | void btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans, | 3071 | int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans, |
3041 | struct btrfs_pending_snapshot *pending); | 3072 | struct btrfs_pending_snapshot *pending); |
3042 | 3073 | ||
3043 | /* scrub.c */ | 3074 | /* scrub.c */ |
3044 | int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end, | 3075 | int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end, |
3045 | struct btrfs_scrub_progress *progress, int readonly); | 3076 | struct btrfs_scrub_progress *progress, int readonly); |
3046 | int btrfs_scrub_pause(struct btrfs_root *root); | 3077 | void btrfs_scrub_pause(struct btrfs_root *root); |
3047 | int btrfs_scrub_pause_super(struct btrfs_root *root); | 3078 | void btrfs_scrub_pause_super(struct btrfs_root *root); |
3048 | int btrfs_scrub_continue(struct btrfs_root *root); | 3079 | void btrfs_scrub_continue(struct btrfs_root *root); |
3049 | int btrfs_scrub_continue_super(struct btrfs_root *root); | 3080 | void btrfs_scrub_continue_super(struct btrfs_root *root); |
3081 | int __btrfs_scrub_cancel(struct btrfs_fs_info *info); | ||
3050 | int btrfs_scrub_cancel(struct btrfs_root *root); | 3082 | int btrfs_scrub_cancel(struct btrfs_root *root); |
3051 | int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev); | 3083 | int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev); |
3052 | int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid); | 3084 | int btrfs_scrub_cancel_devid(struct btrfs_root *root, u64 devid); |
diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c index fe4cd0f1cef1..03e3748d84d0 100644 --- a/fs/btrfs/delayed-inode.c +++ b/fs/btrfs/delayed-inode.c | |||
@@ -115,6 +115,7 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node(struct inode *inode) | |||
115 | return NULL; | 115 | return NULL; |
116 | } | 116 | } |
117 | 117 | ||
118 | /* Will return either the node or PTR_ERR(-ENOMEM) */ | ||
118 | static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node( | 119 | static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node( |
119 | struct inode *inode) | 120 | struct inode *inode) |
120 | { | 121 | { |
@@ -836,10 +837,8 @@ static int btrfs_batch_insert_items(struct btrfs_trans_handle *trans, | |||
836 | btrfs_clear_path_blocking(path, NULL, 0); | 837 | btrfs_clear_path_blocking(path, NULL, 0); |
837 | 838 | ||
838 | /* insert the keys of the items */ | 839 | /* insert the keys of the items */ |
839 | ret = setup_items_for_insert(trans, root, path, keys, data_size, | 840 | setup_items_for_insert(trans, root, path, keys, data_size, |
840 | total_data_size, total_size, nitems); | 841 | total_data_size, total_size, nitems); |
841 | if (ret) | ||
842 | goto error; | ||
843 | 842 | ||
844 | /* insert the dir index items */ | 843 | /* insert the dir index items */ |
845 | slot = path->slots[0]; | 844 | slot = path->slots[0]; |
@@ -1108,16 +1107,25 @@ static int btrfs_update_delayed_inode(struct btrfs_trans_handle *trans, | |||
1108 | return 0; | 1107 | return 0; |
1109 | } | 1108 | } |
1110 | 1109 | ||
1111 | /* Called when committing the transaction. */ | 1110 | /* |
1111 | * Called when committing the transaction. | ||
1112 | * Returns 0 on success. | ||
1113 | * Returns < 0 on error and returns with an aborted transaction with any | ||
1114 | * outstanding delayed items cleaned up. | ||
1115 | */ | ||
1112 | int btrfs_run_delayed_items(struct btrfs_trans_handle *trans, | 1116 | int btrfs_run_delayed_items(struct btrfs_trans_handle *trans, |
1113 | struct btrfs_root *root) | 1117 | struct btrfs_root *root) |
1114 | { | 1118 | { |
1119 | struct btrfs_root *curr_root = root; | ||
1115 | struct btrfs_delayed_root *delayed_root; | 1120 | struct btrfs_delayed_root *delayed_root; |
1116 | struct btrfs_delayed_node *curr_node, *prev_node; | 1121 | struct btrfs_delayed_node *curr_node, *prev_node; |
1117 | struct btrfs_path *path; | 1122 | struct btrfs_path *path; |
1118 | struct btrfs_block_rsv *block_rsv; | 1123 | struct btrfs_block_rsv *block_rsv; |
1119 | int ret = 0; | 1124 | int ret = 0; |
1120 | 1125 | ||
1126 | if (trans->aborted) | ||
1127 | return -EIO; | ||
1128 | |||
1121 | path = btrfs_alloc_path(); | 1129 | path = btrfs_alloc_path(); |
1122 | if (!path) | 1130 | if (!path) |
1123 | return -ENOMEM; | 1131 | return -ENOMEM; |
@@ -1130,17 +1138,18 @@ int btrfs_run_delayed_items(struct btrfs_trans_handle *trans, | |||
1130 | 1138 | ||
1131 | curr_node = btrfs_first_delayed_node(delayed_root); | 1139 | curr_node = btrfs_first_delayed_node(delayed_root); |
1132 | while (curr_node) { | 1140 | while (curr_node) { |
1133 | root = curr_node->root; | 1141 | curr_root = curr_node->root; |
1134 | ret = btrfs_insert_delayed_items(trans, path, root, | 1142 | ret = btrfs_insert_delayed_items(trans, path, curr_root, |
1135 | curr_node); | 1143 | curr_node); |
1136 | if (!ret) | 1144 | if (!ret) |
1137 | ret = btrfs_delete_delayed_items(trans, path, root, | 1145 | ret = btrfs_delete_delayed_items(trans, path, |
1138 | curr_node); | 1146 | curr_root, curr_node); |
1139 | if (!ret) | 1147 | if (!ret) |
1140 | ret = btrfs_update_delayed_inode(trans, root, path, | 1148 | ret = btrfs_update_delayed_inode(trans, curr_root, |
1141 | curr_node); | 1149 | path, curr_node); |
1142 | if (ret) { | 1150 | if (ret) { |
1143 | btrfs_release_delayed_node(curr_node); | 1151 | btrfs_release_delayed_node(curr_node); |
1152 | btrfs_abort_transaction(trans, root, ret); | ||
1144 | break; | 1153 | break; |
1145 | } | 1154 | } |
1146 | 1155 | ||
@@ -1151,6 +1160,7 @@ int btrfs_run_delayed_items(struct btrfs_trans_handle *trans, | |||
1151 | 1160 | ||
1152 | btrfs_free_path(path); | 1161 | btrfs_free_path(path); |
1153 | trans->block_rsv = block_rsv; | 1162 | trans->block_rsv = block_rsv; |
1163 | |||
1154 | return ret; | 1164 | return ret; |
1155 | } | 1165 | } |
1156 | 1166 | ||
@@ -1371,6 +1381,7 @@ void btrfs_balance_delayed_items(struct btrfs_root *root) | |||
1371 | btrfs_wq_run_delayed_node(delayed_root, root, 0); | 1381 | btrfs_wq_run_delayed_node(delayed_root, root, 0); |
1372 | } | 1382 | } |
1373 | 1383 | ||
1384 | /* Will return 0 or -ENOMEM */ | ||
1374 | int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans, | 1385 | int btrfs_insert_delayed_dir_index(struct btrfs_trans_handle *trans, |
1375 | struct btrfs_root *root, const char *name, | 1386 | struct btrfs_root *root, const char *name, |
1376 | int name_len, struct inode *dir, | 1387 | int name_len, struct inode *dir, |
diff --git a/fs/btrfs/delayed-ref.c b/fs/btrfs/delayed-ref.c index 66e4f29505a3..69f22e3ab3bc 100644 --- a/fs/btrfs/delayed-ref.c +++ b/fs/btrfs/delayed-ref.c | |||
@@ -420,7 +420,7 @@ update_existing_head_ref(struct btrfs_delayed_ref_node *existing, | |||
420 | * this does all the dirty work in terms of maintaining the correct | 420 | * this does all the dirty work in terms of maintaining the correct |
421 | * overall modification count. | 421 | * overall modification count. |
422 | */ | 422 | */ |
423 | static noinline int add_delayed_ref_head(struct btrfs_fs_info *fs_info, | 423 | static noinline void add_delayed_ref_head(struct btrfs_fs_info *fs_info, |
424 | struct btrfs_trans_handle *trans, | 424 | struct btrfs_trans_handle *trans, |
425 | struct btrfs_delayed_ref_node *ref, | 425 | struct btrfs_delayed_ref_node *ref, |
426 | u64 bytenr, u64 num_bytes, | 426 | u64 bytenr, u64 num_bytes, |
@@ -487,20 +487,19 @@ static noinline int add_delayed_ref_head(struct btrfs_fs_info *fs_info, | |||
487 | * we've updated the existing ref, free the newly | 487 | * we've updated the existing ref, free the newly |
488 | * allocated ref | 488 | * allocated ref |
489 | */ | 489 | */ |
490 | kfree(ref); | 490 | kfree(head_ref); |
491 | } else { | 491 | } else { |
492 | delayed_refs->num_heads++; | 492 | delayed_refs->num_heads++; |
493 | delayed_refs->num_heads_ready++; | 493 | delayed_refs->num_heads_ready++; |
494 | delayed_refs->num_entries++; | 494 | delayed_refs->num_entries++; |
495 | trans->delayed_ref_updates++; | 495 | trans->delayed_ref_updates++; |
496 | } | 496 | } |
497 | return 0; | ||
498 | } | 497 | } |
499 | 498 | ||
500 | /* | 499 | /* |
501 | * helper to insert a delayed tree ref into the rbtree. | 500 | * helper to insert a delayed tree ref into the rbtree. |
502 | */ | 501 | */ |
503 | static noinline int add_delayed_tree_ref(struct btrfs_fs_info *fs_info, | 502 | static noinline void add_delayed_tree_ref(struct btrfs_fs_info *fs_info, |
504 | struct btrfs_trans_handle *trans, | 503 | struct btrfs_trans_handle *trans, |
505 | struct btrfs_delayed_ref_node *ref, | 504 | struct btrfs_delayed_ref_node *ref, |
506 | u64 bytenr, u64 num_bytes, u64 parent, | 505 | u64 bytenr, u64 num_bytes, u64 parent, |
@@ -549,18 +548,17 @@ static noinline int add_delayed_tree_ref(struct btrfs_fs_info *fs_info, | |||
549 | * we've updated the existing ref, free the newly | 548 | * we've updated the existing ref, free the newly |
550 | * allocated ref | 549 | * allocated ref |
551 | */ | 550 | */ |
552 | kfree(ref); | 551 | kfree(full_ref); |
553 | } else { | 552 | } else { |
554 | delayed_refs->num_entries++; | 553 | delayed_refs->num_entries++; |
555 | trans->delayed_ref_updates++; | 554 | trans->delayed_ref_updates++; |
556 | } | 555 | } |
557 | return 0; | ||
558 | } | 556 | } |
559 | 557 | ||
560 | /* | 558 | /* |
561 | * helper to insert a delayed data ref into the rbtree. | 559 | * helper to insert a delayed data ref into the rbtree. |
562 | */ | 560 | */ |
563 | static noinline int add_delayed_data_ref(struct btrfs_fs_info *fs_info, | 561 | static noinline void add_delayed_data_ref(struct btrfs_fs_info *fs_info, |
564 | struct btrfs_trans_handle *trans, | 562 | struct btrfs_trans_handle *trans, |
565 | struct btrfs_delayed_ref_node *ref, | 563 | struct btrfs_delayed_ref_node *ref, |
566 | u64 bytenr, u64 num_bytes, u64 parent, | 564 | u64 bytenr, u64 num_bytes, u64 parent, |
@@ -611,12 +609,11 @@ static noinline int add_delayed_data_ref(struct btrfs_fs_info *fs_info, | |||
611 | * we've updated the existing ref, free the newly | 609 | * we've updated the existing ref, free the newly |
612 | * allocated ref | 610 | * allocated ref |
613 | */ | 611 | */ |
614 | kfree(ref); | 612 | kfree(full_ref); |
615 | } else { | 613 | } else { |
616 | delayed_refs->num_entries++; | 614 | delayed_refs->num_entries++; |
617 | trans->delayed_ref_updates++; | 615 | trans->delayed_ref_updates++; |
618 | } | 616 | } |
619 | return 0; | ||
620 | } | 617 | } |
621 | 618 | ||
622 | /* | 619 | /* |
@@ -634,7 +631,6 @@ int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info, | |||
634 | struct btrfs_delayed_tree_ref *ref; | 631 | struct btrfs_delayed_tree_ref *ref; |
635 | struct btrfs_delayed_ref_head *head_ref; | 632 | struct btrfs_delayed_ref_head *head_ref; |
636 | struct btrfs_delayed_ref_root *delayed_refs; | 633 | struct btrfs_delayed_ref_root *delayed_refs; |
637 | int ret; | ||
638 | 634 | ||
639 | BUG_ON(extent_op && extent_op->is_data); | 635 | BUG_ON(extent_op && extent_op->is_data); |
640 | ref = kmalloc(sizeof(*ref), GFP_NOFS); | 636 | ref = kmalloc(sizeof(*ref), GFP_NOFS); |
@@ -656,14 +652,12 @@ int btrfs_add_delayed_tree_ref(struct btrfs_fs_info *fs_info, | |||
656 | * insert both the head node and the new ref without dropping | 652 | * insert both the head node and the new ref without dropping |
657 | * the spin lock | 653 | * the spin lock |
658 | */ | 654 | */ |
659 | ret = add_delayed_ref_head(fs_info, trans, &head_ref->node, bytenr, | 655 | add_delayed_ref_head(fs_info, trans, &head_ref->node, bytenr, |
660 | num_bytes, action, 0); | 656 | num_bytes, action, 0); |
661 | BUG_ON(ret); | ||
662 | 657 | ||
663 | ret = add_delayed_tree_ref(fs_info, trans, &ref->node, bytenr, | 658 | add_delayed_tree_ref(fs_info, trans, &ref->node, bytenr, |
664 | num_bytes, parent, ref_root, level, action, | 659 | num_bytes, parent, ref_root, level, action, |
665 | for_cow); | 660 | for_cow); |
666 | BUG_ON(ret); | ||
667 | if (!need_ref_seq(for_cow, ref_root) && | 661 | if (!need_ref_seq(for_cow, ref_root) && |
668 | waitqueue_active(&delayed_refs->seq_wait)) | 662 | waitqueue_active(&delayed_refs->seq_wait)) |
669 | wake_up(&delayed_refs->seq_wait); | 663 | wake_up(&delayed_refs->seq_wait); |
@@ -685,7 +679,6 @@ int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info, | |||
685 | struct btrfs_delayed_data_ref *ref; | 679 | struct btrfs_delayed_data_ref *ref; |
686 | struct btrfs_delayed_ref_head *head_ref; | 680 | struct btrfs_delayed_ref_head *head_ref; |
687 | struct btrfs_delayed_ref_root *delayed_refs; | 681 | struct btrfs_delayed_ref_root *delayed_refs; |
688 | int ret; | ||
689 | 682 | ||
690 | BUG_ON(extent_op && !extent_op->is_data); | 683 | BUG_ON(extent_op && !extent_op->is_data); |
691 | ref = kmalloc(sizeof(*ref), GFP_NOFS); | 684 | ref = kmalloc(sizeof(*ref), GFP_NOFS); |
@@ -707,14 +700,12 @@ int btrfs_add_delayed_data_ref(struct btrfs_fs_info *fs_info, | |||
707 | * insert both the head node and the new ref without dropping | 700 | * insert both the head node and the new ref without dropping |
708 | * the spin lock | 701 | * the spin lock |
709 | */ | 702 | */ |
710 | ret = add_delayed_ref_head(fs_info, trans, &head_ref->node, bytenr, | 703 | add_delayed_ref_head(fs_info, trans, &head_ref->node, bytenr, |
711 | num_bytes, action, 1); | 704 | num_bytes, action, 1); |
712 | BUG_ON(ret); | ||
713 | 705 | ||
714 | ret = add_delayed_data_ref(fs_info, trans, &ref->node, bytenr, | 706 | add_delayed_data_ref(fs_info, trans, &ref->node, bytenr, |
715 | num_bytes, parent, ref_root, owner, offset, | 707 | num_bytes, parent, ref_root, owner, offset, |
716 | action, for_cow); | 708 | action, for_cow); |
717 | BUG_ON(ret); | ||
718 | if (!need_ref_seq(for_cow, ref_root) && | 709 | if (!need_ref_seq(for_cow, ref_root) && |
719 | waitqueue_active(&delayed_refs->seq_wait)) | 710 | waitqueue_active(&delayed_refs->seq_wait)) |
720 | wake_up(&delayed_refs->seq_wait); | 711 | wake_up(&delayed_refs->seq_wait); |
@@ -729,7 +720,6 @@ int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info, | |||
729 | { | 720 | { |
730 | struct btrfs_delayed_ref_head *head_ref; | 721 | struct btrfs_delayed_ref_head *head_ref; |
731 | struct btrfs_delayed_ref_root *delayed_refs; | 722 | struct btrfs_delayed_ref_root *delayed_refs; |
732 | int ret; | ||
733 | 723 | ||
734 | head_ref = kmalloc(sizeof(*head_ref), GFP_NOFS); | 724 | head_ref = kmalloc(sizeof(*head_ref), GFP_NOFS); |
735 | if (!head_ref) | 725 | if (!head_ref) |
@@ -740,10 +730,9 @@ int btrfs_add_delayed_extent_op(struct btrfs_fs_info *fs_info, | |||
740 | delayed_refs = &trans->transaction->delayed_refs; | 730 | delayed_refs = &trans->transaction->delayed_refs; |
741 | spin_lock(&delayed_refs->lock); | 731 | spin_lock(&delayed_refs->lock); |
742 | 732 | ||
743 | ret = add_delayed_ref_head(fs_info, trans, &head_ref->node, bytenr, | 733 | add_delayed_ref_head(fs_info, trans, &head_ref->node, bytenr, |
744 | num_bytes, BTRFS_UPDATE_DELAYED_HEAD, | 734 | num_bytes, BTRFS_UPDATE_DELAYED_HEAD, |
745 | extent_op->is_data); | 735 | extent_op->is_data); |
746 | BUG_ON(ret); | ||
747 | 736 | ||
748 | if (waitqueue_active(&delayed_refs->seq_wait)) | 737 | if (waitqueue_active(&delayed_refs->seq_wait)) |
749 | wake_up(&delayed_refs->seq_wait); | 738 | wake_up(&delayed_refs->seq_wait); |
diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c index 31d84e78129b..c1a074d0696f 100644 --- a/fs/btrfs/dir-item.c +++ b/fs/btrfs/dir-item.c | |||
@@ -49,9 +49,8 @@ static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle | |||
49 | di = btrfs_match_dir_item_name(root, path, name, name_len); | 49 | di = btrfs_match_dir_item_name(root, path, name, name_len); |
50 | if (di) | 50 | if (di) |
51 | return ERR_PTR(-EEXIST); | 51 | return ERR_PTR(-EEXIST); |
52 | ret = btrfs_extend_item(trans, root, path, data_size); | 52 | btrfs_extend_item(trans, root, path, data_size); |
53 | } | 53 | } else if (ret < 0) |
54 | if (ret < 0) | ||
55 | return ERR_PTR(ret); | 54 | return ERR_PTR(ret); |
56 | WARN_ON(ret > 0); | 55 | WARN_ON(ret > 0); |
57 | leaf = path->nodes[0]; | 56 | leaf = path->nodes[0]; |
@@ -116,6 +115,7 @@ int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans, | |||
116 | * 'location' is the key to stuff into the directory item, 'type' is the | 115 | * 'location' is the key to stuff into the directory item, 'type' is the |
117 | * type of the inode we're pointing to, and 'index' is the sequence number | 116 | * type of the inode we're pointing to, and 'index' is the sequence number |
118 | * to use for the second index (if one is created). | 117 | * to use for the second index (if one is created). |
118 | * Will return 0 or -ENOMEM | ||
119 | */ | 119 | */ |
120 | int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root | 120 | int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, struct btrfs_root |
121 | *root, const char *name, int name_len, | 121 | *root, const char *name, int name_len, |
@@ -383,8 +383,8 @@ int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, | |||
383 | start = btrfs_item_ptr_offset(leaf, path->slots[0]); | 383 | start = btrfs_item_ptr_offset(leaf, path->slots[0]); |
384 | memmove_extent_buffer(leaf, ptr, ptr + sub_item_len, | 384 | memmove_extent_buffer(leaf, ptr, ptr + sub_item_len, |
385 | item_len - (ptr + sub_item_len - start)); | 385 | item_len - (ptr + sub_item_len - start)); |
386 | ret = btrfs_truncate_item(trans, root, path, | 386 | btrfs_truncate_item(trans, root, path, |
387 | item_len - sub_item_len, 1); | 387 | item_len - sub_item_len, 1); |
388 | } | 388 | } |
389 | return ret; | 389 | return ret; |
390 | } | 390 | } |
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c index 6107b6958413..7b55eee15a51 100644 --- a/fs/btrfs/disk-io.c +++ b/fs/btrfs/disk-io.c | |||
@@ -48,20 +48,19 @@ | |||
48 | static struct extent_io_ops btree_extent_io_ops; | 48 | static struct extent_io_ops btree_extent_io_ops; |
49 | static void end_workqueue_fn(struct btrfs_work *work); | 49 | static void end_workqueue_fn(struct btrfs_work *work); |
50 | static void free_fs_root(struct btrfs_root *root); | 50 | static void free_fs_root(struct btrfs_root *root); |
51 | static void btrfs_check_super_valid(struct btrfs_fs_info *fs_info, | 51 | static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info, |
52 | int read_only); | 52 | int read_only); |
53 | static int btrfs_destroy_ordered_operations(struct btrfs_root *root); | 53 | static void btrfs_destroy_ordered_operations(struct btrfs_root *root); |
54 | static int btrfs_destroy_ordered_extents(struct btrfs_root *root); | 54 | static void btrfs_destroy_ordered_extents(struct btrfs_root *root); |
55 | static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans, | 55 | static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans, |
56 | struct btrfs_root *root); | 56 | struct btrfs_root *root); |
57 | static int btrfs_destroy_pending_snapshots(struct btrfs_transaction *t); | 57 | static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t); |
58 | static int btrfs_destroy_delalloc_inodes(struct btrfs_root *root); | 58 | static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root); |
59 | static int btrfs_destroy_marked_extents(struct btrfs_root *root, | 59 | static int btrfs_destroy_marked_extents(struct btrfs_root *root, |
60 | struct extent_io_tree *dirty_pages, | 60 | struct extent_io_tree *dirty_pages, |
61 | int mark); | 61 | int mark); |
62 | static int btrfs_destroy_pinned_extent(struct btrfs_root *root, | 62 | static int btrfs_destroy_pinned_extent(struct btrfs_root *root, |
63 | struct extent_io_tree *pinned_extents); | 63 | struct extent_io_tree *pinned_extents); |
64 | static int btrfs_cleanup_transaction(struct btrfs_root *root); | ||
65 | 64 | ||
66 | /* | 65 | /* |
67 | * end_io_wq structs are used to do processing in task context when an IO is | 66 | * end_io_wq structs are used to do processing in task context when an IO is |
@@ -99,6 +98,7 @@ struct async_submit_bio { | |||
99 | */ | 98 | */ |
100 | u64 bio_offset; | 99 | u64 bio_offset; |
101 | struct btrfs_work work; | 100 | struct btrfs_work work; |
101 | int error; | ||
102 | }; | 102 | }; |
103 | 103 | ||
104 | /* | 104 | /* |
@@ -332,7 +332,7 @@ static int verify_parent_transid(struct extent_io_tree *io_tree, | |||
332 | return 0; | 332 | return 0; |
333 | 333 | ||
334 | lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1, | 334 | lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1, |
335 | 0, &cached_state, GFP_NOFS); | 335 | 0, &cached_state); |
336 | if (extent_buffer_uptodate(eb) && | 336 | if (extent_buffer_uptodate(eb) && |
337 | btrfs_header_generation(eb) == parent_transid) { | 337 | btrfs_header_generation(eb) == parent_transid) { |
338 | ret = 0; | 338 | ret = 0; |
@@ -425,7 +425,6 @@ static int csum_dirty_buffer(struct btrfs_root *root, struct page *page) | |||
425 | eb = (struct extent_buffer *)page->private; | 425 | eb = (struct extent_buffer *)page->private; |
426 | if (page != eb->pages[0]) | 426 | if (page != eb->pages[0]) |
427 | return 0; | 427 | return 0; |
428 | |||
429 | found_start = btrfs_header_bytenr(eb); | 428 | found_start = btrfs_header_bytenr(eb); |
430 | if (found_start != start) { | 429 | if (found_start != start) { |
431 | WARN_ON(1); | 430 | WARN_ON(1); |
@@ -727,11 +726,14 @@ unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info) | |||
727 | static void run_one_async_start(struct btrfs_work *work) | 726 | static void run_one_async_start(struct btrfs_work *work) |
728 | { | 727 | { |
729 | struct async_submit_bio *async; | 728 | struct async_submit_bio *async; |
729 | int ret; | ||
730 | 730 | ||
731 | async = container_of(work, struct async_submit_bio, work); | 731 | async = container_of(work, struct async_submit_bio, work); |
732 | async->submit_bio_start(async->inode, async->rw, async->bio, | 732 | ret = async->submit_bio_start(async->inode, async->rw, async->bio, |
733 | async->mirror_num, async->bio_flags, | 733 | async->mirror_num, async->bio_flags, |
734 | async->bio_offset); | 734 | async->bio_offset); |
735 | if (ret) | ||
736 | async->error = ret; | ||
735 | } | 737 | } |
736 | 738 | ||
737 | static void run_one_async_done(struct btrfs_work *work) | 739 | static void run_one_async_done(struct btrfs_work *work) |
@@ -752,6 +754,12 @@ static void run_one_async_done(struct btrfs_work *work) | |||
752 | waitqueue_active(&fs_info->async_submit_wait)) | 754 | waitqueue_active(&fs_info->async_submit_wait)) |
753 | wake_up(&fs_info->async_submit_wait); | 755 | wake_up(&fs_info->async_submit_wait); |
754 | 756 | ||
757 | /* If an error occured we just want to clean up the bio and move on */ | ||
758 | if (async->error) { | ||
759 | bio_endio(async->bio, async->error); | ||
760 | return; | ||
761 | } | ||
762 | |||
755 | async->submit_bio_done(async->inode, async->rw, async->bio, | 763 | async->submit_bio_done(async->inode, async->rw, async->bio, |
756 | async->mirror_num, async->bio_flags, | 764 | async->mirror_num, async->bio_flags, |
757 | async->bio_offset); | 765 | async->bio_offset); |
@@ -793,6 +801,8 @@ int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode, | |||
793 | async->bio_flags = bio_flags; | 801 | async->bio_flags = bio_flags; |
794 | async->bio_offset = bio_offset; | 802 | async->bio_offset = bio_offset; |
795 | 803 | ||
804 | async->error = 0; | ||
805 | |||
796 | atomic_inc(&fs_info->nr_async_submits); | 806 | atomic_inc(&fs_info->nr_async_submits); |
797 | 807 | ||
798 | if (rw & REQ_SYNC) | 808 | if (rw & REQ_SYNC) |
@@ -814,15 +824,18 @@ static int btree_csum_one_bio(struct bio *bio) | |||
814 | struct bio_vec *bvec = bio->bi_io_vec; | 824 | struct bio_vec *bvec = bio->bi_io_vec; |
815 | int bio_index = 0; | 825 | int bio_index = 0; |
816 | struct btrfs_root *root; | 826 | struct btrfs_root *root; |
827 | int ret = 0; | ||
817 | 828 | ||
818 | WARN_ON(bio->bi_vcnt <= 0); | 829 | WARN_ON(bio->bi_vcnt <= 0); |
819 | while (bio_index < bio->bi_vcnt) { | 830 | while (bio_index < bio->bi_vcnt) { |
820 | root = BTRFS_I(bvec->bv_page->mapping->host)->root; | 831 | root = BTRFS_I(bvec->bv_page->mapping->host)->root; |
821 | csum_dirty_buffer(root, bvec->bv_page); | 832 | ret = csum_dirty_buffer(root, bvec->bv_page); |
833 | if (ret) | ||
834 | break; | ||
822 | bio_index++; | 835 | bio_index++; |
823 | bvec++; | 836 | bvec++; |
824 | } | 837 | } |
825 | return 0; | 838 | return ret; |
826 | } | 839 | } |
827 | 840 | ||
828 | static int __btree_submit_bio_start(struct inode *inode, int rw, | 841 | static int __btree_submit_bio_start(struct inode *inode, int rw, |
@@ -834,8 +847,7 @@ static int __btree_submit_bio_start(struct inode *inode, int rw, | |||
834 | * when we're called for a write, we're already in the async | 847 | * when we're called for a write, we're already in the async |
835 | * submission context. Just jump into btrfs_map_bio | 848 | * submission context. Just jump into btrfs_map_bio |
836 | */ | 849 | */ |
837 | btree_csum_one_bio(bio); | 850 | return btree_csum_one_bio(bio); |
838 | return 0; | ||
839 | } | 851 | } |
840 | 852 | ||
841 | static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio, | 853 | static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio, |
@@ -863,7 +875,8 @@ static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio, | |||
863 | */ | 875 | */ |
864 | ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info, | 876 | ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info, |
865 | bio, 1); | 877 | bio, 1); |
866 | BUG_ON(ret); | 878 | if (ret) |
879 | return ret; | ||
867 | return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, | 880 | return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, |
868 | mirror_num, 0); | 881 | mirror_num, 0); |
869 | } | 882 | } |
@@ -1080,8 +1093,8 @@ struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr, | |||
1080 | 1093 | ||
1081 | } | 1094 | } |
1082 | 1095 | ||
1083 | int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, | 1096 | void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, |
1084 | struct extent_buffer *buf) | 1097 | struct extent_buffer *buf) |
1085 | { | 1098 | { |
1086 | if (btrfs_header_generation(buf) == | 1099 | if (btrfs_header_generation(buf) == |
1087 | root->fs_info->running_transaction->transid) { | 1100 | root->fs_info->running_transaction->transid) { |
@@ -1091,8 +1104,14 @@ int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, | |||
1091 | spin_lock(&root->fs_info->delalloc_lock); | 1104 | spin_lock(&root->fs_info->delalloc_lock); |
1092 | if (root->fs_info->dirty_metadata_bytes >= buf->len) | 1105 | if (root->fs_info->dirty_metadata_bytes >= buf->len) |
1093 | root->fs_info->dirty_metadata_bytes -= buf->len; | 1106 | root->fs_info->dirty_metadata_bytes -= buf->len; |
1094 | else | 1107 | else { |
1095 | WARN_ON(1); | 1108 | spin_unlock(&root->fs_info->delalloc_lock); |
1109 | btrfs_panic(root->fs_info, -EOVERFLOW, | ||
1110 | "Can't clear %lu bytes from " | ||
1111 | " dirty_mdatadata_bytes (%lu)", | ||
1112 | buf->len, | ||
1113 | root->fs_info->dirty_metadata_bytes); | ||
1114 | } | ||
1096 | spin_unlock(&root->fs_info->delalloc_lock); | 1115 | spin_unlock(&root->fs_info->delalloc_lock); |
1097 | } | 1116 | } |
1098 | 1117 | ||
@@ -1100,13 +1119,12 @@ int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, | |||
1100 | btrfs_set_lock_blocking(buf); | 1119 | btrfs_set_lock_blocking(buf); |
1101 | clear_extent_buffer_dirty(buf); | 1120 | clear_extent_buffer_dirty(buf); |
1102 | } | 1121 | } |
1103 | return 0; | ||
1104 | } | 1122 | } |
1105 | 1123 | ||
1106 | static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize, | 1124 | static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize, |
1107 | u32 stripesize, struct btrfs_root *root, | 1125 | u32 stripesize, struct btrfs_root *root, |
1108 | struct btrfs_fs_info *fs_info, | 1126 | struct btrfs_fs_info *fs_info, |
1109 | u64 objectid) | 1127 | u64 objectid) |
1110 | { | 1128 | { |
1111 | root->node = NULL; | 1129 | root->node = NULL; |
1112 | root->commit_root = NULL; | 1130 | root->commit_root = NULL; |
@@ -1158,13 +1176,12 @@ static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize, | |||
1158 | root->defrag_running = 0; | 1176 | root->defrag_running = 0; |
1159 | root->root_key.objectid = objectid; | 1177 | root->root_key.objectid = objectid; |
1160 | root->anon_dev = 0; | 1178 | root->anon_dev = 0; |
1161 | return 0; | ||
1162 | } | 1179 | } |
1163 | 1180 | ||
1164 | static int find_and_setup_root(struct btrfs_root *tree_root, | 1181 | static int __must_check find_and_setup_root(struct btrfs_root *tree_root, |
1165 | struct btrfs_fs_info *fs_info, | 1182 | struct btrfs_fs_info *fs_info, |
1166 | u64 objectid, | 1183 | u64 objectid, |
1167 | struct btrfs_root *root) | 1184 | struct btrfs_root *root) |
1168 | { | 1185 | { |
1169 | int ret; | 1186 | int ret; |
1170 | u32 blocksize; | 1187 | u32 blocksize; |
@@ -1177,7 +1194,8 @@ static int find_and_setup_root(struct btrfs_root *tree_root, | |||
1177 | &root->root_item, &root->root_key); | 1194 | &root->root_item, &root->root_key); |
1178 | if (ret > 0) | 1195 | if (ret > 0) |
1179 | return -ENOENT; | 1196 | return -ENOENT; |
1180 | BUG_ON(ret); | 1197 | else if (ret < 0) |
1198 | return ret; | ||
1181 | 1199 | ||
1182 | generation = btrfs_root_generation(&root->root_item); | 1200 | generation = btrfs_root_generation(&root->root_item); |
1183 | blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item)); | 1201 | blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item)); |
@@ -1346,7 +1364,7 @@ struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root, | |||
1346 | root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item), | 1364 | root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item), |
1347 | blocksize, generation); | 1365 | blocksize, generation); |
1348 | root->commit_root = btrfs_root_node(root); | 1366 | root->commit_root = btrfs_root_node(root); |
1349 | BUG_ON(!root->node); | 1367 | BUG_ON(!root->node); /* -ENOMEM */ |
1350 | out: | 1368 | out: |
1351 | if (location->objectid != BTRFS_TREE_LOG_OBJECTID) { | 1369 | if (location->objectid != BTRFS_TREE_LOG_OBJECTID) { |
1352 | root->ref_cows = 1; | 1370 | root->ref_cows = 1; |
@@ -1537,9 +1555,10 @@ static int transaction_kthread(void *arg) | |||
1537 | u64 transid; | 1555 | u64 transid; |
1538 | unsigned long now; | 1556 | unsigned long now; |
1539 | unsigned long delay; | 1557 | unsigned long delay; |
1540 | int ret; | 1558 | bool cannot_commit; |
1541 | 1559 | ||
1542 | do { | 1560 | do { |
1561 | cannot_commit = false; | ||
1543 | delay = HZ * 30; | 1562 | delay = HZ * 30; |
1544 | vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE); | 1563 | vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE); |
1545 | mutex_lock(&root->fs_info->transaction_kthread_mutex); | 1564 | mutex_lock(&root->fs_info->transaction_kthread_mutex); |
@@ -1561,11 +1580,14 @@ static int transaction_kthread(void *arg) | |||
1561 | transid = cur->transid; | 1580 | transid = cur->transid; |
1562 | spin_unlock(&root->fs_info->trans_lock); | 1581 | spin_unlock(&root->fs_info->trans_lock); |
1563 | 1582 | ||
1583 | /* If the file system is aborted, this will always fail. */ | ||
1564 | trans = btrfs_join_transaction(root); | 1584 | trans = btrfs_join_transaction(root); |
1565 | BUG_ON(IS_ERR(trans)); | 1585 | if (IS_ERR(trans)) { |
1586 | cannot_commit = true; | ||
1587 | goto sleep; | ||
1588 | } | ||
1566 | if (transid == trans->transid) { | 1589 | if (transid == trans->transid) { |
1567 | ret = btrfs_commit_transaction(trans, root); | 1590 | btrfs_commit_transaction(trans, root); |
1568 | BUG_ON(ret); | ||
1569 | } else { | 1591 | } else { |
1570 | btrfs_end_transaction(trans, root); | 1592 | btrfs_end_transaction(trans, root); |
1571 | } | 1593 | } |
@@ -1576,7 +1598,8 @@ sleep: | |||
1576 | if (!try_to_freeze()) { | 1598 | if (!try_to_freeze()) { |
1577 | set_current_state(TASK_INTERRUPTIBLE); | 1599 | set_current_state(TASK_INTERRUPTIBLE); |
1578 | if (!kthread_should_stop() && | 1600 | if (!kthread_should_stop() && |
1579 | !btrfs_transaction_blocked(root->fs_info)) | 1601 | (!btrfs_transaction_blocked(root->fs_info) || |
1602 | cannot_commit)) | ||
1580 | schedule_timeout(delay); | 1603 | schedule_timeout(delay); |
1581 | __set_current_state(TASK_RUNNING); | 1604 | __set_current_state(TASK_RUNNING); |
1582 | } | 1605 | } |
@@ -2028,7 +2051,12 @@ int open_ctree(struct super_block *sb, | |||
2028 | /* check FS state, whether FS is broken. */ | 2051 | /* check FS state, whether FS is broken. */ |
2029 | fs_info->fs_state |= btrfs_super_flags(disk_super); | 2052 | fs_info->fs_state |= btrfs_super_flags(disk_super); |
2030 | 2053 | ||
2031 | btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY); | 2054 | ret = btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY); |
2055 | if (ret) { | ||
2056 | printk(KERN_ERR "btrfs: superblock contains fatal errors\n"); | ||
2057 | err = ret; | ||
2058 | goto fail_alloc; | ||
2059 | } | ||
2032 | 2060 | ||
2033 | /* | 2061 | /* |
2034 | * run through our array of backup supers and setup | 2062 | * run through our array of backup supers and setup |
@@ -2218,6 +2246,14 @@ int open_ctree(struct super_block *sb, | |||
2218 | goto fail_sb_buffer; | 2246 | goto fail_sb_buffer; |
2219 | } | 2247 | } |
2220 | 2248 | ||
2249 | if ((features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) && | ||
2250 | (leafsize != nodesize || sectorsize != nodesize)) { | ||
2251 | printk(KERN_WARNING "btrfs: unequal leaf/node/sector sizes " | ||
2252 | "are not allowed for mixed block groups on %s\n", | ||
2253 | sb->s_id); | ||
2254 | goto fail_sb_buffer; | ||
2255 | } | ||
2256 | |||
2221 | mutex_lock(&fs_info->chunk_mutex); | 2257 | mutex_lock(&fs_info->chunk_mutex); |
2222 | ret = btrfs_read_sys_array(tree_root); | 2258 | ret = btrfs_read_sys_array(tree_root); |
2223 | mutex_unlock(&fs_info->chunk_mutex); | 2259 | mutex_unlock(&fs_info->chunk_mutex); |
@@ -2237,7 +2273,7 @@ int open_ctree(struct super_block *sb, | |||
2237 | chunk_root->node = read_tree_block(chunk_root, | 2273 | chunk_root->node = read_tree_block(chunk_root, |
2238 | btrfs_super_chunk_root(disk_super), | 2274 | btrfs_super_chunk_root(disk_super), |
2239 | blocksize, generation); | 2275 | blocksize, generation); |
2240 | BUG_ON(!chunk_root->node); | 2276 | BUG_ON(!chunk_root->node); /* -ENOMEM */ |
2241 | if (!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) { | 2277 | if (!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) { |
2242 | printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n", | 2278 | printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n", |
2243 | sb->s_id); | 2279 | sb->s_id); |
@@ -2377,21 +2413,31 @@ retry_root_backup: | |||
2377 | log_tree_root->node = read_tree_block(tree_root, bytenr, | 2413 | log_tree_root->node = read_tree_block(tree_root, bytenr, |
2378 | blocksize, | 2414 | blocksize, |
2379 | generation + 1); | 2415 | generation + 1); |
2416 | /* returns with log_tree_root freed on success */ | ||
2380 | ret = btrfs_recover_log_trees(log_tree_root); | 2417 | ret = btrfs_recover_log_trees(log_tree_root); |
2381 | BUG_ON(ret); | 2418 | if (ret) { |
2419 | btrfs_error(tree_root->fs_info, ret, | ||
2420 | "Failed to recover log tree"); | ||
2421 | free_extent_buffer(log_tree_root->node); | ||
2422 | kfree(log_tree_root); | ||
2423 | goto fail_trans_kthread; | ||
2424 | } | ||
2382 | 2425 | ||
2383 | if (sb->s_flags & MS_RDONLY) { | 2426 | if (sb->s_flags & MS_RDONLY) { |
2384 | ret = btrfs_commit_super(tree_root); | 2427 | ret = btrfs_commit_super(tree_root); |
2385 | BUG_ON(ret); | 2428 | if (ret) |
2429 | goto fail_trans_kthread; | ||
2386 | } | 2430 | } |
2387 | } | 2431 | } |
2388 | 2432 | ||
2389 | ret = btrfs_find_orphan_roots(tree_root); | 2433 | ret = btrfs_find_orphan_roots(tree_root); |
2390 | BUG_ON(ret); | 2434 | if (ret) |
2435 | goto fail_trans_kthread; | ||
2391 | 2436 | ||
2392 | if (!(sb->s_flags & MS_RDONLY)) { | 2437 | if (!(sb->s_flags & MS_RDONLY)) { |
2393 | ret = btrfs_cleanup_fs_roots(fs_info); | 2438 | ret = btrfs_cleanup_fs_roots(fs_info); |
2394 | BUG_ON(ret); | 2439 | if (ret) { |
2440 | } | ||
2395 | 2441 | ||
2396 | ret = btrfs_recover_relocation(tree_root); | 2442 | ret = btrfs_recover_relocation(tree_root); |
2397 | if (ret < 0) { | 2443 | if (ret < 0) { |
@@ -2811,6 +2857,8 @@ int write_all_supers(struct btrfs_root *root, int max_mirrors) | |||
2811 | if (total_errors > max_errors) { | 2857 | if (total_errors > max_errors) { |
2812 | printk(KERN_ERR "btrfs: %d errors while writing supers\n", | 2858 | printk(KERN_ERR "btrfs: %d errors while writing supers\n", |
2813 | total_errors); | 2859 | total_errors); |
2860 | |||
2861 | /* This shouldn't happen. FUA is masked off if unsupported */ | ||
2814 | BUG(); | 2862 | BUG(); |
2815 | } | 2863 | } |
2816 | 2864 | ||
@@ -2827,9 +2875,9 @@ int write_all_supers(struct btrfs_root *root, int max_mirrors) | |||
2827 | } | 2875 | } |
2828 | mutex_unlock(&root->fs_info->fs_devices->device_list_mutex); | 2876 | mutex_unlock(&root->fs_info->fs_devices->device_list_mutex); |
2829 | if (total_errors > max_errors) { | 2877 | if (total_errors > max_errors) { |
2830 | printk(KERN_ERR "btrfs: %d errors while writing supers\n", | 2878 | btrfs_error(root->fs_info, -EIO, |
2831 | total_errors); | 2879 | "%d errors while writing supers", total_errors); |
2832 | BUG(); | 2880 | return -EIO; |
2833 | } | 2881 | } |
2834 | return 0; | 2882 | return 0; |
2835 | } | 2883 | } |
@@ -2843,7 +2891,20 @@ int write_ctree_super(struct btrfs_trans_handle *trans, | |||
2843 | return ret; | 2891 | return ret; |
2844 | } | 2892 | } |
2845 | 2893 | ||
2846 | int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root) | 2894 | /* Kill all outstanding I/O */ |
2895 | void btrfs_abort_devices(struct btrfs_root *root) | ||
2896 | { | ||
2897 | struct list_head *head; | ||
2898 | struct btrfs_device *dev; | ||
2899 | mutex_lock(&root->fs_info->fs_devices->device_list_mutex); | ||
2900 | head = &root->fs_info->fs_devices->devices; | ||
2901 | list_for_each_entry_rcu(dev, head, dev_list) { | ||
2902 | blk_abort_queue(dev->bdev->bd_disk->queue); | ||
2903 | } | ||
2904 | mutex_unlock(&root->fs_info->fs_devices->device_list_mutex); | ||
2905 | } | ||
2906 | |||
2907 | void btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root) | ||
2847 | { | 2908 | { |
2848 | spin_lock(&fs_info->fs_roots_radix_lock); | 2909 | spin_lock(&fs_info->fs_roots_radix_lock); |
2849 | radix_tree_delete(&fs_info->fs_roots_radix, | 2910 | radix_tree_delete(&fs_info->fs_roots_radix, |
@@ -2856,7 +2917,6 @@ int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root) | |||
2856 | __btrfs_remove_free_space_cache(root->free_ino_pinned); | 2917 | __btrfs_remove_free_space_cache(root->free_ino_pinned); |
2857 | __btrfs_remove_free_space_cache(root->free_ino_ctl); | 2918 | __btrfs_remove_free_space_cache(root->free_ino_ctl); |
2858 | free_fs_root(root); | 2919 | free_fs_root(root); |
2859 | return 0; | ||
2860 | } | 2920 | } |
2861 | 2921 | ||
2862 | static void free_fs_root(struct btrfs_root *root) | 2922 | static void free_fs_root(struct btrfs_root *root) |
@@ -2873,7 +2933,7 @@ static void free_fs_root(struct btrfs_root *root) | |||
2873 | kfree(root); | 2933 | kfree(root); |
2874 | } | 2934 | } |
2875 | 2935 | ||
2876 | static int del_fs_roots(struct btrfs_fs_info *fs_info) | 2936 | static void del_fs_roots(struct btrfs_fs_info *fs_info) |
2877 | { | 2937 | { |
2878 | int ret; | 2938 | int ret; |
2879 | struct btrfs_root *gang[8]; | 2939 | struct btrfs_root *gang[8]; |
@@ -2902,7 +2962,6 @@ static int del_fs_roots(struct btrfs_fs_info *fs_info) | |||
2902 | for (i = 0; i < ret; i++) | 2962 | for (i = 0; i < ret; i++) |
2903 | btrfs_free_fs_root(fs_info, gang[i]); | 2963 | btrfs_free_fs_root(fs_info, gang[i]); |
2904 | } | 2964 | } |
2905 | return 0; | ||
2906 | } | 2965 | } |
2907 | 2966 | ||
2908 | int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info) | 2967 | int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info) |
@@ -2951,14 +3010,21 @@ int btrfs_commit_super(struct btrfs_root *root) | |||
2951 | if (IS_ERR(trans)) | 3010 | if (IS_ERR(trans)) |
2952 | return PTR_ERR(trans); | 3011 | return PTR_ERR(trans); |
2953 | ret = btrfs_commit_transaction(trans, root); | 3012 | ret = btrfs_commit_transaction(trans, root); |
2954 | BUG_ON(ret); | 3013 | if (ret) |
3014 | return ret; | ||
2955 | /* run commit again to drop the original snapshot */ | 3015 | /* run commit again to drop the original snapshot */ |
2956 | trans = btrfs_join_transaction(root); | 3016 | trans = btrfs_join_transaction(root); |
2957 | if (IS_ERR(trans)) | 3017 | if (IS_ERR(trans)) |
2958 | return PTR_ERR(trans); | 3018 | return PTR_ERR(trans); |
2959 | btrfs_commit_transaction(trans, root); | 3019 | ret = btrfs_commit_transaction(trans, root); |
3020 | if (ret) | ||
3021 | return ret; | ||
2960 | ret = btrfs_write_and_wait_transaction(NULL, root); | 3022 | ret = btrfs_write_and_wait_transaction(NULL, root); |
2961 | BUG_ON(ret); | 3023 | if (ret) { |
3024 | btrfs_error(root->fs_info, ret, | ||
3025 | "Failed to sync btree inode to disk."); | ||
3026 | return ret; | ||
3027 | } | ||
2962 | 3028 | ||
2963 | ret = write_ctree_super(NULL, root, 0); | 3029 | ret = write_ctree_super(NULL, root, 0); |
2964 | return ret; | 3030 | return ret; |
@@ -3209,15 +3275,23 @@ out: | |||
3209 | return 0; | 3275 | return 0; |
3210 | } | 3276 | } |
3211 | 3277 | ||
3212 | static void btrfs_check_super_valid(struct btrfs_fs_info *fs_info, | 3278 | static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info, |
3213 | int read_only) | 3279 | int read_only) |
3214 | { | 3280 | { |
3281 | if (btrfs_super_csum_type(fs_info->super_copy) >= ARRAY_SIZE(btrfs_csum_sizes)) { | ||
3282 | printk(KERN_ERR "btrfs: unsupported checksum algorithm\n"); | ||
3283 | return -EINVAL; | ||
3284 | } | ||
3285 | |||
3215 | if (read_only) | 3286 | if (read_only) |
3216 | return; | 3287 | return 0; |
3217 | 3288 | ||
3218 | if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) | 3289 | if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { |
3219 | printk(KERN_WARNING "warning: mount fs with errors, " | 3290 | printk(KERN_WARNING "warning: mount fs with errors, " |
3220 | "running btrfsck is recommended\n"); | 3291 | "running btrfsck is recommended\n"); |
3292 | } | ||
3293 | |||
3294 | return 0; | ||
3221 | } | 3295 | } |
3222 | 3296 | ||
3223 | int btrfs_error_commit_super(struct btrfs_root *root) | 3297 | int btrfs_error_commit_super(struct btrfs_root *root) |
@@ -3239,7 +3313,7 @@ int btrfs_error_commit_super(struct btrfs_root *root) | |||
3239 | return ret; | 3313 | return ret; |
3240 | } | 3314 | } |
3241 | 3315 | ||
3242 | static int btrfs_destroy_ordered_operations(struct btrfs_root *root) | 3316 | static void btrfs_destroy_ordered_operations(struct btrfs_root *root) |
3243 | { | 3317 | { |
3244 | struct btrfs_inode *btrfs_inode; | 3318 | struct btrfs_inode *btrfs_inode; |
3245 | struct list_head splice; | 3319 | struct list_head splice; |
@@ -3261,11 +3335,9 @@ static int btrfs_destroy_ordered_operations(struct btrfs_root *root) | |||
3261 | 3335 | ||
3262 | spin_unlock(&root->fs_info->ordered_extent_lock); | 3336 | spin_unlock(&root->fs_info->ordered_extent_lock); |
3263 | mutex_unlock(&root->fs_info->ordered_operations_mutex); | 3337 | mutex_unlock(&root->fs_info->ordered_operations_mutex); |
3264 | |||
3265 | return 0; | ||
3266 | } | 3338 | } |
3267 | 3339 | ||
3268 | static int btrfs_destroy_ordered_extents(struct btrfs_root *root) | 3340 | static void btrfs_destroy_ordered_extents(struct btrfs_root *root) |
3269 | { | 3341 | { |
3270 | struct list_head splice; | 3342 | struct list_head splice; |
3271 | struct btrfs_ordered_extent *ordered; | 3343 | struct btrfs_ordered_extent *ordered; |
@@ -3297,12 +3369,10 @@ static int btrfs_destroy_ordered_extents(struct btrfs_root *root) | |||
3297 | } | 3369 | } |
3298 | 3370 | ||
3299 | spin_unlock(&root->fs_info->ordered_extent_lock); | 3371 | spin_unlock(&root->fs_info->ordered_extent_lock); |
3300 | |||
3301 | return 0; | ||
3302 | } | 3372 | } |
3303 | 3373 | ||
3304 | static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans, | 3374 | int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans, |
3305 | struct btrfs_root *root) | 3375 | struct btrfs_root *root) |
3306 | { | 3376 | { |
3307 | struct rb_node *node; | 3377 | struct rb_node *node; |
3308 | struct btrfs_delayed_ref_root *delayed_refs; | 3378 | struct btrfs_delayed_ref_root *delayed_refs; |
@@ -3311,6 +3381,7 @@ static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans, | |||
3311 | 3381 | ||
3312 | delayed_refs = &trans->delayed_refs; | 3382 | delayed_refs = &trans->delayed_refs; |
3313 | 3383 | ||
3384 | again: | ||
3314 | spin_lock(&delayed_refs->lock); | 3385 | spin_lock(&delayed_refs->lock); |
3315 | if (delayed_refs->num_entries == 0) { | 3386 | if (delayed_refs->num_entries == 0) { |
3316 | spin_unlock(&delayed_refs->lock); | 3387 | spin_unlock(&delayed_refs->lock); |
@@ -3332,6 +3403,7 @@ static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans, | |||
3332 | struct btrfs_delayed_ref_head *head; | 3403 | struct btrfs_delayed_ref_head *head; |
3333 | 3404 | ||
3334 | head = btrfs_delayed_node_to_head(ref); | 3405 | head = btrfs_delayed_node_to_head(ref); |
3406 | spin_unlock(&delayed_refs->lock); | ||
3335 | mutex_lock(&head->mutex); | 3407 | mutex_lock(&head->mutex); |
3336 | kfree(head->extent_op); | 3408 | kfree(head->extent_op); |
3337 | delayed_refs->num_heads--; | 3409 | delayed_refs->num_heads--; |
@@ -3339,8 +3411,9 @@ static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans, | |||
3339 | delayed_refs->num_heads_ready--; | 3411 | delayed_refs->num_heads_ready--; |
3340 | list_del_init(&head->cluster); | 3412 | list_del_init(&head->cluster); |
3341 | mutex_unlock(&head->mutex); | 3413 | mutex_unlock(&head->mutex); |
3414 | btrfs_put_delayed_ref(ref); | ||
3415 | goto again; | ||
3342 | } | 3416 | } |
3343 | |||
3344 | spin_unlock(&delayed_refs->lock); | 3417 | spin_unlock(&delayed_refs->lock); |
3345 | btrfs_put_delayed_ref(ref); | 3418 | btrfs_put_delayed_ref(ref); |
3346 | 3419 | ||
@@ -3353,7 +3426,7 @@ static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans, | |||
3353 | return ret; | 3426 | return ret; |
3354 | } | 3427 | } |
3355 | 3428 | ||
3356 | static int btrfs_destroy_pending_snapshots(struct btrfs_transaction *t) | 3429 | static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t) |
3357 | { | 3430 | { |
3358 | struct btrfs_pending_snapshot *snapshot; | 3431 | struct btrfs_pending_snapshot *snapshot; |
3359 | struct list_head splice; | 3432 | struct list_head splice; |
@@ -3371,11 +3444,9 @@ static int btrfs_destroy_pending_snapshots(struct btrfs_transaction *t) | |||
3371 | 3444 | ||
3372 | kfree(snapshot); | 3445 | kfree(snapshot); |
3373 | } | 3446 | } |
3374 | |||
3375 | return 0; | ||
3376 | } | 3447 | } |
3377 | 3448 | ||
3378 | static int btrfs_destroy_delalloc_inodes(struct btrfs_root *root) | 3449 | static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root) |
3379 | { | 3450 | { |
3380 | struct btrfs_inode *btrfs_inode; | 3451 | struct btrfs_inode *btrfs_inode; |
3381 | struct list_head splice; | 3452 | struct list_head splice; |
@@ -3395,8 +3466,6 @@ static int btrfs_destroy_delalloc_inodes(struct btrfs_root *root) | |||
3395 | } | 3466 | } |
3396 | 3467 | ||
3397 | spin_unlock(&root->fs_info->delalloc_lock); | 3468 | spin_unlock(&root->fs_info->delalloc_lock); |
3398 | |||
3399 | return 0; | ||
3400 | } | 3469 | } |
3401 | 3470 | ||
3402 | static int btrfs_destroy_marked_extents(struct btrfs_root *root, | 3471 | static int btrfs_destroy_marked_extents(struct btrfs_root *root, |
@@ -3487,13 +3556,43 @@ static int btrfs_destroy_pinned_extent(struct btrfs_root *root, | |||
3487 | return 0; | 3556 | return 0; |
3488 | } | 3557 | } |
3489 | 3558 | ||
3490 | static int btrfs_cleanup_transaction(struct btrfs_root *root) | 3559 | void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans, |
3560 | struct btrfs_root *root) | ||
3561 | { | ||
3562 | btrfs_destroy_delayed_refs(cur_trans, root); | ||
3563 | btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv, | ||
3564 | cur_trans->dirty_pages.dirty_bytes); | ||
3565 | |||
3566 | /* FIXME: cleanup wait for commit */ | ||
3567 | cur_trans->in_commit = 1; | ||
3568 | cur_trans->blocked = 1; | ||
3569 | if (waitqueue_active(&root->fs_info->transaction_blocked_wait)) | ||
3570 | wake_up(&root->fs_info->transaction_blocked_wait); | ||
3571 | |||
3572 | cur_trans->blocked = 0; | ||
3573 | if (waitqueue_active(&root->fs_info->transaction_wait)) | ||
3574 | wake_up(&root->fs_info->transaction_wait); | ||
3575 | |||
3576 | cur_trans->commit_done = 1; | ||
3577 | if (waitqueue_active(&cur_trans->commit_wait)) | ||
3578 | wake_up(&cur_trans->commit_wait); | ||
3579 | |||
3580 | btrfs_destroy_pending_snapshots(cur_trans); | ||
3581 | |||
3582 | btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages, | ||
3583 | EXTENT_DIRTY); | ||
3584 | |||
3585 | /* | ||
3586 | memset(cur_trans, 0, sizeof(*cur_trans)); | ||
3587 | kmem_cache_free(btrfs_transaction_cachep, cur_trans); | ||
3588 | */ | ||
3589 | } | ||
3590 | |||
3591 | int btrfs_cleanup_transaction(struct btrfs_root *root) | ||
3491 | { | 3592 | { |
3492 | struct btrfs_transaction *t; | 3593 | struct btrfs_transaction *t; |
3493 | LIST_HEAD(list); | 3594 | LIST_HEAD(list); |
3494 | 3595 | ||
3495 | WARN_ON(1); | ||
3496 | |||
3497 | mutex_lock(&root->fs_info->transaction_kthread_mutex); | 3596 | mutex_lock(&root->fs_info->transaction_kthread_mutex); |
3498 | 3597 | ||
3499 | spin_lock(&root->fs_info->trans_lock); | 3598 | spin_lock(&root->fs_info->trans_lock); |
@@ -3558,6 +3657,17 @@ static int btrfs_cleanup_transaction(struct btrfs_root *root) | |||
3558 | return 0; | 3657 | return 0; |
3559 | } | 3658 | } |
3560 | 3659 | ||
3660 | static int btree_writepage_io_failed_hook(struct bio *bio, struct page *page, | ||
3661 | u64 start, u64 end, | ||
3662 | struct extent_state *state) | ||
3663 | { | ||
3664 | struct super_block *sb = page->mapping->host->i_sb; | ||
3665 | struct btrfs_fs_info *fs_info = btrfs_sb(sb); | ||
3666 | btrfs_error(fs_info, -EIO, | ||
3667 | "Error occured while writing out btree at %llu", start); | ||
3668 | return -EIO; | ||
3669 | } | ||
3670 | |||
3561 | static struct extent_io_ops btree_extent_io_ops = { | 3671 | static struct extent_io_ops btree_extent_io_ops = { |
3562 | .write_cache_pages_lock_hook = btree_lock_page_hook, | 3672 | .write_cache_pages_lock_hook = btree_lock_page_hook, |
3563 | .readpage_end_io_hook = btree_readpage_end_io_hook, | 3673 | .readpage_end_io_hook = btree_readpage_end_io_hook, |
@@ -3565,4 +3675,5 @@ static struct extent_io_ops btree_extent_io_ops = { | |||
3565 | .submit_bio_hook = btree_submit_bio_hook, | 3675 | .submit_bio_hook = btree_submit_bio_hook, |
3566 | /* note we're sharing with inode.c for the merge bio hook */ | 3676 | /* note we're sharing with inode.c for the merge bio hook */ |
3567 | .merge_bio_hook = btrfs_merge_bio_hook, | 3677 | .merge_bio_hook = btrfs_merge_bio_hook, |
3678 | .writepage_io_failed_hook = btree_writepage_io_failed_hook, | ||
3568 | }; | 3679 | }; |
diff --git a/fs/btrfs/disk-io.h b/fs/btrfs/disk-io.h index e4bc4741319b..a7ace1a2dd12 100644 --- a/fs/btrfs/disk-io.h +++ b/fs/btrfs/disk-io.h | |||
@@ -44,8 +44,8 @@ int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize, | |||
44 | int mirror_num, struct extent_buffer **eb); | 44 | int mirror_num, struct extent_buffer **eb); |
45 | struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root, | 45 | struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root, |
46 | u64 bytenr, u32 blocksize); | 46 | u64 bytenr, u32 blocksize); |
47 | int clean_tree_block(struct btrfs_trans_handle *trans, | 47 | void clean_tree_block(struct btrfs_trans_handle *trans, |
48 | struct btrfs_root *root, struct extent_buffer *buf); | 48 | struct btrfs_root *root, struct extent_buffer *buf); |
49 | int open_ctree(struct super_block *sb, | 49 | int open_ctree(struct super_block *sb, |
50 | struct btrfs_fs_devices *fs_devices, | 50 | struct btrfs_fs_devices *fs_devices, |
51 | char *options); | 51 | char *options); |
@@ -64,7 +64,7 @@ struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info, | |||
64 | int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info); | 64 | int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info); |
65 | void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr); | 65 | void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr); |
66 | void __btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr); | 66 | void __btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr); |
67 | int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root); | 67 | void btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root); |
68 | void btrfs_mark_buffer_dirty(struct extent_buffer *buf); | 68 | void btrfs_mark_buffer_dirty(struct extent_buffer *buf); |
69 | int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid); | 69 | int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid); |
70 | int btrfs_set_buffer_uptodate(struct extent_buffer *buf); | 70 | int btrfs_set_buffer_uptodate(struct extent_buffer *buf); |
@@ -85,6 +85,10 @@ int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans, | |||
85 | struct btrfs_fs_info *fs_info); | 85 | struct btrfs_fs_info *fs_info); |
86 | int btrfs_add_log_tree(struct btrfs_trans_handle *trans, | 86 | int btrfs_add_log_tree(struct btrfs_trans_handle *trans, |
87 | struct btrfs_root *root); | 87 | struct btrfs_root *root); |
88 | int btrfs_cleanup_transaction(struct btrfs_root *root); | ||
89 | void btrfs_cleanup_one_transaction(struct btrfs_transaction *trans, | ||
90 | struct btrfs_root *root); | ||
91 | void btrfs_abort_devices(struct btrfs_root *root); | ||
88 | 92 | ||
89 | #ifdef CONFIG_DEBUG_LOCK_ALLOC | 93 | #ifdef CONFIG_DEBUG_LOCK_ALLOC |
90 | void btrfs_init_lockdep(void); | 94 | void btrfs_init_lockdep(void); |
diff --git a/fs/btrfs/export.c b/fs/btrfs/export.c index 5f77166fd01c..e887ee62b6d4 100644 --- a/fs/btrfs/export.c +++ b/fs/btrfs/export.c | |||
@@ -193,7 +193,7 @@ static struct dentry *btrfs_get_parent(struct dentry *child) | |||
193 | if (ret < 0) | 193 | if (ret < 0) |
194 | goto fail; | 194 | goto fail; |
195 | 195 | ||
196 | BUG_ON(ret == 0); | 196 | BUG_ON(ret == 0); /* Key with offset of -1 found */ |
197 | if (path->slots[0] == 0) { | 197 | if (path->slots[0] == 0) { |
198 | ret = -ENOENT; | 198 | ret = -ENOENT; |
199 | goto fail; | 199 | goto fail; |
diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c index 1b831ac4c079..8b304e3537c4 100644 --- a/fs/btrfs/extent-tree.c +++ b/fs/btrfs/extent-tree.c | |||
@@ -245,7 +245,7 @@ static int exclude_super_stripes(struct btrfs_root *root, | |||
245 | cache->bytes_super += stripe_len; | 245 | cache->bytes_super += stripe_len; |
246 | ret = add_excluded_extent(root, cache->key.objectid, | 246 | ret = add_excluded_extent(root, cache->key.objectid, |
247 | stripe_len); | 247 | stripe_len); |
248 | BUG_ON(ret); | 248 | BUG_ON(ret); /* -ENOMEM */ |
249 | } | 249 | } |
250 | 250 | ||
251 | for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { | 251 | for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { |
@@ -253,13 +253,13 @@ static int exclude_super_stripes(struct btrfs_root *root, | |||
253 | ret = btrfs_rmap_block(&root->fs_info->mapping_tree, | 253 | ret = btrfs_rmap_block(&root->fs_info->mapping_tree, |
254 | cache->key.objectid, bytenr, | 254 | cache->key.objectid, bytenr, |
255 | 0, &logical, &nr, &stripe_len); | 255 | 0, &logical, &nr, &stripe_len); |
256 | BUG_ON(ret); | 256 | BUG_ON(ret); /* -ENOMEM */ |
257 | 257 | ||
258 | while (nr--) { | 258 | while (nr--) { |
259 | cache->bytes_super += stripe_len; | 259 | cache->bytes_super += stripe_len; |
260 | ret = add_excluded_extent(root, logical[nr], | 260 | ret = add_excluded_extent(root, logical[nr], |
261 | stripe_len); | 261 | stripe_len); |
262 | BUG_ON(ret); | 262 | BUG_ON(ret); /* -ENOMEM */ |
263 | } | 263 | } |
264 | 264 | ||
265 | kfree(logical); | 265 | kfree(logical); |
@@ -321,7 +321,7 @@ static u64 add_new_free_space(struct btrfs_block_group_cache *block_group, | |||
321 | total_added += size; | 321 | total_added += size; |
322 | ret = btrfs_add_free_space(block_group, start, | 322 | ret = btrfs_add_free_space(block_group, start, |
323 | size); | 323 | size); |
324 | BUG_ON(ret); | 324 | BUG_ON(ret); /* -ENOMEM or logic error */ |
325 | start = extent_end + 1; | 325 | start = extent_end + 1; |
326 | } else { | 326 | } else { |
327 | break; | 327 | break; |
@@ -332,7 +332,7 @@ static u64 add_new_free_space(struct btrfs_block_group_cache *block_group, | |||
332 | size = end - start; | 332 | size = end - start; |
333 | total_added += size; | 333 | total_added += size; |
334 | ret = btrfs_add_free_space(block_group, start, size); | 334 | ret = btrfs_add_free_space(block_group, start, size); |
335 | BUG_ON(ret); | 335 | BUG_ON(ret); /* -ENOMEM or logic error */ |
336 | } | 336 | } |
337 | 337 | ||
338 | return total_added; | 338 | return total_added; |
@@ -474,7 +474,8 @@ static int cache_block_group(struct btrfs_block_group_cache *cache, | |||
474 | int ret = 0; | 474 | int ret = 0; |
475 | 475 | ||
476 | caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS); | 476 | caching_ctl = kzalloc(sizeof(*caching_ctl), GFP_NOFS); |
477 | BUG_ON(!caching_ctl); | 477 | if (!caching_ctl) |
478 | return -ENOMEM; | ||
478 | 479 | ||
479 | INIT_LIST_HEAD(&caching_ctl->list); | 480 | INIT_LIST_HEAD(&caching_ctl->list); |
480 | mutex_init(&caching_ctl->mutex); | 481 | mutex_init(&caching_ctl->mutex); |
@@ -982,7 +983,7 @@ static int convert_extent_item_v0(struct btrfs_trans_handle *trans, | |||
982 | ret = btrfs_next_leaf(root, path); | 983 | ret = btrfs_next_leaf(root, path); |
983 | if (ret < 0) | 984 | if (ret < 0) |
984 | return ret; | 985 | return ret; |
985 | BUG_ON(ret > 0); | 986 | BUG_ON(ret > 0); /* Corruption */ |
986 | leaf = path->nodes[0]; | 987 | leaf = path->nodes[0]; |
987 | } | 988 | } |
988 | btrfs_item_key_to_cpu(leaf, &found_key, | 989 | btrfs_item_key_to_cpu(leaf, &found_key, |
@@ -1008,9 +1009,9 @@ static int convert_extent_item_v0(struct btrfs_trans_handle *trans, | |||
1008 | new_size + extra_size, 1); | 1009 | new_size + extra_size, 1); |
1009 | if (ret < 0) | 1010 | if (ret < 0) |
1010 | return ret; | 1011 | return ret; |
1011 | BUG_ON(ret); | 1012 | BUG_ON(ret); /* Corruption */ |
1012 | 1013 | ||
1013 | ret = btrfs_extend_item(trans, root, path, new_size); | 1014 | btrfs_extend_item(trans, root, path, new_size); |
1014 | 1015 | ||
1015 | leaf = path->nodes[0]; | 1016 | leaf = path->nodes[0]; |
1016 | item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item); | 1017 | item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item); |
@@ -1478,7 +1479,11 @@ int lookup_inline_extent_backref(struct btrfs_trans_handle *trans, | |||
1478 | err = ret; | 1479 | err = ret; |
1479 | goto out; | 1480 | goto out; |
1480 | } | 1481 | } |
1481 | BUG_ON(ret); | 1482 | if (ret && !insert) { |
1483 | err = -ENOENT; | ||
1484 | goto out; | ||
1485 | } | ||
1486 | BUG_ON(ret); /* Corruption */ | ||
1482 | 1487 | ||
1483 | leaf = path->nodes[0]; | 1488 | leaf = path->nodes[0]; |
1484 | item_size = btrfs_item_size_nr(leaf, path->slots[0]); | 1489 | item_size = btrfs_item_size_nr(leaf, path->slots[0]); |
@@ -1592,13 +1597,13 @@ out: | |||
1592 | * helper to add new inline back ref | 1597 | * helper to add new inline back ref |
1593 | */ | 1598 | */ |
1594 | static noinline_for_stack | 1599 | static noinline_for_stack |
1595 | int setup_inline_extent_backref(struct btrfs_trans_handle *trans, | 1600 | void setup_inline_extent_backref(struct btrfs_trans_handle *trans, |
1596 | struct btrfs_root *root, | 1601 | struct btrfs_root *root, |
1597 | struct btrfs_path *path, | 1602 | struct btrfs_path *path, |
1598 | struct btrfs_extent_inline_ref *iref, | 1603 | struct btrfs_extent_inline_ref *iref, |
1599 | u64 parent, u64 root_objectid, | 1604 | u64 parent, u64 root_objectid, |
1600 | u64 owner, u64 offset, int refs_to_add, | 1605 | u64 owner, u64 offset, int refs_to_add, |
1601 | struct btrfs_delayed_extent_op *extent_op) | 1606 | struct btrfs_delayed_extent_op *extent_op) |
1602 | { | 1607 | { |
1603 | struct extent_buffer *leaf; | 1608 | struct extent_buffer *leaf; |
1604 | struct btrfs_extent_item *ei; | 1609 | struct btrfs_extent_item *ei; |
@@ -1608,7 +1613,6 @@ int setup_inline_extent_backref(struct btrfs_trans_handle *trans, | |||
1608 | u64 refs; | 1613 | u64 refs; |
1609 | int size; | 1614 | int size; |
1610 | int type; | 1615 | int type; |
1611 | int ret; | ||
1612 | 1616 | ||
1613 | leaf = path->nodes[0]; | 1617 | leaf = path->nodes[0]; |
1614 | ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item); | 1618 | ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item); |
@@ -1617,7 +1621,7 @@ int setup_inline_extent_backref(struct btrfs_trans_handle *trans, | |||
1617 | type = extent_ref_type(parent, owner); | 1621 | type = extent_ref_type(parent, owner); |
1618 | size = btrfs_extent_inline_ref_size(type); | 1622 | size = btrfs_extent_inline_ref_size(type); |
1619 | 1623 | ||
1620 | ret = btrfs_extend_item(trans, root, path, size); | 1624 | btrfs_extend_item(trans, root, path, size); |
1621 | 1625 | ||
1622 | ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item); | 1626 | ei = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_extent_item); |
1623 | refs = btrfs_extent_refs(leaf, ei); | 1627 | refs = btrfs_extent_refs(leaf, ei); |
@@ -1652,7 +1656,6 @@ int setup_inline_extent_backref(struct btrfs_trans_handle *trans, | |||
1652 | btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid); | 1656 | btrfs_set_extent_inline_ref_offset(leaf, iref, root_objectid); |
1653 | } | 1657 | } |
1654 | btrfs_mark_buffer_dirty(leaf); | 1658 | btrfs_mark_buffer_dirty(leaf); |
1655 | return 0; | ||
1656 | } | 1659 | } |
1657 | 1660 | ||
1658 | static int lookup_extent_backref(struct btrfs_trans_handle *trans, | 1661 | static int lookup_extent_backref(struct btrfs_trans_handle *trans, |
@@ -1687,12 +1690,12 @@ static int lookup_extent_backref(struct btrfs_trans_handle *trans, | |||
1687 | * helper to update/remove inline back ref | 1690 | * helper to update/remove inline back ref |
1688 | */ | 1691 | */ |
1689 | static noinline_for_stack | 1692 | static noinline_for_stack |
1690 | int update_inline_extent_backref(struct btrfs_trans_handle *trans, | 1693 | void update_inline_extent_backref(struct btrfs_trans_handle *trans, |
1691 | struct btrfs_root *root, | 1694 | struct btrfs_root *root, |
1692 | struct btrfs_path *path, | 1695 | struct btrfs_path *path, |
1693 | struct btrfs_extent_inline_ref *iref, | 1696 | struct btrfs_extent_inline_ref *iref, |
1694 | int refs_to_mod, | 1697 | int refs_to_mod, |
1695 | struct btrfs_delayed_extent_op *extent_op) | 1698 | struct btrfs_delayed_extent_op *extent_op) |
1696 | { | 1699 | { |
1697 | struct extent_buffer *leaf; | 1700 | struct extent_buffer *leaf; |
1698 | struct btrfs_extent_item *ei; | 1701 | struct btrfs_extent_item *ei; |
@@ -1703,7 +1706,6 @@ int update_inline_extent_backref(struct btrfs_trans_handle *trans, | |||
1703 | u32 item_size; | 1706 | u32 item_size; |
1704 | int size; | 1707 | int size; |
1705 | int type; | 1708 | int type; |
1706 | int ret; | ||
1707 | u64 refs; | 1709 | u64 refs; |
1708 | 1710 | ||
1709 | leaf = path->nodes[0]; | 1711 | leaf = path->nodes[0]; |
@@ -1745,10 +1747,9 @@ int update_inline_extent_backref(struct btrfs_trans_handle *trans, | |||
1745 | memmove_extent_buffer(leaf, ptr, ptr + size, | 1747 | memmove_extent_buffer(leaf, ptr, ptr + size, |
1746 | end - ptr - size); | 1748 | end - ptr - size); |
1747 | item_size -= size; | 1749 | item_size -= size; |
1748 | ret = btrfs_truncate_item(trans, root, path, item_size, 1); | 1750 | btrfs_truncate_item(trans, root, path, item_size, 1); |
1749 | } | 1751 | } |
1750 | btrfs_mark_buffer_dirty(leaf); | 1752 | btrfs_mark_buffer_dirty(leaf); |
1751 | return 0; | ||
1752 | } | 1753 | } |
1753 | 1754 | ||
1754 | static noinline_for_stack | 1755 | static noinline_for_stack |
@@ -1768,13 +1769,13 @@ int insert_inline_extent_backref(struct btrfs_trans_handle *trans, | |||
1768 | root_objectid, owner, offset, 1); | 1769 | root_objectid, owner, offset, 1); |
1769 | if (ret == 0) { | 1770 | if (ret == 0) { |
1770 | BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID); | 1771 | BUG_ON(owner < BTRFS_FIRST_FREE_OBJECTID); |
1771 | ret = update_inline_extent_backref(trans, root, path, iref, | 1772 | update_inline_extent_backref(trans, root, path, iref, |
1772 | refs_to_add, extent_op); | 1773 | refs_to_add, extent_op); |
1773 | } else if (ret == -ENOENT) { | 1774 | } else if (ret == -ENOENT) { |
1774 | ret = setup_inline_extent_backref(trans, root, path, iref, | 1775 | setup_inline_extent_backref(trans, root, path, iref, parent, |
1775 | parent, root_objectid, | 1776 | root_objectid, owner, offset, |
1776 | owner, offset, refs_to_add, | 1777 | refs_to_add, extent_op); |
1777 | extent_op); | 1778 | ret = 0; |
1778 | } | 1779 | } |
1779 | return ret; | 1780 | return ret; |
1780 | } | 1781 | } |
@@ -1804,12 +1805,12 @@ static int remove_extent_backref(struct btrfs_trans_handle *trans, | |||
1804 | struct btrfs_extent_inline_ref *iref, | 1805 | struct btrfs_extent_inline_ref *iref, |
1805 | int refs_to_drop, int is_data) | 1806 | int refs_to_drop, int is_data) |
1806 | { | 1807 | { |
1807 | int ret; | 1808 | int ret = 0; |
1808 | 1809 | ||
1809 | BUG_ON(!is_data && refs_to_drop != 1); | 1810 | BUG_ON(!is_data && refs_to_drop != 1); |
1810 | if (iref) { | 1811 | if (iref) { |
1811 | ret = update_inline_extent_backref(trans, root, path, iref, | 1812 | update_inline_extent_backref(trans, root, path, iref, |
1812 | -refs_to_drop, NULL); | 1813 | -refs_to_drop, NULL); |
1813 | } else if (is_data) { | 1814 | } else if (is_data) { |
1814 | ret = remove_extent_data_ref(trans, root, path, refs_to_drop); | 1815 | ret = remove_extent_data_ref(trans, root, path, refs_to_drop); |
1815 | } else { | 1816 | } else { |
@@ -1835,6 +1836,7 @@ static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr, | |||
1835 | /* Tell the block device(s) that the sectors can be discarded */ | 1836 | /* Tell the block device(s) that the sectors can be discarded */ |
1836 | ret = btrfs_map_block(&root->fs_info->mapping_tree, REQ_DISCARD, | 1837 | ret = btrfs_map_block(&root->fs_info->mapping_tree, REQ_DISCARD, |
1837 | bytenr, &num_bytes, &bbio, 0); | 1838 | bytenr, &num_bytes, &bbio, 0); |
1839 | /* Error condition is -ENOMEM */ | ||
1838 | if (!ret) { | 1840 | if (!ret) { |
1839 | struct btrfs_bio_stripe *stripe = bbio->stripes; | 1841 | struct btrfs_bio_stripe *stripe = bbio->stripes; |
1840 | int i; | 1842 | int i; |
@@ -1850,7 +1852,7 @@ static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr, | |||
1850 | if (!ret) | 1852 | if (!ret) |
1851 | discarded_bytes += stripe->length; | 1853 | discarded_bytes += stripe->length; |
1852 | else if (ret != -EOPNOTSUPP) | 1854 | else if (ret != -EOPNOTSUPP) |
1853 | break; | 1855 | break; /* Logic errors or -ENOMEM, or -EIO but I don't know how that could happen JDM */ |
1854 | 1856 | ||
1855 | /* | 1857 | /* |
1856 | * Just in case we get back EOPNOTSUPP for some reason, | 1858 | * Just in case we get back EOPNOTSUPP for some reason, |
@@ -1869,6 +1871,7 @@ static int btrfs_discard_extent(struct btrfs_root *root, u64 bytenr, | |||
1869 | return ret; | 1871 | return ret; |
1870 | } | 1872 | } |
1871 | 1873 | ||
1874 | /* Can return -ENOMEM */ | ||
1872 | int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, | 1875 | int btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, |
1873 | struct btrfs_root *root, | 1876 | struct btrfs_root *root, |
1874 | u64 bytenr, u64 num_bytes, u64 parent, | 1877 | u64 bytenr, u64 num_bytes, u64 parent, |
@@ -1944,7 +1947,8 @@ static int __btrfs_inc_extent_ref(struct btrfs_trans_handle *trans, | |||
1944 | ret = insert_extent_backref(trans, root->fs_info->extent_root, | 1947 | ret = insert_extent_backref(trans, root->fs_info->extent_root, |
1945 | path, bytenr, parent, root_objectid, | 1948 | path, bytenr, parent, root_objectid, |
1946 | owner, offset, refs_to_add); | 1949 | owner, offset, refs_to_add); |
1947 | BUG_ON(ret); | 1950 | if (ret) |
1951 | btrfs_abort_transaction(trans, root, ret); | ||
1948 | out: | 1952 | out: |
1949 | btrfs_free_path(path); | 1953 | btrfs_free_path(path); |
1950 | return err; | 1954 | return err; |
@@ -2031,6 +2035,9 @@ static int run_delayed_extent_op(struct btrfs_trans_handle *trans, | |||
2031 | int ret; | 2035 | int ret; |
2032 | int err = 0; | 2036 | int err = 0; |
2033 | 2037 | ||
2038 | if (trans->aborted) | ||
2039 | return 0; | ||
2040 | |||
2034 | path = btrfs_alloc_path(); | 2041 | path = btrfs_alloc_path(); |
2035 | if (!path) | 2042 | if (!path) |
2036 | return -ENOMEM; | 2043 | return -ENOMEM; |
@@ -2128,7 +2135,11 @@ static int run_one_delayed_ref(struct btrfs_trans_handle *trans, | |||
2128 | struct btrfs_delayed_extent_op *extent_op, | 2135 | struct btrfs_delayed_extent_op *extent_op, |
2129 | int insert_reserved) | 2136 | int insert_reserved) |
2130 | { | 2137 | { |
2131 | int ret; | 2138 | int ret = 0; |
2139 | |||
2140 | if (trans->aborted) | ||
2141 | return 0; | ||
2142 | |||
2132 | if (btrfs_delayed_ref_is_head(node)) { | 2143 | if (btrfs_delayed_ref_is_head(node)) { |
2133 | struct btrfs_delayed_ref_head *head; | 2144 | struct btrfs_delayed_ref_head *head; |
2134 | /* | 2145 | /* |
@@ -2146,11 +2157,10 @@ static int run_one_delayed_ref(struct btrfs_trans_handle *trans, | |||
2146 | ret = btrfs_del_csums(trans, root, | 2157 | ret = btrfs_del_csums(trans, root, |
2147 | node->bytenr, | 2158 | node->bytenr, |
2148 | node->num_bytes); | 2159 | node->num_bytes); |
2149 | BUG_ON(ret); | ||
2150 | } | 2160 | } |
2151 | } | 2161 | } |
2152 | mutex_unlock(&head->mutex); | 2162 | mutex_unlock(&head->mutex); |
2153 | return 0; | 2163 | return ret; |
2154 | } | 2164 | } |
2155 | 2165 | ||
2156 | if (node->type == BTRFS_TREE_BLOCK_REF_KEY || | 2166 | if (node->type == BTRFS_TREE_BLOCK_REF_KEY || |
@@ -2197,6 +2207,10 @@ again: | |||
2197 | return NULL; | 2207 | return NULL; |
2198 | } | 2208 | } |
2199 | 2209 | ||
2210 | /* | ||
2211 | * Returns 0 on success or if called with an already aborted transaction. | ||
2212 | * Returns -ENOMEM or -EIO on failure and will abort the transaction. | ||
2213 | */ | ||
2200 | static noinline int run_clustered_refs(struct btrfs_trans_handle *trans, | 2214 | static noinline int run_clustered_refs(struct btrfs_trans_handle *trans, |
2201 | struct btrfs_root *root, | 2215 | struct btrfs_root *root, |
2202 | struct list_head *cluster) | 2216 | struct list_head *cluster) |
@@ -2285,9 +2299,13 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans, | |||
2285 | 2299 | ||
2286 | ret = run_delayed_extent_op(trans, root, | 2300 | ret = run_delayed_extent_op(trans, root, |
2287 | ref, extent_op); | 2301 | ref, extent_op); |
2288 | BUG_ON(ret); | ||
2289 | kfree(extent_op); | 2302 | kfree(extent_op); |
2290 | 2303 | ||
2304 | if (ret) { | ||
2305 | printk(KERN_DEBUG "btrfs: run_delayed_extent_op returned %d\n", ret); | ||
2306 | return ret; | ||
2307 | } | ||
2308 | |||
2291 | goto next; | 2309 | goto next; |
2292 | } | 2310 | } |
2293 | 2311 | ||
@@ -2308,11 +2326,16 @@ static noinline int run_clustered_refs(struct btrfs_trans_handle *trans, | |||
2308 | 2326 | ||
2309 | ret = run_one_delayed_ref(trans, root, ref, extent_op, | 2327 | ret = run_one_delayed_ref(trans, root, ref, extent_op, |
2310 | must_insert_reserved); | 2328 | must_insert_reserved); |
2311 | BUG_ON(ret); | ||
2312 | 2329 | ||
2313 | btrfs_put_delayed_ref(ref); | 2330 | btrfs_put_delayed_ref(ref); |
2314 | kfree(extent_op); | 2331 | kfree(extent_op); |
2315 | count++; | 2332 | count++; |
2333 | |||
2334 | if (ret) { | ||
2335 | printk(KERN_DEBUG "btrfs: run_one_delayed_ref returned %d\n", ret); | ||
2336 | return ret; | ||
2337 | } | ||
2338 | |||
2316 | next: | 2339 | next: |
2317 | do_chunk_alloc(trans, root->fs_info->extent_root, | 2340 | do_chunk_alloc(trans, root->fs_info->extent_root, |
2318 | 2 * 1024 * 1024, | 2341 | 2 * 1024 * 1024, |
@@ -2347,6 +2370,9 @@ static void wait_for_more_refs(struct btrfs_delayed_ref_root *delayed_refs, | |||
2347 | * 0, which means to process everything in the tree at the start | 2370 | * 0, which means to process everything in the tree at the start |
2348 | * of the run (but not newly added entries), or it can be some target | 2371 | * of the run (but not newly added entries), or it can be some target |
2349 | * number you'd like to process. | 2372 | * number you'd like to process. |
2373 | * | ||
2374 | * Returns 0 on success or if called with an aborted transaction | ||
2375 | * Returns <0 on error and aborts the transaction | ||
2350 | */ | 2376 | */ |
2351 | int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans, | 2377 | int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans, |
2352 | struct btrfs_root *root, unsigned long count) | 2378 | struct btrfs_root *root, unsigned long count) |
@@ -2362,6 +2388,10 @@ int btrfs_run_delayed_refs(struct btrfs_trans_handle *trans, | |||
2362 | unsigned long num_refs = 0; | 2388 | unsigned long num_refs = 0; |
2363 | int consider_waiting; | 2389 | int consider_waiting; |
2364 | 2390 | ||
2391 | /* We'll clean this up in btrfs_cleanup_transaction */ | ||
2392 | if (trans->aborted) | ||
2393 | return 0; | ||
2394 | |||
2365 | if (root == root->fs_info->extent_root) | 2395 | if (root == root->fs_info->extent_root) |
2366 | root = root->fs_info->tree_root; | 2396 | root = root->fs_info->tree_root; |
2367 | 2397 | ||
@@ -2419,7 +2449,11 @@ again: | |||
2419 | } | 2449 | } |
2420 | 2450 | ||
2421 | ret = run_clustered_refs(trans, root, &cluster); | 2451 | ret = run_clustered_refs(trans, root, &cluster); |
2422 | BUG_ON(ret < 0); | 2452 | if (ret < 0) { |
2453 | spin_unlock(&delayed_refs->lock); | ||
2454 | btrfs_abort_transaction(trans, root, ret); | ||
2455 | return ret; | ||
2456 | } | ||
2423 | 2457 | ||
2424 | count -= min_t(unsigned long, ret, count); | 2458 | count -= min_t(unsigned long, ret, count); |
2425 | 2459 | ||
@@ -2584,7 +2618,7 @@ static noinline int check_committed_ref(struct btrfs_trans_handle *trans, | |||
2584 | ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0); | 2618 | ret = btrfs_search_slot(NULL, extent_root, &key, path, 0, 0); |
2585 | if (ret < 0) | 2619 | if (ret < 0) |
2586 | goto out; | 2620 | goto out; |
2587 | BUG_ON(ret == 0); | 2621 | BUG_ON(ret == 0); /* Corruption */ |
2588 | 2622 | ||
2589 | ret = -ENOENT; | 2623 | ret = -ENOENT; |
2590 | if (path->slots[0] == 0) | 2624 | if (path->slots[0] == 0) |
@@ -2738,7 +2772,6 @@ static int __btrfs_mod_ref(struct btrfs_trans_handle *trans, | |||
2738 | } | 2772 | } |
2739 | return 0; | 2773 | return 0; |
2740 | fail: | 2774 | fail: |
2741 | BUG(); | ||
2742 | return ret; | 2775 | return ret; |
2743 | } | 2776 | } |
2744 | 2777 | ||
@@ -2767,7 +2800,7 @@ static int write_one_cache_group(struct btrfs_trans_handle *trans, | |||
2767 | ret = btrfs_search_slot(trans, extent_root, &cache->key, path, 0, 1); | 2800 | ret = btrfs_search_slot(trans, extent_root, &cache->key, path, 0, 1); |
2768 | if (ret < 0) | 2801 | if (ret < 0) |
2769 | goto fail; | 2802 | goto fail; |
2770 | BUG_ON(ret); | 2803 | BUG_ON(ret); /* Corruption */ |
2771 | 2804 | ||
2772 | leaf = path->nodes[0]; | 2805 | leaf = path->nodes[0]; |
2773 | bi = btrfs_item_ptr_offset(leaf, path->slots[0]); | 2806 | bi = btrfs_item_ptr_offset(leaf, path->slots[0]); |
@@ -2775,8 +2808,10 @@ static int write_one_cache_group(struct btrfs_trans_handle *trans, | |||
2775 | btrfs_mark_buffer_dirty(leaf); | 2808 | btrfs_mark_buffer_dirty(leaf); |
2776 | btrfs_release_path(path); | 2809 | btrfs_release_path(path); |
2777 | fail: | 2810 | fail: |
2778 | if (ret) | 2811 | if (ret) { |
2812 | btrfs_abort_transaction(trans, root, ret); | ||
2779 | return ret; | 2813 | return ret; |
2814 | } | ||
2780 | return 0; | 2815 | return 0; |
2781 | 2816 | ||
2782 | } | 2817 | } |
@@ -2949,7 +2984,8 @@ again: | |||
2949 | if (last == 0) { | 2984 | if (last == 0) { |
2950 | err = btrfs_run_delayed_refs(trans, root, | 2985 | err = btrfs_run_delayed_refs(trans, root, |
2951 | (unsigned long)-1); | 2986 | (unsigned long)-1); |
2952 | BUG_ON(err); | 2987 | if (err) /* File system offline */ |
2988 | goto out; | ||
2953 | } | 2989 | } |
2954 | 2990 | ||
2955 | cache = btrfs_lookup_first_block_group(root->fs_info, last); | 2991 | cache = btrfs_lookup_first_block_group(root->fs_info, last); |
@@ -2976,7 +3012,9 @@ again: | |||
2976 | last = cache->key.objectid + cache->key.offset; | 3012 | last = cache->key.objectid + cache->key.offset; |
2977 | 3013 | ||
2978 | err = write_one_cache_group(trans, root, path, cache); | 3014 | err = write_one_cache_group(trans, root, path, cache); |
2979 | BUG_ON(err); | 3015 | if (err) /* File system offline */ |
3016 | goto out; | ||
3017 | |||
2980 | btrfs_put_block_group(cache); | 3018 | btrfs_put_block_group(cache); |
2981 | } | 3019 | } |
2982 | 3020 | ||
@@ -2989,7 +3027,8 @@ again: | |||
2989 | if (last == 0) { | 3027 | if (last == 0) { |
2990 | err = btrfs_run_delayed_refs(trans, root, | 3028 | err = btrfs_run_delayed_refs(trans, root, |
2991 | (unsigned long)-1); | 3029 | (unsigned long)-1); |
2992 | BUG_ON(err); | 3030 | if (err) /* File system offline */ |
3031 | goto out; | ||
2993 | } | 3032 | } |
2994 | 3033 | ||
2995 | cache = btrfs_lookup_first_block_group(root->fs_info, last); | 3034 | cache = btrfs_lookup_first_block_group(root->fs_info, last); |
@@ -3014,20 +3053,21 @@ again: | |||
3014 | continue; | 3053 | continue; |
3015 | } | 3054 | } |
3016 | 3055 | ||
3017 | btrfs_write_out_cache(root, trans, cache, path); | 3056 | err = btrfs_write_out_cache(root, trans, cache, path); |
3018 | 3057 | ||
3019 | /* | 3058 | /* |
3020 | * If we didn't have an error then the cache state is still | 3059 | * If we didn't have an error then the cache state is still |
3021 | * NEED_WRITE, so we can set it to WRITTEN. | 3060 | * NEED_WRITE, so we can set it to WRITTEN. |
3022 | */ | 3061 | */ |
3023 | if (cache->disk_cache_state == BTRFS_DC_NEED_WRITE) | 3062 | if (!err && cache->disk_cache_state == BTRFS_DC_NEED_WRITE) |
3024 | cache->disk_cache_state = BTRFS_DC_WRITTEN; | 3063 | cache->disk_cache_state = BTRFS_DC_WRITTEN; |
3025 | last = cache->key.objectid + cache->key.offset; | 3064 | last = cache->key.objectid + cache->key.offset; |
3026 | btrfs_put_block_group(cache); | 3065 | btrfs_put_block_group(cache); |
3027 | } | 3066 | } |
3067 | out: | ||
3028 | 3068 | ||
3029 | btrfs_free_path(path); | 3069 | btrfs_free_path(path); |
3030 | return 0; | 3070 | return err; |
3031 | } | 3071 | } |
3032 | 3072 | ||
3033 | int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr) | 3073 | int btrfs_extent_readonly(struct btrfs_root *root, u64 bytenr) |
@@ -3411,9 +3451,9 @@ static int do_chunk_alloc(struct btrfs_trans_handle *trans, | |||
3411 | if (!space_info) { | 3451 | if (!space_info) { |
3412 | ret = update_space_info(extent_root->fs_info, flags, | 3452 | ret = update_space_info(extent_root->fs_info, flags, |
3413 | 0, 0, &space_info); | 3453 | 0, 0, &space_info); |
3414 | BUG_ON(ret); | 3454 | BUG_ON(ret); /* -ENOMEM */ |
3415 | } | 3455 | } |
3416 | BUG_ON(!space_info); | 3456 | BUG_ON(!space_info); /* Logic error */ |
3417 | 3457 | ||
3418 | again: | 3458 | again: |
3419 | spin_lock(&space_info->lock); | 3459 | spin_lock(&space_info->lock); |
@@ -3678,8 +3718,10 @@ again: | |||
3678 | ret = wait_event_interruptible(space_info->wait, | 3718 | ret = wait_event_interruptible(space_info->wait, |
3679 | !space_info->flush); | 3719 | !space_info->flush); |
3680 | /* Must have been interrupted, return */ | 3720 | /* Must have been interrupted, return */ |
3681 | if (ret) | 3721 | if (ret) { |
3722 | printk(KERN_DEBUG "btrfs: %s returning -EINTR\n", __func__); | ||
3682 | return -EINTR; | 3723 | return -EINTR; |
3724 | } | ||
3683 | 3725 | ||
3684 | spin_lock(&space_info->lock); | 3726 | spin_lock(&space_info->lock); |
3685 | } | 3727 | } |
@@ -3836,8 +3878,9 @@ out: | |||
3836 | return ret; | 3878 | return ret; |
3837 | } | 3879 | } |
3838 | 3880 | ||
3839 | static struct btrfs_block_rsv *get_block_rsv(struct btrfs_trans_handle *trans, | 3881 | static struct btrfs_block_rsv *get_block_rsv( |
3840 | struct btrfs_root *root) | 3882 | const struct btrfs_trans_handle *trans, |
3883 | const struct btrfs_root *root) | ||
3841 | { | 3884 | { |
3842 | struct btrfs_block_rsv *block_rsv = NULL; | 3885 | struct btrfs_block_rsv *block_rsv = NULL; |
3843 | 3886 | ||
@@ -4204,6 +4247,7 @@ void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans, | |||
4204 | trans->bytes_reserved = 0; | 4247 | trans->bytes_reserved = 0; |
4205 | } | 4248 | } |
4206 | 4249 | ||
4250 | /* Can only return 0 or -ENOSPC */ | ||
4207 | int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans, | 4251 | int btrfs_orphan_reserve_metadata(struct btrfs_trans_handle *trans, |
4208 | struct inode *inode) | 4252 | struct inode *inode) |
4209 | { | 4253 | { |
@@ -4540,7 +4584,7 @@ static int update_block_group(struct btrfs_trans_handle *trans, | |||
4540 | while (total) { | 4584 | while (total) { |
4541 | cache = btrfs_lookup_block_group(info, bytenr); | 4585 | cache = btrfs_lookup_block_group(info, bytenr); |
4542 | if (!cache) | 4586 | if (!cache) |
4543 | return -1; | 4587 | return -ENOENT; |
4544 | if (cache->flags & (BTRFS_BLOCK_GROUP_DUP | | 4588 | if (cache->flags & (BTRFS_BLOCK_GROUP_DUP | |
4545 | BTRFS_BLOCK_GROUP_RAID1 | | 4589 | BTRFS_BLOCK_GROUP_RAID1 | |
4546 | BTRFS_BLOCK_GROUP_RAID10)) | 4590 | BTRFS_BLOCK_GROUP_RAID10)) |
@@ -4643,7 +4687,7 @@ int btrfs_pin_extent(struct btrfs_root *root, | |||
4643 | struct btrfs_block_group_cache *cache; | 4687 | struct btrfs_block_group_cache *cache; |
4644 | 4688 | ||
4645 | cache = btrfs_lookup_block_group(root->fs_info, bytenr); | 4689 | cache = btrfs_lookup_block_group(root->fs_info, bytenr); |
4646 | BUG_ON(!cache); | 4690 | BUG_ON(!cache); /* Logic error */ |
4647 | 4691 | ||
4648 | pin_down_extent(root, cache, bytenr, num_bytes, reserved); | 4692 | pin_down_extent(root, cache, bytenr, num_bytes, reserved); |
4649 | 4693 | ||
@@ -4661,7 +4705,7 @@ int btrfs_pin_extent_for_log_replay(struct btrfs_trans_handle *trans, | |||
4661 | struct btrfs_block_group_cache *cache; | 4705 | struct btrfs_block_group_cache *cache; |
4662 | 4706 | ||
4663 | cache = btrfs_lookup_block_group(root->fs_info, bytenr); | 4707 | cache = btrfs_lookup_block_group(root->fs_info, bytenr); |
4664 | BUG_ON(!cache); | 4708 | BUG_ON(!cache); /* Logic error */ |
4665 | 4709 | ||
4666 | /* | 4710 | /* |
4667 | * pull in the free space cache (if any) so that our pin | 4711 | * pull in the free space cache (if any) so that our pin |
@@ -4706,6 +4750,7 @@ static int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache, | |||
4706 | { | 4750 | { |
4707 | struct btrfs_space_info *space_info = cache->space_info; | 4751 | struct btrfs_space_info *space_info = cache->space_info; |
4708 | int ret = 0; | 4752 | int ret = 0; |
4753 | |||
4709 | spin_lock(&space_info->lock); | 4754 | spin_lock(&space_info->lock); |
4710 | spin_lock(&cache->lock); | 4755 | spin_lock(&cache->lock); |
4711 | if (reserve != RESERVE_FREE) { | 4756 | if (reserve != RESERVE_FREE) { |
@@ -4734,7 +4779,7 @@ static int btrfs_update_reserved_bytes(struct btrfs_block_group_cache *cache, | |||
4734 | return ret; | 4779 | return ret; |
4735 | } | 4780 | } |
4736 | 4781 | ||
4737 | int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans, | 4782 | void btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans, |
4738 | struct btrfs_root *root) | 4783 | struct btrfs_root *root) |
4739 | { | 4784 | { |
4740 | struct btrfs_fs_info *fs_info = root->fs_info; | 4785 | struct btrfs_fs_info *fs_info = root->fs_info; |
@@ -4764,7 +4809,6 @@ int btrfs_prepare_extent_commit(struct btrfs_trans_handle *trans, | |||
4764 | up_write(&fs_info->extent_commit_sem); | 4809 | up_write(&fs_info->extent_commit_sem); |
4765 | 4810 | ||
4766 | update_global_block_rsv(fs_info); | 4811 | update_global_block_rsv(fs_info); |
4767 | return 0; | ||
4768 | } | 4812 | } |
4769 | 4813 | ||
4770 | static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end) | 4814 | static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end) |
@@ -4779,7 +4823,7 @@ static int unpin_extent_range(struct btrfs_root *root, u64 start, u64 end) | |||
4779 | if (cache) | 4823 | if (cache) |
4780 | btrfs_put_block_group(cache); | 4824 | btrfs_put_block_group(cache); |
4781 | cache = btrfs_lookup_block_group(fs_info, start); | 4825 | cache = btrfs_lookup_block_group(fs_info, start); |
4782 | BUG_ON(!cache); | 4826 | BUG_ON(!cache); /* Logic error */ |
4783 | } | 4827 | } |
4784 | 4828 | ||
4785 | len = cache->key.objectid + cache->key.offset - start; | 4829 | len = cache->key.objectid + cache->key.offset - start; |
@@ -4816,6 +4860,9 @@ int btrfs_finish_extent_commit(struct btrfs_trans_handle *trans, | |||
4816 | u64 end; | 4860 | u64 end; |
4817 | int ret; | 4861 | int ret; |
4818 | 4862 | ||
4863 | if (trans->aborted) | ||
4864 | return 0; | ||
4865 | |||
4819 | if (fs_info->pinned_extents == &fs_info->freed_extents[0]) | 4866 | if (fs_info->pinned_extents == &fs_info->freed_extents[0]) |
4820 | unpin = &fs_info->freed_extents[1]; | 4867 | unpin = &fs_info->freed_extents[1]; |
4821 | else | 4868 | else |
@@ -4901,7 +4948,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, | |||
4901 | ret = remove_extent_backref(trans, extent_root, path, | 4948 | ret = remove_extent_backref(trans, extent_root, path, |
4902 | NULL, refs_to_drop, | 4949 | NULL, refs_to_drop, |
4903 | is_data); | 4950 | is_data); |
4904 | BUG_ON(ret); | 4951 | if (ret) |
4952 | goto abort; | ||
4905 | btrfs_release_path(path); | 4953 | btrfs_release_path(path); |
4906 | path->leave_spinning = 1; | 4954 | path->leave_spinning = 1; |
4907 | 4955 | ||
@@ -4919,10 +4967,11 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, | |||
4919 | btrfs_print_leaf(extent_root, | 4967 | btrfs_print_leaf(extent_root, |
4920 | path->nodes[0]); | 4968 | path->nodes[0]); |
4921 | } | 4969 | } |
4922 | BUG_ON(ret); | 4970 | if (ret < 0) |
4971 | goto abort; | ||
4923 | extent_slot = path->slots[0]; | 4972 | extent_slot = path->slots[0]; |
4924 | } | 4973 | } |
4925 | } else { | 4974 | } else if (ret == -ENOENT) { |
4926 | btrfs_print_leaf(extent_root, path->nodes[0]); | 4975 | btrfs_print_leaf(extent_root, path->nodes[0]); |
4927 | WARN_ON(1); | 4976 | WARN_ON(1); |
4928 | printk(KERN_ERR "btrfs unable to find ref byte nr %llu " | 4977 | printk(KERN_ERR "btrfs unable to find ref byte nr %llu " |
@@ -4932,6 +4981,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, | |||
4932 | (unsigned long long)root_objectid, | 4981 | (unsigned long long)root_objectid, |
4933 | (unsigned long long)owner_objectid, | 4982 | (unsigned long long)owner_objectid, |
4934 | (unsigned long long)owner_offset); | 4983 | (unsigned long long)owner_offset); |
4984 | } else { | ||
4985 | goto abort; | ||
4935 | } | 4986 | } |
4936 | 4987 | ||
4937 | leaf = path->nodes[0]; | 4988 | leaf = path->nodes[0]; |
@@ -4941,7 +4992,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, | |||
4941 | BUG_ON(found_extent || extent_slot != path->slots[0]); | 4992 | BUG_ON(found_extent || extent_slot != path->slots[0]); |
4942 | ret = convert_extent_item_v0(trans, extent_root, path, | 4993 | ret = convert_extent_item_v0(trans, extent_root, path, |
4943 | owner_objectid, 0); | 4994 | owner_objectid, 0); |
4944 | BUG_ON(ret < 0); | 4995 | if (ret < 0) |
4996 | goto abort; | ||
4945 | 4997 | ||
4946 | btrfs_release_path(path); | 4998 | btrfs_release_path(path); |
4947 | path->leave_spinning = 1; | 4999 | path->leave_spinning = 1; |
@@ -4958,7 +5010,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, | |||
4958 | (unsigned long long)bytenr); | 5010 | (unsigned long long)bytenr); |
4959 | btrfs_print_leaf(extent_root, path->nodes[0]); | 5011 | btrfs_print_leaf(extent_root, path->nodes[0]); |
4960 | } | 5012 | } |
4961 | BUG_ON(ret); | 5013 | if (ret < 0) |
5014 | goto abort; | ||
4962 | extent_slot = path->slots[0]; | 5015 | extent_slot = path->slots[0]; |
4963 | leaf = path->nodes[0]; | 5016 | leaf = path->nodes[0]; |
4964 | item_size = btrfs_item_size_nr(leaf, extent_slot); | 5017 | item_size = btrfs_item_size_nr(leaf, extent_slot); |
@@ -4995,7 +5048,8 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, | |||
4995 | ret = remove_extent_backref(trans, extent_root, path, | 5048 | ret = remove_extent_backref(trans, extent_root, path, |
4996 | iref, refs_to_drop, | 5049 | iref, refs_to_drop, |
4997 | is_data); | 5050 | is_data); |
4998 | BUG_ON(ret); | 5051 | if (ret) |
5052 | goto abort; | ||
4999 | } | 5053 | } |
5000 | } else { | 5054 | } else { |
5001 | if (found_extent) { | 5055 | if (found_extent) { |
@@ -5012,19 +5066,27 @@ static int __btrfs_free_extent(struct btrfs_trans_handle *trans, | |||
5012 | 5066 | ||
5013 | ret = btrfs_del_items(trans, extent_root, path, path->slots[0], | 5067 | ret = btrfs_del_items(trans, extent_root, path, path->slots[0], |
5014 | num_to_del); | 5068 | num_to_del); |
5015 | BUG_ON(ret); | 5069 | if (ret) |
5070 | goto abort; | ||
5016 | btrfs_release_path(path); | 5071 | btrfs_release_path(path); |
5017 | 5072 | ||
5018 | if (is_data) { | 5073 | if (is_data) { |
5019 | ret = btrfs_del_csums(trans, root, bytenr, num_bytes); | 5074 | ret = btrfs_del_csums(trans, root, bytenr, num_bytes); |
5020 | BUG_ON(ret); | 5075 | if (ret) |
5076 | goto abort; | ||
5021 | } | 5077 | } |
5022 | 5078 | ||
5023 | ret = update_block_group(trans, root, bytenr, num_bytes, 0); | 5079 | ret = update_block_group(trans, root, bytenr, num_bytes, 0); |
5024 | BUG_ON(ret); | 5080 | if (ret) |
5081 | goto abort; | ||
5025 | } | 5082 | } |
5083 | out: | ||
5026 | btrfs_free_path(path); | 5084 | btrfs_free_path(path); |
5027 | return ret; | 5085 | return ret; |
5086 | |||
5087 | abort: | ||
5088 | btrfs_abort_transaction(trans, extent_root, ret); | ||
5089 | goto out; | ||
5028 | } | 5090 | } |
5029 | 5091 | ||
5030 | /* | 5092 | /* |
@@ -5120,7 +5182,7 @@ void btrfs_free_tree_block(struct btrfs_trans_handle *trans, | |||
5120 | parent, root->root_key.objectid, | 5182 | parent, root->root_key.objectid, |
5121 | btrfs_header_level(buf), | 5183 | btrfs_header_level(buf), |
5122 | BTRFS_DROP_DELAYED_REF, NULL, for_cow); | 5184 | BTRFS_DROP_DELAYED_REF, NULL, for_cow); |
5123 | BUG_ON(ret); | 5185 | BUG_ON(ret); /* -ENOMEM */ |
5124 | } | 5186 | } |
5125 | 5187 | ||
5126 | if (!last_ref) | 5188 | if (!last_ref) |
@@ -5154,6 +5216,7 @@ out: | |||
5154 | btrfs_put_block_group(cache); | 5216 | btrfs_put_block_group(cache); |
5155 | } | 5217 | } |
5156 | 5218 | ||
5219 | /* Can return -ENOMEM */ | ||
5157 | int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root *root, | 5220 | int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root *root, |
5158 | u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid, | 5221 | u64 bytenr, u64 num_bytes, u64 parent, u64 root_objectid, |
5159 | u64 owner, u64 offset, int for_cow) | 5222 | u64 owner, u64 offset, int for_cow) |
@@ -5175,14 +5238,12 @@ int btrfs_free_extent(struct btrfs_trans_handle *trans, struct btrfs_root *root, | |||
5175 | num_bytes, | 5238 | num_bytes, |
5176 | parent, root_objectid, (int)owner, | 5239 | parent, root_objectid, (int)owner, |
5177 | BTRFS_DROP_DELAYED_REF, NULL, for_cow); | 5240 | BTRFS_DROP_DELAYED_REF, NULL, for_cow); |
5178 | BUG_ON(ret); | ||
5179 | } else { | 5241 | } else { |
5180 | ret = btrfs_add_delayed_data_ref(fs_info, trans, bytenr, | 5242 | ret = btrfs_add_delayed_data_ref(fs_info, trans, bytenr, |
5181 | num_bytes, | 5243 | num_bytes, |
5182 | parent, root_objectid, owner, | 5244 | parent, root_objectid, owner, |
5183 | offset, BTRFS_DROP_DELAYED_REF, | 5245 | offset, BTRFS_DROP_DELAYED_REF, |
5184 | NULL, for_cow); | 5246 | NULL, for_cow); |
5185 | BUG_ON(ret); | ||
5186 | } | 5247 | } |
5187 | return ret; | 5248 | return ret; |
5188 | } | 5249 | } |
@@ -5412,7 +5473,8 @@ have_block_group: | |||
5412 | found_uncached_bg = true; | 5473 | found_uncached_bg = true; |
5413 | ret = cache_block_group(block_group, trans, | 5474 | ret = cache_block_group(block_group, trans, |
5414 | orig_root, 0); | 5475 | orig_root, 0); |
5415 | BUG_ON(ret); | 5476 | BUG_ON(ret < 0); |
5477 | ret = 0; | ||
5416 | } | 5478 | } |
5417 | 5479 | ||
5418 | if (unlikely(block_group->ro)) | 5480 | if (unlikely(block_group->ro)) |
@@ -5631,6 +5693,11 @@ loop: | |||
5631 | ret = do_chunk_alloc(trans, root, num_bytes + | 5693 | ret = do_chunk_alloc(trans, root, num_bytes + |
5632 | 2 * 1024 * 1024, data, | 5694 | 2 * 1024 * 1024, data, |
5633 | CHUNK_ALLOC_LIMITED); | 5695 | CHUNK_ALLOC_LIMITED); |
5696 | if (ret < 0) { | ||
5697 | btrfs_abort_transaction(trans, | ||
5698 | root, ret); | ||
5699 | goto out; | ||
5700 | } | ||
5634 | allowed_chunk_alloc = 0; | 5701 | allowed_chunk_alloc = 0; |
5635 | if (ret == 1) | 5702 | if (ret == 1) |
5636 | done_chunk_alloc = 1; | 5703 | done_chunk_alloc = 1; |
@@ -5659,6 +5726,7 @@ loop: | |||
5659 | } else if (ins->objectid) { | 5726 | } else if (ins->objectid) { |
5660 | ret = 0; | 5727 | ret = 0; |
5661 | } | 5728 | } |
5729 | out: | ||
5662 | 5730 | ||
5663 | return ret; | 5731 | return ret; |
5664 | } | 5732 | } |
@@ -5723,10 +5791,15 @@ again: | |||
5723 | * the only place that sets empty_size is btrfs_realloc_node, which | 5791 | * the only place that sets empty_size is btrfs_realloc_node, which |
5724 | * is not called recursively on allocations | 5792 | * is not called recursively on allocations |
5725 | */ | 5793 | */ |
5726 | if (empty_size || root->ref_cows) | 5794 | if (empty_size || root->ref_cows) { |
5727 | ret = do_chunk_alloc(trans, root->fs_info->extent_root, | 5795 | ret = do_chunk_alloc(trans, root->fs_info->extent_root, |
5728 | num_bytes + 2 * 1024 * 1024, data, | 5796 | num_bytes + 2 * 1024 * 1024, data, |
5729 | CHUNK_ALLOC_NO_FORCE); | 5797 | CHUNK_ALLOC_NO_FORCE); |
5798 | if (ret < 0 && ret != -ENOSPC) { | ||
5799 | btrfs_abort_transaction(trans, root, ret); | ||
5800 | return ret; | ||
5801 | } | ||
5802 | } | ||
5730 | 5803 | ||
5731 | WARN_ON(num_bytes < root->sectorsize); | 5804 | WARN_ON(num_bytes < root->sectorsize); |
5732 | ret = find_free_extent(trans, root, num_bytes, empty_size, | 5805 | ret = find_free_extent(trans, root, num_bytes, empty_size, |
@@ -5737,8 +5810,12 @@ again: | |||
5737 | num_bytes = num_bytes >> 1; | 5810 | num_bytes = num_bytes >> 1; |
5738 | num_bytes = num_bytes & ~(root->sectorsize - 1); | 5811 | num_bytes = num_bytes & ~(root->sectorsize - 1); |
5739 | num_bytes = max(num_bytes, min_alloc_size); | 5812 | num_bytes = max(num_bytes, min_alloc_size); |
5740 | do_chunk_alloc(trans, root->fs_info->extent_root, | 5813 | ret = do_chunk_alloc(trans, root->fs_info->extent_root, |
5741 | num_bytes, data, CHUNK_ALLOC_FORCE); | 5814 | num_bytes, data, CHUNK_ALLOC_FORCE); |
5815 | if (ret < 0 && ret != -ENOSPC) { | ||
5816 | btrfs_abort_transaction(trans, root, ret); | ||
5817 | return ret; | ||
5818 | } | ||
5742 | if (num_bytes == min_alloc_size) | 5819 | if (num_bytes == min_alloc_size) |
5743 | final_tried = true; | 5820 | final_tried = true; |
5744 | goto again; | 5821 | goto again; |
@@ -5749,7 +5826,8 @@ again: | |||
5749 | printk(KERN_ERR "btrfs allocation failed flags %llu, " | 5826 | printk(KERN_ERR "btrfs allocation failed flags %llu, " |
5750 | "wanted %llu\n", (unsigned long long)data, | 5827 | "wanted %llu\n", (unsigned long long)data, |
5751 | (unsigned long long)num_bytes); | 5828 | (unsigned long long)num_bytes); |
5752 | dump_space_info(sinfo, num_bytes, 1); | 5829 | if (sinfo) |
5830 | dump_space_info(sinfo, num_bytes, 1); | ||
5753 | } | 5831 | } |
5754 | } | 5832 | } |
5755 | 5833 | ||
@@ -5828,7 +5906,10 @@ static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans, | |||
5828 | path->leave_spinning = 1; | 5906 | path->leave_spinning = 1; |
5829 | ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path, | 5907 | ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path, |
5830 | ins, size); | 5908 | ins, size); |
5831 | BUG_ON(ret); | 5909 | if (ret) { |
5910 | btrfs_free_path(path); | ||
5911 | return ret; | ||
5912 | } | ||
5832 | 5913 | ||
5833 | leaf = path->nodes[0]; | 5914 | leaf = path->nodes[0]; |
5834 | extent_item = btrfs_item_ptr(leaf, path->slots[0], | 5915 | extent_item = btrfs_item_ptr(leaf, path->slots[0], |
@@ -5858,7 +5939,7 @@ static int alloc_reserved_file_extent(struct btrfs_trans_handle *trans, | |||
5858 | btrfs_free_path(path); | 5939 | btrfs_free_path(path); |
5859 | 5940 | ||
5860 | ret = update_block_group(trans, root, ins->objectid, ins->offset, 1); | 5941 | ret = update_block_group(trans, root, ins->objectid, ins->offset, 1); |
5861 | if (ret) { | 5942 | if (ret) { /* -ENOENT, logic error */ |
5862 | printk(KERN_ERR "btrfs update block group failed for %llu " | 5943 | printk(KERN_ERR "btrfs update block group failed for %llu " |
5863 | "%llu\n", (unsigned long long)ins->objectid, | 5944 | "%llu\n", (unsigned long long)ins->objectid, |
5864 | (unsigned long long)ins->offset); | 5945 | (unsigned long long)ins->offset); |
@@ -5889,7 +5970,10 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans, | |||
5889 | path->leave_spinning = 1; | 5970 | path->leave_spinning = 1; |
5890 | ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path, | 5971 | ret = btrfs_insert_empty_item(trans, fs_info->extent_root, path, |
5891 | ins, size); | 5972 | ins, size); |
5892 | BUG_ON(ret); | 5973 | if (ret) { |
5974 | btrfs_free_path(path); | ||
5975 | return ret; | ||
5976 | } | ||
5893 | 5977 | ||
5894 | leaf = path->nodes[0]; | 5978 | leaf = path->nodes[0]; |
5895 | extent_item = btrfs_item_ptr(leaf, path->slots[0], | 5979 | extent_item = btrfs_item_ptr(leaf, path->slots[0], |
@@ -5919,7 +6003,7 @@ static int alloc_reserved_tree_block(struct btrfs_trans_handle *trans, | |||
5919 | btrfs_free_path(path); | 6003 | btrfs_free_path(path); |
5920 | 6004 | ||
5921 | ret = update_block_group(trans, root, ins->objectid, ins->offset, 1); | 6005 | ret = update_block_group(trans, root, ins->objectid, ins->offset, 1); |
5922 | if (ret) { | 6006 | if (ret) { /* -ENOENT, logic error */ |
5923 | printk(KERN_ERR "btrfs update block group failed for %llu " | 6007 | printk(KERN_ERR "btrfs update block group failed for %llu " |
5924 | "%llu\n", (unsigned long long)ins->objectid, | 6008 | "%llu\n", (unsigned long long)ins->objectid, |
5925 | (unsigned long long)ins->offset); | 6009 | (unsigned long long)ins->offset); |
@@ -5967,28 +6051,28 @@ int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans, | |||
5967 | if (!caching_ctl) { | 6051 | if (!caching_ctl) { |
5968 | BUG_ON(!block_group_cache_done(block_group)); | 6052 | BUG_ON(!block_group_cache_done(block_group)); |
5969 | ret = btrfs_remove_free_space(block_group, start, num_bytes); | 6053 | ret = btrfs_remove_free_space(block_group, start, num_bytes); |
5970 | BUG_ON(ret); | 6054 | BUG_ON(ret); /* -ENOMEM */ |
5971 | } else { | 6055 | } else { |
5972 | mutex_lock(&caching_ctl->mutex); | 6056 | mutex_lock(&caching_ctl->mutex); |
5973 | 6057 | ||
5974 | if (start >= caching_ctl->progress) { | 6058 | if (start >= caching_ctl->progress) { |
5975 | ret = add_excluded_extent(root, start, num_bytes); | 6059 | ret = add_excluded_extent(root, start, num_bytes); |
5976 | BUG_ON(ret); | 6060 | BUG_ON(ret); /* -ENOMEM */ |
5977 | } else if (start + num_bytes <= caching_ctl->progress) { | 6061 | } else if (start + num_bytes <= caching_ctl->progress) { |
5978 | ret = btrfs_remove_free_space(block_group, | 6062 | ret = btrfs_remove_free_space(block_group, |
5979 | start, num_bytes); | 6063 | start, num_bytes); |
5980 | BUG_ON(ret); | 6064 | BUG_ON(ret); /* -ENOMEM */ |
5981 | } else { | 6065 | } else { |
5982 | num_bytes = caching_ctl->progress - start; | 6066 | num_bytes = caching_ctl->progress - start; |
5983 | ret = btrfs_remove_free_space(block_group, | 6067 | ret = btrfs_remove_free_space(block_group, |
5984 | start, num_bytes); | 6068 | start, num_bytes); |
5985 | BUG_ON(ret); | 6069 | BUG_ON(ret); /* -ENOMEM */ |
5986 | 6070 | ||
5987 | start = caching_ctl->progress; | 6071 | start = caching_ctl->progress; |
5988 | num_bytes = ins->objectid + ins->offset - | 6072 | num_bytes = ins->objectid + ins->offset - |
5989 | caching_ctl->progress; | 6073 | caching_ctl->progress; |
5990 | ret = add_excluded_extent(root, start, num_bytes); | 6074 | ret = add_excluded_extent(root, start, num_bytes); |
5991 | BUG_ON(ret); | 6075 | BUG_ON(ret); /* -ENOMEM */ |
5992 | } | 6076 | } |
5993 | 6077 | ||
5994 | mutex_unlock(&caching_ctl->mutex); | 6078 | mutex_unlock(&caching_ctl->mutex); |
@@ -5997,7 +6081,7 @@ int btrfs_alloc_logged_file_extent(struct btrfs_trans_handle *trans, | |||
5997 | 6081 | ||
5998 | ret = btrfs_update_reserved_bytes(block_group, ins->offset, | 6082 | ret = btrfs_update_reserved_bytes(block_group, ins->offset, |
5999 | RESERVE_ALLOC_NO_ACCOUNT); | 6083 | RESERVE_ALLOC_NO_ACCOUNT); |
6000 | BUG_ON(ret); | 6084 | BUG_ON(ret); /* logic error */ |
6001 | btrfs_put_block_group(block_group); | 6085 | btrfs_put_block_group(block_group); |
6002 | ret = alloc_reserved_file_extent(trans, root, 0, root_objectid, | 6086 | ret = alloc_reserved_file_extent(trans, root, 0, root_objectid, |
6003 | 0, owner, offset, ins, 1); | 6087 | 0, owner, offset, ins, 1); |
@@ -6134,7 +6218,7 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, | |||
6134 | 6218 | ||
6135 | buf = btrfs_init_new_buffer(trans, root, ins.objectid, | 6219 | buf = btrfs_init_new_buffer(trans, root, ins.objectid, |
6136 | blocksize, level); | 6220 | blocksize, level); |
6137 | BUG_ON(IS_ERR(buf)); | 6221 | BUG_ON(IS_ERR(buf)); /* -ENOMEM */ |
6138 | 6222 | ||
6139 | if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) { | 6223 | if (root_objectid == BTRFS_TREE_RELOC_OBJECTID) { |
6140 | if (parent == 0) | 6224 | if (parent == 0) |
@@ -6146,7 +6230,7 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, | |||
6146 | if (root_objectid != BTRFS_TREE_LOG_OBJECTID) { | 6230 | if (root_objectid != BTRFS_TREE_LOG_OBJECTID) { |
6147 | struct btrfs_delayed_extent_op *extent_op; | 6231 | struct btrfs_delayed_extent_op *extent_op; |
6148 | extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS); | 6232 | extent_op = kmalloc(sizeof(*extent_op), GFP_NOFS); |
6149 | BUG_ON(!extent_op); | 6233 | BUG_ON(!extent_op); /* -ENOMEM */ |
6150 | if (key) | 6234 | if (key) |
6151 | memcpy(&extent_op->key, key, sizeof(extent_op->key)); | 6235 | memcpy(&extent_op->key, key, sizeof(extent_op->key)); |
6152 | else | 6236 | else |
@@ -6161,7 +6245,7 @@ struct extent_buffer *btrfs_alloc_free_block(struct btrfs_trans_handle *trans, | |||
6161 | ins.offset, parent, root_objectid, | 6245 | ins.offset, parent, root_objectid, |
6162 | level, BTRFS_ADD_DELAYED_EXTENT, | 6246 | level, BTRFS_ADD_DELAYED_EXTENT, |
6163 | extent_op, for_cow); | 6247 | extent_op, for_cow); |
6164 | BUG_ON(ret); | 6248 | BUG_ON(ret); /* -ENOMEM */ |
6165 | } | 6249 | } |
6166 | return buf; | 6250 | return buf; |
6167 | } | 6251 | } |
@@ -6231,7 +6315,9 @@ static noinline void reada_walk_down(struct btrfs_trans_handle *trans, | |||
6231 | /* We don't lock the tree block, it's OK to be racy here */ | 6315 | /* We don't lock the tree block, it's OK to be racy here */ |
6232 | ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize, | 6316 | ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize, |
6233 | &refs, &flags); | 6317 | &refs, &flags); |
6234 | BUG_ON(ret); | 6318 | /* We don't care about errors in readahead. */ |
6319 | if (ret < 0) | ||
6320 | continue; | ||
6235 | BUG_ON(refs == 0); | 6321 | BUG_ON(refs == 0); |
6236 | 6322 | ||
6237 | if (wc->stage == DROP_REFERENCE) { | 6323 | if (wc->stage == DROP_REFERENCE) { |
@@ -6298,7 +6384,9 @@ static noinline int walk_down_proc(struct btrfs_trans_handle *trans, | |||
6298 | eb->start, eb->len, | 6384 | eb->start, eb->len, |
6299 | &wc->refs[level], | 6385 | &wc->refs[level], |
6300 | &wc->flags[level]); | 6386 | &wc->flags[level]); |
6301 | BUG_ON(ret); | 6387 | BUG_ON(ret == -ENOMEM); |
6388 | if (ret) | ||
6389 | return ret; | ||
6302 | BUG_ON(wc->refs[level] == 0); | 6390 | BUG_ON(wc->refs[level] == 0); |
6303 | } | 6391 | } |
6304 | 6392 | ||
@@ -6317,12 +6405,12 @@ static noinline int walk_down_proc(struct btrfs_trans_handle *trans, | |||
6317 | if (!(wc->flags[level] & flag)) { | 6405 | if (!(wc->flags[level] & flag)) { |
6318 | BUG_ON(!path->locks[level]); | 6406 | BUG_ON(!path->locks[level]); |
6319 | ret = btrfs_inc_ref(trans, root, eb, 1, wc->for_reloc); | 6407 | ret = btrfs_inc_ref(trans, root, eb, 1, wc->for_reloc); |
6320 | BUG_ON(ret); | 6408 | BUG_ON(ret); /* -ENOMEM */ |
6321 | ret = btrfs_dec_ref(trans, root, eb, 0, wc->for_reloc); | 6409 | ret = btrfs_dec_ref(trans, root, eb, 0, wc->for_reloc); |
6322 | BUG_ON(ret); | 6410 | BUG_ON(ret); /* -ENOMEM */ |
6323 | ret = btrfs_set_disk_extent_flags(trans, root, eb->start, | 6411 | ret = btrfs_set_disk_extent_flags(trans, root, eb->start, |
6324 | eb->len, flag, 0); | 6412 | eb->len, flag, 0); |
6325 | BUG_ON(ret); | 6413 | BUG_ON(ret); /* -ENOMEM */ |
6326 | wc->flags[level] |= flag; | 6414 | wc->flags[level] |= flag; |
6327 | } | 6415 | } |
6328 | 6416 | ||
@@ -6394,7 +6482,11 @@ static noinline int do_walk_down(struct btrfs_trans_handle *trans, | |||
6394 | ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize, | 6482 | ret = btrfs_lookup_extent_info(trans, root, bytenr, blocksize, |
6395 | &wc->refs[level - 1], | 6483 | &wc->refs[level - 1], |
6396 | &wc->flags[level - 1]); | 6484 | &wc->flags[level - 1]); |
6397 | BUG_ON(ret); | 6485 | if (ret < 0) { |
6486 | btrfs_tree_unlock(next); | ||
6487 | return ret; | ||
6488 | } | ||
6489 | |||
6398 | BUG_ON(wc->refs[level - 1] == 0); | 6490 | BUG_ON(wc->refs[level - 1] == 0); |
6399 | *lookup_info = 0; | 6491 | *lookup_info = 0; |
6400 | 6492 | ||
@@ -6463,7 +6555,7 @@ skip: | |||
6463 | 6555 | ||
6464 | ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent, | 6556 | ret = btrfs_free_extent(trans, root, bytenr, blocksize, parent, |
6465 | root->root_key.objectid, level - 1, 0, 0); | 6557 | root->root_key.objectid, level - 1, 0, 0); |
6466 | BUG_ON(ret); | 6558 | BUG_ON(ret); /* -ENOMEM */ |
6467 | } | 6559 | } |
6468 | btrfs_tree_unlock(next); | 6560 | btrfs_tree_unlock(next); |
6469 | free_extent_buffer(next); | 6561 | free_extent_buffer(next); |
@@ -6521,7 +6613,10 @@ static noinline int walk_up_proc(struct btrfs_trans_handle *trans, | |||
6521 | eb->start, eb->len, | 6613 | eb->start, eb->len, |
6522 | &wc->refs[level], | 6614 | &wc->refs[level], |
6523 | &wc->flags[level]); | 6615 | &wc->flags[level]); |
6524 | BUG_ON(ret); | 6616 | if (ret < 0) { |
6617 | btrfs_tree_unlock_rw(eb, path->locks[level]); | ||
6618 | return ret; | ||
6619 | } | ||
6525 | BUG_ON(wc->refs[level] == 0); | 6620 | BUG_ON(wc->refs[level] == 0); |
6526 | if (wc->refs[level] == 1) { | 6621 | if (wc->refs[level] == 1) { |
6527 | btrfs_tree_unlock_rw(eb, path->locks[level]); | 6622 | btrfs_tree_unlock_rw(eb, path->locks[level]); |
@@ -6541,7 +6636,7 @@ static noinline int walk_up_proc(struct btrfs_trans_handle *trans, | |||
6541 | else | 6636 | else |
6542 | ret = btrfs_dec_ref(trans, root, eb, 0, | 6637 | ret = btrfs_dec_ref(trans, root, eb, 0, |
6543 | wc->for_reloc); | 6638 | wc->for_reloc); |
6544 | BUG_ON(ret); | 6639 | BUG_ON(ret); /* -ENOMEM */ |
6545 | } | 6640 | } |
6546 | /* make block locked assertion in clean_tree_block happy */ | 6641 | /* make block locked assertion in clean_tree_block happy */ |
6547 | if (!path->locks[level] && | 6642 | if (!path->locks[level] && |
@@ -6650,7 +6745,7 @@ static noinline int walk_up_tree(struct btrfs_trans_handle *trans, | |||
6650 | * also make sure backrefs for the shared block and all lower level | 6745 | * also make sure backrefs for the shared block and all lower level |
6651 | * blocks are properly updated. | 6746 | * blocks are properly updated. |
6652 | */ | 6747 | */ |
6653 | void btrfs_drop_snapshot(struct btrfs_root *root, | 6748 | int btrfs_drop_snapshot(struct btrfs_root *root, |
6654 | struct btrfs_block_rsv *block_rsv, int update_ref, | 6749 | struct btrfs_block_rsv *block_rsv, int update_ref, |
6655 | int for_reloc) | 6750 | int for_reloc) |
6656 | { | 6751 | { |
@@ -6678,7 +6773,10 @@ void btrfs_drop_snapshot(struct btrfs_root *root, | |||
6678 | } | 6773 | } |
6679 | 6774 | ||
6680 | trans = btrfs_start_transaction(tree_root, 0); | 6775 | trans = btrfs_start_transaction(tree_root, 0); |
6681 | BUG_ON(IS_ERR(trans)); | 6776 | if (IS_ERR(trans)) { |
6777 | err = PTR_ERR(trans); | ||
6778 | goto out_free; | ||
6779 | } | ||
6682 | 6780 | ||
6683 | if (block_rsv) | 6781 | if (block_rsv) |
6684 | trans->block_rsv = block_rsv; | 6782 | trans->block_rsv = block_rsv; |
@@ -6703,7 +6801,7 @@ void btrfs_drop_snapshot(struct btrfs_root *root, | |||
6703 | path->lowest_level = 0; | 6801 | path->lowest_level = 0; |
6704 | if (ret < 0) { | 6802 | if (ret < 0) { |
6705 | err = ret; | 6803 | err = ret; |
6706 | goto out_free; | 6804 | goto out_end_trans; |
6707 | } | 6805 | } |
6708 | WARN_ON(ret > 0); | 6806 | WARN_ON(ret > 0); |
6709 | 6807 | ||
@@ -6723,7 +6821,10 @@ void btrfs_drop_snapshot(struct btrfs_root *root, | |||
6723 | path->nodes[level]->len, | 6821 | path->nodes[level]->len, |
6724 | &wc->refs[level], | 6822 | &wc->refs[level], |
6725 | &wc->flags[level]); | 6823 | &wc->flags[level]); |
6726 | BUG_ON(ret); | 6824 | if (ret < 0) { |
6825 | err = ret; | ||
6826 | goto out_end_trans; | ||
6827 | } | ||
6727 | BUG_ON(wc->refs[level] == 0); | 6828 | BUG_ON(wc->refs[level] == 0); |
6728 | 6829 | ||
6729 | if (level == root_item->drop_level) | 6830 | if (level == root_item->drop_level) |
@@ -6774,26 +6875,40 @@ void btrfs_drop_snapshot(struct btrfs_root *root, | |||
6774 | ret = btrfs_update_root(trans, tree_root, | 6875 | ret = btrfs_update_root(trans, tree_root, |
6775 | &root->root_key, | 6876 | &root->root_key, |
6776 | root_item); | 6877 | root_item); |
6777 | BUG_ON(ret); | 6878 | if (ret) { |
6879 | btrfs_abort_transaction(trans, tree_root, ret); | ||
6880 | err = ret; | ||
6881 | goto out_end_trans; | ||
6882 | } | ||
6778 | 6883 | ||
6779 | btrfs_end_transaction_throttle(trans, tree_root); | 6884 | btrfs_end_transaction_throttle(trans, tree_root); |
6780 | trans = btrfs_start_transaction(tree_root, 0); | 6885 | trans = btrfs_start_transaction(tree_root, 0); |
6781 | BUG_ON(IS_ERR(trans)); | 6886 | if (IS_ERR(trans)) { |
6887 | err = PTR_ERR(trans); | ||
6888 | goto out_free; | ||
6889 | } | ||
6782 | if (block_rsv) | 6890 | if (block_rsv) |
6783 | trans->block_rsv = block_rsv; | 6891 | trans->block_rsv = block_rsv; |
6784 | } | 6892 | } |
6785 | } | 6893 | } |
6786 | btrfs_release_path(path); | 6894 | btrfs_release_path(path); |
6787 | BUG_ON(err); | 6895 | if (err) |
6896 | goto out_end_trans; | ||
6788 | 6897 | ||
6789 | ret = btrfs_del_root(trans, tree_root, &root->root_key); | 6898 | ret = btrfs_del_root(trans, tree_root, &root->root_key); |
6790 | BUG_ON(ret); | 6899 | if (ret) { |
6900 | btrfs_abort_transaction(trans, tree_root, ret); | ||
6901 | goto out_end_trans; | ||
6902 | } | ||
6791 | 6903 | ||
6792 | if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) { | 6904 | if (root->root_key.objectid != BTRFS_TREE_RELOC_OBJECTID) { |
6793 | ret = btrfs_find_last_root(tree_root, root->root_key.objectid, | 6905 | ret = btrfs_find_last_root(tree_root, root->root_key.objectid, |
6794 | NULL, NULL); | 6906 | NULL, NULL); |
6795 | BUG_ON(ret < 0); | 6907 | if (ret < 0) { |
6796 | if (ret > 0) { | 6908 | btrfs_abort_transaction(trans, tree_root, ret); |
6909 | err = ret; | ||
6910 | goto out_end_trans; | ||
6911 | } else if (ret > 0) { | ||
6797 | /* if we fail to delete the orphan item this time | 6912 | /* if we fail to delete the orphan item this time |
6798 | * around, it'll get picked up the next time. | 6913 | * around, it'll get picked up the next time. |
6799 | * | 6914 | * |
@@ -6811,14 +6926,15 @@ void btrfs_drop_snapshot(struct btrfs_root *root, | |||
6811 | free_extent_buffer(root->commit_root); | 6926 | free_extent_buffer(root->commit_root); |
6812 | kfree(root); | 6927 | kfree(root); |
6813 | } | 6928 | } |
6814 | out_free: | 6929 | out_end_trans: |
6815 | btrfs_end_transaction_throttle(trans, tree_root); | 6930 | btrfs_end_transaction_throttle(trans, tree_root); |
6931 | out_free: | ||
6816 | kfree(wc); | 6932 | kfree(wc); |
6817 | btrfs_free_path(path); | 6933 | btrfs_free_path(path); |
6818 | out: | 6934 | out: |
6819 | if (err) | 6935 | if (err) |
6820 | btrfs_std_error(root->fs_info, err); | 6936 | btrfs_std_error(root->fs_info, err); |
6821 | return; | 6937 | return err; |
6822 | } | 6938 | } |
6823 | 6939 | ||
6824 | /* | 6940 | /* |
@@ -7015,12 +7131,16 @@ int btrfs_set_block_group_ro(struct btrfs_root *root, | |||
7015 | BUG_ON(cache->ro); | 7131 | BUG_ON(cache->ro); |
7016 | 7132 | ||
7017 | trans = btrfs_join_transaction(root); | 7133 | trans = btrfs_join_transaction(root); |
7018 | BUG_ON(IS_ERR(trans)); | 7134 | if (IS_ERR(trans)) |
7135 | return PTR_ERR(trans); | ||
7019 | 7136 | ||
7020 | alloc_flags = update_block_group_flags(root, cache->flags); | 7137 | alloc_flags = update_block_group_flags(root, cache->flags); |
7021 | if (alloc_flags != cache->flags) | 7138 | if (alloc_flags != cache->flags) { |
7022 | do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags, | 7139 | ret = do_chunk_alloc(trans, root, 2 * 1024 * 1024, alloc_flags, |
7023 | CHUNK_ALLOC_FORCE); | 7140 | CHUNK_ALLOC_FORCE); |
7141 | if (ret < 0) | ||
7142 | goto out; | ||
7143 | } | ||
7024 | 7144 | ||
7025 | ret = set_block_group_ro(cache, 0); | 7145 | ret = set_block_group_ro(cache, 0); |
7026 | if (!ret) | 7146 | if (!ret) |
@@ -7100,7 +7220,7 @@ u64 btrfs_account_ro_block_groups_free_space(struct btrfs_space_info *sinfo) | |||
7100 | return free_bytes; | 7220 | return free_bytes; |
7101 | } | 7221 | } |
7102 | 7222 | ||
7103 | int btrfs_set_block_group_rw(struct btrfs_root *root, | 7223 | void btrfs_set_block_group_rw(struct btrfs_root *root, |
7104 | struct btrfs_block_group_cache *cache) | 7224 | struct btrfs_block_group_cache *cache) |
7105 | { | 7225 | { |
7106 | struct btrfs_space_info *sinfo = cache->space_info; | 7226 | struct btrfs_space_info *sinfo = cache->space_info; |
@@ -7116,7 +7236,6 @@ int btrfs_set_block_group_rw(struct btrfs_root *root, | |||
7116 | cache->ro = 0; | 7236 | cache->ro = 0; |
7117 | spin_unlock(&cache->lock); | 7237 | spin_unlock(&cache->lock); |
7118 | spin_unlock(&sinfo->lock); | 7238 | spin_unlock(&sinfo->lock); |
7119 | return 0; | ||
7120 | } | 7239 | } |
7121 | 7240 | ||
7122 | /* | 7241 | /* |
@@ -7484,7 +7603,7 @@ int btrfs_read_block_groups(struct btrfs_root *root) | |||
7484 | ret = update_space_info(info, cache->flags, found_key.offset, | 7603 | ret = update_space_info(info, cache->flags, found_key.offset, |
7485 | btrfs_block_group_used(&cache->item), | 7604 | btrfs_block_group_used(&cache->item), |
7486 | &space_info); | 7605 | &space_info); |
7487 | BUG_ON(ret); | 7606 | BUG_ON(ret); /* -ENOMEM */ |
7488 | cache->space_info = space_info; | 7607 | cache->space_info = space_info; |
7489 | spin_lock(&cache->space_info->lock); | 7608 | spin_lock(&cache->space_info->lock); |
7490 | cache->space_info->bytes_readonly += cache->bytes_super; | 7609 | cache->space_info->bytes_readonly += cache->bytes_super; |
@@ -7493,7 +7612,7 @@ int btrfs_read_block_groups(struct btrfs_root *root) | |||
7493 | __link_block_group(space_info, cache); | 7612 | __link_block_group(space_info, cache); |
7494 | 7613 | ||
7495 | ret = btrfs_add_block_group_cache(root->fs_info, cache); | 7614 | ret = btrfs_add_block_group_cache(root->fs_info, cache); |
7496 | BUG_ON(ret); | 7615 | BUG_ON(ret); /* Logic error */ |
7497 | 7616 | ||
7498 | set_avail_alloc_bits(root->fs_info, cache->flags); | 7617 | set_avail_alloc_bits(root->fs_info, cache->flags); |
7499 | if (btrfs_chunk_readonly(root, cache->key.objectid)) | 7618 | if (btrfs_chunk_readonly(root, cache->key.objectid)) |
@@ -7575,7 +7694,7 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, | |||
7575 | 7694 | ||
7576 | ret = update_space_info(root->fs_info, cache->flags, size, bytes_used, | 7695 | ret = update_space_info(root->fs_info, cache->flags, size, bytes_used, |
7577 | &cache->space_info); | 7696 | &cache->space_info); |
7578 | BUG_ON(ret); | 7697 | BUG_ON(ret); /* -ENOMEM */ |
7579 | update_global_block_rsv(root->fs_info); | 7698 | update_global_block_rsv(root->fs_info); |
7580 | 7699 | ||
7581 | spin_lock(&cache->space_info->lock); | 7700 | spin_lock(&cache->space_info->lock); |
@@ -7585,11 +7704,14 @@ int btrfs_make_block_group(struct btrfs_trans_handle *trans, | |||
7585 | __link_block_group(cache->space_info, cache); | 7704 | __link_block_group(cache->space_info, cache); |
7586 | 7705 | ||
7587 | ret = btrfs_add_block_group_cache(root->fs_info, cache); | 7706 | ret = btrfs_add_block_group_cache(root->fs_info, cache); |
7588 | BUG_ON(ret); | 7707 | BUG_ON(ret); /* Logic error */ |
7589 | 7708 | ||
7590 | ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item, | 7709 | ret = btrfs_insert_item(trans, extent_root, &cache->key, &cache->item, |
7591 | sizeof(cache->item)); | 7710 | sizeof(cache->item)); |
7592 | BUG_ON(ret); | 7711 | if (ret) { |
7712 | btrfs_abort_transaction(trans, extent_root, ret); | ||
7713 | return ret; | ||
7714 | } | ||
7593 | 7715 | ||
7594 | set_avail_alloc_bits(extent_root->fs_info, type); | 7716 | set_avail_alloc_bits(extent_root->fs_info, type); |
7595 | 7717 | ||
@@ -7670,7 +7792,10 @@ int btrfs_remove_block_group(struct btrfs_trans_handle *trans, | |||
7670 | inode = lookup_free_space_inode(tree_root, block_group, path); | 7792 | inode = lookup_free_space_inode(tree_root, block_group, path); |
7671 | if (!IS_ERR(inode)) { | 7793 | if (!IS_ERR(inode)) { |
7672 | ret = btrfs_orphan_add(trans, inode); | 7794 | ret = btrfs_orphan_add(trans, inode); |
7673 | BUG_ON(ret); | 7795 | if (ret) { |
7796 | btrfs_add_delayed_iput(inode); | ||
7797 | goto out; | ||
7798 | } | ||
7674 | clear_nlink(inode); | 7799 | clear_nlink(inode); |
7675 | /* One for the block groups ref */ | 7800 | /* One for the block groups ref */ |
7676 | spin_lock(&block_group->lock); | 7801 | spin_lock(&block_group->lock); |
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c index 49a368593a16..0c3ec003f273 100644 --- a/fs/btrfs/extent_io.c +++ b/fs/btrfs/extent_io.c | |||
@@ -55,6 +55,11 @@ struct extent_page_data { | |||
55 | }; | 55 | }; |
56 | 56 | ||
57 | static noinline void flush_write_bio(void *data); | 57 | static noinline void flush_write_bio(void *data); |
58 | static inline struct btrfs_fs_info * | ||
59 | tree_fs_info(struct extent_io_tree *tree) | ||
60 | { | ||
61 | return btrfs_sb(tree->mapping->host->i_sb); | ||
62 | } | ||
58 | 63 | ||
59 | int __init extent_io_init(void) | 64 | int __init extent_io_init(void) |
60 | { | 65 | { |
@@ -139,6 +144,7 @@ static struct extent_state *alloc_extent_state(gfp_t mask) | |||
139 | #endif | 144 | #endif |
140 | atomic_set(&state->refs, 1); | 145 | atomic_set(&state->refs, 1); |
141 | init_waitqueue_head(&state->wq); | 146 | init_waitqueue_head(&state->wq); |
147 | trace_alloc_extent_state(state, mask, _RET_IP_); | ||
142 | return state; | 148 | return state; |
143 | } | 149 | } |
144 | 150 | ||
@@ -156,6 +162,7 @@ void free_extent_state(struct extent_state *state) | |||
156 | list_del(&state->leak_list); | 162 | list_del(&state->leak_list); |
157 | spin_unlock_irqrestore(&leak_lock, flags); | 163 | spin_unlock_irqrestore(&leak_lock, flags); |
158 | #endif | 164 | #endif |
165 | trace_free_extent_state(state, _RET_IP_); | ||
159 | kmem_cache_free(extent_state_cache, state); | 166 | kmem_cache_free(extent_state_cache, state); |
160 | } | 167 | } |
161 | } | 168 | } |
@@ -442,6 +449,13 @@ alloc_extent_state_atomic(struct extent_state *prealloc) | |||
442 | return prealloc; | 449 | return prealloc; |
443 | } | 450 | } |
444 | 451 | ||
452 | void extent_io_tree_panic(struct extent_io_tree *tree, int err) | ||
453 | { | ||
454 | btrfs_panic(tree_fs_info(tree), err, "Locking error: " | ||
455 | "Extent tree was modified by another " | ||
456 | "thread while locked."); | ||
457 | } | ||
458 | |||
445 | /* | 459 | /* |
446 | * clear some bits on a range in the tree. This may require splitting | 460 | * clear some bits on a range in the tree. This may require splitting |
447 | * or inserting elements in the tree, so the gfp mask is used to | 461 | * or inserting elements in the tree, so the gfp mask is used to |
@@ -452,8 +466,7 @@ alloc_extent_state_atomic(struct extent_state *prealloc) | |||
452 | * | 466 | * |
453 | * the range [start, end] is inclusive. | 467 | * the range [start, end] is inclusive. |
454 | * | 468 | * |
455 | * This takes the tree lock, and returns < 0 on error, > 0 if any of the | 469 | * This takes the tree lock, and returns 0 on success and < 0 on error. |
456 | * bits were already set, or zero if none of the bits were already set. | ||
457 | */ | 470 | */ |
458 | int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, | 471 | int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, |
459 | int bits, int wake, int delete, | 472 | int bits, int wake, int delete, |
@@ -467,7 +480,6 @@ int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, | |||
467 | struct rb_node *node; | 480 | struct rb_node *node; |
468 | u64 last_end; | 481 | u64 last_end; |
469 | int err; | 482 | int err; |
470 | int set = 0; | ||
471 | int clear = 0; | 483 | int clear = 0; |
472 | 484 | ||
473 | if (delete) | 485 | if (delete) |
@@ -545,12 +557,14 @@ hit_next: | |||
545 | prealloc = alloc_extent_state_atomic(prealloc); | 557 | prealloc = alloc_extent_state_atomic(prealloc); |
546 | BUG_ON(!prealloc); | 558 | BUG_ON(!prealloc); |
547 | err = split_state(tree, state, prealloc, start); | 559 | err = split_state(tree, state, prealloc, start); |
548 | BUG_ON(err == -EEXIST); | 560 | if (err) |
561 | extent_io_tree_panic(tree, err); | ||
562 | |||
549 | prealloc = NULL; | 563 | prealloc = NULL; |
550 | if (err) | 564 | if (err) |
551 | goto out; | 565 | goto out; |
552 | if (state->end <= end) { | 566 | if (state->end <= end) { |
553 | set |= clear_state_bit(tree, state, &bits, wake); | 567 | clear_state_bit(tree, state, &bits, wake); |
554 | if (last_end == (u64)-1) | 568 | if (last_end == (u64)-1) |
555 | goto out; | 569 | goto out; |
556 | start = last_end + 1; | 570 | start = last_end + 1; |
@@ -567,17 +581,19 @@ hit_next: | |||
567 | prealloc = alloc_extent_state_atomic(prealloc); | 581 | prealloc = alloc_extent_state_atomic(prealloc); |
568 | BUG_ON(!prealloc); | 582 | BUG_ON(!prealloc); |
569 | err = split_state(tree, state, prealloc, end + 1); | 583 | err = split_state(tree, state, prealloc, end + 1); |
570 | BUG_ON(err == -EEXIST); | 584 | if (err) |
585 | extent_io_tree_panic(tree, err); | ||
586 | |||
571 | if (wake) | 587 | if (wake) |
572 | wake_up(&state->wq); | 588 | wake_up(&state->wq); |
573 | 589 | ||
574 | set |= clear_state_bit(tree, prealloc, &bits, wake); | 590 | clear_state_bit(tree, prealloc, &bits, wake); |
575 | 591 | ||
576 | prealloc = NULL; | 592 | prealloc = NULL; |
577 | goto out; | 593 | goto out; |
578 | } | 594 | } |
579 | 595 | ||
580 | set |= clear_state_bit(tree, state, &bits, wake); | 596 | clear_state_bit(tree, state, &bits, wake); |
581 | next: | 597 | next: |
582 | if (last_end == (u64)-1) | 598 | if (last_end == (u64)-1) |
583 | goto out; | 599 | goto out; |
@@ -594,7 +610,7 @@ out: | |||
594 | if (prealloc) | 610 | if (prealloc) |
595 | free_extent_state(prealloc); | 611 | free_extent_state(prealloc); |
596 | 612 | ||
597 | return set; | 613 | return 0; |
598 | 614 | ||
599 | search_again: | 615 | search_again: |
600 | if (start > end) | 616 | if (start > end) |
@@ -605,8 +621,8 @@ search_again: | |||
605 | goto again; | 621 | goto again; |
606 | } | 622 | } |
607 | 623 | ||
608 | static int wait_on_state(struct extent_io_tree *tree, | 624 | static void wait_on_state(struct extent_io_tree *tree, |
609 | struct extent_state *state) | 625 | struct extent_state *state) |
610 | __releases(tree->lock) | 626 | __releases(tree->lock) |
611 | __acquires(tree->lock) | 627 | __acquires(tree->lock) |
612 | { | 628 | { |
@@ -616,7 +632,6 @@ static int wait_on_state(struct extent_io_tree *tree, | |||
616 | schedule(); | 632 | schedule(); |
617 | spin_lock(&tree->lock); | 633 | spin_lock(&tree->lock); |
618 | finish_wait(&state->wq, &wait); | 634 | finish_wait(&state->wq, &wait); |
619 | return 0; | ||
620 | } | 635 | } |
621 | 636 | ||
622 | /* | 637 | /* |
@@ -624,7 +639,7 @@ static int wait_on_state(struct extent_io_tree *tree, | |||
624 | * The range [start, end] is inclusive. | 639 | * The range [start, end] is inclusive. |
625 | * The tree lock is taken by this function | 640 | * The tree lock is taken by this function |
626 | */ | 641 | */ |
627 | int wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits) | 642 | void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits) |
628 | { | 643 | { |
629 | struct extent_state *state; | 644 | struct extent_state *state; |
630 | struct rb_node *node; | 645 | struct rb_node *node; |
@@ -661,7 +676,6 @@ again: | |||
661 | } | 676 | } |
662 | out: | 677 | out: |
663 | spin_unlock(&tree->lock); | 678 | spin_unlock(&tree->lock); |
664 | return 0; | ||
665 | } | 679 | } |
666 | 680 | ||
667 | static void set_state_bits(struct extent_io_tree *tree, | 681 | static void set_state_bits(struct extent_io_tree *tree, |
@@ -709,9 +723,10 @@ static void uncache_state(struct extent_state **cached_ptr) | |||
709 | * [start, end] is inclusive This takes the tree lock. | 723 | * [start, end] is inclusive This takes the tree lock. |
710 | */ | 724 | */ |
711 | 725 | ||
712 | int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, | 726 | static int __must_check |
713 | int bits, int exclusive_bits, u64 *failed_start, | 727 | __set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, |
714 | struct extent_state **cached_state, gfp_t mask) | 728 | int bits, int exclusive_bits, u64 *failed_start, |
729 | struct extent_state **cached_state, gfp_t mask) | ||
715 | { | 730 | { |
716 | struct extent_state *state; | 731 | struct extent_state *state; |
717 | struct extent_state *prealloc = NULL; | 732 | struct extent_state *prealloc = NULL; |
@@ -745,8 +760,10 @@ again: | |||
745 | prealloc = alloc_extent_state_atomic(prealloc); | 760 | prealloc = alloc_extent_state_atomic(prealloc); |
746 | BUG_ON(!prealloc); | 761 | BUG_ON(!prealloc); |
747 | err = insert_state(tree, prealloc, start, end, &bits); | 762 | err = insert_state(tree, prealloc, start, end, &bits); |
763 | if (err) | ||
764 | extent_io_tree_panic(tree, err); | ||
765 | |||
748 | prealloc = NULL; | 766 | prealloc = NULL; |
749 | BUG_ON(err == -EEXIST); | ||
750 | goto out; | 767 | goto out; |
751 | } | 768 | } |
752 | state = rb_entry(node, struct extent_state, rb_node); | 769 | state = rb_entry(node, struct extent_state, rb_node); |
@@ -812,7 +829,9 @@ hit_next: | |||
812 | prealloc = alloc_extent_state_atomic(prealloc); | 829 | prealloc = alloc_extent_state_atomic(prealloc); |
813 | BUG_ON(!prealloc); | 830 | BUG_ON(!prealloc); |
814 | err = split_state(tree, state, prealloc, start); | 831 | err = split_state(tree, state, prealloc, start); |
815 | BUG_ON(err == -EEXIST); | 832 | if (err) |
833 | extent_io_tree_panic(tree, err); | ||
834 | |||
816 | prealloc = NULL; | 835 | prealloc = NULL; |
817 | if (err) | 836 | if (err) |
818 | goto out; | 837 | goto out; |
@@ -849,12 +868,9 @@ hit_next: | |||
849 | */ | 868 | */ |
850 | err = insert_state(tree, prealloc, start, this_end, | 869 | err = insert_state(tree, prealloc, start, this_end, |
851 | &bits); | 870 | &bits); |
852 | BUG_ON(err == -EEXIST); | 871 | if (err) |
853 | if (err) { | 872 | extent_io_tree_panic(tree, err); |
854 | free_extent_state(prealloc); | 873 | |
855 | prealloc = NULL; | ||
856 | goto out; | ||
857 | } | ||
858 | cache_state(prealloc, cached_state); | 874 | cache_state(prealloc, cached_state); |
859 | prealloc = NULL; | 875 | prealloc = NULL; |
860 | start = this_end + 1; | 876 | start = this_end + 1; |
@@ -876,7 +892,8 @@ hit_next: | |||
876 | prealloc = alloc_extent_state_atomic(prealloc); | 892 | prealloc = alloc_extent_state_atomic(prealloc); |
877 | BUG_ON(!prealloc); | 893 | BUG_ON(!prealloc); |
878 | err = split_state(tree, state, prealloc, end + 1); | 894 | err = split_state(tree, state, prealloc, end + 1); |
879 | BUG_ON(err == -EEXIST); | 895 | if (err) |
896 | extent_io_tree_panic(tree, err); | ||
880 | 897 | ||
881 | set_state_bits(tree, prealloc, &bits); | 898 | set_state_bits(tree, prealloc, &bits); |
882 | cache_state(prealloc, cached_state); | 899 | cache_state(prealloc, cached_state); |
@@ -903,6 +920,15 @@ search_again: | |||
903 | goto again; | 920 | goto again; |
904 | } | 921 | } |
905 | 922 | ||
923 | int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits, | ||
924 | u64 *failed_start, struct extent_state **cached_state, | ||
925 | gfp_t mask) | ||
926 | { | ||
927 | return __set_extent_bit(tree, start, end, bits, 0, failed_start, | ||
928 | cached_state, mask); | ||
929 | } | ||
930 | |||
931 | |||
906 | /** | 932 | /** |
907 | * convert_extent - convert all bits in a given range from one bit to another | 933 | * convert_extent - convert all bits in a given range from one bit to another |
908 | * @tree: the io tree to search | 934 | * @tree: the io tree to search |
@@ -949,7 +975,8 @@ again: | |||
949 | } | 975 | } |
950 | err = insert_state(tree, prealloc, start, end, &bits); | 976 | err = insert_state(tree, prealloc, start, end, &bits); |
951 | prealloc = NULL; | 977 | prealloc = NULL; |
952 | BUG_ON(err == -EEXIST); | 978 | if (err) |
979 | extent_io_tree_panic(tree, err); | ||
953 | goto out; | 980 | goto out; |
954 | } | 981 | } |
955 | state = rb_entry(node, struct extent_state, rb_node); | 982 | state = rb_entry(node, struct extent_state, rb_node); |
@@ -1005,7 +1032,8 @@ hit_next: | |||
1005 | goto out; | 1032 | goto out; |
1006 | } | 1033 | } |
1007 | err = split_state(tree, state, prealloc, start); | 1034 | err = split_state(tree, state, prealloc, start); |
1008 | BUG_ON(err == -EEXIST); | 1035 | if (err) |
1036 | extent_io_tree_panic(tree, err); | ||
1009 | prealloc = NULL; | 1037 | prealloc = NULL; |
1010 | if (err) | 1038 | if (err) |
1011 | goto out; | 1039 | goto out; |
@@ -1044,12 +1072,8 @@ hit_next: | |||
1044 | */ | 1072 | */ |
1045 | err = insert_state(tree, prealloc, start, this_end, | 1073 | err = insert_state(tree, prealloc, start, this_end, |
1046 | &bits); | 1074 | &bits); |
1047 | BUG_ON(err == -EEXIST); | 1075 | if (err) |
1048 | if (err) { | 1076 | extent_io_tree_panic(tree, err); |
1049 | free_extent_state(prealloc); | ||
1050 | prealloc = NULL; | ||
1051 | goto out; | ||
1052 | } | ||
1053 | prealloc = NULL; | 1077 | prealloc = NULL; |
1054 | start = this_end + 1; | 1078 | start = this_end + 1; |
1055 | goto search_again; | 1079 | goto search_again; |
@@ -1068,7 +1092,8 @@ hit_next: | |||
1068 | } | 1092 | } |
1069 | 1093 | ||
1070 | err = split_state(tree, state, prealloc, end + 1); | 1094 | err = split_state(tree, state, prealloc, end + 1); |
1071 | BUG_ON(err == -EEXIST); | 1095 | if (err) |
1096 | extent_io_tree_panic(tree, err); | ||
1072 | 1097 | ||
1073 | set_state_bits(tree, prealloc, &bits); | 1098 | set_state_bits(tree, prealloc, &bits); |
1074 | clear_state_bit(tree, prealloc, &clear_bits, 0); | 1099 | clear_state_bit(tree, prealloc, &clear_bits, 0); |
@@ -1098,14 +1123,14 @@ search_again: | |||
1098 | int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end, | 1123 | int set_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end, |
1099 | gfp_t mask) | 1124 | gfp_t mask) |
1100 | { | 1125 | { |
1101 | return set_extent_bit(tree, start, end, EXTENT_DIRTY, 0, NULL, | 1126 | return set_extent_bit(tree, start, end, EXTENT_DIRTY, NULL, |
1102 | NULL, mask); | 1127 | NULL, mask); |
1103 | } | 1128 | } |
1104 | 1129 | ||
1105 | int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, | 1130 | int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, |
1106 | int bits, gfp_t mask) | 1131 | int bits, gfp_t mask) |
1107 | { | 1132 | { |
1108 | return set_extent_bit(tree, start, end, bits, 0, NULL, | 1133 | return set_extent_bit(tree, start, end, bits, NULL, |
1109 | NULL, mask); | 1134 | NULL, mask); |
1110 | } | 1135 | } |
1111 | 1136 | ||
@@ -1120,7 +1145,7 @@ int set_extent_delalloc(struct extent_io_tree *tree, u64 start, u64 end, | |||
1120 | { | 1145 | { |
1121 | return set_extent_bit(tree, start, end, | 1146 | return set_extent_bit(tree, start, end, |
1122 | EXTENT_DELALLOC | EXTENT_UPTODATE, | 1147 | EXTENT_DELALLOC | EXTENT_UPTODATE, |
1123 | 0, NULL, cached_state, mask); | 1148 | NULL, cached_state, mask); |
1124 | } | 1149 | } |
1125 | 1150 | ||
1126 | int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end, | 1151 | int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end, |
@@ -1134,7 +1159,7 @@ int clear_extent_dirty(struct extent_io_tree *tree, u64 start, u64 end, | |||
1134 | int set_extent_new(struct extent_io_tree *tree, u64 start, u64 end, | 1159 | int set_extent_new(struct extent_io_tree *tree, u64 start, u64 end, |
1135 | gfp_t mask) | 1160 | gfp_t mask) |
1136 | { | 1161 | { |
1137 | return set_extent_bit(tree, start, end, EXTENT_NEW, 0, NULL, | 1162 | return set_extent_bit(tree, start, end, EXTENT_NEW, NULL, |
1138 | NULL, mask); | 1163 | NULL, mask); |
1139 | } | 1164 | } |
1140 | 1165 | ||
@@ -1142,7 +1167,7 @@ int set_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end, | |||
1142 | struct extent_state **cached_state, gfp_t mask) | 1167 | struct extent_state **cached_state, gfp_t mask) |
1143 | { | 1168 | { |
1144 | return set_extent_bit(tree, start, end, EXTENT_UPTODATE, 0, | 1169 | return set_extent_bit(tree, start, end, EXTENT_UPTODATE, 0, |
1145 | NULL, cached_state, mask); | 1170 | cached_state, mask); |
1146 | } | 1171 | } |
1147 | 1172 | ||
1148 | static int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, | 1173 | static int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, |
@@ -1158,42 +1183,40 @@ static int clear_extent_uptodate(struct extent_io_tree *tree, u64 start, | |||
1158 | * us if waiting is desired. | 1183 | * us if waiting is desired. |
1159 | */ | 1184 | */ |
1160 | int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, | 1185 | int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, |
1161 | int bits, struct extent_state **cached_state, gfp_t mask) | 1186 | int bits, struct extent_state **cached_state) |
1162 | { | 1187 | { |
1163 | int err; | 1188 | int err; |
1164 | u64 failed_start; | 1189 | u64 failed_start; |
1165 | while (1) { | 1190 | while (1) { |
1166 | err = set_extent_bit(tree, start, end, EXTENT_LOCKED | bits, | 1191 | err = __set_extent_bit(tree, start, end, EXTENT_LOCKED | bits, |
1167 | EXTENT_LOCKED, &failed_start, | 1192 | EXTENT_LOCKED, &failed_start, |
1168 | cached_state, mask); | 1193 | cached_state, GFP_NOFS); |
1169 | if (err == -EEXIST && (mask & __GFP_WAIT)) { | 1194 | if (err == -EEXIST) { |
1170 | wait_extent_bit(tree, failed_start, end, EXTENT_LOCKED); | 1195 | wait_extent_bit(tree, failed_start, end, EXTENT_LOCKED); |
1171 | start = failed_start; | 1196 | start = failed_start; |
1172 | } else { | 1197 | } else |
1173 | break; | 1198 | break; |
1174 | } | ||
1175 | WARN_ON(start > end); | 1199 | WARN_ON(start > end); |
1176 | } | 1200 | } |
1177 | return err; | 1201 | return err; |
1178 | } | 1202 | } |
1179 | 1203 | ||
1180 | int lock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask) | 1204 | int lock_extent(struct extent_io_tree *tree, u64 start, u64 end) |
1181 | { | 1205 | { |
1182 | return lock_extent_bits(tree, start, end, 0, NULL, mask); | 1206 | return lock_extent_bits(tree, start, end, 0, NULL); |
1183 | } | 1207 | } |
1184 | 1208 | ||
1185 | int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end, | 1209 | int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end) |
1186 | gfp_t mask) | ||
1187 | { | 1210 | { |
1188 | int err; | 1211 | int err; |
1189 | u64 failed_start; | 1212 | u64 failed_start; |
1190 | 1213 | ||
1191 | err = set_extent_bit(tree, start, end, EXTENT_LOCKED, EXTENT_LOCKED, | 1214 | err = __set_extent_bit(tree, start, end, EXTENT_LOCKED, EXTENT_LOCKED, |
1192 | &failed_start, NULL, mask); | 1215 | &failed_start, NULL, GFP_NOFS); |
1193 | if (err == -EEXIST) { | 1216 | if (err == -EEXIST) { |
1194 | if (failed_start > start) | 1217 | if (failed_start > start) |
1195 | clear_extent_bit(tree, start, failed_start - 1, | 1218 | clear_extent_bit(tree, start, failed_start - 1, |
1196 | EXTENT_LOCKED, 1, 0, NULL, mask); | 1219 | EXTENT_LOCKED, 1, 0, NULL, GFP_NOFS); |
1197 | return 0; | 1220 | return 0; |
1198 | } | 1221 | } |
1199 | return 1; | 1222 | return 1; |
@@ -1206,10 +1229,10 @@ int unlock_extent_cached(struct extent_io_tree *tree, u64 start, u64 end, | |||
1206 | mask); | 1229 | mask); |
1207 | } | 1230 | } |
1208 | 1231 | ||
1209 | int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask) | 1232 | int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end) |
1210 | { | 1233 | { |
1211 | return clear_extent_bit(tree, start, end, EXTENT_LOCKED, 1, 0, NULL, | 1234 | return clear_extent_bit(tree, start, end, EXTENT_LOCKED, 1, 0, NULL, |
1212 | mask); | 1235 | GFP_NOFS); |
1213 | } | 1236 | } |
1214 | 1237 | ||
1215 | /* | 1238 | /* |
@@ -1223,7 +1246,7 @@ static int set_range_writeback(struct extent_io_tree *tree, u64 start, u64 end) | |||
1223 | 1246 | ||
1224 | while (index <= end_index) { | 1247 | while (index <= end_index) { |
1225 | page = find_get_page(tree->mapping, index); | 1248 | page = find_get_page(tree->mapping, index); |
1226 | BUG_ON(!page); | 1249 | BUG_ON(!page); /* Pages should be in the extent_io_tree */ |
1227 | set_page_writeback(page); | 1250 | set_page_writeback(page); |
1228 | page_cache_release(page); | 1251 | page_cache_release(page); |
1229 | index++; | 1252 | index++; |
@@ -1346,9 +1369,9 @@ out: | |||
1346 | return found; | 1369 | return found; |
1347 | } | 1370 | } |
1348 | 1371 | ||
1349 | static noinline int __unlock_for_delalloc(struct inode *inode, | 1372 | static noinline void __unlock_for_delalloc(struct inode *inode, |
1350 | struct page *locked_page, | 1373 | struct page *locked_page, |
1351 | u64 start, u64 end) | 1374 | u64 start, u64 end) |
1352 | { | 1375 | { |
1353 | int ret; | 1376 | int ret; |
1354 | struct page *pages[16]; | 1377 | struct page *pages[16]; |
@@ -1358,7 +1381,7 @@ static noinline int __unlock_for_delalloc(struct inode *inode, | |||
1358 | int i; | 1381 | int i; |
1359 | 1382 | ||
1360 | if (index == locked_page->index && end_index == index) | 1383 | if (index == locked_page->index && end_index == index) |
1361 | return 0; | 1384 | return; |
1362 | 1385 | ||
1363 | while (nr_pages > 0) { | 1386 | while (nr_pages > 0) { |
1364 | ret = find_get_pages_contig(inode->i_mapping, index, | 1387 | ret = find_get_pages_contig(inode->i_mapping, index, |
@@ -1373,7 +1396,6 @@ static noinline int __unlock_for_delalloc(struct inode *inode, | |||
1373 | index += ret; | 1396 | index += ret; |
1374 | cond_resched(); | 1397 | cond_resched(); |
1375 | } | 1398 | } |
1376 | return 0; | ||
1377 | } | 1399 | } |
1378 | 1400 | ||
1379 | static noinline int lock_delalloc_pages(struct inode *inode, | 1401 | static noinline int lock_delalloc_pages(struct inode *inode, |
@@ -1503,11 +1525,10 @@ again: | |||
1503 | goto out_failed; | 1525 | goto out_failed; |
1504 | } | 1526 | } |
1505 | } | 1527 | } |
1506 | BUG_ON(ret); | 1528 | BUG_ON(ret); /* Only valid values are 0 and -EAGAIN */ |
1507 | 1529 | ||
1508 | /* step three, lock the state bits for the whole range */ | 1530 | /* step three, lock the state bits for the whole range */ |
1509 | lock_extent_bits(tree, delalloc_start, delalloc_end, | 1531 | lock_extent_bits(tree, delalloc_start, delalloc_end, 0, &cached_state); |
1510 | 0, &cached_state, GFP_NOFS); | ||
1511 | 1532 | ||
1512 | /* then test to make sure it is all still delalloc */ | 1533 | /* then test to make sure it is all still delalloc */ |
1513 | ret = test_range_bit(tree, delalloc_start, delalloc_end, | 1534 | ret = test_range_bit(tree, delalloc_start, delalloc_end, |
@@ -1764,39 +1785,34 @@ int test_range_bit(struct extent_io_tree *tree, u64 start, u64 end, | |||
1764 | * helper function to set a given page up to date if all the | 1785 | * helper function to set a given page up to date if all the |
1765 | * extents in the tree for that page are up to date | 1786 | * extents in the tree for that page are up to date |
1766 | */ | 1787 | */ |
1767 | static int check_page_uptodate(struct extent_io_tree *tree, | 1788 | static void check_page_uptodate(struct extent_io_tree *tree, struct page *page) |
1768 | struct page *page) | ||
1769 | { | 1789 | { |
1770 | u64 start = (u64)page->index << PAGE_CACHE_SHIFT; | 1790 | u64 start = (u64)page->index << PAGE_CACHE_SHIFT; |
1771 | u64 end = start + PAGE_CACHE_SIZE - 1; | 1791 | u64 end = start + PAGE_CACHE_SIZE - 1; |
1772 | if (test_range_bit(tree, start, end, EXTENT_UPTODATE, 1, NULL)) | 1792 | if (test_range_bit(tree, start, end, EXTENT_UPTODATE, 1, NULL)) |
1773 | SetPageUptodate(page); | 1793 | SetPageUptodate(page); |
1774 | return 0; | ||
1775 | } | 1794 | } |
1776 | 1795 | ||
1777 | /* | 1796 | /* |
1778 | * helper function to unlock a page if all the extents in the tree | 1797 | * helper function to unlock a page if all the extents in the tree |
1779 | * for that page are unlocked | 1798 | * for that page are unlocked |
1780 | */ | 1799 | */ |
1781 | static int check_page_locked(struct extent_io_tree *tree, | 1800 | static void check_page_locked(struct extent_io_tree *tree, struct page *page) |
1782 | struct page *page) | ||
1783 | { | 1801 | { |
1784 | u64 start = (u64)page->index << PAGE_CACHE_SHIFT; | 1802 | u64 start = (u64)page->index << PAGE_CACHE_SHIFT; |
1785 | u64 end = start + PAGE_CACHE_SIZE - 1; | 1803 | u64 end = start + PAGE_CACHE_SIZE - 1; |
1786 | if (!test_range_bit(tree, start, end, EXTENT_LOCKED, 0, NULL)) | 1804 | if (!test_range_bit(tree, start, end, EXTENT_LOCKED, 0, NULL)) |
1787 | unlock_page(page); | 1805 | unlock_page(page); |
1788 | return 0; | ||
1789 | } | 1806 | } |
1790 | 1807 | ||
1791 | /* | 1808 | /* |
1792 | * helper function to end page writeback if all the extents | 1809 | * helper function to end page writeback if all the extents |
1793 | * in the tree for that page are done with writeback | 1810 | * in the tree for that page are done with writeback |
1794 | */ | 1811 | */ |
1795 | static int check_page_writeback(struct extent_io_tree *tree, | 1812 | static void check_page_writeback(struct extent_io_tree *tree, |
1796 | struct page *page) | 1813 | struct page *page) |
1797 | { | 1814 | { |
1798 | end_page_writeback(page); | 1815 | end_page_writeback(page); |
1799 | return 0; | ||
1800 | } | 1816 | } |
1801 | 1817 | ||
1802 | /* | 1818 | /* |
@@ -2409,8 +2425,12 @@ btrfs_bio_alloc(struct block_device *bdev, u64 first_sector, int nr_vecs, | |||
2409 | return bio; | 2425 | return bio; |
2410 | } | 2426 | } |
2411 | 2427 | ||
2412 | static int submit_one_bio(int rw, struct bio *bio, int mirror_num, | 2428 | /* |
2413 | unsigned long bio_flags) | 2429 | * Since writes are async, they will only return -ENOMEM. |
2430 | * Reads can return the full range of I/O error conditions. | ||
2431 | */ | ||
2432 | static int __must_check submit_one_bio(int rw, struct bio *bio, | ||
2433 | int mirror_num, unsigned long bio_flags) | ||
2414 | { | 2434 | { |
2415 | int ret = 0; | 2435 | int ret = 0; |
2416 | struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1; | 2436 | struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1; |
@@ -2436,6 +2456,19 @@ static int submit_one_bio(int rw, struct bio *bio, int mirror_num, | |||
2436 | return ret; | 2456 | return ret; |
2437 | } | 2457 | } |
2438 | 2458 | ||
2459 | static int merge_bio(struct extent_io_tree *tree, struct page *page, | ||
2460 | unsigned long offset, size_t size, struct bio *bio, | ||
2461 | unsigned long bio_flags) | ||
2462 | { | ||
2463 | int ret = 0; | ||
2464 | if (tree->ops && tree->ops->merge_bio_hook) | ||
2465 | ret = tree->ops->merge_bio_hook(page, offset, size, bio, | ||
2466 | bio_flags); | ||
2467 | BUG_ON(ret < 0); | ||
2468 | return ret; | ||
2469 | |||
2470 | } | ||
2471 | |||
2439 | static int submit_extent_page(int rw, struct extent_io_tree *tree, | 2472 | static int submit_extent_page(int rw, struct extent_io_tree *tree, |
2440 | struct page *page, sector_t sector, | 2473 | struct page *page, sector_t sector, |
2441 | size_t size, unsigned long offset, | 2474 | size_t size, unsigned long offset, |
@@ -2464,12 +2497,12 @@ static int submit_extent_page(int rw, struct extent_io_tree *tree, | |||
2464 | sector; | 2497 | sector; |
2465 | 2498 | ||
2466 | if (prev_bio_flags != bio_flags || !contig || | 2499 | if (prev_bio_flags != bio_flags || !contig || |
2467 | (tree->ops && tree->ops->merge_bio_hook && | 2500 | merge_bio(tree, page, offset, page_size, bio, bio_flags) || |
2468 | tree->ops->merge_bio_hook(page, offset, page_size, bio, | ||
2469 | bio_flags)) || | ||
2470 | bio_add_page(bio, page, page_size, offset) < page_size) { | 2501 | bio_add_page(bio, page, page_size, offset) < page_size) { |
2471 | ret = submit_one_bio(rw, bio, mirror_num, | 2502 | ret = submit_one_bio(rw, bio, mirror_num, |
2472 | prev_bio_flags); | 2503 | prev_bio_flags); |
2504 | if (ret < 0) | ||
2505 | return ret; | ||
2473 | bio = NULL; | 2506 | bio = NULL; |
2474 | } else { | 2507 | } else { |
2475 | return 0; | 2508 | return 0; |
@@ -2520,6 +2553,7 @@ void set_page_extent_mapped(struct page *page) | |||
2520 | * basic readpage implementation. Locked extent state structs are inserted | 2553 | * basic readpage implementation. Locked extent state structs are inserted |
2521 | * into the tree that are removed when the IO is done (by the end_io | 2554 | * into the tree that are removed when the IO is done (by the end_io |
2522 | * handlers) | 2555 | * handlers) |
2556 | * XXX JDM: This needs looking at to ensure proper page locking | ||
2523 | */ | 2557 | */ |
2524 | static int __extent_read_full_page(struct extent_io_tree *tree, | 2558 | static int __extent_read_full_page(struct extent_io_tree *tree, |
2525 | struct page *page, | 2559 | struct page *page, |
@@ -2559,11 +2593,11 @@ static int __extent_read_full_page(struct extent_io_tree *tree, | |||
2559 | 2593 | ||
2560 | end = page_end; | 2594 | end = page_end; |
2561 | while (1) { | 2595 | while (1) { |
2562 | lock_extent(tree, start, end, GFP_NOFS); | 2596 | lock_extent(tree, start, end); |
2563 | ordered = btrfs_lookup_ordered_extent(inode, start); | 2597 | ordered = btrfs_lookup_ordered_extent(inode, start); |
2564 | if (!ordered) | 2598 | if (!ordered) |
2565 | break; | 2599 | break; |
2566 | unlock_extent(tree, start, end, GFP_NOFS); | 2600 | unlock_extent(tree, start, end); |
2567 | btrfs_start_ordered_extent(inode, ordered, 1); | 2601 | btrfs_start_ordered_extent(inode, ordered, 1); |
2568 | btrfs_put_ordered_extent(ordered); | 2602 | btrfs_put_ordered_extent(ordered); |
2569 | } | 2603 | } |
@@ -2600,7 +2634,7 @@ static int __extent_read_full_page(struct extent_io_tree *tree, | |||
2600 | end - cur + 1, 0); | 2634 | end - cur + 1, 0); |
2601 | if (IS_ERR_OR_NULL(em)) { | 2635 | if (IS_ERR_OR_NULL(em)) { |
2602 | SetPageError(page); | 2636 | SetPageError(page); |
2603 | unlock_extent(tree, cur, end, GFP_NOFS); | 2637 | unlock_extent(tree, cur, end); |
2604 | break; | 2638 | break; |
2605 | } | 2639 | } |
2606 | extent_offset = cur - em->start; | 2640 | extent_offset = cur - em->start; |
@@ -2652,7 +2686,7 @@ static int __extent_read_full_page(struct extent_io_tree *tree, | |||
2652 | if (test_range_bit(tree, cur, cur_end, | 2686 | if (test_range_bit(tree, cur, cur_end, |
2653 | EXTENT_UPTODATE, 1, NULL)) { | 2687 | EXTENT_UPTODATE, 1, NULL)) { |
2654 | check_page_uptodate(tree, page); | 2688 | check_page_uptodate(tree, page); |
2655 | unlock_extent(tree, cur, cur + iosize - 1, GFP_NOFS); | 2689 | unlock_extent(tree, cur, cur + iosize - 1); |
2656 | cur = cur + iosize; | 2690 | cur = cur + iosize; |
2657 | pg_offset += iosize; | 2691 | pg_offset += iosize; |
2658 | continue; | 2692 | continue; |
@@ -2662,7 +2696,7 @@ static int __extent_read_full_page(struct extent_io_tree *tree, | |||
2662 | */ | 2696 | */ |
2663 | if (block_start == EXTENT_MAP_INLINE) { | 2697 | if (block_start == EXTENT_MAP_INLINE) { |
2664 | SetPageError(page); | 2698 | SetPageError(page); |
2665 | unlock_extent(tree, cur, cur + iosize - 1, GFP_NOFS); | 2699 | unlock_extent(tree, cur, cur + iosize - 1); |
2666 | cur = cur + iosize; | 2700 | cur = cur + iosize; |
2667 | pg_offset += iosize; | 2701 | pg_offset += iosize; |
2668 | continue; | 2702 | continue; |
@@ -2682,6 +2716,7 @@ static int __extent_read_full_page(struct extent_io_tree *tree, | |||
2682 | end_bio_extent_readpage, mirror_num, | 2716 | end_bio_extent_readpage, mirror_num, |
2683 | *bio_flags, | 2717 | *bio_flags, |
2684 | this_bio_flag); | 2718 | this_bio_flag); |
2719 | BUG_ON(ret == -ENOMEM); | ||
2685 | nr++; | 2720 | nr++; |
2686 | *bio_flags = this_bio_flag; | 2721 | *bio_flags = this_bio_flag; |
2687 | } | 2722 | } |
@@ -2823,7 +2858,11 @@ static int __extent_writepage(struct page *page, struct writeback_control *wbc, | |||
2823 | delalloc_end, | 2858 | delalloc_end, |
2824 | &page_started, | 2859 | &page_started, |
2825 | &nr_written); | 2860 | &nr_written); |
2826 | BUG_ON(ret); | 2861 | /* File system has been set read-only */ |
2862 | if (ret) { | ||
2863 | SetPageError(page); | ||
2864 | goto done; | ||
2865 | } | ||
2827 | /* | 2866 | /* |
2828 | * delalloc_end is already one less than the total | 2867 | * delalloc_end is already one less than the total |
2829 | * length, so we don't subtract one from | 2868 | * length, so we don't subtract one from |
@@ -3396,10 +3435,14 @@ retry: | |||
3396 | static void flush_epd_write_bio(struct extent_page_data *epd) | 3435 | static void flush_epd_write_bio(struct extent_page_data *epd) |
3397 | { | 3436 | { |
3398 | if (epd->bio) { | 3437 | if (epd->bio) { |
3438 | int rw = WRITE; | ||
3439 | int ret; | ||
3440 | |||
3399 | if (epd->sync_io) | 3441 | if (epd->sync_io) |
3400 | submit_one_bio(WRITE_SYNC, epd->bio, 0, 0); | 3442 | rw = WRITE_SYNC; |
3401 | else | 3443 | |
3402 | submit_one_bio(WRITE, epd->bio, 0, 0); | 3444 | ret = submit_one_bio(rw, epd->bio, 0, 0); |
3445 | BUG_ON(ret < 0); /* -ENOMEM */ | ||
3403 | epd->bio = NULL; | 3446 | epd->bio = NULL; |
3404 | } | 3447 | } |
3405 | } | 3448 | } |
@@ -3516,7 +3559,7 @@ int extent_readpages(struct extent_io_tree *tree, | |||
3516 | } | 3559 | } |
3517 | BUG_ON(!list_empty(pages)); | 3560 | BUG_ON(!list_empty(pages)); |
3518 | if (bio) | 3561 | if (bio) |
3519 | submit_one_bio(READ, bio, 0, bio_flags); | 3562 | return submit_one_bio(READ, bio, 0, bio_flags); |
3520 | return 0; | 3563 | return 0; |
3521 | } | 3564 | } |
3522 | 3565 | ||
@@ -3537,7 +3580,7 @@ int extent_invalidatepage(struct extent_io_tree *tree, | |||
3537 | if (start > end) | 3580 | if (start > end) |
3538 | return 0; | 3581 | return 0; |
3539 | 3582 | ||
3540 | lock_extent_bits(tree, start, end, 0, &cached_state, GFP_NOFS); | 3583 | lock_extent_bits(tree, start, end, 0, &cached_state); |
3541 | wait_on_page_writeback(page); | 3584 | wait_on_page_writeback(page); |
3542 | clear_extent_bit(tree, start, end, | 3585 | clear_extent_bit(tree, start, end, |
3543 | EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC | | 3586 | EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC | |
@@ -3751,7 +3794,7 @@ int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo, | |||
3751 | } | 3794 | } |
3752 | 3795 | ||
3753 | lock_extent_bits(&BTRFS_I(inode)->io_tree, start, start + len, 0, | 3796 | lock_extent_bits(&BTRFS_I(inode)->io_tree, start, start + len, 0, |
3754 | &cached_state, GFP_NOFS); | 3797 | &cached_state); |
3755 | 3798 | ||
3756 | em = get_extent_skip_holes(inode, start, last_for_get_extent, | 3799 | em = get_extent_skip_holes(inode, start, last_for_get_extent, |
3757 | get_extent); | 3800 | get_extent); |
@@ -4239,14 +4282,13 @@ void free_extent_buffer_stale(struct extent_buffer *eb) | |||
4239 | release_extent_buffer(eb, GFP_NOFS); | 4282 | release_extent_buffer(eb, GFP_NOFS); |
4240 | } | 4283 | } |
4241 | 4284 | ||
4242 | int clear_extent_buffer_dirty(struct extent_buffer *eb) | 4285 | void clear_extent_buffer_dirty(struct extent_buffer *eb) |
4243 | { | 4286 | { |
4244 | unsigned long i; | 4287 | unsigned long i; |
4245 | unsigned long num_pages; | 4288 | unsigned long num_pages; |
4246 | struct page *page; | 4289 | struct page *page; |
4247 | 4290 | ||
4248 | num_pages = num_extent_pages(eb->start, eb->len); | 4291 | num_pages = num_extent_pages(eb->start, eb->len); |
4249 | WARN_ON(atomic_read(&eb->refs) == 0); | ||
4250 | 4292 | ||
4251 | for (i = 0; i < num_pages; i++) { | 4293 | for (i = 0; i < num_pages; i++) { |
4252 | page = extent_buffer_page(eb, i); | 4294 | page = extent_buffer_page(eb, i); |
@@ -4268,7 +4310,6 @@ int clear_extent_buffer_dirty(struct extent_buffer *eb) | |||
4268 | unlock_page(page); | 4310 | unlock_page(page); |
4269 | } | 4311 | } |
4270 | WARN_ON(atomic_read(&eb->refs) == 0); | 4312 | WARN_ON(atomic_read(&eb->refs) == 0); |
4271 | return 0; | ||
4272 | } | 4313 | } |
4273 | 4314 | ||
4274 | int set_extent_buffer_dirty(struct extent_buffer *eb) | 4315 | int set_extent_buffer_dirty(struct extent_buffer *eb) |
@@ -4433,8 +4474,11 @@ int read_extent_buffer_pages(struct extent_io_tree *tree, | |||
4433 | } | 4474 | } |
4434 | } | 4475 | } |
4435 | 4476 | ||
4436 | if (bio) | 4477 | if (bio) { |
4437 | submit_one_bio(READ, bio, mirror_num, bio_flags); | 4478 | err = submit_one_bio(READ, bio, mirror_num, bio_flags); |
4479 | if (err) | ||
4480 | return err; | ||
4481 | } | ||
4438 | 4482 | ||
4439 | if (ret || wait != WAIT_COMPLETE) | 4483 | if (ret || wait != WAIT_COMPLETE) |
4440 | return ret; | 4484 | return ret; |
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h index 38c1af7092f3..faf10eb57f75 100644 --- a/fs/btrfs/extent_io.h +++ b/fs/btrfs/extent_io.h | |||
@@ -194,14 +194,13 @@ int try_release_extent_buffer(struct page *page, gfp_t mask); | |||
194 | int try_release_extent_state(struct extent_map_tree *map, | 194 | int try_release_extent_state(struct extent_map_tree *map, |
195 | struct extent_io_tree *tree, struct page *page, | 195 | struct extent_io_tree *tree, struct page *page, |
196 | gfp_t mask); | 196 | gfp_t mask); |
197 | int lock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask); | 197 | int lock_extent(struct extent_io_tree *tree, u64 start, u64 end); |
198 | int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, | 198 | int lock_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, |
199 | int bits, struct extent_state **cached, gfp_t mask); | 199 | int bits, struct extent_state **cached); |
200 | int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end, gfp_t mask); | 200 | int unlock_extent(struct extent_io_tree *tree, u64 start, u64 end); |
201 | int unlock_extent_cached(struct extent_io_tree *tree, u64 start, u64 end, | 201 | int unlock_extent_cached(struct extent_io_tree *tree, u64 start, u64 end, |
202 | struct extent_state **cached, gfp_t mask); | 202 | struct extent_state **cached, gfp_t mask); |
203 | int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end, | 203 | int try_lock_extent(struct extent_io_tree *tree, u64 start, u64 end); |
204 | gfp_t mask); | ||
205 | int extent_read_full_page(struct extent_io_tree *tree, struct page *page, | 204 | int extent_read_full_page(struct extent_io_tree *tree, struct page *page, |
206 | get_extent_t *get_extent, int mirror_num); | 205 | get_extent_t *get_extent, int mirror_num); |
207 | int __init extent_io_init(void); | 206 | int __init extent_io_init(void); |
@@ -222,7 +221,7 @@ int clear_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, | |||
222 | int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, | 221 | int set_extent_bits(struct extent_io_tree *tree, u64 start, u64 end, |
223 | int bits, gfp_t mask); | 222 | int bits, gfp_t mask); |
224 | int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, | 223 | int set_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, |
225 | int bits, int exclusive_bits, u64 *failed_start, | 224 | int bits, u64 *failed_start, |
226 | struct extent_state **cached_state, gfp_t mask); | 225 | struct extent_state **cached_state, gfp_t mask); |
227 | int set_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end, | 226 | int set_extent_uptodate(struct extent_io_tree *tree, u64 start, u64 end, |
228 | struct extent_state **cached_state, gfp_t mask); | 227 | struct extent_state **cached_state, gfp_t mask); |
@@ -301,8 +300,8 @@ void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset, | |||
301 | unsigned long src_offset, unsigned long len); | 300 | unsigned long src_offset, unsigned long len); |
302 | void memset_extent_buffer(struct extent_buffer *eb, char c, | 301 | void memset_extent_buffer(struct extent_buffer *eb, char c, |
303 | unsigned long start, unsigned long len); | 302 | unsigned long start, unsigned long len); |
304 | int wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits); | 303 | void wait_extent_bit(struct extent_io_tree *tree, u64 start, u64 end, int bits); |
305 | int clear_extent_buffer_dirty(struct extent_buffer *eb); | 304 | void clear_extent_buffer_dirty(struct extent_buffer *eb); |
306 | int set_extent_buffer_dirty(struct extent_buffer *eb); | 305 | int set_extent_buffer_dirty(struct extent_buffer *eb); |
307 | int set_extent_buffer_uptodate(struct extent_buffer *eb); | 306 | int set_extent_buffer_uptodate(struct extent_buffer *eb); |
308 | int clear_extent_buffer_uptodate(struct extent_buffer *eb); | 307 | int clear_extent_buffer_uptodate(struct extent_buffer *eb); |
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c index c7fb3a4247d3..a14dbca5974e 100644 --- a/fs/btrfs/file-item.c +++ b/fs/btrfs/file-item.c | |||
@@ -59,7 +59,7 @@ int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, | |||
59 | sizeof(*item)); | 59 | sizeof(*item)); |
60 | if (ret < 0) | 60 | if (ret < 0) |
61 | goto out; | 61 | goto out; |
62 | BUG_ON(ret); | 62 | BUG_ON(ret); /* Can't happen */ |
63 | leaf = path->nodes[0]; | 63 | leaf = path->nodes[0]; |
64 | item = btrfs_item_ptr(leaf, path->slots[0], | 64 | item = btrfs_item_ptr(leaf, path->slots[0], |
65 | struct btrfs_file_extent_item); | 65 | struct btrfs_file_extent_item); |
@@ -284,6 +284,7 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, | |||
284 | struct btrfs_ordered_sum *sums; | 284 | struct btrfs_ordered_sum *sums; |
285 | struct btrfs_sector_sum *sector_sum; | 285 | struct btrfs_sector_sum *sector_sum; |
286 | struct btrfs_csum_item *item; | 286 | struct btrfs_csum_item *item; |
287 | LIST_HEAD(tmplist); | ||
287 | unsigned long offset; | 288 | unsigned long offset; |
288 | int ret; | 289 | int ret; |
289 | size_t size; | 290 | size_t size; |
@@ -358,7 +359,10 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, | |||
358 | MAX_ORDERED_SUM_BYTES(root)); | 359 | MAX_ORDERED_SUM_BYTES(root)); |
359 | sums = kzalloc(btrfs_ordered_sum_size(root, size), | 360 | sums = kzalloc(btrfs_ordered_sum_size(root, size), |
360 | GFP_NOFS); | 361 | GFP_NOFS); |
361 | BUG_ON(!sums); | 362 | if (!sums) { |
363 | ret = -ENOMEM; | ||
364 | goto fail; | ||
365 | } | ||
362 | 366 | ||
363 | sector_sum = sums->sums; | 367 | sector_sum = sums->sums; |
364 | sums->bytenr = start; | 368 | sums->bytenr = start; |
@@ -380,12 +384,19 @@ int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, | |||
380 | offset += csum_size; | 384 | offset += csum_size; |
381 | sector_sum++; | 385 | sector_sum++; |
382 | } | 386 | } |
383 | list_add_tail(&sums->list, list); | 387 | list_add_tail(&sums->list, &tmplist); |
384 | } | 388 | } |
385 | path->slots[0]++; | 389 | path->slots[0]++; |
386 | } | 390 | } |
387 | ret = 0; | 391 | ret = 0; |
388 | fail: | 392 | fail: |
393 | while (ret < 0 && !list_empty(&tmplist)) { | ||
394 | sums = list_entry(&tmplist, struct btrfs_ordered_sum, list); | ||
395 | list_del(&sums->list); | ||
396 | kfree(sums); | ||
397 | } | ||
398 | list_splice_tail(&tmplist, list); | ||
399 | |||
389 | btrfs_free_path(path); | 400 | btrfs_free_path(path); |
390 | return ret; | 401 | return ret; |
391 | } | 402 | } |
@@ -420,7 +431,7 @@ int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode, | |||
420 | offset = page_offset(bvec->bv_page) + bvec->bv_offset; | 431 | offset = page_offset(bvec->bv_page) + bvec->bv_offset; |
421 | 432 | ||
422 | ordered = btrfs_lookup_ordered_extent(inode, offset); | 433 | ordered = btrfs_lookup_ordered_extent(inode, offset); |
423 | BUG_ON(!ordered); | 434 | BUG_ON(!ordered); /* Logic error */ |
424 | sums->bytenr = ordered->start; | 435 | sums->bytenr = ordered->start; |
425 | 436 | ||
426 | while (bio_index < bio->bi_vcnt) { | 437 | while (bio_index < bio->bi_vcnt) { |
@@ -439,11 +450,11 @@ int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode, | |||
439 | 450 | ||
440 | sums = kzalloc(btrfs_ordered_sum_size(root, bytes_left), | 451 | sums = kzalloc(btrfs_ordered_sum_size(root, bytes_left), |
441 | GFP_NOFS); | 452 | GFP_NOFS); |
442 | BUG_ON(!sums); | 453 | BUG_ON(!sums); /* -ENOMEM */ |
443 | sector_sum = sums->sums; | 454 | sector_sum = sums->sums; |
444 | sums->len = bytes_left; | 455 | sums->len = bytes_left; |
445 | ordered = btrfs_lookup_ordered_extent(inode, offset); | 456 | ordered = btrfs_lookup_ordered_extent(inode, offset); |
446 | BUG_ON(!ordered); | 457 | BUG_ON(!ordered); /* Logic error */ |
447 | sums->bytenr = ordered->start; | 458 | sums->bytenr = ordered->start; |
448 | } | 459 | } |
449 | 460 | ||
@@ -483,18 +494,17 @@ int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode, | |||
483 | * This calls btrfs_truncate_item with the correct args based on the | 494 | * This calls btrfs_truncate_item with the correct args based on the |
484 | * overlap, and fixes up the key as required. | 495 | * overlap, and fixes up the key as required. |
485 | */ | 496 | */ |
486 | static noinline int truncate_one_csum(struct btrfs_trans_handle *trans, | 497 | static noinline void truncate_one_csum(struct btrfs_trans_handle *trans, |
487 | struct btrfs_root *root, | 498 | struct btrfs_root *root, |
488 | struct btrfs_path *path, | 499 | struct btrfs_path *path, |
489 | struct btrfs_key *key, | 500 | struct btrfs_key *key, |
490 | u64 bytenr, u64 len) | 501 | u64 bytenr, u64 len) |
491 | { | 502 | { |
492 | struct extent_buffer *leaf; | 503 | struct extent_buffer *leaf; |
493 | u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); | 504 | u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); |
494 | u64 csum_end; | 505 | u64 csum_end; |
495 | u64 end_byte = bytenr + len; | 506 | u64 end_byte = bytenr + len; |
496 | u32 blocksize_bits = root->fs_info->sb->s_blocksize_bits; | 507 | u32 blocksize_bits = root->fs_info->sb->s_blocksize_bits; |
497 | int ret; | ||
498 | 508 | ||
499 | leaf = path->nodes[0]; | 509 | leaf = path->nodes[0]; |
500 | csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; | 510 | csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; |
@@ -510,7 +520,7 @@ static noinline int truncate_one_csum(struct btrfs_trans_handle *trans, | |||
510 | */ | 520 | */ |
511 | u32 new_size = (bytenr - key->offset) >> blocksize_bits; | 521 | u32 new_size = (bytenr - key->offset) >> blocksize_bits; |
512 | new_size *= csum_size; | 522 | new_size *= csum_size; |
513 | ret = btrfs_truncate_item(trans, root, path, new_size, 1); | 523 | btrfs_truncate_item(trans, root, path, new_size, 1); |
514 | } else if (key->offset >= bytenr && csum_end > end_byte && | 524 | } else if (key->offset >= bytenr && csum_end > end_byte && |
515 | end_byte > key->offset) { | 525 | end_byte > key->offset) { |
516 | /* | 526 | /* |
@@ -522,15 +532,13 @@ static noinline int truncate_one_csum(struct btrfs_trans_handle *trans, | |||
522 | u32 new_size = (csum_end - end_byte) >> blocksize_bits; | 532 | u32 new_size = (csum_end - end_byte) >> blocksize_bits; |
523 | new_size *= csum_size; | 533 | new_size *= csum_size; |
524 | 534 | ||
525 | ret = btrfs_truncate_item(trans, root, path, new_size, 0); | 535 | btrfs_truncate_item(trans, root, path, new_size, 0); |
526 | 536 | ||
527 | key->offset = end_byte; | 537 | key->offset = end_byte; |
528 | ret = btrfs_set_item_key_safe(trans, root, path, key); | 538 | btrfs_set_item_key_safe(trans, root, path, key); |
529 | BUG_ON(ret); | ||
530 | } else { | 539 | } else { |
531 | BUG(); | 540 | BUG(); |
532 | } | 541 | } |
533 | return 0; | ||
534 | } | 542 | } |
535 | 543 | ||
536 | /* | 544 | /* |
@@ -635,13 +643,14 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans, | |||
635 | * item changed size or key | 643 | * item changed size or key |
636 | */ | 644 | */ |
637 | ret = btrfs_split_item(trans, root, path, &key, offset); | 645 | ret = btrfs_split_item(trans, root, path, &key, offset); |
638 | BUG_ON(ret && ret != -EAGAIN); | 646 | if (ret && ret != -EAGAIN) { |
647 | btrfs_abort_transaction(trans, root, ret); | ||
648 | goto out; | ||
649 | } | ||
639 | 650 | ||
640 | key.offset = end_byte - 1; | 651 | key.offset = end_byte - 1; |
641 | } else { | 652 | } else { |
642 | ret = truncate_one_csum(trans, root, path, | 653 | truncate_one_csum(trans, root, path, &key, bytenr, len); |
643 | &key, bytenr, len); | ||
644 | BUG_ON(ret); | ||
645 | if (key.offset < bytenr) | 654 | if (key.offset < bytenr) |
646 | break; | 655 | break; |
647 | } | 656 | } |
@@ -772,7 +781,7 @@ again: | |||
772 | if (diff != csum_size) | 781 | if (diff != csum_size) |
773 | goto insert; | 782 | goto insert; |
774 | 783 | ||
775 | ret = btrfs_extend_item(trans, root, path, diff); | 784 | btrfs_extend_item(trans, root, path, diff); |
776 | goto csum; | 785 | goto csum; |
777 | } | 786 | } |
778 | 787 | ||
diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c index e8d06b6b9194..d83260d7498f 100644 --- a/fs/btrfs/file.c +++ b/fs/btrfs/file.c | |||
@@ -452,7 +452,7 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, | |||
452 | split = alloc_extent_map(); | 452 | split = alloc_extent_map(); |
453 | if (!split2) | 453 | if (!split2) |
454 | split2 = alloc_extent_map(); | 454 | split2 = alloc_extent_map(); |
455 | BUG_ON(!split || !split2); | 455 | BUG_ON(!split || !split2); /* -ENOMEM */ |
456 | 456 | ||
457 | write_lock(&em_tree->lock); | 457 | write_lock(&em_tree->lock); |
458 | em = lookup_extent_mapping(em_tree, start, len); | 458 | em = lookup_extent_mapping(em_tree, start, len); |
@@ -494,7 +494,7 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, | |||
494 | split->flags = flags; | 494 | split->flags = flags; |
495 | split->compress_type = em->compress_type; | 495 | split->compress_type = em->compress_type; |
496 | ret = add_extent_mapping(em_tree, split); | 496 | ret = add_extent_mapping(em_tree, split); |
497 | BUG_ON(ret); | 497 | BUG_ON(ret); /* Logic error */ |
498 | free_extent_map(split); | 498 | free_extent_map(split); |
499 | split = split2; | 499 | split = split2; |
500 | split2 = NULL; | 500 | split2 = NULL; |
@@ -520,7 +520,7 @@ int btrfs_drop_extent_cache(struct inode *inode, u64 start, u64 end, | |||
520 | } | 520 | } |
521 | 521 | ||
522 | ret = add_extent_mapping(em_tree, split); | 522 | ret = add_extent_mapping(em_tree, split); |
523 | BUG_ON(ret); | 523 | BUG_ON(ret); /* Logic error */ |
524 | free_extent_map(split); | 524 | free_extent_map(split); |
525 | split = NULL; | 525 | split = NULL; |
526 | } | 526 | } |
@@ -679,7 +679,7 @@ next_slot: | |||
679 | root->root_key.objectid, | 679 | root->root_key.objectid, |
680 | new_key.objectid, | 680 | new_key.objectid, |
681 | start - extent_offset, 0); | 681 | start - extent_offset, 0); |
682 | BUG_ON(ret); | 682 | BUG_ON(ret); /* -ENOMEM */ |
683 | *hint_byte = disk_bytenr; | 683 | *hint_byte = disk_bytenr; |
684 | } | 684 | } |
685 | key.offset = start; | 685 | key.offset = start; |
@@ -754,7 +754,7 @@ next_slot: | |||
754 | root->root_key.objectid, | 754 | root->root_key.objectid, |
755 | key.objectid, key.offset - | 755 | key.objectid, key.offset - |
756 | extent_offset, 0); | 756 | extent_offset, 0); |
757 | BUG_ON(ret); | 757 | BUG_ON(ret); /* -ENOMEM */ |
758 | inode_sub_bytes(inode, | 758 | inode_sub_bytes(inode, |
759 | extent_end - key.offset); | 759 | extent_end - key.offset); |
760 | *hint_byte = disk_bytenr; | 760 | *hint_byte = disk_bytenr; |
@@ -770,7 +770,10 @@ next_slot: | |||
770 | 770 | ||
771 | ret = btrfs_del_items(trans, root, path, del_slot, | 771 | ret = btrfs_del_items(trans, root, path, del_slot, |
772 | del_nr); | 772 | del_nr); |
773 | BUG_ON(ret); | 773 | if (ret) { |
774 | btrfs_abort_transaction(trans, root, ret); | ||
775 | goto out; | ||
776 | } | ||
774 | 777 | ||
775 | del_nr = 0; | 778 | del_nr = 0; |
776 | del_slot = 0; | 779 | del_slot = 0; |
@@ -782,11 +785,13 @@ next_slot: | |||
782 | BUG_ON(1); | 785 | BUG_ON(1); |
783 | } | 786 | } |
784 | 787 | ||
785 | if (del_nr > 0) { | 788 | if (!ret && del_nr > 0) { |
786 | ret = btrfs_del_items(trans, root, path, del_slot, del_nr); | 789 | ret = btrfs_del_items(trans, root, path, del_slot, del_nr); |
787 | BUG_ON(ret); | 790 | if (ret) |
791 | btrfs_abort_transaction(trans, root, ret); | ||
788 | } | 792 | } |
789 | 793 | ||
794 | out: | ||
790 | btrfs_free_path(path); | 795 | btrfs_free_path(path); |
791 | return ret; | 796 | return ret; |
792 | } | 797 | } |
@@ -944,7 +949,10 @@ again: | |||
944 | btrfs_release_path(path); | 949 | btrfs_release_path(path); |
945 | goto again; | 950 | goto again; |
946 | } | 951 | } |
947 | BUG_ON(ret < 0); | 952 | if (ret < 0) { |
953 | btrfs_abort_transaction(trans, root, ret); | ||
954 | goto out; | ||
955 | } | ||
948 | 956 | ||
949 | leaf = path->nodes[0]; | 957 | leaf = path->nodes[0]; |
950 | fi = btrfs_item_ptr(leaf, path->slots[0] - 1, | 958 | fi = btrfs_item_ptr(leaf, path->slots[0] - 1, |
@@ -963,7 +971,7 @@ again: | |||
963 | ret = btrfs_inc_extent_ref(trans, root, bytenr, num_bytes, 0, | 971 | ret = btrfs_inc_extent_ref(trans, root, bytenr, num_bytes, 0, |
964 | root->root_key.objectid, | 972 | root->root_key.objectid, |
965 | ino, orig_offset, 0); | 973 | ino, orig_offset, 0); |
966 | BUG_ON(ret); | 974 | BUG_ON(ret); /* -ENOMEM */ |
967 | 975 | ||
968 | if (split == start) { | 976 | if (split == start) { |
969 | key.offset = start; | 977 | key.offset = start; |
@@ -990,7 +998,7 @@ again: | |||
990 | ret = btrfs_free_extent(trans, root, bytenr, num_bytes, | 998 | ret = btrfs_free_extent(trans, root, bytenr, num_bytes, |
991 | 0, root->root_key.objectid, | 999 | 0, root->root_key.objectid, |
992 | ino, orig_offset, 0); | 1000 | ino, orig_offset, 0); |
993 | BUG_ON(ret); | 1001 | BUG_ON(ret); /* -ENOMEM */ |
994 | } | 1002 | } |
995 | other_start = 0; | 1003 | other_start = 0; |
996 | other_end = start; | 1004 | other_end = start; |
@@ -1007,7 +1015,7 @@ again: | |||
1007 | ret = btrfs_free_extent(trans, root, bytenr, num_bytes, | 1015 | ret = btrfs_free_extent(trans, root, bytenr, num_bytes, |
1008 | 0, root->root_key.objectid, | 1016 | 0, root->root_key.objectid, |
1009 | ino, orig_offset, 0); | 1017 | ino, orig_offset, 0); |
1010 | BUG_ON(ret); | 1018 | BUG_ON(ret); /* -ENOMEM */ |
1011 | } | 1019 | } |
1012 | if (del_nr == 0) { | 1020 | if (del_nr == 0) { |
1013 | fi = btrfs_item_ptr(leaf, path->slots[0], | 1021 | fi = btrfs_item_ptr(leaf, path->slots[0], |
@@ -1025,7 +1033,10 @@ again: | |||
1025 | btrfs_mark_buffer_dirty(leaf); | 1033 | btrfs_mark_buffer_dirty(leaf); |
1026 | 1034 | ||
1027 | ret = btrfs_del_items(trans, root, path, del_slot, del_nr); | 1035 | ret = btrfs_del_items(trans, root, path, del_slot, del_nr); |
1028 | BUG_ON(ret); | 1036 | if (ret < 0) { |
1037 | btrfs_abort_transaction(trans, root, ret); | ||
1038 | goto out; | ||
1039 | } | ||
1029 | } | 1040 | } |
1030 | out: | 1041 | out: |
1031 | btrfs_free_path(path); | 1042 | btrfs_free_path(path); |
@@ -1105,8 +1116,7 @@ again: | |||
1105 | if (start_pos < inode->i_size) { | 1116 | if (start_pos < inode->i_size) { |
1106 | struct btrfs_ordered_extent *ordered; | 1117 | struct btrfs_ordered_extent *ordered; |
1107 | lock_extent_bits(&BTRFS_I(inode)->io_tree, | 1118 | lock_extent_bits(&BTRFS_I(inode)->io_tree, |
1108 | start_pos, last_pos - 1, 0, &cached_state, | 1119 | start_pos, last_pos - 1, 0, &cached_state); |
1109 | GFP_NOFS); | ||
1110 | ordered = btrfs_lookup_first_ordered_extent(inode, | 1120 | ordered = btrfs_lookup_first_ordered_extent(inode, |
1111 | last_pos - 1); | 1121 | last_pos - 1); |
1112 | if (ordered && | 1122 | if (ordered && |
@@ -1638,7 +1648,7 @@ static long btrfs_fallocate(struct file *file, int mode, | |||
1638 | * transaction | 1648 | * transaction |
1639 | */ | 1649 | */ |
1640 | lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start, | 1650 | lock_extent_bits(&BTRFS_I(inode)->io_tree, alloc_start, |
1641 | locked_end, 0, &cached_state, GFP_NOFS); | 1651 | locked_end, 0, &cached_state); |
1642 | ordered = btrfs_lookup_first_ordered_extent(inode, | 1652 | ordered = btrfs_lookup_first_ordered_extent(inode, |
1643 | alloc_end - 1); | 1653 | alloc_end - 1); |
1644 | if (ordered && | 1654 | if (ordered && |
@@ -1667,7 +1677,13 @@ static long btrfs_fallocate(struct file *file, int mode, | |||
1667 | 1677 | ||
1668 | em = btrfs_get_extent(inode, NULL, 0, cur_offset, | 1678 | em = btrfs_get_extent(inode, NULL, 0, cur_offset, |
1669 | alloc_end - cur_offset, 0); | 1679 | alloc_end - cur_offset, 0); |
1670 | BUG_ON(IS_ERR_OR_NULL(em)); | 1680 | if (IS_ERR_OR_NULL(em)) { |
1681 | if (!em) | ||
1682 | ret = -ENOMEM; | ||
1683 | else | ||
1684 | ret = PTR_ERR(em); | ||
1685 | break; | ||
1686 | } | ||
1671 | last_byte = min(extent_map_end(em), alloc_end); | 1687 | last_byte = min(extent_map_end(em), alloc_end); |
1672 | actual_end = min_t(u64, extent_map_end(em), offset + len); | 1688 | actual_end = min_t(u64, extent_map_end(em), offset + len); |
1673 | last_byte = (last_byte + mask) & ~mask; | 1689 | last_byte = (last_byte + mask) & ~mask; |
@@ -1737,7 +1753,7 @@ static int find_desired_extent(struct inode *inode, loff_t *offset, int origin) | |||
1737 | return -ENXIO; | 1753 | return -ENXIO; |
1738 | 1754 | ||
1739 | lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, 0, | 1755 | lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, 0, |
1740 | &cached_state, GFP_NOFS); | 1756 | &cached_state); |
1741 | 1757 | ||
1742 | /* | 1758 | /* |
1743 | * Delalloc is such a pain. If we have a hole and we have pending | 1759 | * Delalloc is such a pain. If we have a hole and we have pending |
diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c index 710ea380c7ed..054707ed5791 100644 --- a/fs/btrfs/free-space-cache.c +++ b/fs/btrfs/free-space-cache.c | |||
@@ -230,11 +230,13 @@ int btrfs_truncate_free_space_cache(struct btrfs_root *root, | |||
230 | 230 | ||
231 | if (ret) { | 231 | if (ret) { |
232 | trans->block_rsv = rsv; | 232 | trans->block_rsv = rsv; |
233 | WARN_ON(1); | 233 | btrfs_abort_transaction(trans, root, ret); |
234 | return ret; | 234 | return ret; |
235 | } | 235 | } |
236 | 236 | ||
237 | ret = btrfs_update_inode(trans, root, inode); | 237 | ret = btrfs_update_inode(trans, root, inode); |
238 | if (ret) | ||
239 | btrfs_abort_transaction(trans, root, ret); | ||
238 | trans->block_rsv = rsv; | 240 | trans->block_rsv = rsv; |
239 | 241 | ||
240 | return ret; | 242 | return ret; |
@@ -869,7 +871,7 @@ int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode, | |||
869 | io_ctl_prepare_pages(&io_ctl, inode, 0); | 871 | io_ctl_prepare_pages(&io_ctl, inode, 0); |
870 | 872 | ||
871 | lock_extent_bits(&BTRFS_I(inode)->io_tree, 0, i_size_read(inode) - 1, | 873 | lock_extent_bits(&BTRFS_I(inode)->io_tree, 0, i_size_read(inode) - 1, |
872 | 0, &cached_state, GFP_NOFS); | 874 | 0, &cached_state); |
873 | 875 | ||
874 | node = rb_first(&ctl->free_space_offset); | 876 | node = rb_first(&ctl->free_space_offset); |
875 | if (!node && cluster) { | 877 | if (!node && cluster) { |
@@ -1948,14 +1950,14 @@ again: | |||
1948 | */ | 1950 | */ |
1949 | ret = btrfs_add_free_space(block_group, old_start, | 1951 | ret = btrfs_add_free_space(block_group, old_start, |
1950 | offset - old_start); | 1952 | offset - old_start); |
1951 | WARN_ON(ret); | 1953 | WARN_ON(ret); /* -ENOMEM */ |
1952 | goto out; | 1954 | goto out; |
1953 | } | 1955 | } |
1954 | 1956 | ||
1955 | ret = remove_from_bitmap(ctl, info, &offset, &bytes); | 1957 | ret = remove_from_bitmap(ctl, info, &offset, &bytes); |
1956 | if (ret == -EAGAIN) | 1958 | if (ret == -EAGAIN) |
1957 | goto again; | 1959 | goto again; |
1958 | BUG_ON(ret); | 1960 | BUG_ON(ret); /* logic error */ |
1959 | out_lock: | 1961 | out_lock: |
1960 | spin_unlock(&ctl->tree_lock); | 1962 | spin_unlock(&ctl->tree_lock); |
1961 | out: | 1963 | out: |
@@ -2346,7 +2348,7 @@ again: | |||
2346 | rb_erase(&entry->offset_index, &ctl->free_space_offset); | 2348 | rb_erase(&entry->offset_index, &ctl->free_space_offset); |
2347 | ret = tree_insert_offset(&cluster->root, entry->offset, | 2349 | ret = tree_insert_offset(&cluster->root, entry->offset, |
2348 | &entry->offset_index, 1); | 2350 | &entry->offset_index, 1); |
2349 | BUG_ON(ret); | 2351 | BUG_ON(ret); /* -EEXIST; Logic error */ |
2350 | 2352 | ||
2351 | trace_btrfs_setup_cluster(block_group, cluster, | 2353 | trace_btrfs_setup_cluster(block_group, cluster, |
2352 | total_found * block_group->sectorsize, 1); | 2354 | total_found * block_group->sectorsize, 1); |
@@ -2439,7 +2441,7 @@ setup_cluster_no_bitmap(struct btrfs_block_group_cache *block_group, | |||
2439 | ret = tree_insert_offset(&cluster->root, entry->offset, | 2441 | ret = tree_insert_offset(&cluster->root, entry->offset, |
2440 | &entry->offset_index, 0); | 2442 | &entry->offset_index, 0); |
2441 | total_size += entry->bytes; | 2443 | total_size += entry->bytes; |
2442 | BUG_ON(ret); | 2444 | BUG_ON(ret); /* -EEXIST; Logic error */ |
2443 | } while (node && entry != last); | 2445 | } while (node && entry != last); |
2444 | 2446 | ||
2445 | cluster->max_size = max_extent; | 2447 | cluster->max_size = max_extent; |
@@ -2830,6 +2832,7 @@ u64 btrfs_find_ino_for_alloc(struct btrfs_root *fs_root) | |||
2830 | int ret; | 2832 | int ret; |
2831 | 2833 | ||
2832 | ret = search_bitmap(ctl, entry, &offset, &count); | 2834 | ret = search_bitmap(ctl, entry, &offset, &count); |
2835 | /* Logic error; Should be empty if it can't find anything */ | ||
2833 | BUG_ON(ret); | 2836 | BUG_ON(ret); |
2834 | 2837 | ||
2835 | ino = offset; | 2838 | ino = offset; |
diff --git a/fs/btrfs/inode-item.c b/fs/btrfs/inode-item.c index 6ea71c60e80a..a13cf1a96c73 100644 --- a/fs/btrfs/inode-item.c +++ b/fs/btrfs/inode-item.c | |||
@@ -129,13 +129,14 @@ int btrfs_del_inode_ref(struct btrfs_trans_handle *trans, | |||
129 | item_start = btrfs_item_ptr_offset(leaf, path->slots[0]); | 129 | item_start = btrfs_item_ptr_offset(leaf, path->slots[0]); |
130 | memmove_extent_buffer(leaf, ptr, ptr + sub_item_len, | 130 | memmove_extent_buffer(leaf, ptr, ptr + sub_item_len, |
131 | item_size - (ptr + sub_item_len - item_start)); | 131 | item_size - (ptr + sub_item_len - item_start)); |
132 | ret = btrfs_truncate_item(trans, root, path, | 132 | btrfs_truncate_item(trans, root, path, |
133 | item_size - sub_item_len, 1); | 133 | item_size - sub_item_len, 1); |
134 | out: | 134 | out: |
135 | btrfs_free_path(path); | 135 | btrfs_free_path(path); |
136 | return ret; | 136 | return ret; |
137 | } | 137 | } |
138 | 138 | ||
139 | /* Will return 0, -ENOMEM, -EMLINK, or -EEXIST or anything from the CoW path */ | ||
139 | int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, | 140 | int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, |
140 | struct btrfs_root *root, | 141 | struct btrfs_root *root, |
141 | const char *name, int name_len, | 142 | const char *name, int name_len, |
@@ -166,7 +167,7 @@ int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, | |||
166 | goto out; | 167 | goto out; |
167 | 168 | ||
168 | old_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]); | 169 | old_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]); |
169 | ret = btrfs_extend_item(trans, root, path, ins_len); | 170 | btrfs_extend_item(trans, root, path, ins_len); |
170 | ref = btrfs_item_ptr(path->nodes[0], path->slots[0], | 171 | ref = btrfs_item_ptr(path->nodes[0], path->slots[0], |
171 | struct btrfs_inode_ref); | 172 | struct btrfs_inode_ref); |
172 | ref = (struct btrfs_inode_ref *)((unsigned long)ref + old_size); | 173 | ref = (struct btrfs_inode_ref *)((unsigned long)ref + old_size); |
diff --git a/fs/btrfs/inode-map.c b/fs/btrfs/inode-map.c index ee15d88b33d2..7ca46e6e11ae 100644 --- a/fs/btrfs/inode-map.c +++ b/fs/btrfs/inode-map.c | |||
@@ -178,7 +178,7 @@ static void start_caching(struct btrfs_root *root) | |||
178 | 178 | ||
179 | tsk = kthread_run(caching_kthread, root, "btrfs-ino-cache-%llu\n", | 179 | tsk = kthread_run(caching_kthread, root, "btrfs-ino-cache-%llu\n", |
180 | root->root_key.objectid); | 180 | root->root_key.objectid); |
181 | BUG_ON(IS_ERR(tsk)); | 181 | BUG_ON(IS_ERR(tsk)); /* -ENOMEM */ |
182 | } | 182 | } |
183 | 183 | ||
184 | int btrfs_find_free_ino(struct btrfs_root *root, u64 *objectid) | 184 | int btrfs_find_free_ino(struct btrfs_root *root, u64 *objectid) |
@@ -271,7 +271,7 @@ void btrfs_unpin_free_ino(struct btrfs_root *root) | |||
271 | break; | 271 | break; |
272 | 272 | ||
273 | info = rb_entry(n, struct btrfs_free_space, offset_index); | 273 | info = rb_entry(n, struct btrfs_free_space, offset_index); |
274 | BUG_ON(info->bitmap); | 274 | BUG_ON(info->bitmap); /* Logic error */ |
275 | 275 | ||
276 | if (info->offset > root->cache_progress) | 276 | if (info->offset > root->cache_progress) |
277 | goto free; | 277 | goto free; |
@@ -443,13 +443,13 @@ int btrfs_save_ino_cache(struct btrfs_root *root, | |||
443 | trans->bytes_reserved, 1); | 443 | trans->bytes_reserved, 1); |
444 | again: | 444 | again: |
445 | inode = lookup_free_ino_inode(root, path); | 445 | inode = lookup_free_ino_inode(root, path); |
446 | if (IS_ERR(inode) && PTR_ERR(inode) != -ENOENT) { | 446 | if (IS_ERR(inode) && (PTR_ERR(inode) != -ENOENT || retry)) { |
447 | ret = PTR_ERR(inode); | 447 | ret = PTR_ERR(inode); |
448 | goto out_release; | 448 | goto out_release; |
449 | } | 449 | } |
450 | 450 | ||
451 | if (IS_ERR(inode)) { | 451 | if (IS_ERR(inode)) { |
452 | BUG_ON(retry); | 452 | BUG_ON(retry); /* Logic error */ |
453 | retry = true; | 453 | retry = true; |
454 | 454 | ||
455 | ret = create_free_ino_inode(root, trans, path); | 455 | ret = create_free_ino_inode(root, trans, path); |
@@ -460,12 +460,17 @@ again: | |||
460 | 460 | ||
461 | BTRFS_I(inode)->generation = 0; | 461 | BTRFS_I(inode)->generation = 0; |
462 | ret = btrfs_update_inode(trans, root, inode); | 462 | ret = btrfs_update_inode(trans, root, inode); |
463 | WARN_ON(ret); | 463 | if (ret) { |
464 | btrfs_abort_transaction(trans, root, ret); | ||
465 | goto out_put; | ||
466 | } | ||
464 | 467 | ||
465 | if (i_size_read(inode) > 0) { | 468 | if (i_size_read(inode) > 0) { |
466 | ret = btrfs_truncate_free_space_cache(root, trans, path, inode); | 469 | ret = btrfs_truncate_free_space_cache(root, trans, path, inode); |
467 | if (ret) | 470 | if (ret) { |
471 | btrfs_abort_transaction(trans, root, ret); | ||
468 | goto out_put; | 472 | goto out_put; |
473 | } | ||
469 | } | 474 | } |
470 | 475 | ||
471 | spin_lock(&root->cache_lock); | 476 | spin_lock(&root->cache_lock); |
@@ -532,7 +537,7 @@ static int btrfs_find_highest_objectid(struct btrfs_root *root, u64 *objectid) | |||
532 | ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0); | 537 | ret = btrfs_search_slot(NULL, root, &search_key, path, 0, 0); |
533 | if (ret < 0) | 538 | if (ret < 0) |
534 | goto error; | 539 | goto error; |
535 | BUG_ON(ret == 0); | 540 | BUG_ON(ret == 0); /* Corruption */ |
536 | if (path->slots[0] > 0) { | 541 | if (path->slots[0] > 0) { |
537 | slot = path->slots[0] - 1; | 542 | slot = path->slots[0] - 1; |
538 | l = path->nodes[0]; | 543 | l = path->nodes[0]; |
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c index 341a8670165f..eb6aec7bbacb 100644 --- a/fs/btrfs/inode.c +++ b/fs/btrfs/inode.c | |||
@@ -150,7 +150,6 @@ static noinline int insert_inline_extent(struct btrfs_trans_handle *trans, | |||
150 | inode_add_bytes(inode, size); | 150 | inode_add_bytes(inode, size); |
151 | ret = btrfs_insert_empty_item(trans, root, path, &key, | 151 | ret = btrfs_insert_empty_item(trans, root, path, &key, |
152 | datasize); | 152 | datasize); |
153 | BUG_ON(ret); | ||
154 | if (ret) { | 153 | if (ret) { |
155 | err = ret; | 154 | err = ret; |
156 | goto fail; | 155 | goto fail; |
@@ -206,9 +205,9 @@ static noinline int insert_inline_extent(struct btrfs_trans_handle *trans, | |||
206 | * could end up racing with unlink. | 205 | * could end up racing with unlink. |
207 | */ | 206 | */ |
208 | BTRFS_I(inode)->disk_i_size = inode->i_size; | 207 | BTRFS_I(inode)->disk_i_size = inode->i_size; |
209 | btrfs_update_inode(trans, root, inode); | 208 | ret = btrfs_update_inode(trans, root, inode); |
210 | 209 | ||
211 | return 0; | 210 | return ret; |
212 | fail: | 211 | fail: |
213 | btrfs_free_path(path); | 212 | btrfs_free_path(path); |
214 | return err; | 213 | return err; |
@@ -250,14 +249,18 @@ static noinline int cow_file_range_inline(struct btrfs_trans_handle *trans, | |||
250 | 249 | ||
251 | ret = btrfs_drop_extents(trans, inode, start, aligned_end, | 250 | ret = btrfs_drop_extents(trans, inode, start, aligned_end, |
252 | &hint_byte, 1); | 251 | &hint_byte, 1); |
253 | BUG_ON(ret); | 252 | if (ret) |
253 | return ret; | ||
254 | 254 | ||
255 | if (isize > actual_end) | 255 | if (isize > actual_end) |
256 | inline_len = min_t(u64, isize, actual_end); | 256 | inline_len = min_t(u64, isize, actual_end); |
257 | ret = insert_inline_extent(trans, root, inode, start, | 257 | ret = insert_inline_extent(trans, root, inode, start, |
258 | inline_len, compressed_size, | 258 | inline_len, compressed_size, |
259 | compress_type, compressed_pages); | 259 | compress_type, compressed_pages); |
260 | BUG_ON(ret); | 260 | if (ret) { |
261 | btrfs_abort_transaction(trans, root, ret); | ||
262 | return ret; | ||
263 | } | ||
261 | btrfs_delalloc_release_metadata(inode, end + 1 - start); | 264 | btrfs_delalloc_release_metadata(inode, end + 1 - start); |
262 | btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0); | 265 | btrfs_drop_extent_cache(inode, start, aligned_end - 1, 0); |
263 | return 0; | 266 | return 0; |
@@ -293,7 +296,7 @@ static noinline int add_async_extent(struct async_cow *cow, | |||
293 | struct async_extent *async_extent; | 296 | struct async_extent *async_extent; |
294 | 297 | ||
295 | async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS); | 298 | async_extent = kmalloc(sizeof(*async_extent), GFP_NOFS); |
296 | BUG_ON(!async_extent); | 299 | BUG_ON(!async_extent); /* -ENOMEM */ |
297 | async_extent->start = start; | 300 | async_extent->start = start; |
298 | async_extent->ram_size = ram_size; | 301 | async_extent->ram_size = ram_size; |
299 | async_extent->compressed_size = compressed_size; | 302 | async_extent->compressed_size = compressed_size; |
@@ -433,7 +436,11 @@ again: | |||
433 | cont: | 436 | cont: |
434 | if (start == 0) { | 437 | if (start == 0) { |
435 | trans = btrfs_join_transaction(root); | 438 | trans = btrfs_join_transaction(root); |
436 | BUG_ON(IS_ERR(trans)); | 439 | if (IS_ERR(trans)) { |
440 | ret = PTR_ERR(trans); | ||
441 | trans = NULL; | ||
442 | goto cleanup_and_out; | ||
443 | } | ||
437 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; | 444 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; |
438 | 445 | ||
439 | /* lets try to make an inline extent */ | 446 | /* lets try to make an inline extent */ |
@@ -450,11 +457,11 @@ cont: | |||
450 | total_compressed, | 457 | total_compressed, |
451 | compress_type, pages); | 458 | compress_type, pages); |
452 | } | 459 | } |
453 | if (ret == 0) { | 460 | if (ret <= 0) { |
454 | /* | 461 | /* |
455 | * inline extent creation worked, we don't need | 462 | * inline extent creation worked or returned error, |
456 | * to create any more async work items. Unlock | 463 | * we don't need to create any more async work items. |
457 | * and free up our temp pages. | 464 | * Unlock and free up our temp pages. |
458 | */ | 465 | */ |
459 | extent_clear_unlock_delalloc(inode, | 466 | extent_clear_unlock_delalloc(inode, |
460 | &BTRFS_I(inode)->io_tree, | 467 | &BTRFS_I(inode)->io_tree, |
@@ -547,7 +554,7 @@ cleanup_and_bail_uncompressed: | |||
547 | } | 554 | } |
548 | 555 | ||
549 | out: | 556 | out: |
550 | return 0; | 557 | return ret; |
551 | 558 | ||
552 | free_pages_out: | 559 | free_pages_out: |
553 | for (i = 0; i < nr_pages_ret; i++) { | 560 | for (i = 0; i < nr_pages_ret; i++) { |
@@ -557,6 +564,20 @@ free_pages_out: | |||
557 | kfree(pages); | 564 | kfree(pages); |
558 | 565 | ||
559 | goto out; | 566 | goto out; |
567 | |||
568 | cleanup_and_out: | ||
569 | extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree, | ||
570 | start, end, NULL, | ||
571 | EXTENT_CLEAR_UNLOCK_PAGE | | ||
572 | EXTENT_CLEAR_DIRTY | | ||
573 | EXTENT_CLEAR_DELALLOC | | ||
574 | EXTENT_SET_WRITEBACK | | ||
575 | EXTENT_END_WRITEBACK); | ||
576 | if (!trans || IS_ERR(trans)) | ||
577 | btrfs_error(root->fs_info, ret, "Failed to join transaction"); | ||
578 | else | ||
579 | btrfs_abort_transaction(trans, root, ret); | ||
580 | goto free_pages_out; | ||
560 | } | 581 | } |
561 | 582 | ||
562 | /* | 583 | /* |
@@ -597,7 +618,7 @@ retry: | |||
597 | 618 | ||
598 | lock_extent(io_tree, async_extent->start, | 619 | lock_extent(io_tree, async_extent->start, |
599 | async_extent->start + | 620 | async_extent->start + |
600 | async_extent->ram_size - 1, GFP_NOFS); | 621 | async_extent->ram_size - 1); |
601 | 622 | ||
602 | /* allocate blocks */ | 623 | /* allocate blocks */ |
603 | ret = cow_file_range(inode, async_cow->locked_page, | 624 | ret = cow_file_range(inode, async_cow->locked_page, |
@@ -606,6 +627,8 @@ retry: | |||
606 | async_extent->ram_size - 1, | 627 | async_extent->ram_size - 1, |
607 | &page_started, &nr_written, 0); | 628 | &page_started, &nr_written, 0); |
608 | 629 | ||
630 | /* JDM XXX */ | ||
631 | |||
609 | /* | 632 | /* |
610 | * if page_started, cow_file_range inserted an | 633 | * if page_started, cow_file_range inserted an |
611 | * inline extent and took care of all the unlocking | 634 | * inline extent and took care of all the unlocking |
@@ -625,17 +648,21 @@ retry: | |||
625 | } | 648 | } |
626 | 649 | ||
627 | lock_extent(io_tree, async_extent->start, | 650 | lock_extent(io_tree, async_extent->start, |
628 | async_extent->start + async_extent->ram_size - 1, | 651 | async_extent->start + async_extent->ram_size - 1); |
629 | GFP_NOFS); | ||
630 | 652 | ||
631 | trans = btrfs_join_transaction(root); | 653 | trans = btrfs_join_transaction(root); |
632 | BUG_ON(IS_ERR(trans)); | 654 | if (IS_ERR(trans)) { |
633 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; | 655 | ret = PTR_ERR(trans); |
634 | ret = btrfs_reserve_extent(trans, root, | 656 | } else { |
657 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; | ||
658 | ret = btrfs_reserve_extent(trans, root, | ||
635 | async_extent->compressed_size, | 659 | async_extent->compressed_size, |
636 | async_extent->compressed_size, | 660 | async_extent->compressed_size, |
637 | 0, alloc_hint, &ins, 1); | 661 | 0, alloc_hint, &ins, 1); |
638 | btrfs_end_transaction(trans, root); | 662 | if (ret) |
663 | btrfs_abort_transaction(trans, root, ret); | ||
664 | btrfs_end_transaction(trans, root); | ||
665 | } | ||
639 | 666 | ||
640 | if (ret) { | 667 | if (ret) { |
641 | int i; | 668 | int i; |
@@ -648,8 +675,10 @@ retry: | |||
648 | async_extent->pages = NULL; | 675 | async_extent->pages = NULL; |
649 | unlock_extent(io_tree, async_extent->start, | 676 | unlock_extent(io_tree, async_extent->start, |
650 | async_extent->start + | 677 | async_extent->start + |
651 | async_extent->ram_size - 1, GFP_NOFS); | 678 | async_extent->ram_size - 1); |
652 | goto retry; | 679 | if (ret == -ENOSPC) |
680 | goto retry; | ||
681 | goto out_free; /* JDM: Requeue? */ | ||
653 | } | 682 | } |
654 | 683 | ||
655 | /* | 684 | /* |
@@ -661,7 +690,7 @@ retry: | |||
661 | async_extent->ram_size - 1, 0); | 690 | async_extent->ram_size - 1, 0); |
662 | 691 | ||
663 | em = alloc_extent_map(); | 692 | em = alloc_extent_map(); |
664 | BUG_ON(!em); | 693 | BUG_ON(!em); /* -ENOMEM */ |
665 | em->start = async_extent->start; | 694 | em->start = async_extent->start; |
666 | em->len = async_extent->ram_size; | 695 | em->len = async_extent->ram_size; |
667 | em->orig_start = em->start; | 696 | em->orig_start = em->start; |
@@ -693,7 +722,7 @@ retry: | |||
693 | ins.offset, | 722 | ins.offset, |
694 | BTRFS_ORDERED_COMPRESSED, | 723 | BTRFS_ORDERED_COMPRESSED, |
695 | async_extent->compress_type); | 724 | async_extent->compress_type); |
696 | BUG_ON(ret); | 725 | BUG_ON(ret); /* -ENOMEM */ |
697 | 726 | ||
698 | /* | 727 | /* |
699 | * clear dirty, set writeback and unlock the pages. | 728 | * clear dirty, set writeback and unlock the pages. |
@@ -715,13 +744,17 @@ retry: | |||
715 | ins.offset, async_extent->pages, | 744 | ins.offset, async_extent->pages, |
716 | async_extent->nr_pages); | 745 | async_extent->nr_pages); |
717 | 746 | ||
718 | BUG_ON(ret); | 747 | BUG_ON(ret); /* -ENOMEM */ |
719 | alloc_hint = ins.objectid + ins.offset; | 748 | alloc_hint = ins.objectid + ins.offset; |
720 | kfree(async_extent); | 749 | kfree(async_extent); |
721 | cond_resched(); | 750 | cond_resched(); |
722 | } | 751 | } |
723 | 752 | ret = 0; | |
724 | return 0; | 753 | out: |
754 | return ret; | ||
755 | out_free: | ||
756 | kfree(async_extent); | ||
757 | goto out; | ||
725 | } | 758 | } |
726 | 759 | ||
727 | static u64 get_extent_allocation_hint(struct inode *inode, u64 start, | 760 | static u64 get_extent_allocation_hint(struct inode *inode, u64 start, |
@@ -790,7 +823,18 @@ static noinline int cow_file_range(struct inode *inode, | |||
790 | 823 | ||
791 | BUG_ON(btrfs_is_free_space_inode(root, inode)); | 824 | BUG_ON(btrfs_is_free_space_inode(root, inode)); |
792 | trans = btrfs_join_transaction(root); | 825 | trans = btrfs_join_transaction(root); |
793 | BUG_ON(IS_ERR(trans)); | 826 | if (IS_ERR(trans)) { |
827 | extent_clear_unlock_delalloc(inode, | ||
828 | &BTRFS_I(inode)->io_tree, | ||
829 | start, end, NULL, | ||
830 | EXTENT_CLEAR_UNLOCK_PAGE | | ||
831 | EXTENT_CLEAR_UNLOCK | | ||
832 | EXTENT_CLEAR_DELALLOC | | ||
833 | EXTENT_CLEAR_DIRTY | | ||
834 | EXTENT_SET_WRITEBACK | | ||
835 | EXTENT_END_WRITEBACK); | ||
836 | return PTR_ERR(trans); | ||
837 | } | ||
794 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; | 838 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; |
795 | 839 | ||
796 | num_bytes = (end - start + blocksize) & ~(blocksize - 1); | 840 | num_bytes = (end - start + blocksize) & ~(blocksize - 1); |
@@ -820,8 +864,10 @@ static noinline int cow_file_range(struct inode *inode, | |||
820 | *nr_written = *nr_written + | 864 | *nr_written = *nr_written + |
821 | (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE; | 865 | (end - start + PAGE_CACHE_SIZE) / PAGE_CACHE_SIZE; |
822 | *page_started = 1; | 866 | *page_started = 1; |
823 | ret = 0; | ||
824 | goto out; | 867 | goto out; |
868 | } else if (ret < 0) { | ||
869 | btrfs_abort_transaction(trans, root, ret); | ||
870 | goto out_unlock; | ||
825 | } | 871 | } |
826 | } | 872 | } |
827 | 873 | ||
@@ -838,10 +884,13 @@ static noinline int cow_file_range(struct inode *inode, | |||
838 | ret = btrfs_reserve_extent(trans, root, cur_alloc_size, | 884 | ret = btrfs_reserve_extent(trans, root, cur_alloc_size, |
839 | root->sectorsize, 0, alloc_hint, | 885 | root->sectorsize, 0, alloc_hint, |
840 | &ins, 1); | 886 | &ins, 1); |
841 | BUG_ON(ret); | 887 | if (ret < 0) { |
888 | btrfs_abort_transaction(trans, root, ret); | ||
889 | goto out_unlock; | ||
890 | } | ||
842 | 891 | ||
843 | em = alloc_extent_map(); | 892 | em = alloc_extent_map(); |
844 | BUG_ON(!em); | 893 | BUG_ON(!em); /* -ENOMEM */ |
845 | em->start = start; | 894 | em->start = start; |
846 | em->orig_start = em->start; | 895 | em->orig_start = em->start; |
847 | ram_size = ins.offset; | 896 | ram_size = ins.offset; |
@@ -867,13 +916,16 @@ static noinline int cow_file_range(struct inode *inode, | |||
867 | cur_alloc_size = ins.offset; | 916 | cur_alloc_size = ins.offset; |
868 | ret = btrfs_add_ordered_extent(inode, start, ins.objectid, | 917 | ret = btrfs_add_ordered_extent(inode, start, ins.objectid, |
869 | ram_size, cur_alloc_size, 0); | 918 | ram_size, cur_alloc_size, 0); |
870 | BUG_ON(ret); | 919 | BUG_ON(ret); /* -ENOMEM */ |
871 | 920 | ||
872 | if (root->root_key.objectid == | 921 | if (root->root_key.objectid == |
873 | BTRFS_DATA_RELOC_TREE_OBJECTID) { | 922 | BTRFS_DATA_RELOC_TREE_OBJECTID) { |
874 | ret = btrfs_reloc_clone_csums(inode, start, | 923 | ret = btrfs_reloc_clone_csums(inode, start, |
875 | cur_alloc_size); | 924 | cur_alloc_size); |
876 | BUG_ON(ret); | 925 | if (ret) { |
926 | btrfs_abort_transaction(trans, root, ret); | ||
927 | goto out_unlock; | ||
928 | } | ||
877 | } | 929 | } |
878 | 930 | ||
879 | if (disk_num_bytes < cur_alloc_size) | 931 | if (disk_num_bytes < cur_alloc_size) |
@@ -898,11 +950,23 @@ static noinline int cow_file_range(struct inode *inode, | |||
898 | alloc_hint = ins.objectid + ins.offset; | 950 | alloc_hint = ins.objectid + ins.offset; |
899 | start += cur_alloc_size; | 951 | start += cur_alloc_size; |
900 | } | 952 | } |
901 | out: | ||
902 | ret = 0; | 953 | ret = 0; |
954 | out: | ||
903 | btrfs_end_transaction(trans, root); | 955 | btrfs_end_transaction(trans, root); |
904 | 956 | ||
905 | return ret; | 957 | return ret; |
958 | out_unlock: | ||
959 | extent_clear_unlock_delalloc(inode, | ||
960 | &BTRFS_I(inode)->io_tree, | ||
961 | start, end, NULL, | ||
962 | EXTENT_CLEAR_UNLOCK_PAGE | | ||
963 | EXTENT_CLEAR_UNLOCK | | ||
964 | EXTENT_CLEAR_DELALLOC | | ||
965 | EXTENT_CLEAR_DIRTY | | ||
966 | EXTENT_SET_WRITEBACK | | ||
967 | EXTENT_END_WRITEBACK); | ||
968 | |||
969 | goto out; | ||
906 | } | 970 | } |
907 | 971 | ||
908 | /* | 972 | /* |
@@ -968,7 +1032,7 @@ static int cow_file_range_async(struct inode *inode, struct page *locked_page, | |||
968 | 1, 0, NULL, GFP_NOFS); | 1032 | 1, 0, NULL, GFP_NOFS); |
969 | while (start < end) { | 1033 | while (start < end) { |
970 | async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS); | 1034 | async_cow = kmalloc(sizeof(*async_cow), GFP_NOFS); |
971 | BUG_ON(!async_cow); | 1035 | BUG_ON(!async_cow); /* -ENOMEM */ |
972 | async_cow->inode = inode; | 1036 | async_cow->inode = inode; |
973 | async_cow->root = root; | 1037 | async_cow->root = root; |
974 | async_cow->locked_page = locked_page; | 1038 | async_cow->locked_page = locked_page; |
@@ -1059,7 +1123,7 @@ static noinline int run_delalloc_nocow(struct inode *inode, | |||
1059 | u64 disk_bytenr; | 1123 | u64 disk_bytenr; |
1060 | u64 num_bytes; | 1124 | u64 num_bytes; |
1061 | int extent_type; | 1125 | int extent_type; |
1062 | int ret; | 1126 | int ret, err; |
1063 | int type; | 1127 | int type; |
1064 | int nocow; | 1128 | int nocow; |
1065 | int check_prev = 1; | 1129 | int check_prev = 1; |
@@ -1077,7 +1141,11 @@ static noinline int run_delalloc_nocow(struct inode *inode, | |||
1077 | else | 1141 | else |
1078 | trans = btrfs_join_transaction(root); | 1142 | trans = btrfs_join_transaction(root); |
1079 | 1143 | ||
1080 | BUG_ON(IS_ERR(trans)); | 1144 | if (IS_ERR(trans)) { |
1145 | btrfs_free_path(path); | ||
1146 | return PTR_ERR(trans); | ||
1147 | } | ||
1148 | |||
1081 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; | 1149 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; |
1082 | 1150 | ||
1083 | cow_start = (u64)-1; | 1151 | cow_start = (u64)-1; |
@@ -1085,7 +1153,10 @@ static noinline int run_delalloc_nocow(struct inode *inode, | |||
1085 | while (1) { | 1153 | while (1) { |
1086 | ret = btrfs_lookup_file_extent(trans, root, path, ino, | 1154 | ret = btrfs_lookup_file_extent(trans, root, path, ino, |
1087 | cur_offset, 0); | 1155 | cur_offset, 0); |
1088 | BUG_ON(ret < 0); | 1156 | if (ret < 0) { |
1157 | btrfs_abort_transaction(trans, root, ret); | ||
1158 | goto error; | ||
1159 | } | ||
1089 | if (ret > 0 && path->slots[0] > 0 && check_prev) { | 1160 | if (ret > 0 && path->slots[0] > 0 && check_prev) { |
1090 | leaf = path->nodes[0]; | 1161 | leaf = path->nodes[0]; |
1091 | btrfs_item_key_to_cpu(leaf, &found_key, | 1162 | btrfs_item_key_to_cpu(leaf, &found_key, |
@@ -1099,8 +1170,10 @@ next_slot: | |||
1099 | leaf = path->nodes[0]; | 1170 | leaf = path->nodes[0]; |
1100 | if (path->slots[0] >= btrfs_header_nritems(leaf)) { | 1171 | if (path->slots[0] >= btrfs_header_nritems(leaf)) { |
1101 | ret = btrfs_next_leaf(root, path); | 1172 | ret = btrfs_next_leaf(root, path); |
1102 | if (ret < 0) | 1173 | if (ret < 0) { |
1103 | BUG_ON(1); | 1174 | btrfs_abort_transaction(trans, root, ret); |
1175 | goto error; | ||
1176 | } | ||
1104 | if (ret > 0) | 1177 | if (ret > 0) |
1105 | break; | 1178 | break; |
1106 | leaf = path->nodes[0]; | 1179 | leaf = path->nodes[0]; |
@@ -1188,7 +1261,10 @@ out_check: | |||
1188 | ret = cow_file_range(inode, locked_page, cow_start, | 1261 | ret = cow_file_range(inode, locked_page, cow_start, |
1189 | found_key.offset - 1, page_started, | 1262 | found_key.offset - 1, page_started, |
1190 | nr_written, 1); | 1263 | nr_written, 1); |
1191 | BUG_ON(ret); | 1264 | if (ret) { |
1265 | btrfs_abort_transaction(trans, root, ret); | ||
1266 | goto error; | ||
1267 | } | ||
1192 | cow_start = (u64)-1; | 1268 | cow_start = (u64)-1; |
1193 | } | 1269 | } |
1194 | 1270 | ||
@@ -1197,7 +1273,7 @@ out_check: | |||
1197 | struct extent_map_tree *em_tree; | 1273 | struct extent_map_tree *em_tree; |
1198 | em_tree = &BTRFS_I(inode)->extent_tree; | 1274 | em_tree = &BTRFS_I(inode)->extent_tree; |
1199 | em = alloc_extent_map(); | 1275 | em = alloc_extent_map(); |
1200 | BUG_ON(!em); | 1276 | BUG_ON(!em); /* -ENOMEM */ |
1201 | em->start = cur_offset; | 1277 | em->start = cur_offset; |
1202 | em->orig_start = em->start; | 1278 | em->orig_start = em->start; |
1203 | em->len = num_bytes; | 1279 | em->len = num_bytes; |
@@ -1223,13 +1299,16 @@ out_check: | |||
1223 | 1299 | ||
1224 | ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr, | 1300 | ret = btrfs_add_ordered_extent(inode, cur_offset, disk_bytenr, |
1225 | num_bytes, num_bytes, type); | 1301 | num_bytes, num_bytes, type); |
1226 | BUG_ON(ret); | 1302 | BUG_ON(ret); /* -ENOMEM */ |
1227 | 1303 | ||
1228 | if (root->root_key.objectid == | 1304 | if (root->root_key.objectid == |
1229 | BTRFS_DATA_RELOC_TREE_OBJECTID) { | 1305 | BTRFS_DATA_RELOC_TREE_OBJECTID) { |
1230 | ret = btrfs_reloc_clone_csums(inode, cur_offset, | 1306 | ret = btrfs_reloc_clone_csums(inode, cur_offset, |
1231 | num_bytes); | 1307 | num_bytes); |
1232 | BUG_ON(ret); | 1308 | if (ret) { |
1309 | btrfs_abort_transaction(trans, root, ret); | ||
1310 | goto error; | ||
1311 | } | ||
1233 | } | 1312 | } |
1234 | 1313 | ||
1235 | extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree, | 1314 | extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree, |
@@ -1248,18 +1327,23 @@ out_check: | |||
1248 | if (cow_start != (u64)-1) { | 1327 | if (cow_start != (u64)-1) { |
1249 | ret = cow_file_range(inode, locked_page, cow_start, end, | 1328 | ret = cow_file_range(inode, locked_page, cow_start, end, |
1250 | page_started, nr_written, 1); | 1329 | page_started, nr_written, 1); |
1251 | BUG_ON(ret); | 1330 | if (ret) { |
1331 | btrfs_abort_transaction(trans, root, ret); | ||
1332 | goto error; | ||
1333 | } | ||
1252 | } | 1334 | } |
1253 | 1335 | ||
1336 | error: | ||
1254 | if (nolock) { | 1337 | if (nolock) { |
1255 | ret = btrfs_end_transaction_nolock(trans, root); | 1338 | err = btrfs_end_transaction_nolock(trans, root); |
1256 | BUG_ON(ret); | ||
1257 | } else { | 1339 | } else { |
1258 | ret = btrfs_end_transaction(trans, root); | 1340 | err = btrfs_end_transaction(trans, root); |
1259 | BUG_ON(ret); | ||
1260 | } | 1341 | } |
1342 | if (!ret) | ||
1343 | ret = err; | ||
1344 | |||
1261 | btrfs_free_path(path); | 1345 | btrfs_free_path(path); |
1262 | return 0; | 1346 | return ret; |
1263 | } | 1347 | } |
1264 | 1348 | ||
1265 | /* | 1349 | /* |
@@ -1424,10 +1508,11 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset, | |||
1424 | map_length = length; | 1508 | map_length = length; |
1425 | ret = btrfs_map_block(map_tree, READ, logical, | 1509 | ret = btrfs_map_block(map_tree, READ, logical, |
1426 | &map_length, NULL, 0); | 1510 | &map_length, NULL, 0); |
1427 | 1511 | /* Will always return 0 or 1 with map_multi == NULL */ | |
1512 | BUG_ON(ret < 0); | ||
1428 | if (map_length < length + size) | 1513 | if (map_length < length + size) |
1429 | return 1; | 1514 | return 1; |
1430 | return ret; | 1515 | return 0; |
1431 | } | 1516 | } |
1432 | 1517 | ||
1433 | /* | 1518 | /* |
@@ -1447,7 +1532,7 @@ static int __btrfs_submit_bio_start(struct inode *inode, int rw, | |||
1447 | int ret = 0; | 1532 | int ret = 0; |
1448 | 1533 | ||
1449 | ret = btrfs_csum_one_bio(root, inode, bio, 0, 0); | 1534 | ret = btrfs_csum_one_bio(root, inode, bio, 0, 0); |
1450 | BUG_ON(ret); | 1535 | BUG_ON(ret); /* -ENOMEM */ |
1451 | return 0; | 1536 | return 0; |
1452 | } | 1537 | } |
1453 | 1538 | ||
@@ -1478,14 +1563,16 @@ static int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio, | |||
1478 | struct btrfs_root *root = BTRFS_I(inode)->root; | 1563 | struct btrfs_root *root = BTRFS_I(inode)->root; |
1479 | int ret = 0; | 1564 | int ret = 0; |
1480 | int skip_sum; | 1565 | int skip_sum; |
1566 | int metadata = 0; | ||
1481 | 1567 | ||
1482 | skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM; | 1568 | skip_sum = BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM; |
1483 | 1569 | ||
1484 | if (btrfs_is_free_space_inode(root, inode)) | 1570 | if (btrfs_is_free_space_inode(root, inode)) |
1485 | ret = btrfs_bio_wq_end_io(root->fs_info, bio, 2); | 1571 | metadata = 2; |
1486 | else | 1572 | |
1487 | ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0); | 1573 | ret = btrfs_bio_wq_end_io(root->fs_info, bio, metadata); |
1488 | BUG_ON(ret); | 1574 | if (ret) |
1575 | return ret; | ||
1489 | 1576 | ||
1490 | if (!(rw & REQ_WRITE)) { | 1577 | if (!(rw & REQ_WRITE)) { |
1491 | if (bio_flags & EXTENT_BIO_COMPRESSED) { | 1578 | if (bio_flags & EXTENT_BIO_COMPRESSED) { |
@@ -1570,7 +1657,7 @@ again: | |||
1570 | page_end = page_offset(page) + PAGE_CACHE_SIZE - 1; | 1657 | page_end = page_offset(page) + PAGE_CACHE_SIZE - 1; |
1571 | 1658 | ||
1572 | lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0, | 1659 | lock_extent_bits(&BTRFS_I(inode)->io_tree, page_start, page_end, 0, |
1573 | &cached_state, GFP_NOFS); | 1660 | &cached_state); |
1574 | 1661 | ||
1575 | /* already ordered? We're done */ | 1662 | /* already ordered? We're done */ |
1576 | if (PagePrivate2(page)) | 1663 | if (PagePrivate2(page)) |
@@ -1674,13 +1761,15 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans, | |||
1674 | */ | 1761 | */ |
1675 | ret = btrfs_drop_extents(trans, inode, file_pos, file_pos + num_bytes, | 1762 | ret = btrfs_drop_extents(trans, inode, file_pos, file_pos + num_bytes, |
1676 | &hint, 0); | 1763 | &hint, 0); |
1677 | BUG_ON(ret); | 1764 | if (ret) |
1765 | goto out; | ||
1678 | 1766 | ||
1679 | ins.objectid = btrfs_ino(inode); | 1767 | ins.objectid = btrfs_ino(inode); |
1680 | ins.offset = file_pos; | 1768 | ins.offset = file_pos; |
1681 | ins.type = BTRFS_EXTENT_DATA_KEY; | 1769 | ins.type = BTRFS_EXTENT_DATA_KEY; |
1682 | ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi)); | 1770 | ret = btrfs_insert_empty_item(trans, root, path, &ins, sizeof(*fi)); |
1683 | BUG_ON(ret); | 1771 | if (ret) |
1772 | goto out; | ||
1684 | leaf = path->nodes[0]; | 1773 | leaf = path->nodes[0]; |
1685 | fi = btrfs_item_ptr(leaf, path->slots[0], | 1774 | fi = btrfs_item_ptr(leaf, path->slots[0], |
1686 | struct btrfs_file_extent_item); | 1775 | struct btrfs_file_extent_item); |
@@ -1708,10 +1797,10 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans, | |||
1708 | ret = btrfs_alloc_reserved_file_extent(trans, root, | 1797 | ret = btrfs_alloc_reserved_file_extent(trans, root, |
1709 | root->root_key.objectid, | 1798 | root->root_key.objectid, |
1710 | btrfs_ino(inode), file_pos, &ins); | 1799 | btrfs_ino(inode), file_pos, &ins); |
1711 | BUG_ON(ret); | 1800 | out: |
1712 | btrfs_free_path(path); | 1801 | btrfs_free_path(path); |
1713 | 1802 | ||
1714 | return 0; | 1803 | return ret; |
1715 | } | 1804 | } |
1716 | 1805 | ||
1717 | /* | 1806 | /* |
@@ -1739,35 +1828,41 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end) | |||
1739 | end - start + 1); | 1828 | end - start + 1); |
1740 | if (!ret) | 1829 | if (!ret) |
1741 | return 0; | 1830 | return 0; |
1742 | BUG_ON(!ordered_extent); | 1831 | BUG_ON(!ordered_extent); /* Logic error */ |
1743 | 1832 | ||
1744 | nolock = btrfs_is_free_space_inode(root, inode); | 1833 | nolock = btrfs_is_free_space_inode(root, inode); |
1745 | 1834 | ||
1746 | if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) { | 1835 | if (test_bit(BTRFS_ORDERED_NOCOW, &ordered_extent->flags)) { |
1747 | BUG_ON(!list_empty(&ordered_extent->list)); | 1836 | BUG_ON(!list_empty(&ordered_extent->list)); /* Logic error */ |
1748 | ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent); | 1837 | ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent); |
1749 | if (!ret) { | 1838 | if (!ret) { |
1750 | if (nolock) | 1839 | if (nolock) |
1751 | trans = btrfs_join_transaction_nolock(root); | 1840 | trans = btrfs_join_transaction_nolock(root); |
1752 | else | 1841 | else |
1753 | trans = btrfs_join_transaction(root); | 1842 | trans = btrfs_join_transaction(root); |
1754 | BUG_ON(IS_ERR(trans)); | 1843 | if (IS_ERR(trans)) |
1844 | return PTR_ERR(trans); | ||
1755 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; | 1845 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; |
1756 | ret = btrfs_update_inode_fallback(trans, root, inode); | 1846 | ret = btrfs_update_inode_fallback(trans, root, inode); |
1757 | BUG_ON(ret); | 1847 | if (ret) /* -ENOMEM or corruption */ |
1848 | btrfs_abort_transaction(trans, root, ret); | ||
1758 | } | 1849 | } |
1759 | goto out; | 1850 | goto out; |
1760 | } | 1851 | } |
1761 | 1852 | ||
1762 | lock_extent_bits(io_tree, ordered_extent->file_offset, | 1853 | lock_extent_bits(io_tree, ordered_extent->file_offset, |
1763 | ordered_extent->file_offset + ordered_extent->len - 1, | 1854 | ordered_extent->file_offset + ordered_extent->len - 1, |
1764 | 0, &cached_state, GFP_NOFS); | 1855 | 0, &cached_state); |
1765 | 1856 | ||
1766 | if (nolock) | 1857 | if (nolock) |
1767 | trans = btrfs_join_transaction_nolock(root); | 1858 | trans = btrfs_join_transaction_nolock(root); |
1768 | else | 1859 | else |
1769 | trans = btrfs_join_transaction(root); | 1860 | trans = btrfs_join_transaction(root); |
1770 | BUG_ON(IS_ERR(trans)); | 1861 | if (IS_ERR(trans)) { |
1862 | ret = PTR_ERR(trans); | ||
1863 | trans = NULL; | ||
1864 | goto out_unlock; | ||
1865 | } | ||
1771 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; | 1866 | trans->block_rsv = &root->fs_info->delalloc_block_rsv; |
1772 | 1867 | ||
1773 | if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags)) | 1868 | if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags)) |
@@ -1778,7 +1873,6 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end) | |||
1778 | ordered_extent->file_offset, | 1873 | ordered_extent->file_offset, |
1779 | ordered_extent->file_offset + | 1874 | ordered_extent->file_offset + |
1780 | ordered_extent->len); | 1875 | ordered_extent->len); |
1781 | BUG_ON(ret); | ||
1782 | } else { | 1876 | } else { |
1783 | BUG_ON(root == root->fs_info->tree_root); | 1877 | BUG_ON(root == root->fs_info->tree_root); |
1784 | ret = insert_reserved_file_extent(trans, inode, | 1878 | ret = insert_reserved_file_extent(trans, inode, |
@@ -1792,11 +1886,14 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end) | |||
1792 | unpin_extent_cache(&BTRFS_I(inode)->extent_tree, | 1886 | unpin_extent_cache(&BTRFS_I(inode)->extent_tree, |
1793 | ordered_extent->file_offset, | 1887 | ordered_extent->file_offset, |
1794 | ordered_extent->len); | 1888 | ordered_extent->len); |
1795 | BUG_ON(ret); | ||
1796 | } | 1889 | } |
1797 | unlock_extent_cached(io_tree, ordered_extent->file_offset, | 1890 | unlock_extent_cached(io_tree, ordered_extent->file_offset, |
1798 | ordered_extent->file_offset + | 1891 | ordered_extent->file_offset + |
1799 | ordered_extent->len - 1, &cached_state, GFP_NOFS); | 1892 | ordered_extent->len - 1, &cached_state, GFP_NOFS); |
1893 | if (ret < 0) { | ||
1894 | btrfs_abort_transaction(trans, root, ret); | ||
1895 | goto out; | ||
1896 | } | ||
1800 | 1897 | ||
1801 | add_pending_csums(trans, inode, ordered_extent->file_offset, | 1898 | add_pending_csums(trans, inode, ordered_extent->file_offset, |
1802 | &ordered_extent->list); | 1899 | &ordered_extent->list); |
@@ -1804,7 +1901,10 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end) | |||
1804 | ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent); | 1901 | ret = btrfs_ordered_update_i_size(inode, 0, ordered_extent); |
1805 | if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { | 1902 | if (!ret || !test_bit(BTRFS_ORDERED_PREALLOC, &ordered_extent->flags)) { |
1806 | ret = btrfs_update_inode_fallback(trans, root, inode); | 1903 | ret = btrfs_update_inode_fallback(trans, root, inode); |
1807 | BUG_ON(ret); | 1904 | if (ret) { /* -ENOMEM or corruption */ |
1905 | btrfs_abort_transaction(trans, root, ret); | ||
1906 | goto out; | ||
1907 | } | ||
1808 | } | 1908 | } |
1809 | ret = 0; | 1909 | ret = 0; |
1810 | out: | 1910 | out: |
@@ -1823,6 +1923,11 @@ out: | |||
1823 | btrfs_put_ordered_extent(ordered_extent); | 1923 | btrfs_put_ordered_extent(ordered_extent); |
1824 | 1924 | ||
1825 | return 0; | 1925 | return 0; |
1926 | out_unlock: | ||
1927 | unlock_extent_cached(io_tree, ordered_extent->file_offset, | ||
1928 | ordered_extent->file_offset + | ||
1929 | ordered_extent->len - 1, &cached_state, GFP_NOFS); | ||
1930 | goto out; | ||
1826 | } | 1931 | } |
1827 | 1932 | ||
1828 | static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end, | 1933 | static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end, |
@@ -1904,6 +2009,8 @@ struct delayed_iput { | |||
1904 | struct inode *inode; | 2009 | struct inode *inode; |
1905 | }; | 2010 | }; |
1906 | 2011 | ||
2012 | /* JDM: If this is fs-wide, why can't we add a pointer to | ||
2013 | * btrfs_inode instead and avoid the allocation? */ | ||
1907 | void btrfs_add_delayed_iput(struct inode *inode) | 2014 | void btrfs_add_delayed_iput(struct inode *inode) |
1908 | { | 2015 | { |
1909 | struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; | 2016 | struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info; |
@@ -2050,20 +2157,27 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode) | |||
2050 | /* grab metadata reservation from transaction handle */ | 2157 | /* grab metadata reservation from transaction handle */ |
2051 | if (reserve) { | 2158 | if (reserve) { |
2052 | ret = btrfs_orphan_reserve_metadata(trans, inode); | 2159 | ret = btrfs_orphan_reserve_metadata(trans, inode); |
2053 | BUG_ON(ret); | 2160 | BUG_ON(ret); /* -ENOSPC in reservation; Logic error? JDM */ |
2054 | } | 2161 | } |
2055 | 2162 | ||
2056 | /* insert an orphan item to track this unlinked/truncated file */ | 2163 | /* insert an orphan item to track this unlinked/truncated file */ |
2057 | if (insert >= 1) { | 2164 | if (insert >= 1) { |
2058 | ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode)); | 2165 | ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(inode)); |
2059 | BUG_ON(ret && ret != -EEXIST); | 2166 | if (ret && ret != -EEXIST) { |
2167 | btrfs_abort_transaction(trans, root, ret); | ||
2168 | return ret; | ||
2169 | } | ||
2170 | ret = 0; | ||
2060 | } | 2171 | } |
2061 | 2172 | ||
2062 | /* insert an orphan item to track subvolume contains orphan files */ | 2173 | /* insert an orphan item to track subvolume contains orphan files */ |
2063 | if (insert >= 2) { | 2174 | if (insert >= 2) { |
2064 | ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root, | 2175 | ret = btrfs_insert_orphan_item(trans, root->fs_info->tree_root, |
2065 | root->root_key.objectid); | 2176 | root->root_key.objectid); |
2066 | BUG_ON(ret); | 2177 | if (ret && ret != -EEXIST) { |
2178 | btrfs_abort_transaction(trans, root, ret); | ||
2179 | return ret; | ||
2180 | } | ||
2067 | } | 2181 | } |
2068 | return 0; | 2182 | return 0; |
2069 | } | 2183 | } |
@@ -2093,7 +2207,7 @@ int btrfs_orphan_del(struct btrfs_trans_handle *trans, struct inode *inode) | |||
2093 | 2207 | ||
2094 | if (trans && delete_item) { | 2208 | if (trans && delete_item) { |
2095 | ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode)); | 2209 | ret = btrfs_del_orphan_item(trans, root, btrfs_ino(inode)); |
2096 | BUG_ON(ret); | 2210 | BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */ |
2097 | } | 2211 | } |
2098 | 2212 | ||
2099 | if (release_rsv) | 2213 | if (release_rsv) |
@@ -2227,7 +2341,7 @@ int btrfs_orphan_cleanup(struct btrfs_root *root) | |||
2227 | } | 2341 | } |
2228 | ret = btrfs_del_orphan_item(trans, root, | 2342 | ret = btrfs_del_orphan_item(trans, root, |
2229 | found_key.objectid); | 2343 | found_key.objectid); |
2230 | BUG_ON(ret); | 2344 | BUG_ON(ret); /* -ENOMEM or corruption (JDM: Recheck) */ |
2231 | btrfs_end_transaction(trans, root); | 2345 | btrfs_end_transaction(trans, root); |
2232 | continue; | 2346 | continue; |
2233 | } | 2347 | } |
@@ -2609,16 +2723,22 @@ static int __btrfs_unlink_inode(struct btrfs_trans_handle *trans, | |||
2609 | printk(KERN_INFO "btrfs failed to delete reference to %.*s, " | 2723 | printk(KERN_INFO "btrfs failed to delete reference to %.*s, " |
2610 | "inode %llu parent %llu\n", name_len, name, | 2724 | "inode %llu parent %llu\n", name_len, name, |
2611 | (unsigned long long)ino, (unsigned long long)dir_ino); | 2725 | (unsigned long long)ino, (unsigned long long)dir_ino); |
2726 | btrfs_abort_transaction(trans, root, ret); | ||
2612 | goto err; | 2727 | goto err; |
2613 | } | 2728 | } |
2614 | 2729 | ||
2615 | ret = btrfs_delete_delayed_dir_index(trans, root, dir, index); | 2730 | ret = btrfs_delete_delayed_dir_index(trans, root, dir, index); |
2616 | if (ret) | 2731 | if (ret) { |
2732 | btrfs_abort_transaction(trans, root, ret); | ||
2617 | goto err; | 2733 | goto err; |
2734 | } | ||
2618 | 2735 | ||
2619 | ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len, | 2736 | ret = btrfs_del_inode_ref_in_log(trans, root, name, name_len, |
2620 | inode, dir_ino); | 2737 | inode, dir_ino); |
2621 | BUG_ON(ret != 0 && ret != -ENOENT); | 2738 | if (ret != 0 && ret != -ENOENT) { |
2739 | btrfs_abort_transaction(trans, root, ret); | ||
2740 | goto err; | ||
2741 | } | ||
2622 | 2742 | ||
2623 | ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len, | 2743 | ret = btrfs_del_dir_entries_in_log(trans, root, name, name_len, |
2624 | dir, index); | 2744 | dir, index); |
@@ -2776,7 +2896,7 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir, | |||
2776 | err = ret; | 2896 | err = ret; |
2777 | goto out; | 2897 | goto out; |
2778 | } | 2898 | } |
2779 | BUG_ON(ret == 0); | 2899 | BUG_ON(ret == 0); /* Corruption */ |
2780 | if (check_path_shared(root, path)) | 2900 | if (check_path_shared(root, path)) |
2781 | goto out; | 2901 | goto out; |
2782 | btrfs_release_path(path); | 2902 | btrfs_release_path(path); |
@@ -2809,7 +2929,7 @@ static struct btrfs_trans_handle *__unlink_start_trans(struct inode *dir, | |||
2809 | err = PTR_ERR(ref); | 2929 | err = PTR_ERR(ref); |
2810 | goto out; | 2930 | goto out; |
2811 | } | 2931 | } |
2812 | BUG_ON(!ref); | 2932 | BUG_ON(!ref); /* Logic error */ |
2813 | if (check_path_shared(root, path)) | 2933 | if (check_path_shared(root, path)) |
2814 | goto out; | 2934 | goto out; |
2815 | index = btrfs_inode_ref_index(path->nodes[0], ref); | 2935 | index = btrfs_inode_ref_index(path->nodes[0], ref); |
@@ -2916,23 +3036,42 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans, | |||
2916 | 3036 | ||
2917 | di = btrfs_lookup_dir_item(trans, root, path, dir_ino, | 3037 | di = btrfs_lookup_dir_item(trans, root, path, dir_ino, |
2918 | name, name_len, -1); | 3038 | name, name_len, -1); |
2919 | BUG_ON(IS_ERR_OR_NULL(di)); | 3039 | if (IS_ERR_OR_NULL(di)) { |
3040 | if (!di) | ||
3041 | ret = -ENOENT; | ||
3042 | else | ||
3043 | ret = PTR_ERR(di); | ||
3044 | goto out; | ||
3045 | } | ||
2920 | 3046 | ||
2921 | leaf = path->nodes[0]; | 3047 | leaf = path->nodes[0]; |
2922 | btrfs_dir_item_key_to_cpu(leaf, di, &key); | 3048 | btrfs_dir_item_key_to_cpu(leaf, di, &key); |
2923 | WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid); | 3049 | WARN_ON(key.type != BTRFS_ROOT_ITEM_KEY || key.objectid != objectid); |
2924 | ret = btrfs_delete_one_dir_name(trans, root, path, di); | 3050 | ret = btrfs_delete_one_dir_name(trans, root, path, di); |
2925 | BUG_ON(ret); | 3051 | if (ret) { |
3052 | btrfs_abort_transaction(trans, root, ret); | ||
3053 | goto out; | ||
3054 | } | ||
2926 | btrfs_release_path(path); | 3055 | btrfs_release_path(path); |
2927 | 3056 | ||
2928 | ret = btrfs_del_root_ref(trans, root->fs_info->tree_root, | 3057 | ret = btrfs_del_root_ref(trans, root->fs_info->tree_root, |
2929 | objectid, root->root_key.objectid, | 3058 | objectid, root->root_key.objectid, |
2930 | dir_ino, &index, name, name_len); | 3059 | dir_ino, &index, name, name_len); |
2931 | if (ret < 0) { | 3060 | if (ret < 0) { |
2932 | BUG_ON(ret != -ENOENT); | 3061 | if (ret != -ENOENT) { |
3062 | btrfs_abort_transaction(trans, root, ret); | ||
3063 | goto out; | ||
3064 | } | ||
2933 | di = btrfs_search_dir_index_item(root, path, dir_ino, | 3065 | di = btrfs_search_dir_index_item(root, path, dir_ino, |
2934 | name, name_len); | 3066 | name, name_len); |
2935 | BUG_ON(IS_ERR_OR_NULL(di)); | 3067 | if (IS_ERR_OR_NULL(di)) { |
3068 | if (!di) | ||
3069 | ret = -ENOENT; | ||
3070 | else | ||
3071 | ret = PTR_ERR(di); | ||
3072 | btrfs_abort_transaction(trans, root, ret); | ||
3073 | goto out; | ||
3074 | } | ||
2936 | 3075 | ||
2937 | leaf = path->nodes[0]; | 3076 | leaf = path->nodes[0]; |
2938 | btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); | 3077 | btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); |
@@ -2942,15 +3081,19 @@ int btrfs_unlink_subvol(struct btrfs_trans_handle *trans, | |||
2942 | btrfs_release_path(path); | 3081 | btrfs_release_path(path); |
2943 | 3082 | ||
2944 | ret = btrfs_delete_delayed_dir_index(trans, root, dir, index); | 3083 | ret = btrfs_delete_delayed_dir_index(trans, root, dir, index); |
2945 | BUG_ON(ret); | 3084 | if (ret) { |
3085 | btrfs_abort_transaction(trans, root, ret); | ||
3086 | goto out; | ||
3087 | } | ||
2946 | 3088 | ||
2947 | btrfs_i_size_write(dir, dir->i_size - name_len * 2); | 3089 | btrfs_i_size_write(dir, dir->i_size - name_len * 2); |
2948 | dir->i_mtime = dir->i_ctime = CURRENT_TIME; | 3090 | dir->i_mtime = dir->i_ctime = CURRENT_TIME; |
2949 | ret = btrfs_update_inode(trans, root, dir); | 3091 | ret = btrfs_update_inode(trans, root, dir); |
2950 | BUG_ON(ret); | 3092 | if (ret) |
2951 | 3093 | btrfs_abort_transaction(trans, root, ret); | |
3094 | out: | ||
2952 | btrfs_free_path(path); | 3095 | btrfs_free_path(path); |
2953 | return 0; | 3096 | return ret; |
2954 | } | 3097 | } |
2955 | 3098 | ||
2956 | static int btrfs_rmdir(struct inode *dir, struct dentry *dentry) | 3099 | static int btrfs_rmdir(struct inode *dir, struct dentry *dentry) |
@@ -3160,8 +3303,8 @@ search_again: | |||
3160 | } | 3303 | } |
3161 | size = | 3304 | size = |
3162 | btrfs_file_extent_calc_inline_size(size); | 3305 | btrfs_file_extent_calc_inline_size(size); |
3163 | ret = btrfs_truncate_item(trans, root, path, | 3306 | btrfs_truncate_item(trans, root, path, |
3164 | size, 1); | 3307 | size, 1); |
3165 | } else if (root->ref_cows) { | 3308 | } else if (root->ref_cows) { |
3166 | inode_sub_bytes(inode, item_end + 1 - | 3309 | inode_sub_bytes(inode, item_end + 1 - |
3167 | found_key.offset); | 3310 | found_key.offset); |
@@ -3209,7 +3352,11 @@ delete: | |||
3209 | ret = btrfs_del_items(trans, root, path, | 3352 | ret = btrfs_del_items(trans, root, path, |
3210 | pending_del_slot, | 3353 | pending_del_slot, |
3211 | pending_del_nr); | 3354 | pending_del_nr); |
3212 | BUG_ON(ret); | 3355 | if (ret) { |
3356 | btrfs_abort_transaction(trans, | ||
3357 | root, ret); | ||
3358 | goto error; | ||
3359 | } | ||
3213 | pending_del_nr = 0; | 3360 | pending_del_nr = 0; |
3214 | } | 3361 | } |
3215 | btrfs_release_path(path); | 3362 | btrfs_release_path(path); |
@@ -3222,8 +3369,10 @@ out: | |||
3222 | if (pending_del_nr) { | 3369 | if (pending_del_nr) { |
3223 | ret = btrfs_del_items(trans, root, path, pending_del_slot, | 3370 | ret = btrfs_del_items(trans, root, path, pending_del_slot, |
3224 | pending_del_nr); | 3371 | pending_del_nr); |
3225 | BUG_ON(ret); | 3372 | if (ret) |
3373 | btrfs_abort_transaction(trans, root, ret); | ||
3226 | } | 3374 | } |
3375 | error: | ||
3227 | btrfs_free_path(path); | 3376 | btrfs_free_path(path); |
3228 | return err; | 3377 | return err; |
3229 | } | 3378 | } |
@@ -3281,8 +3430,7 @@ again: | |||
3281 | } | 3430 | } |
3282 | wait_on_page_writeback(page); | 3431 | wait_on_page_writeback(page); |
3283 | 3432 | ||
3284 | lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state, | 3433 | lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state); |
3285 | GFP_NOFS); | ||
3286 | set_page_extent_mapped(page); | 3434 | set_page_extent_mapped(page); |
3287 | 3435 | ||
3288 | ordered = btrfs_lookup_ordered_extent(inode, page_start); | 3436 | ordered = btrfs_lookup_ordered_extent(inode, page_start); |
@@ -3358,7 +3506,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size) | |||
3358 | btrfs_wait_ordered_range(inode, hole_start, | 3506 | btrfs_wait_ordered_range(inode, hole_start, |
3359 | block_end - hole_start); | 3507 | block_end - hole_start); |
3360 | lock_extent_bits(io_tree, hole_start, block_end - 1, 0, | 3508 | lock_extent_bits(io_tree, hole_start, block_end - 1, 0, |
3361 | &cached_state, GFP_NOFS); | 3509 | &cached_state); |
3362 | ordered = btrfs_lookup_ordered_extent(inode, hole_start); | 3510 | ordered = btrfs_lookup_ordered_extent(inode, hole_start); |
3363 | if (!ordered) | 3511 | if (!ordered) |
3364 | break; | 3512 | break; |
@@ -3371,7 +3519,10 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size) | |||
3371 | while (1) { | 3519 | while (1) { |
3372 | em = btrfs_get_extent(inode, NULL, 0, cur_offset, | 3520 | em = btrfs_get_extent(inode, NULL, 0, cur_offset, |
3373 | block_end - cur_offset, 0); | 3521 | block_end - cur_offset, 0); |
3374 | BUG_ON(IS_ERR_OR_NULL(em)); | 3522 | if (IS_ERR(em)) { |
3523 | err = PTR_ERR(em); | ||
3524 | break; | ||
3525 | } | ||
3375 | last_byte = min(extent_map_end(em), block_end); | 3526 | last_byte = min(extent_map_end(em), block_end); |
3376 | last_byte = (last_byte + mask) & ~mask; | 3527 | last_byte = (last_byte + mask) & ~mask; |
3377 | if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) { | 3528 | if (!test_bit(EXTENT_FLAG_PREALLOC, &em->flags)) { |
@@ -3388,7 +3539,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size) | |||
3388 | cur_offset + hole_size, | 3539 | cur_offset + hole_size, |
3389 | &hint_byte, 1); | 3540 | &hint_byte, 1); |
3390 | if (err) { | 3541 | if (err) { |
3391 | btrfs_update_inode(trans, root, inode); | 3542 | btrfs_abort_transaction(trans, root, err); |
3392 | btrfs_end_transaction(trans, root); | 3543 | btrfs_end_transaction(trans, root); |
3393 | break; | 3544 | break; |
3394 | } | 3545 | } |
@@ -3398,7 +3549,7 @@ int btrfs_cont_expand(struct inode *inode, loff_t oldsize, loff_t size) | |||
3398 | 0, hole_size, 0, hole_size, | 3549 | 0, hole_size, 0, hole_size, |
3399 | 0, 0, 0); | 3550 | 0, 0, 0); |
3400 | if (err) { | 3551 | if (err) { |
3401 | btrfs_update_inode(trans, root, inode); | 3552 | btrfs_abort_transaction(trans, root, err); |
3402 | btrfs_end_transaction(trans, root); | 3553 | btrfs_end_transaction(trans, root); |
3403 | break; | 3554 | break; |
3404 | } | 3555 | } |
@@ -3778,7 +3929,7 @@ static void inode_tree_del(struct inode *inode) | |||
3778 | } | 3929 | } |
3779 | } | 3930 | } |
3780 | 3931 | ||
3781 | int btrfs_invalidate_inodes(struct btrfs_root *root) | 3932 | void btrfs_invalidate_inodes(struct btrfs_root *root) |
3782 | { | 3933 | { |
3783 | struct rb_node *node; | 3934 | struct rb_node *node; |
3784 | struct rb_node *prev; | 3935 | struct rb_node *prev; |
@@ -3838,7 +3989,6 @@ again: | |||
3838 | node = rb_next(node); | 3989 | node = rb_next(node); |
3839 | } | 3990 | } |
3840 | spin_unlock(&root->inode_lock); | 3991 | spin_unlock(&root->inode_lock); |
3841 | return 0; | ||
3842 | } | 3992 | } |
3843 | 3993 | ||
3844 | static int btrfs_init_locked_inode(struct inode *inode, void *p) | 3994 | static int btrfs_init_locked_inode(struct inode *inode, void *p) |
@@ -4580,18 +4730,26 @@ int btrfs_add_link(struct btrfs_trans_handle *trans, | |||
4580 | parent_ino, index); | 4730 | parent_ino, index); |
4581 | } | 4731 | } |
4582 | 4732 | ||
4583 | if (ret == 0) { | 4733 | /* Nothing to clean up yet */ |
4584 | ret = btrfs_insert_dir_item(trans, root, name, name_len, | 4734 | if (ret) |
4585 | parent_inode, &key, | 4735 | return ret; |
4586 | btrfs_inode_type(inode), index); | ||
4587 | if (ret) | ||
4588 | goto fail_dir_item; | ||
4589 | 4736 | ||
4590 | btrfs_i_size_write(parent_inode, parent_inode->i_size + | 4737 | ret = btrfs_insert_dir_item(trans, root, name, name_len, |
4591 | name_len * 2); | 4738 | parent_inode, &key, |
4592 | parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME; | 4739 | btrfs_inode_type(inode), index); |
4593 | ret = btrfs_update_inode(trans, root, parent_inode); | 4740 | if (ret == -EEXIST) |
4741 | goto fail_dir_item; | ||
4742 | else if (ret) { | ||
4743 | btrfs_abort_transaction(trans, root, ret); | ||
4744 | return ret; | ||
4594 | } | 4745 | } |
4746 | |||
4747 | btrfs_i_size_write(parent_inode, parent_inode->i_size + | ||
4748 | name_len * 2); | ||
4749 | parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME; | ||
4750 | ret = btrfs_update_inode(trans, root, parent_inode); | ||
4751 | if (ret) | ||
4752 | btrfs_abort_transaction(trans, root, ret); | ||
4595 | return ret; | 4753 | return ret; |
4596 | 4754 | ||
4597 | fail_dir_item: | 4755 | fail_dir_item: |
@@ -4805,7 +4963,8 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir, | |||
4805 | } else { | 4963 | } else { |
4806 | struct dentry *parent = dentry->d_parent; | 4964 | struct dentry *parent = dentry->d_parent; |
4807 | err = btrfs_update_inode(trans, root, inode); | 4965 | err = btrfs_update_inode(trans, root, inode); |
4808 | BUG_ON(err); | 4966 | if (err) |
4967 | goto fail; | ||
4809 | d_instantiate(dentry, inode); | 4968 | d_instantiate(dentry, inode); |
4810 | btrfs_log_new_name(trans, inode, NULL, parent); | 4969 | btrfs_log_new_name(trans, inode, NULL, parent); |
4811 | } | 4970 | } |
@@ -5136,7 +5295,7 @@ again: | |||
5136 | ret = uncompress_inline(path, inode, page, | 5295 | ret = uncompress_inline(path, inode, page, |
5137 | pg_offset, | 5296 | pg_offset, |
5138 | extent_offset, item); | 5297 | extent_offset, item); |
5139 | BUG_ON(ret); | 5298 | BUG_ON(ret); /* -ENOMEM */ |
5140 | } else { | 5299 | } else { |
5141 | map = kmap(page); | 5300 | map = kmap(page); |
5142 | read_extent_buffer(leaf, map + pg_offset, ptr, | 5301 | read_extent_buffer(leaf, map + pg_offset, ptr, |
@@ -5251,6 +5410,7 @@ out: | |||
5251 | free_extent_map(em); | 5410 | free_extent_map(em); |
5252 | return ERR_PTR(err); | 5411 | return ERR_PTR(err); |
5253 | } | 5412 | } |
5413 | BUG_ON(!em); /* Error is always set */ | ||
5254 | return em; | 5414 | return em; |
5255 | } | 5415 | } |
5256 | 5416 | ||
@@ -5601,7 +5761,7 @@ static int btrfs_get_blocks_direct(struct inode *inode, sector_t iblock, | |||
5601 | free_extent_map(em); | 5761 | free_extent_map(em); |
5602 | /* DIO will do one hole at a time, so just unlock a sector */ | 5762 | /* DIO will do one hole at a time, so just unlock a sector */ |
5603 | unlock_extent(&BTRFS_I(inode)->io_tree, start, | 5763 | unlock_extent(&BTRFS_I(inode)->io_tree, start, |
5604 | start + root->sectorsize - 1, GFP_NOFS); | 5764 | start + root->sectorsize - 1); |
5605 | return 0; | 5765 | return 0; |
5606 | } | 5766 | } |
5607 | 5767 | ||
@@ -5742,7 +5902,7 @@ static void btrfs_endio_direct_read(struct bio *bio, int err) | |||
5742 | } while (bvec <= bvec_end); | 5902 | } while (bvec <= bvec_end); |
5743 | 5903 | ||
5744 | unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset, | 5904 | unlock_extent(&BTRFS_I(inode)->io_tree, dip->logical_offset, |
5745 | dip->logical_offset + dip->bytes - 1, GFP_NOFS); | 5905 | dip->logical_offset + dip->bytes - 1); |
5746 | bio->bi_private = dip->private; | 5906 | bio->bi_private = dip->private; |
5747 | 5907 | ||
5748 | kfree(dip->csums); | 5908 | kfree(dip->csums); |
@@ -5793,7 +5953,7 @@ again: | |||
5793 | 5953 | ||
5794 | lock_extent_bits(&BTRFS_I(inode)->io_tree, ordered->file_offset, | 5954 | lock_extent_bits(&BTRFS_I(inode)->io_tree, ordered->file_offset, |
5795 | ordered->file_offset + ordered->len - 1, 0, | 5955 | ordered->file_offset + ordered->len - 1, 0, |
5796 | &cached_state, GFP_NOFS); | 5956 | &cached_state); |
5797 | 5957 | ||
5798 | if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags)) { | 5958 | if (test_bit(BTRFS_ORDERED_PREALLOC, &ordered->flags)) { |
5799 | ret = btrfs_mark_extent_written(trans, inode, | 5959 | ret = btrfs_mark_extent_written(trans, inode, |
@@ -5867,7 +6027,7 @@ static int __btrfs_submit_bio_start_direct_io(struct inode *inode, int rw, | |||
5867 | int ret; | 6027 | int ret; |
5868 | struct btrfs_root *root = BTRFS_I(inode)->root; | 6028 | struct btrfs_root *root = BTRFS_I(inode)->root; |
5869 | ret = btrfs_csum_one_bio(root, inode, bio, offset, 1); | 6029 | ret = btrfs_csum_one_bio(root, inode, bio, offset, 1); |
5870 | BUG_ON(ret); | 6030 | BUG_ON(ret); /* -ENOMEM */ |
5871 | return 0; | 6031 | return 0; |
5872 | } | 6032 | } |
5873 | 6033 | ||
@@ -6208,7 +6368,7 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb, | |||
6208 | 6368 | ||
6209 | while (1) { | 6369 | while (1) { |
6210 | lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, | 6370 | lock_extent_bits(&BTRFS_I(inode)->io_tree, lockstart, lockend, |
6211 | 0, &cached_state, GFP_NOFS); | 6371 | 0, &cached_state); |
6212 | /* | 6372 | /* |
6213 | * We're concerned with the entire range that we're going to be | 6373 | * We're concerned with the entire range that we're going to be |
6214 | * doing DIO to, so we need to make sure theres no ordered | 6374 | * doing DIO to, so we need to make sure theres no ordered |
@@ -6232,7 +6392,7 @@ static ssize_t btrfs_direct_IO(int rw, struct kiocb *iocb, | |||
6232 | if (writing) { | 6392 | if (writing) { |
6233 | write_bits = EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING; | 6393 | write_bits = EXTENT_DELALLOC | EXTENT_DO_ACCOUNTING; |
6234 | ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend, | 6394 | ret = set_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, lockend, |
6235 | EXTENT_DELALLOC, 0, NULL, &cached_state, | 6395 | EXTENT_DELALLOC, NULL, &cached_state, |
6236 | GFP_NOFS); | 6396 | GFP_NOFS); |
6237 | if (ret) { | 6397 | if (ret) { |
6238 | clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, | 6398 | clear_extent_bit(&BTRFS_I(inode)->io_tree, lockstart, |
@@ -6362,8 +6522,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset) | |||
6362 | btrfs_releasepage(page, GFP_NOFS); | 6522 | btrfs_releasepage(page, GFP_NOFS); |
6363 | return; | 6523 | return; |
6364 | } | 6524 | } |
6365 | lock_extent_bits(tree, page_start, page_end, 0, &cached_state, | 6525 | lock_extent_bits(tree, page_start, page_end, 0, &cached_state); |
6366 | GFP_NOFS); | ||
6367 | ordered = btrfs_lookup_ordered_extent(page->mapping->host, | 6526 | ordered = btrfs_lookup_ordered_extent(page->mapping->host, |
6368 | page_offset(page)); | 6527 | page_offset(page)); |
6369 | if (ordered) { | 6528 | if (ordered) { |
@@ -6385,8 +6544,7 @@ static void btrfs_invalidatepage(struct page *page, unsigned long offset) | |||
6385 | } | 6544 | } |
6386 | btrfs_put_ordered_extent(ordered); | 6545 | btrfs_put_ordered_extent(ordered); |
6387 | cached_state = NULL; | 6546 | cached_state = NULL; |
6388 | lock_extent_bits(tree, page_start, page_end, 0, &cached_state, | 6547 | lock_extent_bits(tree, page_start, page_end, 0, &cached_state); |
6389 | GFP_NOFS); | ||
6390 | } | 6548 | } |
6391 | clear_extent_bit(tree, page_start, page_end, | 6549 | clear_extent_bit(tree, page_start, page_end, |
6392 | EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC | | 6550 | EXTENT_LOCKED | EXTENT_DIRTY | EXTENT_DELALLOC | |
@@ -6461,8 +6619,7 @@ again: | |||
6461 | } | 6619 | } |
6462 | wait_on_page_writeback(page); | 6620 | wait_on_page_writeback(page); |
6463 | 6621 | ||
6464 | lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state, | 6622 | lock_extent_bits(io_tree, page_start, page_end, 0, &cached_state); |
6465 | GFP_NOFS); | ||
6466 | set_page_extent_mapped(page); | 6623 | set_page_extent_mapped(page); |
6467 | 6624 | ||
6468 | /* | 6625 | /* |
@@ -6736,10 +6893,9 @@ int btrfs_create_subvol_root(struct btrfs_trans_handle *trans, | |||
6736 | btrfs_i_size_write(inode, 0); | 6893 | btrfs_i_size_write(inode, 0); |
6737 | 6894 | ||
6738 | err = btrfs_update_inode(trans, new_root, inode); | 6895 | err = btrfs_update_inode(trans, new_root, inode); |
6739 | BUG_ON(err); | ||
6740 | 6896 | ||
6741 | iput(inode); | 6897 | iput(inode); |
6742 | return 0; | 6898 | return err; |
6743 | } | 6899 | } |
6744 | 6900 | ||
6745 | struct inode *btrfs_alloc_inode(struct super_block *sb) | 6901 | struct inode *btrfs_alloc_inode(struct super_block *sb) |
@@ -7073,7 +7229,10 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry, | |||
7073 | if (!ret) | 7229 | if (!ret) |
7074 | ret = btrfs_update_inode(trans, root, old_inode); | 7230 | ret = btrfs_update_inode(trans, root, old_inode); |
7075 | } | 7231 | } |
7076 | BUG_ON(ret); | 7232 | if (ret) { |
7233 | btrfs_abort_transaction(trans, root, ret); | ||
7234 | goto out_fail; | ||
7235 | } | ||
7077 | 7236 | ||
7078 | if (new_inode) { | 7237 | if (new_inode) { |
7079 | new_inode->i_ctime = CURRENT_TIME; | 7238 | new_inode->i_ctime = CURRENT_TIME; |
@@ -7091,11 +7250,14 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry, | |||
7091 | new_dentry->d_name.name, | 7250 | new_dentry->d_name.name, |
7092 | new_dentry->d_name.len); | 7251 | new_dentry->d_name.len); |
7093 | } | 7252 | } |
7094 | BUG_ON(ret); | 7253 | if (!ret && new_inode->i_nlink == 0) { |
7095 | if (new_inode->i_nlink == 0) { | ||
7096 | ret = btrfs_orphan_add(trans, new_dentry->d_inode); | 7254 | ret = btrfs_orphan_add(trans, new_dentry->d_inode); |
7097 | BUG_ON(ret); | 7255 | BUG_ON(ret); |
7098 | } | 7256 | } |
7257 | if (ret) { | ||
7258 | btrfs_abort_transaction(trans, root, ret); | ||
7259 | goto out_fail; | ||
7260 | } | ||
7099 | } | 7261 | } |
7100 | 7262 | ||
7101 | fixup_inode_flags(new_dir, old_inode); | 7263 | fixup_inode_flags(new_dir, old_inode); |
@@ -7103,7 +7265,10 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry, | |||
7103 | ret = btrfs_add_link(trans, new_dir, old_inode, | 7265 | ret = btrfs_add_link(trans, new_dir, old_inode, |
7104 | new_dentry->d_name.name, | 7266 | new_dentry->d_name.name, |
7105 | new_dentry->d_name.len, 0, index); | 7267 | new_dentry->d_name.len, 0, index); |
7106 | BUG_ON(ret); | 7268 | if (ret) { |
7269 | btrfs_abort_transaction(trans, root, ret); | ||
7270 | goto out_fail; | ||
7271 | } | ||
7107 | 7272 | ||
7108 | if (old_ino != BTRFS_FIRST_FREE_OBJECTID) { | 7273 | if (old_ino != BTRFS_FIRST_FREE_OBJECTID) { |
7109 | struct dentry *parent = new_dentry->d_parent; | 7274 | struct dentry *parent = new_dentry->d_parent; |
@@ -7328,7 +7493,12 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode, | |||
7328 | ins.offset, ins.offset, | 7493 | ins.offset, ins.offset, |
7329 | ins.offset, 0, 0, 0, | 7494 | ins.offset, 0, 0, 0, |
7330 | BTRFS_FILE_EXTENT_PREALLOC); | 7495 | BTRFS_FILE_EXTENT_PREALLOC); |
7331 | BUG_ON(ret); | 7496 | if (ret) { |
7497 | btrfs_abort_transaction(trans, root, ret); | ||
7498 | if (own_trans) | ||
7499 | btrfs_end_transaction(trans, root); | ||
7500 | break; | ||
7501 | } | ||
7332 | btrfs_drop_extent_cache(inode, cur_offset, | 7502 | btrfs_drop_extent_cache(inode, cur_offset, |
7333 | cur_offset + ins.offset -1, 0); | 7503 | cur_offset + ins.offset -1, 0); |
7334 | 7504 | ||
@@ -7350,7 +7520,13 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode, | |||
7350 | } | 7520 | } |
7351 | 7521 | ||
7352 | ret = btrfs_update_inode(trans, root, inode); | 7522 | ret = btrfs_update_inode(trans, root, inode); |
7353 | BUG_ON(ret); | 7523 | |
7524 | if (ret) { | ||
7525 | btrfs_abort_transaction(trans, root, ret); | ||
7526 | if (own_trans) | ||
7527 | btrfs_end_transaction(trans, root); | ||
7528 | break; | ||
7529 | } | ||
7354 | 7530 | ||
7355 | if (own_trans) | 7531 | if (own_trans) |
7356 | btrfs_end_transaction(trans, root); | 7532 | btrfs_end_transaction(trans, root); |
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c index d8b54715c2de..205809200714 100644 --- a/fs/btrfs/ioctl.c +++ b/fs/btrfs/ioctl.c | |||
@@ -425,22 +425,37 @@ static noinline int create_subvol(struct btrfs_root *root, | |||
425 | 425 | ||
426 | key.offset = (u64)-1; | 426 | key.offset = (u64)-1; |
427 | new_root = btrfs_read_fs_root_no_name(root->fs_info, &key); | 427 | new_root = btrfs_read_fs_root_no_name(root->fs_info, &key); |
428 | BUG_ON(IS_ERR(new_root)); | 428 | if (IS_ERR(new_root)) { |
429 | btrfs_abort_transaction(trans, root, PTR_ERR(new_root)); | ||
430 | ret = PTR_ERR(new_root); | ||
431 | goto fail; | ||
432 | } | ||
429 | 433 | ||
430 | btrfs_record_root_in_trans(trans, new_root); | 434 | btrfs_record_root_in_trans(trans, new_root); |
431 | 435 | ||
432 | ret = btrfs_create_subvol_root(trans, new_root, new_dirid); | 436 | ret = btrfs_create_subvol_root(trans, new_root, new_dirid); |
437 | if (ret) { | ||
438 | /* We potentially lose an unused inode item here */ | ||
439 | btrfs_abort_transaction(trans, root, ret); | ||
440 | goto fail; | ||
441 | } | ||
442 | |||
433 | /* | 443 | /* |
434 | * insert the directory item | 444 | * insert the directory item |
435 | */ | 445 | */ |
436 | ret = btrfs_set_inode_index(dir, &index); | 446 | ret = btrfs_set_inode_index(dir, &index); |
437 | BUG_ON(ret); | 447 | if (ret) { |
448 | btrfs_abort_transaction(trans, root, ret); | ||
449 | goto fail; | ||
450 | } | ||
438 | 451 | ||
439 | ret = btrfs_insert_dir_item(trans, root, | 452 | ret = btrfs_insert_dir_item(trans, root, |
440 | name, namelen, dir, &key, | 453 | name, namelen, dir, &key, |
441 | BTRFS_FT_DIR, index); | 454 | BTRFS_FT_DIR, index); |
442 | if (ret) | 455 | if (ret) { |
456 | btrfs_abort_transaction(trans, root, ret); | ||
443 | goto fail; | 457 | goto fail; |
458 | } | ||
444 | 459 | ||
445 | btrfs_i_size_write(dir, dir->i_size + namelen * 2); | 460 | btrfs_i_size_write(dir, dir->i_size + namelen * 2); |
446 | ret = btrfs_update_inode(trans, root, dir); | 461 | ret = btrfs_update_inode(trans, root, dir); |
@@ -797,9 +812,9 @@ static int should_defrag_range(struct inode *inode, u64 start, u64 len, | |||
797 | 812 | ||
798 | if (!em) { | 813 | if (!em) { |
799 | /* get the big lock and read metadata off disk */ | 814 | /* get the big lock and read metadata off disk */ |
800 | lock_extent(io_tree, start, start + len - 1, GFP_NOFS); | 815 | lock_extent(io_tree, start, start + len - 1); |
801 | em = btrfs_get_extent(inode, NULL, 0, start, len, 0); | 816 | em = btrfs_get_extent(inode, NULL, 0, start, len, 0); |
802 | unlock_extent(io_tree, start, start + len - 1, GFP_NOFS); | 817 | unlock_extent(io_tree, start, start + len - 1); |
803 | 818 | ||
804 | if (IS_ERR(em)) | 819 | if (IS_ERR(em)) |
805 | return 0; | 820 | return 0; |
@@ -887,10 +902,10 @@ again: | |||
887 | page_start = page_offset(page); | 902 | page_start = page_offset(page); |
888 | page_end = page_start + PAGE_CACHE_SIZE - 1; | 903 | page_end = page_start + PAGE_CACHE_SIZE - 1; |
889 | while (1) { | 904 | while (1) { |
890 | lock_extent(tree, page_start, page_end, GFP_NOFS); | 905 | lock_extent(tree, page_start, page_end); |
891 | ordered = btrfs_lookup_ordered_extent(inode, | 906 | ordered = btrfs_lookup_ordered_extent(inode, |
892 | page_start); | 907 | page_start); |
893 | unlock_extent(tree, page_start, page_end, GFP_NOFS); | 908 | unlock_extent(tree, page_start, page_end); |
894 | if (!ordered) | 909 | if (!ordered) |
895 | break; | 910 | break; |
896 | 911 | ||
@@ -946,8 +961,7 @@ again: | |||
946 | page_end = page_offset(pages[i_done - 1]) + PAGE_CACHE_SIZE; | 961 | page_end = page_offset(pages[i_done - 1]) + PAGE_CACHE_SIZE; |
947 | 962 | ||
948 | lock_extent_bits(&BTRFS_I(inode)->io_tree, | 963 | lock_extent_bits(&BTRFS_I(inode)->io_tree, |
949 | page_start, page_end - 1, 0, &cached_state, | 964 | page_start, page_end - 1, 0, &cached_state); |
950 | GFP_NOFS); | ||
951 | clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, | 965 | clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, |
952 | page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC | | 966 | page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC | |
953 | EXTENT_DO_ACCOUNTING, 0, 0, &cached_state, | 967 | EXTENT_DO_ACCOUNTING, 0, 0, &cached_state, |
@@ -1966,7 +1980,11 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file, | |||
1966 | dest->root_key.objectid, | 1980 | dest->root_key.objectid, |
1967 | dentry->d_name.name, | 1981 | dentry->d_name.name, |
1968 | dentry->d_name.len); | 1982 | dentry->d_name.len); |
1969 | BUG_ON(ret); | 1983 | if (ret) { |
1984 | err = ret; | ||
1985 | btrfs_abort_transaction(trans, root, ret); | ||
1986 | goto out_end_trans; | ||
1987 | } | ||
1970 | 1988 | ||
1971 | btrfs_record_root_in_trans(trans, dest); | 1989 | btrfs_record_root_in_trans(trans, dest); |
1972 | 1990 | ||
@@ -1979,11 +1997,16 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file, | |||
1979 | ret = btrfs_insert_orphan_item(trans, | 1997 | ret = btrfs_insert_orphan_item(trans, |
1980 | root->fs_info->tree_root, | 1998 | root->fs_info->tree_root, |
1981 | dest->root_key.objectid); | 1999 | dest->root_key.objectid); |
1982 | BUG_ON(ret); | 2000 | if (ret) { |
2001 | btrfs_abort_transaction(trans, root, ret); | ||
2002 | err = ret; | ||
2003 | goto out_end_trans; | ||
2004 | } | ||
1983 | } | 2005 | } |
1984 | 2006 | out_end_trans: | |
1985 | ret = btrfs_end_transaction(trans, root); | 2007 | ret = btrfs_end_transaction(trans, root); |
1986 | BUG_ON(ret); | 2008 | if (ret && !err) |
2009 | err = ret; | ||
1987 | inode->i_flags |= S_DEAD; | 2010 | inode->i_flags |= S_DEAD; |
1988 | out_up_write: | 2011 | out_up_write: |
1989 | up_write(&root->fs_info->subvol_sem); | 2012 | up_write(&root->fs_info->subvol_sem); |
@@ -2326,13 +2349,13 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd, | |||
2326 | another, and lock file content */ | 2349 | another, and lock file content */ |
2327 | while (1) { | 2350 | while (1) { |
2328 | struct btrfs_ordered_extent *ordered; | 2351 | struct btrfs_ordered_extent *ordered; |
2329 | lock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS); | 2352 | lock_extent(&BTRFS_I(src)->io_tree, off, off+len); |
2330 | ordered = btrfs_lookup_first_ordered_extent(src, off+len); | 2353 | ordered = btrfs_lookup_first_ordered_extent(src, off+len); |
2331 | if (!ordered && | 2354 | if (!ordered && |
2332 | !test_range_bit(&BTRFS_I(src)->io_tree, off, off+len, | 2355 | !test_range_bit(&BTRFS_I(src)->io_tree, off, off+len, |
2333 | EXTENT_DELALLOC, 0, NULL)) | 2356 | EXTENT_DELALLOC, 0, NULL)) |
2334 | break; | 2357 | break; |
2335 | unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS); | 2358 | unlock_extent(&BTRFS_I(src)->io_tree, off, off+len); |
2336 | if (ordered) | 2359 | if (ordered) |
2337 | btrfs_put_ordered_extent(ordered); | 2360 | btrfs_put_ordered_extent(ordered); |
2338 | btrfs_wait_ordered_range(src, off, len); | 2361 | btrfs_wait_ordered_range(src, off, len); |
@@ -2447,11 +2470,21 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd, | |||
2447 | new_key.offset, | 2470 | new_key.offset, |
2448 | new_key.offset + datal, | 2471 | new_key.offset + datal, |
2449 | &hint_byte, 1); | 2472 | &hint_byte, 1); |
2450 | BUG_ON(ret); | 2473 | if (ret) { |
2474 | btrfs_abort_transaction(trans, root, | ||
2475 | ret); | ||
2476 | btrfs_end_transaction(trans, root); | ||
2477 | goto out; | ||
2478 | } | ||
2451 | 2479 | ||
2452 | ret = btrfs_insert_empty_item(trans, root, path, | 2480 | ret = btrfs_insert_empty_item(trans, root, path, |
2453 | &new_key, size); | 2481 | &new_key, size); |
2454 | BUG_ON(ret); | 2482 | if (ret) { |
2483 | btrfs_abort_transaction(trans, root, | ||
2484 | ret); | ||
2485 | btrfs_end_transaction(trans, root); | ||
2486 | goto out; | ||
2487 | } | ||
2455 | 2488 | ||
2456 | leaf = path->nodes[0]; | 2489 | leaf = path->nodes[0]; |
2457 | slot = path->slots[0]; | 2490 | slot = path->slots[0]; |
@@ -2478,7 +2511,15 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd, | |||
2478 | btrfs_ino(inode), | 2511 | btrfs_ino(inode), |
2479 | new_key.offset - datao, | 2512 | new_key.offset - datao, |
2480 | 0); | 2513 | 0); |
2481 | BUG_ON(ret); | 2514 | if (ret) { |
2515 | btrfs_abort_transaction(trans, | ||
2516 | root, | ||
2517 | ret); | ||
2518 | btrfs_end_transaction(trans, | ||
2519 | root); | ||
2520 | goto out; | ||
2521 | |||
2522 | } | ||
2482 | } | 2523 | } |
2483 | } else if (type == BTRFS_FILE_EXTENT_INLINE) { | 2524 | } else if (type == BTRFS_FILE_EXTENT_INLINE) { |
2484 | u64 skip = 0; | 2525 | u64 skip = 0; |
@@ -2503,11 +2544,21 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd, | |||
2503 | new_key.offset, | 2544 | new_key.offset, |
2504 | new_key.offset + datal, | 2545 | new_key.offset + datal, |
2505 | &hint_byte, 1); | 2546 | &hint_byte, 1); |
2506 | BUG_ON(ret); | 2547 | if (ret) { |
2548 | btrfs_abort_transaction(trans, root, | ||
2549 | ret); | ||
2550 | btrfs_end_transaction(trans, root); | ||
2551 | goto out; | ||
2552 | } | ||
2507 | 2553 | ||
2508 | ret = btrfs_insert_empty_item(trans, root, path, | 2554 | ret = btrfs_insert_empty_item(trans, root, path, |
2509 | &new_key, size); | 2555 | &new_key, size); |
2510 | BUG_ON(ret); | 2556 | if (ret) { |
2557 | btrfs_abort_transaction(trans, root, | ||
2558 | ret); | ||
2559 | btrfs_end_transaction(trans, root); | ||
2560 | goto out; | ||
2561 | } | ||
2511 | 2562 | ||
2512 | if (skip) { | 2563 | if (skip) { |
2513 | u32 start = | 2564 | u32 start = |
@@ -2541,8 +2592,12 @@ static noinline long btrfs_ioctl_clone(struct file *file, unsigned long srcfd, | |||
2541 | btrfs_i_size_write(inode, endoff); | 2592 | btrfs_i_size_write(inode, endoff); |
2542 | 2593 | ||
2543 | ret = btrfs_update_inode(trans, root, inode); | 2594 | ret = btrfs_update_inode(trans, root, inode); |
2544 | BUG_ON(ret); | 2595 | if (ret) { |
2545 | btrfs_end_transaction(trans, root); | 2596 | btrfs_abort_transaction(trans, root, ret); |
2597 | btrfs_end_transaction(trans, root); | ||
2598 | goto out; | ||
2599 | } | ||
2600 | ret = btrfs_end_transaction(trans, root); | ||
2546 | } | 2601 | } |
2547 | next: | 2602 | next: |
2548 | btrfs_release_path(path); | 2603 | btrfs_release_path(path); |
@@ -2551,7 +2606,7 @@ next: | |||
2551 | ret = 0; | 2606 | ret = 0; |
2552 | out: | 2607 | out: |
2553 | btrfs_release_path(path); | 2608 | btrfs_release_path(path); |
2554 | unlock_extent(&BTRFS_I(src)->io_tree, off, off+len, GFP_NOFS); | 2609 | unlock_extent(&BTRFS_I(src)->io_tree, off, off+len); |
2555 | out_unlock: | 2610 | out_unlock: |
2556 | mutex_unlock(&src->i_mutex); | 2611 | mutex_unlock(&src->i_mutex); |
2557 | mutex_unlock(&inode->i_mutex); | 2612 | mutex_unlock(&inode->i_mutex); |
diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c index 5e178d8f7167..272f911203ff 100644 --- a/fs/btrfs/locking.c +++ b/fs/btrfs/locking.c | |||
@@ -208,7 +208,7 @@ void btrfs_tree_read_unlock_blocking(struct extent_buffer *eb) | |||
208 | * take a spinning write lock. This will wait for both | 208 | * take a spinning write lock. This will wait for both |
209 | * blocking readers or writers | 209 | * blocking readers or writers |
210 | */ | 210 | */ |
211 | int btrfs_tree_lock(struct extent_buffer *eb) | 211 | void btrfs_tree_lock(struct extent_buffer *eb) |
212 | { | 212 | { |
213 | again: | 213 | again: |
214 | wait_event(eb->read_lock_wq, atomic_read(&eb->blocking_readers) == 0); | 214 | wait_event(eb->read_lock_wq, atomic_read(&eb->blocking_readers) == 0); |
@@ -230,13 +230,12 @@ again: | |||
230 | atomic_inc(&eb->spinning_writers); | 230 | atomic_inc(&eb->spinning_writers); |
231 | atomic_inc(&eb->write_locks); | 231 | atomic_inc(&eb->write_locks); |
232 | eb->lock_owner = current->pid; | 232 | eb->lock_owner = current->pid; |
233 | return 0; | ||
234 | } | 233 | } |
235 | 234 | ||
236 | /* | 235 | /* |
237 | * drop a spinning or a blocking write lock. | 236 | * drop a spinning or a blocking write lock. |
238 | */ | 237 | */ |
239 | int btrfs_tree_unlock(struct extent_buffer *eb) | 238 | void btrfs_tree_unlock(struct extent_buffer *eb) |
240 | { | 239 | { |
241 | int blockers = atomic_read(&eb->blocking_writers); | 240 | int blockers = atomic_read(&eb->blocking_writers); |
242 | 241 | ||
@@ -255,7 +254,6 @@ int btrfs_tree_unlock(struct extent_buffer *eb) | |||
255 | atomic_dec(&eb->spinning_writers); | 254 | atomic_dec(&eb->spinning_writers); |
256 | write_unlock(&eb->lock); | 255 | write_unlock(&eb->lock); |
257 | } | 256 | } |
258 | return 0; | ||
259 | } | 257 | } |
260 | 258 | ||
261 | void btrfs_assert_tree_locked(struct extent_buffer *eb) | 259 | void btrfs_assert_tree_locked(struct extent_buffer *eb) |
diff --git a/fs/btrfs/locking.h b/fs/btrfs/locking.h index 17247ddb81a0..ca52681e5f40 100644 --- a/fs/btrfs/locking.h +++ b/fs/btrfs/locking.h | |||
@@ -24,8 +24,8 @@ | |||
24 | #define BTRFS_WRITE_LOCK_BLOCKING 3 | 24 | #define BTRFS_WRITE_LOCK_BLOCKING 3 |
25 | #define BTRFS_READ_LOCK_BLOCKING 4 | 25 | #define BTRFS_READ_LOCK_BLOCKING 4 |
26 | 26 | ||
27 | int btrfs_tree_lock(struct extent_buffer *eb); | 27 | void btrfs_tree_lock(struct extent_buffer *eb); |
28 | int btrfs_tree_unlock(struct extent_buffer *eb); | 28 | void btrfs_tree_unlock(struct extent_buffer *eb); |
29 | int btrfs_try_spin_lock(struct extent_buffer *eb); | 29 | int btrfs_try_spin_lock(struct extent_buffer *eb); |
30 | 30 | ||
31 | void btrfs_tree_read_lock(struct extent_buffer *eb); | 31 | void btrfs_tree_read_lock(struct extent_buffer *eb); |
diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c index a1c940425307..bbf6d0d9aebe 100644 --- a/fs/btrfs/ordered-data.c +++ b/fs/btrfs/ordered-data.c | |||
@@ -59,6 +59,14 @@ static struct rb_node *tree_insert(struct rb_root *root, u64 file_offset, | |||
59 | return NULL; | 59 | return NULL; |
60 | } | 60 | } |
61 | 61 | ||
62 | static void ordered_data_tree_panic(struct inode *inode, int errno, | ||
63 | u64 offset) | ||
64 | { | ||
65 | struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); | ||
66 | btrfs_panic(fs_info, errno, "Inconsistency in ordered tree at offset " | ||
67 | "%llu\n", (unsigned long long)offset); | ||
68 | } | ||
69 | |||
62 | /* | 70 | /* |
63 | * look for a given offset in the tree, and if it can't be found return the | 71 | * look for a given offset in the tree, and if it can't be found return the |
64 | * first lesser offset | 72 | * first lesser offset |
@@ -207,7 +215,8 @@ static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset, | |||
207 | spin_lock(&tree->lock); | 215 | spin_lock(&tree->lock); |
208 | node = tree_insert(&tree->tree, file_offset, | 216 | node = tree_insert(&tree->tree, file_offset, |
209 | &entry->rb_node); | 217 | &entry->rb_node); |
210 | BUG_ON(node); | 218 | if (node) |
219 | ordered_data_tree_panic(inode, -EEXIST, file_offset); | ||
211 | spin_unlock(&tree->lock); | 220 | spin_unlock(&tree->lock); |
212 | 221 | ||
213 | spin_lock(&BTRFS_I(inode)->root->fs_info->ordered_extent_lock); | 222 | spin_lock(&BTRFS_I(inode)->root->fs_info->ordered_extent_lock); |
@@ -215,7 +224,6 @@ static int __btrfs_add_ordered_extent(struct inode *inode, u64 file_offset, | |||
215 | &BTRFS_I(inode)->root->fs_info->ordered_extents); | 224 | &BTRFS_I(inode)->root->fs_info->ordered_extents); |
216 | spin_unlock(&BTRFS_I(inode)->root->fs_info->ordered_extent_lock); | 225 | spin_unlock(&BTRFS_I(inode)->root->fs_info->ordered_extent_lock); |
217 | 226 | ||
218 | BUG_ON(node); | ||
219 | return 0; | 227 | return 0; |
220 | } | 228 | } |
221 | 229 | ||
@@ -249,9 +257,9 @@ int btrfs_add_ordered_extent_compress(struct inode *inode, u64 file_offset, | |||
249 | * when an ordered extent is finished. If the list covers more than one | 257 | * when an ordered extent is finished. If the list covers more than one |
250 | * ordered extent, it is split across multiples. | 258 | * ordered extent, it is split across multiples. |
251 | */ | 259 | */ |
252 | int btrfs_add_ordered_sum(struct inode *inode, | 260 | void btrfs_add_ordered_sum(struct inode *inode, |
253 | struct btrfs_ordered_extent *entry, | 261 | struct btrfs_ordered_extent *entry, |
254 | struct btrfs_ordered_sum *sum) | 262 | struct btrfs_ordered_sum *sum) |
255 | { | 263 | { |
256 | struct btrfs_ordered_inode_tree *tree; | 264 | struct btrfs_ordered_inode_tree *tree; |
257 | 265 | ||
@@ -259,7 +267,6 @@ int btrfs_add_ordered_sum(struct inode *inode, | |||
259 | spin_lock(&tree->lock); | 267 | spin_lock(&tree->lock); |
260 | list_add_tail(&sum->list, &entry->list); | 268 | list_add_tail(&sum->list, &entry->list); |
261 | spin_unlock(&tree->lock); | 269 | spin_unlock(&tree->lock); |
262 | return 0; | ||
263 | } | 270 | } |
264 | 271 | ||
265 | /* | 272 | /* |
@@ -384,7 +391,7 @@ out: | |||
384 | * used to drop a reference on an ordered extent. This will free | 391 | * used to drop a reference on an ordered extent. This will free |
385 | * the extent if the last reference is dropped | 392 | * the extent if the last reference is dropped |
386 | */ | 393 | */ |
387 | int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry) | 394 | void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry) |
388 | { | 395 | { |
389 | struct list_head *cur; | 396 | struct list_head *cur; |
390 | struct btrfs_ordered_sum *sum; | 397 | struct btrfs_ordered_sum *sum; |
@@ -400,7 +407,6 @@ int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry) | |||
400 | } | 407 | } |
401 | kfree(entry); | 408 | kfree(entry); |
402 | } | 409 | } |
403 | return 0; | ||
404 | } | 410 | } |
405 | 411 | ||
406 | /* | 412 | /* |
@@ -408,8 +414,8 @@ int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry) | |||
408 | * and you must wake_up entry->wait. You must hold the tree lock | 414 | * and you must wake_up entry->wait. You must hold the tree lock |
409 | * while you call this function. | 415 | * while you call this function. |
410 | */ | 416 | */ |
411 | static int __btrfs_remove_ordered_extent(struct inode *inode, | 417 | static void __btrfs_remove_ordered_extent(struct inode *inode, |
412 | struct btrfs_ordered_extent *entry) | 418 | struct btrfs_ordered_extent *entry) |
413 | { | 419 | { |
414 | struct btrfs_ordered_inode_tree *tree; | 420 | struct btrfs_ordered_inode_tree *tree; |
415 | struct btrfs_root *root = BTRFS_I(inode)->root; | 421 | struct btrfs_root *root = BTRFS_I(inode)->root; |
@@ -436,35 +442,30 @@ static int __btrfs_remove_ordered_extent(struct inode *inode, | |||
436 | list_del_init(&BTRFS_I(inode)->ordered_operations); | 442 | list_del_init(&BTRFS_I(inode)->ordered_operations); |
437 | } | 443 | } |
438 | spin_unlock(&root->fs_info->ordered_extent_lock); | 444 | spin_unlock(&root->fs_info->ordered_extent_lock); |
439 | |||
440 | return 0; | ||
441 | } | 445 | } |
442 | 446 | ||
443 | /* | 447 | /* |
444 | * remove an ordered extent from the tree. No references are dropped | 448 | * remove an ordered extent from the tree. No references are dropped |
445 | * but any waiters are woken. | 449 | * but any waiters are woken. |
446 | */ | 450 | */ |
447 | int btrfs_remove_ordered_extent(struct inode *inode, | 451 | void btrfs_remove_ordered_extent(struct inode *inode, |
448 | struct btrfs_ordered_extent *entry) | 452 | struct btrfs_ordered_extent *entry) |
449 | { | 453 | { |
450 | struct btrfs_ordered_inode_tree *tree; | 454 | struct btrfs_ordered_inode_tree *tree; |
451 | int ret; | ||
452 | 455 | ||
453 | tree = &BTRFS_I(inode)->ordered_tree; | 456 | tree = &BTRFS_I(inode)->ordered_tree; |
454 | spin_lock(&tree->lock); | 457 | spin_lock(&tree->lock); |
455 | ret = __btrfs_remove_ordered_extent(inode, entry); | 458 | __btrfs_remove_ordered_extent(inode, entry); |
456 | spin_unlock(&tree->lock); | 459 | spin_unlock(&tree->lock); |
457 | wake_up(&entry->wait); | 460 | wake_up(&entry->wait); |
458 | |||
459 | return ret; | ||
460 | } | 461 | } |
461 | 462 | ||
462 | /* | 463 | /* |
463 | * wait for all the ordered extents in a root. This is done when balancing | 464 | * wait for all the ordered extents in a root. This is done when balancing |
464 | * space between drives. | 465 | * space between drives. |
465 | */ | 466 | */ |
466 | int btrfs_wait_ordered_extents(struct btrfs_root *root, | 467 | void btrfs_wait_ordered_extents(struct btrfs_root *root, |
467 | int nocow_only, int delay_iput) | 468 | int nocow_only, int delay_iput) |
468 | { | 469 | { |
469 | struct list_head splice; | 470 | struct list_head splice; |
470 | struct list_head *cur; | 471 | struct list_head *cur; |
@@ -512,7 +513,6 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root, | |||
512 | spin_lock(&root->fs_info->ordered_extent_lock); | 513 | spin_lock(&root->fs_info->ordered_extent_lock); |
513 | } | 514 | } |
514 | spin_unlock(&root->fs_info->ordered_extent_lock); | 515 | spin_unlock(&root->fs_info->ordered_extent_lock); |
515 | return 0; | ||
516 | } | 516 | } |
517 | 517 | ||
518 | /* | 518 | /* |
@@ -525,7 +525,7 @@ int btrfs_wait_ordered_extents(struct btrfs_root *root, | |||
525 | * extra check to make sure the ordered operation list really is empty | 525 | * extra check to make sure the ordered operation list really is empty |
526 | * before we return | 526 | * before we return |
527 | */ | 527 | */ |
528 | int btrfs_run_ordered_operations(struct btrfs_root *root, int wait) | 528 | void btrfs_run_ordered_operations(struct btrfs_root *root, int wait) |
529 | { | 529 | { |
530 | struct btrfs_inode *btrfs_inode; | 530 | struct btrfs_inode *btrfs_inode; |
531 | struct inode *inode; | 531 | struct inode *inode; |
@@ -573,8 +573,6 @@ again: | |||
573 | 573 | ||
574 | spin_unlock(&root->fs_info->ordered_extent_lock); | 574 | spin_unlock(&root->fs_info->ordered_extent_lock); |
575 | mutex_unlock(&root->fs_info->ordered_operations_mutex); | 575 | mutex_unlock(&root->fs_info->ordered_operations_mutex); |
576 | |||
577 | return 0; | ||
578 | } | 576 | } |
579 | 577 | ||
580 | /* | 578 | /* |
@@ -609,7 +607,7 @@ void btrfs_start_ordered_extent(struct inode *inode, | |||
609 | /* | 607 | /* |
610 | * Used to wait on ordered extents across a large range of bytes. | 608 | * Used to wait on ordered extents across a large range of bytes. |
611 | */ | 609 | */ |
612 | int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len) | 610 | void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len) |
613 | { | 611 | { |
614 | u64 end; | 612 | u64 end; |
615 | u64 orig_end; | 613 | u64 orig_end; |
@@ -664,7 +662,6 @@ again: | |||
664 | schedule_timeout(1); | 662 | schedule_timeout(1); |
665 | goto again; | 663 | goto again; |
666 | } | 664 | } |
667 | return 0; | ||
668 | } | 665 | } |
669 | 666 | ||
670 | /* | 667 | /* |
@@ -948,9 +945,8 @@ out: | |||
948 | * If trans is not null, we'll do a friendly check for a transaction that | 945 | * If trans is not null, we'll do a friendly check for a transaction that |
949 | * is already flushing things and force the IO down ourselves. | 946 | * is already flushing things and force the IO down ourselves. |
950 | */ | 947 | */ |
951 | int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans, | 948 | void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans, |
952 | struct btrfs_root *root, | 949 | struct btrfs_root *root, struct inode *inode) |
953 | struct inode *inode) | ||
954 | { | 950 | { |
955 | u64 last_mod; | 951 | u64 last_mod; |
956 | 952 | ||
@@ -961,7 +957,7 @@ int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans, | |||
961 | * commit, we can safely return without doing anything | 957 | * commit, we can safely return without doing anything |
962 | */ | 958 | */ |
963 | if (last_mod < root->fs_info->last_trans_committed) | 959 | if (last_mod < root->fs_info->last_trans_committed) |
964 | return 0; | 960 | return; |
965 | 961 | ||
966 | /* | 962 | /* |
967 | * the transaction is already committing. Just start the IO and | 963 | * the transaction is already committing. Just start the IO and |
@@ -969,7 +965,7 @@ int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans, | |||
969 | */ | 965 | */ |
970 | if (trans && root->fs_info->running_transaction->blocked) { | 966 | if (trans && root->fs_info->running_transaction->blocked) { |
971 | btrfs_wait_ordered_range(inode, 0, (u64)-1); | 967 | btrfs_wait_ordered_range(inode, 0, (u64)-1); |
972 | return 0; | 968 | return; |
973 | } | 969 | } |
974 | 970 | ||
975 | spin_lock(&root->fs_info->ordered_extent_lock); | 971 | spin_lock(&root->fs_info->ordered_extent_lock); |
@@ -978,6 +974,4 @@ int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans, | |||
978 | &root->fs_info->ordered_operations); | 974 | &root->fs_info->ordered_operations); |
979 | } | 975 | } |
980 | spin_unlock(&root->fs_info->ordered_extent_lock); | 976 | spin_unlock(&root->fs_info->ordered_extent_lock); |
981 | |||
982 | return 0; | ||
983 | } | 977 | } |
diff --git a/fs/btrfs/ordered-data.h b/fs/btrfs/ordered-data.h index ff1f69aa1883..c355ad4dc1a6 100644 --- a/fs/btrfs/ordered-data.h +++ b/fs/btrfs/ordered-data.h | |||
@@ -138,8 +138,8 @@ btrfs_ordered_inode_tree_init(struct btrfs_ordered_inode_tree *t) | |||
138 | t->last = NULL; | 138 | t->last = NULL; |
139 | } | 139 | } |
140 | 140 | ||
141 | int btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry); | 141 | void btrfs_put_ordered_extent(struct btrfs_ordered_extent *entry); |
142 | int btrfs_remove_ordered_extent(struct inode *inode, | 142 | void btrfs_remove_ordered_extent(struct inode *inode, |
143 | struct btrfs_ordered_extent *entry); | 143 | struct btrfs_ordered_extent *entry); |
144 | int btrfs_dec_test_ordered_pending(struct inode *inode, | 144 | int btrfs_dec_test_ordered_pending(struct inode *inode, |
145 | struct btrfs_ordered_extent **cached, | 145 | struct btrfs_ordered_extent **cached, |
@@ -154,14 +154,14 @@ int btrfs_add_ordered_extent_dio(struct inode *inode, u64 file_offset, | |||
154 | int btrfs_add_ordered_extent_compress(struct inode *inode, u64 file_offset, | 154 | int btrfs_add_ordered_extent_compress(struct inode *inode, u64 file_offset, |
155 | u64 start, u64 len, u64 disk_len, | 155 | u64 start, u64 len, u64 disk_len, |
156 | int type, int compress_type); | 156 | int type, int compress_type); |
157 | int btrfs_add_ordered_sum(struct inode *inode, | 157 | void btrfs_add_ordered_sum(struct inode *inode, |
158 | struct btrfs_ordered_extent *entry, | 158 | struct btrfs_ordered_extent *entry, |
159 | struct btrfs_ordered_sum *sum); | 159 | struct btrfs_ordered_sum *sum); |
160 | struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct inode *inode, | 160 | struct btrfs_ordered_extent *btrfs_lookup_ordered_extent(struct inode *inode, |
161 | u64 file_offset); | 161 | u64 file_offset); |
162 | void btrfs_start_ordered_extent(struct inode *inode, | 162 | void btrfs_start_ordered_extent(struct inode *inode, |
163 | struct btrfs_ordered_extent *entry, int wait); | 163 | struct btrfs_ordered_extent *entry, int wait); |
164 | int btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len); | 164 | void btrfs_wait_ordered_range(struct inode *inode, u64 start, u64 len); |
165 | struct btrfs_ordered_extent * | 165 | struct btrfs_ordered_extent * |
166 | btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset); | 166 | btrfs_lookup_first_ordered_extent(struct inode * inode, u64 file_offset); |
167 | struct btrfs_ordered_extent *btrfs_lookup_ordered_range(struct inode *inode, | 167 | struct btrfs_ordered_extent *btrfs_lookup_ordered_range(struct inode *inode, |
@@ -170,10 +170,10 @@ struct btrfs_ordered_extent *btrfs_lookup_ordered_range(struct inode *inode, | |||
170 | int btrfs_ordered_update_i_size(struct inode *inode, u64 offset, | 170 | int btrfs_ordered_update_i_size(struct inode *inode, u64 offset, |
171 | struct btrfs_ordered_extent *ordered); | 171 | struct btrfs_ordered_extent *ordered); |
172 | int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr, u32 *sum); | 172 | int btrfs_find_ordered_sum(struct inode *inode, u64 offset, u64 disk_bytenr, u32 *sum); |
173 | int btrfs_run_ordered_operations(struct btrfs_root *root, int wait); | 173 | void btrfs_run_ordered_operations(struct btrfs_root *root, int wait); |
174 | int btrfs_add_ordered_operation(struct btrfs_trans_handle *trans, | 174 | void btrfs_add_ordered_operation(struct btrfs_trans_handle *trans, |
175 | struct btrfs_root *root, | 175 | struct btrfs_root *root, |
176 | struct inode *inode); | 176 | struct inode *inode); |
177 | int btrfs_wait_ordered_extents(struct btrfs_root *root, | 177 | void btrfs_wait_ordered_extents(struct btrfs_root *root, |
178 | int nocow_only, int delay_iput); | 178 | int nocow_only, int delay_iput); |
179 | #endif | 179 | #endif |
diff --git a/fs/btrfs/orphan.c b/fs/btrfs/orphan.c index f8be250963a0..24cad1695af7 100644 --- a/fs/btrfs/orphan.c +++ b/fs/btrfs/orphan.c | |||
@@ -58,7 +58,7 @@ int btrfs_del_orphan_item(struct btrfs_trans_handle *trans, | |||
58 | ret = btrfs_search_slot(trans, root, &key, path, -1, 1); | 58 | ret = btrfs_search_slot(trans, root, &key, path, -1, 1); |
59 | if (ret < 0) | 59 | if (ret < 0) |
60 | goto out; | 60 | goto out; |
61 | if (ret) { | 61 | if (ret) { /* JDM: Really? */ |
62 | ret = -ENOENT; | 62 | ret = -ENOENT; |
63 | goto out; | 63 | goto out; |
64 | } | 64 | } |
diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c index 8c1aae2c845d..017281dbb2a7 100644 --- a/fs/btrfs/relocation.c +++ b/fs/btrfs/relocation.c | |||
@@ -326,6 +326,19 @@ static struct rb_node *tree_search(struct rb_root *root, u64 bytenr) | |||
326 | return NULL; | 326 | return NULL; |
327 | } | 327 | } |
328 | 328 | ||
329 | void backref_tree_panic(struct rb_node *rb_node, int errno, | ||
330 | u64 bytenr) | ||
331 | { | ||
332 | |||
333 | struct btrfs_fs_info *fs_info = NULL; | ||
334 | struct backref_node *bnode = rb_entry(rb_node, struct backref_node, | ||
335 | rb_node); | ||
336 | if (bnode->root) | ||
337 | fs_info = bnode->root->fs_info; | ||
338 | btrfs_panic(fs_info, errno, "Inconsistency in backref cache " | ||
339 | "found at offset %llu\n", (unsigned long long)bytenr); | ||
340 | } | ||
341 | |||
329 | /* | 342 | /* |
330 | * walk up backref nodes until reach node presents tree root | 343 | * walk up backref nodes until reach node presents tree root |
331 | */ | 344 | */ |
@@ -452,7 +465,8 @@ static void update_backref_node(struct backref_cache *cache, | |||
452 | rb_erase(&node->rb_node, &cache->rb_root); | 465 | rb_erase(&node->rb_node, &cache->rb_root); |
453 | node->bytenr = bytenr; | 466 | node->bytenr = bytenr; |
454 | rb_node = tree_insert(&cache->rb_root, node->bytenr, &node->rb_node); | 467 | rb_node = tree_insert(&cache->rb_root, node->bytenr, &node->rb_node); |
455 | BUG_ON(rb_node); | 468 | if (rb_node) |
469 | backref_tree_panic(rb_node, -EEXIST, bytenr); | ||
456 | } | 470 | } |
457 | 471 | ||
458 | /* | 472 | /* |
@@ -999,7 +1013,8 @@ next: | |||
999 | if (!cowonly) { | 1013 | if (!cowonly) { |
1000 | rb_node = tree_insert(&cache->rb_root, node->bytenr, | 1014 | rb_node = tree_insert(&cache->rb_root, node->bytenr, |
1001 | &node->rb_node); | 1015 | &node->rb_node); |
1002 | BUG_ON(rb_node); | 1016 | if (rb_node) |
1017 | backref_tree_panic(rb_node, -EEXIST, node->bytenr); | ||
1003 | list_add_tail(&node->lower, &cache->leaves); | 1018 | list_add_tail(&node->lower, &cache->leaves); |
1004 | } | 1019 | } |
1005 | 1020 | ||
@@ -1034,7 +1049,9 @@ next: | |||
1034 | if (!cowonly) { | 1049 | if (!cowonly) { |
1035 | rb_node = tree_insert(&cache->rb_root, upper->bytenr, | 1050 | rb_node = tree_insert(&cache->rb_root, upper->bytenr, |
1036 | &upper->rb_node); | 1051 | &upper->rb_node); |
1037 | BUG_ON(rb_node); | 1052 | if (rb_node) |
1053 | backref_tree_panic(rb_node, -EEXIST, | ||
1054 | upper->bytenr); | ||
1038 | } | 1055 | } |
1039 | 1056 | ||
1040 | list_add_tail(&edge->list[UPPER], &upper->lower); | 1057 | list_add_tail(&edge->list[UPPER], &upper->lower); |
@@ -1180,7 +1197,8 @@ static int clone_backref_node(struct btrfs_trans_handle *trans, | |||
1180 | 1197 | ||
1181 | rb_node = tree_insert(&cache->rb_root, new_node->bytenr, | 1198 | rb_node = tree_insert(&cache->rb_root, new_node->bytenr, |
1182 | &new_node->rb_node); | 1199 | &new_node->rb_node); |
1183 | BUG_ON(rb_node); | 1200 | if (rb_node) |
1201 | backref_tree_panic(rb_node, -EEXIST, new_node->bytenr); | ||
1184 | 1202 | ||
1185 | if (!new_node->lowest) { | 1203 | if (!new_node->lowest) { |
1186 | list_for_each_entry(new_edge, &new_node->lower, list[UPPER]) { | 1204 | list_for_each_entry(new_edge, &new_node->lower, list[UPPER]) { |
@@ -1203,14 +1221,15 @@ fail: | |||
1203 | /* | 1221 | /* |
1204 | * helper to add 'address of tree root -> reloc tree' mapping | 1222 | * helper to add 'address of tree root -> reloc tree' mapping |
1205 | */ | 1223 | */ |
1206 | static int __add_reloc_root(struct btrfs_root *root) | 1224 | static int __must_check __add_reloc_root(struct btrfs_root *root) |
1207 | { | 1225 | { |
1208 | struct rb_node *rb_node; | 1226 | struct rb_node *rb_node; |
1209 | struct mapping_node *node; | 1227 | struct mapping_node *node; |
1210 | struct reloc_control *rc = root->fs_info->reloc_ctl; | 1228 | struct reloc_control *rc = root->fs_info->reloc_ctl; |
1211 | 1229 | ||
1212 | node = kmalloc(sizeof(*node), GFP_NOFS); | 1230 | node = kmalloc(sizeof(*node), GFP_NOFS); |
1213 | BUG_ON(!node); | 1231 | if (!node) |
1232 | return -ENOMEM; | ||
1214 | 1233 | ||
1215 | node->bytenr = root->node->start; | 1234 | node->bytenr = root->node->start; |
1216 | node->data = root; | 1235 | node->data = root; |
@@ -1219,7 +1238,12 @@ static int __add_reloc_root(struct btrfs_root *root) | |||
1219 | rb_node = tree_insert(&rc->reloc_root_tree.rb_root, | 1238 | rb_node = tree_insert(&rc->reloc_root_tree.rb_root, |
1220 | node->bytenr, &node->rb_node); | 1239 | node->bytenr, &node->rb_node); |
1221 | spin_unlock(&rc->reloc_root_tree.lock); | 1240 | spin_unlock(&rc->reloc_root_tree.lock); |
1222 | BUG_ON(rb_node); | 1241 | if (rb_node) { |
1242 | kfree(node); | ||
1243 | btrfs_panic(root->fs_info, -EEXIST, "Duplicate root found " | ||
1244 | "for start=%llu while inserting into relocation " | ||
1245 | "tree\n"); | ||
1246 | } | ||
1223 | 1247 | ||
1224 | list_add_tail(&root->root_list, &rc->reloc_roots); | 1248 | list_add_tail(&root->root_list, &rc->reloc_roots); |
1225 | return 0; | 1249 | return 0; |
@@ -1252,7 +1276,8 @@ static int __update_reloc_root(struct btrfs_root *root, int del) | |||
1252 | rb_node = tree_insert(&rc->reloc_root_tree.rb_root, | 1276 | rb_node = tree_insert(&rc->reloc_root_tree.rb_root, |
1253 | node->bytenr, &node->rb_node); | 1277 | node->bytenr, &node->rb_node); |
1254 | spin_unlock(&rc->reloc_root_tree.lock); | 1278 | spin_unlock(&rc->reloc_root_tree.lock); |
1255 | BUG_ON(rb_node); | 1279 | if (rb_node) |
1280 | backref_tree_panic(rb_node, -EEXIST, node->bytenr); | ||
1256 | } else { | 1281 | } else { |
1257 | list_del_init(&root->root_list); | 1282 | list_del_init(&root->root_list); |
1258 | kfree(node); | 1283 | kfree(node); |
@@ -1334,6 +1359,7 @@ int btrfs_init_reloc_root(struct btrfs_trans_handle *trans, | |||
1334 | struct btrfs_root *reloc_root; | 1359 | struct btrfs_root *reloc_root; |
1335 | struct reloc_control *rc = root->fs_info->reloc_ctl; | 1360 | struct reloc_control *rc = root->fs_info->reloc_ctl; |
1336 | int clear_rsv = 0; | 1361 | int clear_rsv = 0; |
1362 | int ret; | ||
1337 | 1363 | ||
1338 | if (root->reloc_root) { | 1364 | if (root->reloc_root) { |
1339 | reloc_root = root->reloc_root; | 1365 | reloc_root = root->reloc_root; |
@@ -1353,7 +1379,8 @@ int btrfs_init_reloc_root(struct btrfs_trans_handle *trans, | |||
1353 | if (clear_rsv) | 1379 | if (clear_rsv) |
1354 | trans->block_rsv = NULL; | 1380 | trans->block_rsv = NULL; |
1355 | 1381 | ||
1356 | __add_reloc_root(reloc_root); | 1382 | ret = __add_reloc_root(reloc_root); |
1383 | BUG_ON(ret < 0); | ||
1357 | root->reloc_root = reloc_root; | 1384 | root->reloc_root = reloc_root; |
1358 | return 0; | 1385 | return 0; |
1359 | } | 1386 | } |
@@ -1577,15 +1604,14 @@ int replace_file_extents(struct btrfs_trans_handle *trans, | |||
1577 | WARN_ON(!IS_ALIGNED(end, root->sectorsize)); | 1604 | WARN_ON(!IS_ALIGNED(end, root->sectorsize)); |
1578 | end--; | 1605 | end--; |
1579 | ret = try_lock_extent(&BTRFS_I(inode)->io_tree, | 1606 | ret = try_lock_extent(&BTRFS_I(inode)->io_tree, |
1580 | key.offset, end, | 1607 | key.offset, end); |
1581 | GFP_NOFS); | ||
1582 | if (!ret) | 1608 | if (!ret) |
1583 | continue; | 1609 | continue; |
1584 | 1610 | ||
1585 | btrfs_drop_extent_cache(inode, key.offset, end, | 1611 | btrfs_drop_extent_cache(inode, key.offset, end, |
1586 | 1); | 1612 | 1); |
1587 | unlock_extent(&BTRFS_I(inode)->io_tree, | 1613 | unlock_extent(&BTRFS_I(inode)->io_tree, |
1588 | key.offset, end, GFP_NOFS); | 1614 | key.offset, end); |
1589 | } | 1615 | } |
1590 | } | 1616 | } |
1591 | 1617 | ||
@@ -1956,9 +1982,9 @@ static int invalidate_extent_cache(struct btrfs_root *root, | |||
1956 | } | 1982 | } |
1957 | 1983 | ||
1958 | /* the lock_extent waits for readpage to complete */ | 1984 | /* the lock_extent waits for readpage to complete */ |
1959 | lock_extent(&BTRFS_I(inode)->io_tree, start, end, GFP_NOFS); | 1985 | lock_extent(&BTRFS_I(inode)->io_tree, start, end); |
1960 | btrfs_drop_extent_cache(inode, start, end, 1); | 1986 | btrfs_drop_extent_cache(inode, start, end, 1); |
1961 | unlock_extent(&BTRFS_I(inode)->io_tree, start, end, GFP_NOFS); | 1987 | unlock_extent(&BTRFS_I(inode)->io_tree, start, end); |
1962 | } | 1988 | } |
1963 | return 0; | 1989 | return 0; |
1964 | } | 1990 | } |
@@ -2246,7 +2272,8 @@ again: | |||
2246 | } else { | 2272 | } else { |
2247 | list_del_init(&reloc_root->root_list); | 2273 | list_del_init(&reloc_root->root_list); |
2248 | } | 2274 | } |
2249 | btrfs_drop_snapshot(reloc_root, rc->block_rsv, 0, 1); | 2275 | ret = btrfs_drop_snapshot(reloc_root, rc->block_rsv, 0, 1); |
2276 | BUG_ON(ret < 0); | ||
2250 | } | 2277 | } |
2251 | 2278 | ||
2252 | if (found) { | 2279 | if (found) { |
@@ -2862,12 +2889,12 @@ int prealloc_file_extent_cluster(struct inode *inode, | |||
2862 | else | 2889 | else |
2863 | end = cluster->end - offset; | 2890 | end = cluster->end - offset; |
2864 | 2891 | ||
2865 | lock_extent(&BTRFS_I(inode)->io_tree, start, end, GFP_NOFS); | 2892 | lock_extent(&BTRFS_I(inode)->io_tree, start, end); |
2866 | num_bytes = end + 1 - start; | 2893 | num_bytes = end + 1 - start; |
2867 | ret = btrfs_prealloc_file_range(inode, 0, start, | 2894 | ret = btrfs_prealloc_file_range(inode, 0, start, |
2868 | num_bytes, num_bytes, | 2895 | num_bytes, num_bytes, |
2869 | end + 1, &alloc_hint); | 2896 | end + 1, &alloc_hint); |
2870 | unlock_extent(&BTRFS_I(inode)->io_tree, start, end, GFP_NOFS); | 2897 | unlock_extent(&BTRFS_I(inode)->io_tree, start, end); |
2871 | if (ret) | 2898 | if (ret) |
2872 | break; | 2899 | break; |
2873 | nr++; | 2900 | nr++; |
@@ -2899,7 +2926,7 @@ int setup_extent_mapping(struct inode *inode, u64 start, u64 end, | |||
2899 | em->bdev = root->fs_info->fs_devices->latest_bdev; | 2926 | em->bdev = root->fs_info->fs_devices->latest_bdev; |
2900 | set_bit(EXTENT_FLAG_PINNED, &em->flags); | 2927 | set_bit(EXTENT_FLAG_PINNED, &em->flags); |
2901 | 2928 | ||
2902 | lock_extent(&BTRFS_I(inode)->io_tree, start, end, GFP_NOFS); | 2929 | lock_extent(&BTRFS_I(inode)->io_tree, start, end); |
2903 | while (1) { | 2930 | while (1) { |
2904 | write_lock(&em_tree->lock); | 2931 | write_lock(&em_tree->lock); |
2905 | ret = add_extent_mapping(em_tree, em); | 2932 | ret = add_extent_mapping(em_tree, em); |
@@ -2910,7 +2937,7 @@ int setup_extent_mapping(struct inode *inode, u64 start, u64 end, | |||
2910 | } | 2937 | } |
2911 | btrfs_drop_extent_cache(inode, start, end, 0); | 2938 | btrfs_drop_extent_cache(inode, start, end, 0); |
2912 | } | 2939 | } |
2913 | unlock_extent(&BTRFS_I(inode)->io_tree, start, end, GFP_NOFS); | 2940 | unlock_extent(&BTRFS_I(inode)->io_tree, start, end); |
2914 | return ret; | 2941 | return ret; |
2915 | } | 2942 | } |
2916 | 2943 | ||
@@ -2990,8 +3017,7 @@ static int relocate_file_extent_cluster(struct inode *inode, | |||
2990 | page_start = (u64)page->index << PAGE_CACHE_SHIFT; | 3017 | page_start = (u64)page->index << PAGE_CACHE_SHIFT; |
2991 | page_end = page_start + PAGE_CACHE_SIZE - 1; | 3018 | page_end = page_start + PAGE_CACHE_SIZE - 1; |
2992 | 3019 | ||
2993 | lock_extent(&BTRFS_I(inode)->io_tree, | 3020 | lock_extent(&BTRFS_I(inode)->io_tree, page_start, page_end); |
2994 | page_start, page_end, GFP_NOFS); | ||
2995 | 3021 | ||
2996 | set_page_extent_mapped(page); | 3022 | set_page_extent_mapped(page); |
2997 | 3023 | ||
@@ -3007,7 +3033,7 @@ static int relocate_file_extent_cluster(struct inode *inode, | |||
3007 | set_page_dirty(page); | 3033 | set_page_dirty(page); |
3008 | 3034 | ||
3009 | unlock_extent(&BTRFS_I(inode)->io_tree, | 3035 | unlock_extent(&BTRFS_I(inode)->io_tree, |
3010 | page_start, page_end, GFP_NOFS); | 3036 | page_start, page_end); |
3011 | unlock_page(page); | 3037 | unlock_page(page); |
3012 | page_cache_release(page); | 3038 | page_cache_release(page); |
3013 | 3039 | ||
@@ -3154,7 +3180,8 @@ static int add_tree_block(struct reloc_control *rc, | |||
3154 | block->key_ready = 0; | 3180 | block->key_ready = 0; |
3155 | 3181 | ||
3156 | rb_node = tree_insert(blocks, block->bytenr, &block->rb_node); | 3182 | rb_node = tree_insert(blocks, block->bytenr, &block->rb_node); |
3157 | BUG_ON(rb_node); | 3183 | if (rb_node) |
3184 | backref_tree_panic(rb_node, -EEXIST, block->bytenr); | ||
3158 | 3185 | ||
3159 | return 0; | 3186 | return 0; |
3160 | } | 3187 | } |
@@ -3426,7 +3453,9 @@ static int find_data_references(struct reloc_control *rc, | |||
3426 | block->key_ready = 1; | 3453 | block->key_ready = 1; |
3427 | rb_node = tree_insert(blocks, block->bytenr, | 3454 | rb_node = tree_insert(blocks, block->bytenr, |
3428 | &block->rb_node); | 3455 | &block->rb_node); |
3429 | BUG_ON(rb_node); | 3456 | if (rb_node) |
3457 | backref_tree_panic(rb_node, -EEXIST, | ||
3458 | block->bytenr); | ||
3430 | } | 3459 | } |
3431 | if (counted) | 3460 | if (counted) |
3432 | added = 1; | 3461 | added = 1; |
@@ -4073,10 +4102,11 @@ out: | |||
4073 | static noinline_for_stack int mark_garbage_root(struct btrfs_root *root) | 4102 | static noinline_for_stack int mark_garbage_root(struct btrfs_root *root) |
4074 | { | 4103 | { |
4075 | struct btrfs_trans_handle *trans; | 4104 | struct btrfs_trans_handle *trans; |
4076 | int ret; | 4105 | int ret, err; |
4077 | 4106 | ||
4078 | trans = btrfs_start_transaction(root->fs_info->tree_root, 0); | 4107 | trans = btrfs_start_transaction(root->fs_info->tree_root, 0); |
4079 | BUG_ON(IS_ERR(trans)); | 4108 | if (IS_ERR(trans)) |
4109 | return PTR_ERR(trans); | ||
4080 | 4110 | ||
4081 | memset(&root->root_item.drop_progress, 0, | 4111 | memset(&root->root_item.drop_progress, 0, |
4082 | sizeof(root->root_item.drop_progress)); | 4112 | sizeof(root->root_item.drop_progress)); |
@@ -4084,11 +4114,11 @@ static noinline_for_stack int mark_garbage_root(struct btrfs_root *root) | |||
4084 | btrfs_set_root_refs(&root->root_item, 0); | 4114 | btrfs_set_root_refs(&root->root_item, 0); |
4085 | ret = btrfs_update_root(trans, root->fs_info->tree_root, | 4115 | ret = btrfs_update_root(trans, root->fs_info->tree_root, |
4086 | &root->root_key, &root->root_item); | 4116 | &root->root_key, &root->root_item); |
4087 | BUG_ON(ret); | ||
4088 | 4117 | ||
4089 | ret = btrfs_end_transaction(trans, root->fs_info->tree_root); | 4118 | err = btrfs_end_transaction(trans, root->fs_info->tree_root); |
4090 | BUG_ON(ret); | 4119 | if (err) |
4091 | return 0; | 4120 | return err; |
4121 | return ret; | ||
4092 | } | 4122 | } |
4093 | 4123 | ||
4094 | /* | 4124 | /* |
@@ -4156,7 +4186,11 @@ int btrfs_recover_relocation(struct btrfs_root *root) | |||
4156 | err = ret; | 4186 | err = ret; |
4157 | goto out; | 4187 | goto out; |
4158 | } | 4188 | } |
4159 | mark_garbage_root(reloc_root); | 4189 | ret = mark_garbage_root(reloc_root); |
4190 | if (ret < 0) { | ||
4191 | err = ret; | ||
4192 | goto out; | ||
4193 | } | ||
4160 | } | 4194 | } |
4161 | } | 4195 | } |
4162 | 4196 | ||
@@ -4202,13 +4236,19 @@ int btrfs_recover_relocation(struct btrfs_root *root) | |||
4202 | 4236 | ||
4203 | fs_root = read_fs_root(root->fs_info, | 4237 | fs_root = read_fs_root(root->fs_info, |
4204 | reloc_root->root_key.offset); | 4238 | reloc_root->root_key.offset); |
4205 | BUG_ON(IS_ERR(fs_root)); | 4239 | if (IS_ERR(fs_root)) { |
4240 | err = PTR_ERR(fs_root); | ||
4241 | goto out_free; | ||
4242 | } | ||
4206 | 4243 | ||
4207 | __add_reloc_root(reloc_root); | 4244 | err = __add_reloc_root(reloc_root); |
4245 | BUG_ON(err < 0); /* -ENOMEM or logic error */ | ||
4208 | fs_root->reloc_root = reloc_root; | 4246 | fs_root->reloc_root = reloc_root; |
4209 | } | 4247 | } |
4210 | 4248 | ||
4211 | btrfs_commit_transaction(trans, rc->extent_root); | 4249 | err = btrfs_commit_transaction(trans, rc->extent_root); |
4250 | if (err) | ||
4251 | goto out_free; | ||
4212 | 4252 | ||
4213 | merge_reloc_roots(rc); | 4253 | merge_reloc_roots(rc); |
4214 | 4254 | ||
@@ -4218,7 +4258,7 @@ int btrfs_recover_relocation(struct btrfs_root *root) | |||
4218 | if (IS_ERR(trans)) | 4258 | if (IS_ERR(trans)) |
4219 | err = PTR_ERR(trans); | 4259 | err = PTR_ERR(trans); |
4220 | else | 4260 | else |
4221 | btrfs_commit_transaction(trans, rc->extent_root); | 4261 | err = btrfs_commit_transaction(trans, rc->extent_root); |
4222 | out_free: | 4262 | out_free: |
4223 | kfree(rc); | 4263 | kfree(rc); |
4224 | out: | 4264 | out: |
@@ -4267,6 +4307,8 @@ int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len) | |||
4267 | disk_bytenr = file_pos + BTRFS_I(inode)->index_cnt; | 4307 | disk_bytenr = file_pos + BTRFS_I(inode)->index_cnt; |
4268 | ret = btrfs_lookup_csums_range(root->fs_info->csum_root, disk_bytenr, | 4308 | ret = btrfs_lookup_csums_range(root->fs_info->csum_root, disk_bytenr, |
4269 | disk_bytenr + len - 1, &list, 0); | 4309 | disk_bytenr + len - 1, &list, 0); |
4310 | if (ret) | ||
4311 | goto out; | ||
4270 | 4312 | ||
4271 | while (!list_empty(&list)) { | 4313 | while (!list_empty(&list)) { |
4272 | sums = list_entry(list.next, struct btrfs_ordered_sum, list); | 4314 | sums = list_entry(list.next, struct btrfs_ordered_sum, list); |
@@ -4284,6 +4326,7 @@ int btrfs_reloc_clone_csums(struct inode *inode, u64 file_pos, u64 len) | |||
4284 | 4326 | ||
4285 | btrfs_add_ordered_sum(inode, ordered, sums); | 4327 | btrfs_add_ordered_sum(inode, ordered, sums); |
4286 | } | 4328 | } |
4329 | out: | ||
4287 | btrfs_put_ordered_extent(ordered); | 4330 | btrfs_put_ordered_extent(ordered); |
4288 | return ret; | 4331 | return ret; |
4289 | } | 4332 | } |
@@ -4380,7 +4423,7 @@ void btrfs_reloc_pre_snapshot(struct btrfs_trans_handle *trans, | |||
4380 | * called after snapshot is created. migrate block reservation | 4423 | * called after snapshot is created. migrate block reservation |
4381 | * and create reloc root for the newly created snapshot | 4424 | * and create reloc root for the newly created snapshot |
4382 | */ | 4425 | */ |
4383 | void btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans, | 4426 | int btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans, |
4384 | struct btrfs_pending_snapshot *pending) | 4427 | struct btrfs_pending_snapshot *pending) |
4385 | { | 4428 | { |
4386 | struct btrfs_root *root = pending->root; | 4429 | struct btrfs_root *root = pending->root; |
@@ -4390,7 +4433,7 @@ void btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans, | |||
4390 | int ret; | 4433 | int ret; |
4391 | 4434 | ||
4392 | if (!root->reloc_root) | 4435 | if (!root->reloc_root) |
4393 | return; | 4436 | return 0; |
4394 | 4437 | ||
4395 | rc = root->fs_info->reloc_ctl; | 4438 | rc = root->fs_info->reloc_ctl; |
4396 | rc->merging_rsv_size += rc->nodes_relocated; | 4439 | rc->merging_rsv_size += rc->nodes_relocated; |
@@ -4399,18 +4442,21 @@ void btrfs_reloc_post_snapshot(struct btrfs_trans_handle *trans, | |||
4399 | ret = btrfs_block_rsv_migrate(&pending->block_rsv, | 4442 | ret = btrfs_block_rsv_migrate(&pending->block_rsv, |
4400 | rc->block_rsv, | 4443 | rc->block_rsv, |
4401 | rc->nodes_relocated); | 4444 | rc->nodes_relocated); |
4402 | BUG_ON(ret); | 4445 | if (ret) |
4446 | return ret; | ||
4403 | } | 4447 | } |
4404 | 4448 | ||
4405 | new_root = pending->snap; | 4449 | new_root = pending->snap; |
4406 | reloc_root = create_reloc_root(trans, root->reloc_root, | 4450 | reloc_root = create_reloc_root(trans, root->reloc_root, |
4407 | new_root->root_key.objectid); | 4451 | new_root->root_key.objectid); |
4452 | if (IS_ERR(reloc_root)) | ||
4453 | return PTR_ERR(reloc_root); | ||
4408 | 4454 | ||
4409 | __add_reloc_root(reloc_root); | 4455 | ret = __add_reloc_root(reloc_root); |
4456 | BUG_ON(ret < 0); | ||
4410 | new_root->reloc_root = reloc_root; | 4457 | new_root->reloc_root = reloc_root; |
4411 | 4458 | ||
4412 | if (rc->create_reloc_tree) { | 4459 | if (rc->create_reloc_tree) |
4413 | ret = clone_backref_node(trans, rc, root, reloc_root); | 4460 | ret = clone_backref_node(trans, rc, root, reloc_root); |
4414 | BUG_ON(ret); | 4461 | return ret; |
4415 | } | ||
4416 | } | 4462 | } |
diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c index f4099904565a..24fb8ce4e071 100644 --- a/fs/btrfs/root-tree.c +++ b/fs/btrfs/root-tree.c | |||
@@ -93,10 +93,14 @@ int btrfs_update_root(struct btrfs_trans_handle *trans, struct btrfs_root | |||
93 | unsigned long ptr; | 93 | unsigned long ptr; |
94 | 94 | ||
95 | path = btrfs_alloc_path(); | 95 | path = btrfs_alloc_path(); |
96 | BUG_ON(!path); | 96 | if (!path) |
97 | return -ENOMEM; | ||
98 | |||
97 | ret = btrfs_search_slot(trans, root, key, path, 0, 1); | 99 | ret = btrfs_search_slot(trans, root, key, path, 0, 1); |
98 | if (ret < 0) | 100 | if (ret < 0) { |
101 | btrfs_abort_transaction(trans, root, ret); | ||
99 | goto out; | 102 | goto out; |
103 | } | ||
100 | 104 | ||
101 | if (ret != 0) { | 105 | if (ret != 0) { |
102 | btrfs_print_leaf(root, path->nodes[0]); | 106 | btrfs_print_leaf(root, path->nodes[0]); |
@@ -116,13 +120,10 @@ out: | |||
116 | return ret; | 120 | return ret; |
117 | } | 121 | } |
118 | 122 | ||
119 | int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root | 123 | int btrfs_insert_root(struct btrfs_trans_handle *trans, struct btrfs_root *root, |
120 | *root, struct btrfs_key *key, struct btrfs_root_item | 124 | struct btrfs_key *key, struct btrfs_root_item *item) |
121 | *item) | ||
122 | { | 125 | { |
123 | int ret; | 126 | return btrfs_insert_item(trans, root, key, item, sizeof(*item)); |
124 | ret = btrfs_insert_item(trans, root, key, item, sizeof(*item)); | ||
125 | return ret; | ||
126 | } | 127 | } |
127 | 128 | ||
128 | /* | 129 | /* |
@@ -384,6 +385,8 @@ int btrfs_find_root_ref(struct btrfs_root *tree_root, | |||
384 | * | 385 | * |
385 | * For a back ref the root_id is the id of the subvol or snapshot and | 386 | * For a back ref the root_id is the id of the subvol or snapshot and |
386 | * ref_id is the id of the tree referencing it. | 387 | * ref_id is the id of the tree referencing it. |
388 | * | ||
389 | * Will return 0, -ENOMEM, or anything from the CoW path | ||
387 | */ | 390 | */ |
388 | int btrfs_add_root_ref(struct btrfs_trans_handle *trans, | 391 | int btrfs_add_root_ref(struct btrfs_trans_handle *trans, |
389 | struct btrfs_root *tree_root, | 392 | struct btrfs_root *tree_root, |
@@ -407,7 +410,11 @@ int btrfs_add_root_ref(struct btrfs_trans_handle *trans, | |||
407 | again: | 410 | again: |
408 | ret = btrfs_insert_empty_item(trans, tree_root, path, &key, | 411 | ret = btrfs_insert_empty_item(trans, tree_root, path, &key, |
409 | sizeof(*ref) + name_len); | 412 | sizeof(*ref) + name_len); |
410 | BUG_ON(ret); | 413 | if (ret) { |
414 | btrfs_abort_transaction(trans, tree_root, ret); | ||
415 | btrfs_free_path(path); | ||
416 | return ret; | ||
417 | } | ||
411 | 418 | ||
412 | leaf = path->nodes[0]; | 419 | leaf = path->nodes[0]; |
413 | ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref); | 420 | ref = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_root_ref); |
diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c index 5221e072bb65..07e59d97551a 100644 --- a/fs/btrfs/scrub.c +++ b/fs/btrfs/scrub.c | |||
@@ -2157,6 +2157,9 @@ static noinline_for_stack int scrub_supers(struct scrub_dev *sdev) | |||
2157 | struct btrfs_device *device = sdev->dev; | 2157 | struct btrfs_device *device = sdev->dev; |
2158 | struct btrfs_root *root = device->dev_root; | 2158 | struct btrfs_root *root = device->dev_root; |
2159 | 2159 | ||
2160 | if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) | ||
2161 | return -EIO; | ||
2162 | |||
2160 | gen = root->fs_info->last_trans_committed; | 2163 | gen = root->fs_info->last_trans_committed; |
2161 | 2164 | ||
2162 | for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { | 2165 | for (i = 0; i < BTRFS_SUPER_MIRROR_MAX; i++) { |
@@ -2317,7 +2320,7 @@ int btrfs_scrub_dev(struct btrfs_root *root, u64 devid, u64 start, u64 end, | |||
2317 | return ret; | 2320 | return ret; |
2318 | } | 2321 | } |
2319 | 2322 | ||
2320 | int btrfs_scrub_pause(struct btrfs_root *root) | 2323 | void btrfs_scrub_pause(struct btrfs_root *root) |
2321 | { | 2324 | { |
2322 | struct btrfs_fs_info *fs_info = root->fs_info; | 2325 | struct btrfs_fs_info *fs_info = root->fs_info; |
2323 | 2326 | ||
@@ -2332,34 +2335,28 @@ int btrfs_scrub_pause(struct btrfs_root *root) | |||
2332 | mutex_lock(&fs_info->scrub_lock); | 2335 | mutex_lock(&fs_info->scrub_lock); |
2333 | } | 2336 | } |
2334 | mutex_unlock(&fs_info->scrub_lock); | 2337 | mutex_unlock(&fs_info->scrub_lock); |
2335 | |||
2336 | return 0; | ||
2337 | } | 2338 | } |
2338 | 2339 | ||
2339 | int btrfs_scrub_continue(struct btrfs_root *root) | 2340 | void btrfs_scrub_continue(struct btrfs_root *root) |
2340 | { | 2341 | { |
2341 | struct btrfs_fs_info *fs_info = root->fs_info; | 2342 | struct btrfs_fs_info *fs_info = root->fs_info; |
2342 | 2343 | ||
2343 | atomic_dec(&fs_info->scrub_pause_req); | 2344 | atomic_dec(&fs_info->scrub_pause_req); |
2344 | wake_up(&fs_info->scrub_pause_wait); | 2345 | wake_up(&fs_info->scrub_pause_wait); |
2345 | return 0; | ||
2346 | } | 2346 | } |
2347 | 2347 | ||
2348 | int btrfs_scrub_pause_super(struct btrfs_root *root) | 2348 | void btrfs_scrub_pause_super(struct btrfs_root *root) |
2349 | { | 2349 | { |
2350 | down_write(&root->fs_info->scrub_super_lock); | 2350 | down_write(&root->fs_info->scrub_super_lock); |
2351 | return 0; | ||
2352 | } | 2351 | } |
2353 | 2352 | ||
2354 | int btrfs_scrub_continue_super(struct btrfs_root *root) | 2353 | void btrfs_scrub_continue_super(struct btrfs_root *root) |
2355 | { | 2354 | { |
2356 | up_write(&root->fs_info->scrub_super_lock); | 2355 | up_write(&root->fs_info->scrub_super_lock); |
2357 | return 0; | ||
2358 | } | 2356 | } |
2359 | 2357 | ||
2360 | int btrfs_scrub_cancel(struct btrfs_root *root) | 2358 | int __btrfs_scrub_cancel(struct btrfs_fs_info *fs_info) |
2361 | { | 2359 | { |
2362 | struct btrfs_fs_info *fs_info = root->fs_info; | ||
2363 | 2360 | ||
2364 | mutex_lock(&fs_info->scrub_lock); | 2361 | mutex_lock(&fs_info->scrub_lock); |
2365 | if (!atomic_read(&fs_info->scrubs_running)) { | 2362 | if (!atomic_read(&fs_info->scrubs_running)) { |
@@ -2380,6 +2377,11 @@ int btrfs_scrub_cancel(struct btrfs_root *root) | |||
2380 | return 0; | 2377 | return 0; |
2381 | } | 2378 | } |
2382 | 2379 | ||
2380 | int btrfs_scrub_cancel(struct btrfs_root *root) | ||
2381 | { | ||
2382 | return __btrfs_scrub_cancel(root->fs_info); | ||
2383 | } | ||
2384 | |||
2383 | int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev) | 2385 | int btrfs_scrub_cancel_dev(struct btrfs_root *root, struct btrfs_device *dev) |
2384 | { | 2386 | { |
2385 | struct btrfs_fs_info *fs_info = root->fs_info; | 2387 | struct btrfs_fs_info *fs_info = root->fs_info; |
diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c index 3ce97b217cbe..9db64165123a 100644 --- a/fs/btrfs/super.c +++ b/fs/btrfs/super.c | |||
@@ -76,6 +76,9 @@ static const char *btrfs_decode_error(struct btrfs_fs_info *fs_info, int errno, | |||
76 | case -EROFS: | 76 | case -EROFS: |
77 | errstr = "Readonly filesystem"; | 77 | errstr = "Readonly filesystem"; |
78 | break; | 78 | break; |
79 | case -EEXIST: | ||
80 | errstr = "Object already exists"; | ||
81 | break; | ||
79 | default: | 82 | default: |
80 | if (nbuf) { | 83 | if (nbuf) { |
81 | if (snprintf(nbuf, 16, "error %d", -errno) >= 0) | 84 | if (snprintf(nbuf, 16, "error %d", -errno) >= 0) |
@@ -116,6 +119,8 @@ static void btrfs_handle_error(struct btrfs_fs_info *fs_info) | |||
116 | if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { | 119 | if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { |
117 | sb->s_flags |= MS_RDONLY; | 120 | sb->s_flags |= MS_RDONLY; |
118 | printk(KERN_INFO "btrfs is forced readonly\n"); | 121 | printk(KERN_INFO "btrfs is forced readonly\n"); |
122 | __btrfs_scrub_cancel(fs_info); | ||
123 | // WARN_ON(1); | ||
119 | } | 124 | } |
120 | } | 125 | } |
121 | 126 | ||
@@ -124,25 +129,132 @@ static void btrfs_handle_error(struct btrfs_fs_info *fs_info) | |||
124 | * invokes the approciate error response. | 129 | * invokes the approciate error response. |
125 | */ | 130 | */ |
126 | void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function, | 131 | void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function, |
127 | unsigned int line, int errno) | 132 | unsigned int line, int errno, const char *fmt, ...) |
128 | { | 133 | { |
129 | struct super_block *sb = fs_info->sb; | 134 | struct super_block *sb = fs_info->sb; |
130 | char nbuf[16]; | 135 | char nbuf[16]; |
131 | const char *errstr; | 136 | const char *errstr; |
137 | va_list args; | ||
138 | va_start(args, fmt); | ||
132 | 139 | ||
133 | /* | 140 | /* |
134 | * Special case: if the error is EROFS, and we're already | 141 | * Special case: if the error is EROFS, and we're already |
135 | * under MS_RDONLY, then it is safe here. | 142 | * under MS_RDONLY, then it is safe here. |
136 | */ | 143 | */ |
137 | if (errno == -EROFS && (sb->s_flags & MS_RDONLY)) | 144 | if (errno == -EROFS && (sb->s_flags & MS_RDONLY)) |
145 | return; | ||
146 | |||
147 | errstr = btrfs_decode_error(fs_info, errno, nbuf); | ||
148 | if (fmt) { | ||
149 | struct va_format vaf = { | ||
150 | .fmt = fmt, | ||
151 | .va = &args, | ||
152 | }; | ||
153 | |||
154 | printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s (%pV)\n", | ||
155 | sb->s_id, function, line, errstr, &vaf); | ||
156 | } else { | ||
157 | printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s\n", | ||
158 | sb->s_id, function, line, errstr); | ||
159 | } | ||
160 | |||
161 | /* Don't go through full error handling during mount */ | ||
162 | if (sb->s_flags & MS_BORN) { | ||
163 | save_error_info(fs_info); | ||
164 | btrfs_handle_error(fs_info); | ||
165 | } | ||
166 | va_end(args); | ||
167 | } | ||
168 | |||
169 | const char *logtypes[] = { | ||
170 | "emergency", | ||
171 | "alert", | ||
172 | "critical", | ||
173 | "error", | ||
174 | "warning", | ||
175 | "notice", | ||
176 | "info", | ||
177 | "debug", | ||
178 | }; | ||
179 | |||
180 | void btrfs_printk(struct btrfs_fs_info *fs_info, const char *fmt, ...) | ||
181 | { | ||
182 | struct super_block *sb = fs_info->sb; | ||
183 | char lvl[4]; | ||
184 | struct va_format vaf; | ||
185 | va_list args; | ||
186 | const char *type = logtypes[4]; | ||
187 | |||
188 | va_start(args, fmt); | ||
189 | |||
190 | if (fmt[0] == '<' && isdigit(fmt[1]) && fmt[2] == '>') { | ||
191 | strncpy(lvl, fmt, 3); | ||
192 | fmt += 3; | ||
193 | type = logtypes[fmt[1] - '0']; | ||
194 | } else | ||
195 | *lvl = '\0'; | ||
196 | |||
197 | vaf.fmt = fmt; | ||
198 | vaf.va = &args; | ||
199 | printk("%sBTRFS %s (device %s): %pV", lvl, type, sb->s_id, &vaf); | ||
200 | } | ||
201 | |||
202 | /* | ||
203 | * We only mark the transaction aborted and then set the file system read-only. | ||
204 | * This will prevent new transactions from starting or trying to join this | ||
205 | * one. | ||
206 | * | ||
207 | * This means that error recovery at the call site is limited to freeing | ||
208 | * any local memory allocations and passing the error code up without | ||
209 | * further cleanup. The transaction should complete as it normally would | ||
210 | * in the call path but will return -EIO. | ||
211 | * | ||
212 | * We'll complete the cleanup in btrfs_end_transaction and | ||
213 | * btrfs_commit_transaction. | ||
214 | */ | ||
215 | void __btrfs_abort_transaction(struct btrfs_trans_handle *trans, | ||
216 | struct btrfs_root *root, const char *function, | ||
217 | unsigned int line, int errno) | ||
218 | { | ||
219 | WARN_ONCE(1, KERN_DEBUG "btrfs: Transaction aborted"); | ||
220 | trans->aborted = errno; | ||
221 | /* Nothing used. The other threads that have joined this | ||
222 | * transaction may be able to continue. */ | ||
223 | if (!trans->blocks_used) { | ||
224 | btrfs_printk(root->fs_info, "Aborting unused transaction.\n"); | ||
138 | return; | 225 | return; |
226 | } | ||
227 | trans->transaction->aborted = errno; | ||
228 | __btrfs_std_error(root->fs_info, function, line, errno, NULL); | ||
229 | } | ||
230 | /* | ||
231 | * __btrfs_panic decodes unexpected, fatal errors from the caller, | ||
232 | * issues an alert, and either panics or BUGs, depending on mount options. | ||
233 | */ | ||
234 | void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function, | ||
235 | unsigned int line, int errno, const char *fmt, ...) | ||
236 | { | ||
237 | char nbuf[16]; | ||
238 | char *s_id = "<unknown>"; | ||
239 | const char *errstr; | ||
240 | struct va_format vaf = { .fmt = fmt }; | ||
241 | va_list args; | ||
139 | 242 | ||
140 | errstr = btrfs_decode_error(fs_info, errno, nbuf); | 243 | if (fs_info) |
141 | printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s\n", | 244 | s_id = fs_info->sb->s_id; |
142 | sb->s_id, function, line, errstr); | 245 | |
143 | save_error_info(fs_info); | 246 | va_start(args, fmt); |
247 | vaf.va = &args; | ||
144 | 248 | ||
145 | btrfs_handle_error(fs_info); | 249 | errstr = btrfs_decode_error(fs_info, errno, nbuf); |
250 | if (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR) | ||
251 | panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (%s)\n", | ||
252 | s_id, function, line, &vaf, errstr); | ||
253 | |||
254 | printk(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (%s)\n", | ||
255 | s_id, function, line, &vaf, errstr); | ||
256 | va_end(args); | ||
257 | /* Caller calls BUG() */ | ||
146 | } | 258 | } |
147 | 259 | ||
148 | static void btrfs_put_super(struct super_block *sb) | 260 | static void btrfs_put_super(struct super_block *sb) |
@@ -166,7 +278,7 @@ enum { | |||
166 | Opt_enospc_debug, Opt_subvolrootid, Opt_defrag, Opt_inode_cache, | 278 | Opt_enospc_debug, Opt_subvolrootid, Opt_defrag, Opt_inode_cache, |
167 | Opt_no_space_cache, Opt_recovery, Opt_skip_balance, | 279 | Opt_no_space_cache, Opt_recovery, Opt_skip_balance, |
168 | Opt_check_integrity, Opt_check_integrity_including_extent_data, | 280 | Opt_check_integrity, Opt_check_integrity_including_extent_data, |
169 | Opt_check_integrity_print_mask, | 281 | Opt_check_integrity_print_mask, Opt_fatal_errors, |
170 | Opt_err, | 282 | Opt_err, |
171 | }; | 283 | }; |
172 | 284 | ||
@@ -206,12 +318,14 @@ static match_table_t tokens = { | |||
206 | {Opt_check_integrity, "check_int"}, | 318 | {Opt_check_integrity, "check_int"}, |
207 | {Opt_check_integrity_including_extent_data, "check_int_data"}, | 319 | {Opt_check_integrity_including_extent_data, "check_int_data"}, |
208 | {Opt_check_integrity_print_mask, "check_int_print_mask=%d"}, | 320 | {Opt_check_integrity_print_mask, "check_int_print_mask=%d"}, |
321 | {Opt_fatal_errors, "fatal_errors=%s"}, | ||
209 | {Opt_err, NULL}, | 322 | {Opt_err, NULL}, |
210 | }; | 323 | }; |
211 | 324 | ||
212 | /* | 325 | /* |
213 | * Regular mount options parser. Everything that is needed only when | 326 | * Regular mount options parser. Everything that is needed only when |
214 | * reading in a new superblock is parsed here. | 327 | * reading in a new superblock is parsed here. |
328 | * XXX JDM: This needs to be cleaned up for remount. | ||
215 | */ | 329 | */ |
216 | int btrfs_parse_options(struct btrfs_root *root, char *options) | 330 | int btrfs_parse_options(struct btrfs_root *root, char *options) |
217 | { | 331 | { |
@@ -438,6 +552,18 @@ int btrfs_parse_options(struct btrfs_root *root, char *options) | |||
438 | ret = -EINVAL; | 552 | ret = -EINVAL; |
439 | goto out; | 553 | goto out; |
440 | #endif | 554 | #endif |
555 | case Opt_fatal_errors: | ||
556 | if (strcmp(args[0].from, "panic") == 0) | ||
557 | btrfs_set_opt(info->mount_opt, | ||
558 | PANIC_ON_FATAL_ERROR); | ||
559 | else if (strcmp(args[0].from, "bug") == 0) | ||
560 | btrfs_clear_opt(info->mount_opt, | ||
561 | PANIC_ON_FATAL_ERROR); | ||
562 | else { | ||
563 | ret = -EINVAL; | ||
564 | goto out; | ||
565 | } | ||
566 | break; | ||
441 | case Opt_err: | 567 | case Opt_err: |
442 | printk(KERN_INFO "btrfs: unrecognized mount option " | 568 | printk(KERN_INFO "btrfs: unrecognized mount option " |
443 | "'%s'\n", p); | 569 | "'%s'\n", p); |
@@ -766,6 +892,8 @@ static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry) | |||
766 | seq_puts(seq, ",inode_cache"); | 892 | seq_puts(seq, ",inode_cache"); |
767 | if (btrfs_test_opt(root, SKIP_BALANCE)) | 893 | if (btrfs_test_opt(root, SKIP_BALANCE)) |
768 | seq_puts(seq, ",skip_balance"); | 894 | seq_puts(seq, ",skip_balance"); |
895 | if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR)) | ||
896 | seq_puts(seq, ",fatal_errors=panic"); | ||
769 | return 0; | 897 | return 0; |
770 | } | 898 | } |
771 | 899 | ||
@@ -999,11 +1127,20 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data) | |||
999 | { | 1127 | { |
1000 | struct btrfs_fs_info *fs_info = btrfs_sb(sb); | 1128 | struct btrfs_fs_info *fs_info = btrfs_sb(sb); |
1001 | struct btrfs_root *root = fs_info->tree_root; | 1129 | struct btrfs_root *root = fs_info->tree_root; |
1130 | unsigned old_flags = sb->s_flags; | ||
1131 | unsigned long old_opts = fs_info->mount_opt; | ||
1132 | unsigned long old_compress_type = fs_info->compress_type; | ||
1133 | u64 old_max_inline = fs_info->max_inline; | ||
1134 | u64 old_alloc_start = fs_info->alloc_start; | ||
1135 | int old_thread_pool_size = fs_info->thread_pool_size; | ||
1136 | unsigned int old_metadata_ratio = fs_info->metadata_ratio; | ||
1002 | int ret; | 1137 | int ret; |
1003 | 1138 | ||
1004 | ret = btrfs_parse_options(root, data); | 1139 | ret = btrfs_parse_options(root, data); |
1005 | if (ret) | 1140 | if (ret) { |
1006 | return -EINVAL; | 1141 | ret = -EINVAL; |
1142 | goto restore; | ||
1143 | } | ||
1007 | 1144 | ||
1008 | if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) | 1145 | if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY)) |
1009 | return 0; | 1146 | return 0; |
@@ -1011,26 +1148,44 @@ static int btrfs_remount(struct super_block *sb, int *flags, char *data) | |||
1011 | if (*flags & MS_RDONLY) { | 1148 | if (*flags & MS_RDONLY) { |
1012 | sb->s_flags |= MS_RDONLY; | 1149 | sb->s_flags |= MS_RDONLY; |
1013 | 1150 | ||
1014 | ret = btrfs_commit_super(root); | 1151 | ret = btrfs_commit_super(root); |
1015 | WARN_ON(ret); | 1152 | if (ret) |
1153 | goto restore; | ||
1016 | } else { | 1154 | } else { |
1017 | if (fs_info->fs_devices->rw_devices == 0) | 1155 | if (fs_info->fs_devices->rw_devices == 0) |
1018 | return -EACCES; | 1156 | ret = -EACCES; |
1157 | goto restore; | ||
1019 | 1158 | ||
1020 | if (btrfs_super_log_root(fs_info->super_copy) != 0) | 1159 | if (btrfs_super_log_root(fs_info->super_copy) != 0) |
1021 | return -EINVAL; | 1160 | ret = -EINVAL; |
1161 | goto restore; | ||
1022 | 1162 | ||
1023 | ret = btrfs_cleanup_fs_roots(fs_info); | 1163 | ret = btrfs_cleanup_fs_roots(fs_info); |
1024 | WARN_ON(ret); | 1164 | if (ret) |
1165 | goto restore; | ||
1025 | 1166 | ||
1026 | /* recover relocation */ | 1167 | /* recover relocation */ |
1027 | ret = btrfs_recover_relocation(root); | 1168 | ret = btrfs_recover_relocation(root); |
1028 | WARN_ON(ret); | 1169 | if (ret) |
1170 | goto restore; | ||
1029 | 1171 | ||
1030 | sb->s_flags &= ~MS_RDONLY; | 1172 | sb->s_flags &= ~MS_RDONLY; |
1031 | } | 1173 | } |
1032 | 1174 | ||
1033 | return 0; | 1175 | return 0; |
1176 | |||
1177 | restore: | ||
1178 | /* We've hit an error - don't reset MS_RDONLY */ | ||
1179 | if (sb->s_flags & MS_RDONLY) | ||
1180 | old_flags |= MS_RDONLY; | ||
1181 | sb->s_flags = old_flags; | ||
1182 | fs_info->mount_opt = old_opts; | ||
1183 | fs_info->compress_type = old_compress_type; | ||
1184 | fs_info->max_inline = old_max_inline; | ||
1185 | fs_info->alloc_start = old_alloc_start; | ||
1186 | fs_info->thread_pool_size = old_thread_pool_size; | ||
1187 | fs_info->metadata_ratio = old_metadata_ratio; | ||
1188 | return ret; | ||
1034 | } | 1189 | } |
1035 | 1190 | ||
1036 | /* Used to sort the devices by max_avail(descending sort) */ | 1191 | /* Used to sort the devices by max_avail(descending sort) */ |
@@ -1360,9 +1515,7 @@ static int __init init_btrfs_fs(void) | |||
1360 | if (err) | 1515 | if (err) |
1361 | return err; | 1516 | return err; |
1362 | 1517 | ||
1363 | err = btrfs_init_compress(); | 1518 | btrfs_init_compress(); |
1364 | if (err) | ||
1365 | goto free_sysfs; | ||
1366 | 1519 | ||
1367 | err = btrfs_init_cachep(); | 1520 | err = btrfs_init_cachep(); |
1368 | if (err) | 1521 | if (err) |
@@ -1403,7 +1556,6 @@ free_cachep: | |||
1403 | btrfs_destroy_cachep(); | 1556 | btrfs_destroy_cachep(); |
1404 | free_compress: | 1557 | free_compress: |
1405 | btrfs_exit_compress(); | 1558 | btrfs_exit_compress(); |
1406 | free_sysfs: | ||
1407 | btrfs_exit_sysfs(); | 1559 | btrfs_exit_sysfs(); |
1408 | return err; | 1560 | return err; |
1409 | } | 1561 | } |
diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c index 04b77e3ceb7a..63f835aa9788 100644 --- a/fs/btrfs/transaction.c +++ b/fs/btrfs/transaction.c | |||
@@ -31,7 +31,7 @@ | |||
31 | 31 | ||
32 | #define BTRFS_ROOT_TRANS_TAG 0 | 32 | #define BTRFS_ROOT_TRANS_TAG 0 |
33 | 33 | ||
34 | static noinline void put_transaction(struct btrfs_transaction *transaction) | 34 | void put_transaction(struct btrfs_transaction *transaction) |
35 | { | 35 | { |
36 | WARN_ON(atomic_read(&transaction->use_count) == 0); | 36 | WARN_ON(atomic_read(&transaction->use_count) == 0); |
37 | if (atomic_dec_and_test(&transaction->use_count)) { | 37 | if (atomic_dec_and_test(&transaction->use_count)) { |
@@ -58,6 +58,12 @@ static noinline int join_transaction(struct btrfs_root *root, int nofail) | |||
58 | 58 | ||
59 | spin_lock(&root->fs_info->trans_lock); | 59 | spin_lock(&root->fs_info->trans_lock); |
60 | loop: | 60 | loop: |
61 | /* The file system has been taken offline. No new transactions. */ | ||
62 | if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { | ||
63 | spin_unlock(&root->fs_info->trans_lock); | ||
64 | return -EROFS; | ||
65 | } | ||
66 | |||
61 | if (root->fs_info->trans_no_join) { | 67 | if (root->fs_info->trans_no_join) { |
62 | if (!nofail) { | 68 | if (!nofail) { |
63 | spin_unlock(&root->fs_info->trans_lock); | 69 | spin_unlock(&root->fs_info->trans_lock); |
@@ -67,6 +73,8 @@ loop: | |||
67 | 73 | ||
68 | cur_trans = root->fs_info->running_transaction; | 74 | cur_trans = root->fs_info->running_transaction; |
69 | if (cur_trans) { | 75 | if (cur_trans) { |
76 | if (cur_trans->aborted) | ||
77 | return cur_trans->aborted; | ||
70 | atomic_inc(&cur_trans->use_count); | 78 | atomic_inc(&cur_trans->use_count); |
71 | atomic_inc(&cur_trans->num_writers); | 79 | atomic_inc(&cur_trans->num_writers); |
72 | cur_trans->num_joined++; | 80 | cur_trans->num_joined++; |
@@ -123,6 +131,7 @@ loop: | |||
123 | root->fs_info->generation++; | 131 | root->fs_info->generation++; |
124 | cur_trans->transid = root->fs_info->generation; | 132 | cur_trans->transid = root->fs_info->generation; |
125 | root->fs_info->running_transaction = cur_trans; | 133 | root->fs_info->running_transaction = cur_trans; |
134 | cur_trans->aborted = 0; | ||
126 | spin_unlock(&root->fs_info->trans_lock); | 135 | spin_unlock(&root->fs_info->trans_lock); |
127 | 136 | ||
128 | return 0; | 137 | return 0; |
@@ -318,6 +327,7 @@ again: | |||
318 | h->use_count = 1; | 327 | h->use_count = 1; |
319 | h->block_rsv = NULL; | 328 | h->block_rsv = NULL; |
320 | h->orig_rsv = NULL; | 329 | h->orig_rsv = NULL; |
330 | h->aborted = 0; | ||
321 | 331 | ||
322 | smp_mb(); | 332 | smp_mb(); |
323 | if (cur_trans->blocked && may_wait_transaction(root, type)) { | 333 | if (cur_trans->blocked && may_wait_transaction(root, type)) { |
@@ -440,6 +450,7 @@ int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, | |||
440 | struct btrfs_transaction *cur_trans = trans->transaction; | 450 | struct btrfs_transaction *cur_trans = trans->transaction; |
441 | struct btrfs_block_rsv *rsv = trans->block_rsv; | 451 | struct btrfs_block_rsv *rsv = trans->block_rsv; |
442 | int updates; | 452 | int updates; |
453 | int err; | ||
443 | 454 | ||
444 | smp_mb(); | 455 | smp_mb(); |
445 | if (cur_trans->blocked || cur_trans->delayed_refs.flushing) | 456 | if (cur_trans->blocked || cur_trans->delayed_refs.flushing) |
@@ -453,8 +464,11 @@ int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, | |||
453 | 464 | ||
454 | updates = trans->delayed_ref_updates; | 465 | updates = trans->delayed_ref_updates; |
455 | trans->delayed_ref_updates = 0; | 466 | trans->delayed_ref_updates = 0; |
456 | if (updates) | 467 | if (updates) { |
457 | btrfs_run_delayed_refs(trans, root, updates); | 468 | err = btrfs_run_delayed_refs(trans, root, updates); |
469 | if (err) /* Error code will also eval true */ | ||
470 | return err; | ||
471 | } | ||
458 | 472 | ||
459 | trans->block_rsv = rsv; | 473 | trans->block_rsv = rsv; |
460 | 474 | ||
@@ -525,6 +539,11 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, | |||
525 | if (throttle) | 539 | if (throttle) |
526 | btrfs_run_delayed_iputs(root); | 540 | btrfs_run_delayed_iputs(root); |
527 | 541 | ||
542 | if (trans->aborted || | ||
543 | root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { | ||
544 | return -EIO; | ||
545 | } | ||
546 | |||
528 | return 0; | 547 | return 0; |
529 | } | 548 | } |
530 | 549 | ||
@@ -690,11 +709,13 @@ static int update_cowonly_root(struct btrfs_trans_handle *trans, | |||
690 | ret = btrfs_update_root(trans, tree_root, | 709 | ret = btrfs_update_root(trans, tree_root, |
691 | &root->root_key, | 710 | &root->root_key, |
692 | &root->root_item); | 711 | &root->root_item); |
693 | BUG_ON(ret); | 712 | if (ret) |
713 | return ret; | ||
694 | 714 | ||
695 | old_root_used = btrfs_root_used(&root->root_item); | 715 | old_root_used = btrfs_root_used(&root->root_item); |
696 | ret = btrfs_write_dirty_block_groups(trans, root); | 716 | ret = btrfs_write_dirty_block_groups(trans, root); |
697 | BUG_ON(ret); | 717 | if (ret) |
718 | return ret; | ||
698 | } | 719 | } |
699 | 720 | ||
700 | if (root != root->fs_info->extent_root) | 721 | if (root != root->fs_info->extent_root) |
@@ -705,6 +726,10 @@ static int update_cowonly_root(struct btrfs_trans_handle *trans, | |||
705 | 726 | ||
706 | /* | 727 | /* |
707 | * update all the cowonly tree roots on disk | 728 | * update all the cowonly tree roots on disk |
729 | * | ||
730 | * The error handling in this function may not be obvious. Any of the | ||
731 | * failures will cause the file system to go offline. We still need | ||
732 | * to clean up the delayed refs. | ||
708 | */ | 733 | */ |
709 | static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, | 734 | static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, |
710 | struct btrfs_root *root) | 735 | struct btrfs_root *root) |
@@ -715,22 +740,30 @@ static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, | |||
715 | int ret; | 740 | int ret; |
716 | 741 | ||
717 | ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); | 742 | ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); |
718 | BUG_ON(ret); | 743 | if (ret) |
744 | return ret; | ||
719 | 745 | ||
720 | eb = btrfs_lock_root_node(fs_info->tree_root); | 746 | eb = btrfs_lock_root_node(fs_info->tree_root); |
721 | btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb); | 747 | ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, |
748 | 0, &eb); | ||
722 | btrfs_tree_unlock(eb); | 749 | btrfs_tree_unlock(eb); |
723 | free_extent_buffer(eb); | 750 | free_extent_buffer(eb); |
724 | 751 | ||
752 | if (ret) | ||
753 | return ret; | ||
754 | |||
725 | ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); | 755 | ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); |
726 | BUG_ON(ret); | 756 | if (ret) |
757 | return ret; | ||
727 | 758 | ||
728 | while (!list_empty(&fs_info->dirty_cowonly_roots)) { | 759 | while (!list_empty(&fs_info->dirty_cowonly_roots)) { |
729 | next = fs_info->dirty_cowonly_roots.next; | 760 | next = fs_info->dirty_cowonly_roots.next; |
730 | list_del_init(next); | 761 | list_del_init(next); |
731 | root = list_entry(next, struct btrfs_root, dirty_list); | 762 | root = list_entry(next, struct btrfs_root, dirty_list); |
732 | 763 | ||
733 | update_cowonly_root(trans, root); | 764 | ret = update_cowonly_root(trans, root); |
765 | if (ret) | ||
766 | return ret; | ||
734 | } | 767 | } |
735 | 768 | ||
736 | down_write(&fs_info->extent_commit_sem); | 769 | down_write(&fs_info->extent_commit_sem); |
@@ -874,7 +907,7 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, | |||
874 | 907 | ||
875 | new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); | 908 | new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); |
876 | if (!new_root_item) { | 909 | if (!new_root_item) { |
877 | pending->error = -ENOMEM; | 910 | ret = pending->error = -ENOMEM; |
878 | goto fail; | 911 | goto fail; |
879 | } | 912 | } |
880 | 913 | ||
@@ -911,21 +944,24 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, | |||
911 | * insert the directory item | 944 | * insert the directory item |
912 | */ | 945 | */ |
913 | ret = btrfs_set_inode_index(parent_inode, &index); | 946 | ret = btrfs_set_inode_index(parent_inode, &index); |
914 | BUG_ON(ret); | 947 | BUG_ON(ret); /* -ENOMEM */ |
915 | ret = btrfs_insert_dir_item(trans, parent_root, | 948 | ret = btrfs_insert_dir_item(trans, parent_root, |
916 | dentry->d_name.name, dentry->d_name.len, | 949 | dentry->d_name.name, dentry->d_name.len, |
917 | parent_inode, &key, | 950 | parent_inode, &key, |
918 | BTRFS_FT_DIR, index); | 951 | BTRFS_FT_DIR, index); |
919 | if (ret) { | 952 | if (ret == -EEXIST) { |
920 | pending->error = -EEXIST; | 953 | pending->error = -EEXIST; |
921 | dput(parent); | 954 | dput(parent); |
922 | goto fail; | 955 | goto fail; |
956 | } else if (ret) { | ||
957 | goto abort_trans_dput; | ||
923 | } | 958 | } |
924 | 959 | ||
925 | btrfs_i_size_write(parent_inode, parent_inode->i_size + | 960 | btrfs_i_size_write(parent_inode, parent_inode->i_size + |
926 | dentry->d_name.len * 2); | 961 | dentry->d_name.len * 2); |
927 | ret = btrfs_update_inode(trans, parent_root, parent_inode); | 962 | ret = btrfs_update_inode(trans, parent_root, parent_inode); |
928 | BUG_ON(ret); | 963 | if (ret) |
964 | goto abort_trans_dput; | ||
929 | 965 | ||
930 | /* | 966 | /* |
931 | * pull in the delayed directory update | 967 | * pull in the delayed directory update |
@@ -934,7 +970,10 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, | |||
934 | * snapshot | 970 | * snapshot |
935 | */ | 971 | */ |
936 | ret = btrfs_run_delayed_items(trans, root); | 972 | ret = btrfs_run_delayed_items(trans, root); |
937 | BUG_ON(ret); | 973 | if (ret) { /* Transaction aborted */ |
974 | dput(parent); | ||
975 | goto fail; | ||
976 | } | ||
938 | 977 | ||
939 | record_root_in_trans(trans, root); | 978 | record_root_in_trans(trans, root); |
940 | btrfs_set_root_last_snapshot(&root->root_item, trans->transid); | 979 | btrfs_set_root_last_snapshot(&root->root_item, trans->transid); |
@@ -949,12 +988,21 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, | |||
949 | btrfs_set_root_flags(new_root_item, root_flags); | 988 | btrfs_set_root_flags(new_root_item, root_flags); |
950 | 989 | ||
951 | old = btrfs_lock_root_node(root); | 990 | old = btrfs_lock_root_node(root); |
952 | btrfs_cow_block(trans, root, old, NULL, 0, &old); | 991 | ret = btrfs_cow_block(trans, root, old, NULL, 0, &old); |
992 | if (ret) { | ||
993 | btrfs_tree_unlock(old); | ||
994 | free_extent_buffer(old); | ||
995 | goto abort_trans_dput; | ||
996 | } | ||
997 | |||
953 | btrfs_set_lock_blocking(old); | 998 | btrfs_set_lock_blocking(old); |
954 | 999 | ||
955 | btrfs_copy_root(trans, root, old, &tmp, objectid); | 1000 | ret = btrfs_copy_root(trans, root, old, &tmp, objectid); |
1001 | /* clean up in any case */ | ||
956 | btrfs_tree_unlock(old); | 1002 | btrfs_tree_unlock(old); |
957 | free_extent_buffer(old); | 1003 | free_extent_buffer(old); |
1004 | if (ret) | ||
1005 | goto abort_trans_dput; | ||
958 | 1006 | ||
959 | /* see comments in should_cow_block() */ | 1007 | /* see comments in should_cow_block() */ |
960 | root->force_cow = 1; | 1008 | root->force_cow = 1; |
@@ -966,7 +1014,8 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, | |||
966 | ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); | 1014 | ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); |
967 | btrfs_tree_unlock(tmp); | 1015 | btrfs_tree_unlock(tmp); |
968 | free_extent_buffer(tmp); | 1016 | free_extent_buffer(tmp); |
969 | BUG_ON(ret); | 1017 | if (ret) |
1018 | goto abort_trans_dput; | ||
970 | 1019 | ||
971 | /* | 1020 | /* |
972 | * insert root back/forward references | 1021 | * insert root back/forward references |
@@ -975,19 +1024,32 @@ static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, | |||
975 | parent_root->root_key.objectid, | 1024 | parent_root->root_key.objectid, |
976 | btrfs_ino(parent_inode), index, | 1025 | btrfs_ino(parent_inode), index, |
977 | dentry->d_name.name, dentry->d_name.len); | 1026 | dentry->d_name.name, dentry->d_name.len); |
978 | BUG_ON(ret); | ||
979 | dput(parent); | 1027 | dput(parent); |
1028 | if (ret) | ||
1029 | goto fail; | ||
980 | 1030 | ||
981 | key.offset = (u64)-1; | 1031 | key.offset = (u64)-1; |
982 | pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); | 1032 | pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); |
983 | BUG_ON(IS_ERR(pending->snap)); | 1033 | if (IS_ERR(pending->snap)) { |
1034 | ret = PTR_ERR(pending->snap); | ||
1035 | goto abort_trans; | ||
1036 | } | ||
984 | 1037 | ||
985 | btrfs_reloc_post_snapshot(trans, pending); | 1038 | ret = btrfs_reloc_post_snapshot(trans, pending); |
1039 | if (ret) | ||
1040 | goto abort_trans; | ||
1041 | ret = 0; | ||
986 | fail: | 1042 | fail: |
987 | kfree(new_root_item); | 1043 | kfree(new_root_item); |
988 | trans->block_rsv = rsv; | 1044 | trans->block_rsv = rsv; |
989 | btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1); | 1045 | btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1); |
990 | return 0; | 1046 | return ret; |
1047 | |||
1048 | abort_trans_dput: | ||
1049 | dput(parent); | ||
1050 | abort_trans: | ||
1051 | btrfs_abort_transaction(trans, root, ret); | ||
1052 | goto fail; | ||
991 | } | 1053 | } |
992 | 1054 | ||
993 | /* | 1055 | /* |
@@ -1124,6 +1186,33 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, | |||
1124 | return 0; | 1186 | return 0; |
1125 | } | 1187 | } |
1126 | 1188 | ||
1189 | |||
1190 | static void cleanup_transaction(struct btrfs_trans_handle *trans, | ||
1191 | struct btrfs_root *root) | ||
1192 | { | ||
1193 | struct btrfs_transaction *cur_trans = trans->transaction; | ||
1194 | |||
1195 | WARN_ON(trans->use_count > 1); | ||
1196 | |||
1197 | spin_lock(&root->fs_info->trans_lock); | ||
1198 | list_del_init(&cur_trans->list); | ||
1199 | spin_unlock(&root->fs_info->trans_lock); | ||
1200 | |||
1201 | btrfs_cleanup_one_transaction(trans->transaction, root); | ||
1202 | |||
1203 | put_transaction(cur_trans); | ||
1204 | put_transaction(cur_trans); | ||
1205 | |||
1206 | trace_btrfs_transaction_commit(root); | ||
1207 | |||
1208 | btrfs_scrub_continue(root); | ||
1209 | |||
1210 | if (current->journal_info == trans) | ||
1211 | current->journal_info = NULL; | ||
1212 | |||
1213 | kmem_cache_free(btrfs_trans_handle_cachep, trans); | ||
1214 | } | ||
1215 | |||
1127 | /* | 1216 | /* |
1128 | * btrfs_transaction state sequence: | 1217 | * btrfs_transaction state sequence: |
1129 | * in_commit = 0, blocked = 0 (initial) | 1218 | * in_commit = 0, blocked = 0 (initial) |
@@ -1135,10 +1224,10 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, | |||
1135 | struct btrfs_root *root) | 1224 | struct btrfs_root *root) |
1136 | { | 1225 | { |
1137 | unsigned long joined = 0; | 1226 | unsigned long joined = 0; |
1138 | struct btrfs_transaction *cur_trans; | 1227 | struct btrfs_transaction *cur_trans = trans->transaction; |
1139 | struct btrfs_transaction *prev_trans = NULL; | 1228 | struct btrfs_transaction *prev_trans = NULL; |
1140 | DEFINE_WAIT(wait); | 1229 | DEFINE_WAIT(wait); |
1141 | int ret; | 1230 | int ret = -EIO; |
1142 | int should_grow = 0; | 1231 | int should_grow = 0; |
1143 | unsigned long now = get_seconds(); | 1232 | unsigned long now = get_seconds(); |
1144 | int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT); | 1233 | int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT); |
@@ -1148,13 +1237,18 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, | |||
1148 | btrfs_trans_release_metadata(trans, root); | 1237 | btrfs_trans_release_metadata(trans, root); |
1149 | trans->block_rsv = NULL; | 1238 | trans->block_rsv = NULL; |
1150 | 1239 | ||
1240 | if (cur_trans->aborted) | ||
1241 | goto cleanup_transaction; | ||
1242 | |||
1151 | /* make a pass through all the delayed refs we have so far | 1243 | /* make a pass through all the delayed refs we have so far |
1152 | * any runnings procs may add more while we are here | 1244 | * any runnings procs may add more while we are here |
1153 | */ | 1245 | */ |
1154 | ret = btrfs_run_delayed_refs(trans, root, 0); | 1246 | ret = btrfs_run_delayed_refs(trans, root, 0); |
1155 | BUG_ON(ret); | 1247 | if (ret) |
1248 | goto cleanup_transaction; | ||
1156 | 1249 | ||
1157 | cur_trans = trans->transaction; | 1250 | cur_trans = trans->transaction; |
1251 | |||
1158 | /* | 1252 | /* |
1159 | * set the flushing flag so procs in this transaction have to | 1253 | * set the flushing flag so procs in this transaction have to |
1160 | * start sending their work down. | 1254 | * start sending their work down. |
@@ -1162,19 +1256,20 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, | |||
1162 | cur_trans->delayed_refs.flushing = 1; | 1256 | cur_trans->delayed_refs.flushing = 1; |
1163 | 1257 | ||
1164 | ret = btrfs_run_delayed_refs(trans, root, 0); | 1258 | ret = btrfs_run_delayed_refs(trans, root, 0); |
1165 | BUG_ON(ret); | 1259 | if (ret) |
1260 | goto cleanup_transaction; | ||
1166 | 1261 | ||
1167 | spin_lock(&cur_trans->commit_lock); | 1262 | spin_lock(&cur_trans->commit_lock); |
1168 | if (cur_trans->in_commit) { | 1263 | if (cur_trans->in_commit) { |
1169 | spin_unlock(&cur_trans->commit_lock); | 1264 | spin_unlock(&cur_trans->commit_lock); |
1170 | atomic_inc(&cur_trans->use_count); | 1265 | atomic_inc(&cur_trans->use_count); |
1171 | btrfs_end_transaction(trans, root); | 1266 | ret = btrfs_end_transaction(trans, root); |
1172 | 1267 | ||
1173 | wait_for_commit(root, cur_trans); | 1268 | wait_for_commit(root, cur_trans); |
1174 | 1269 | ||
1175 | put_transaction(cur_trans); | 1270 | put_transaction(cur_trans); |
1176 | 1271 | ||
1177 | return 0; | 1272 | return ret; |
1178 | } | 1273 | } |
1179 | 1274 | ||
1180 | trans->transaction->in_commit = 1; | 1275 | trans->transaction->in_commit = 1; |
@@ -1214,12 +1309,12 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, | |||
1214 | 1309 | ||
1215 | if (flush_on_commit || snap_pending) { | 1310 | if (flush_on_commit || snap_pending) { |
1216 | btrfs_start_delalloc_inodes(root, 1); | 1311 | btrfs_start_delalloc_inodes(root, 1); |
1217 | ret = btrfs_wait_ordered_extents(root, 0, 1); | 1312 | btrfs_wait_ordered_extents(root, 0, 1); |
1218 | BUG_ON(ret); | ||
1219 | } | 1313 | } |
1220 | 1314 | ||
1221 | ret = btrfs_run_delayed_items(trans, root); | 1315 | ret = btrfs_run_delayed_items(trans, root); |
1222 | BUG_ON(ret); | 1316 | if (ret) |
1317 | goto cleanup_transaction; | ||
1223 | 1318 | ||
1224 | /* | 1319 | /* |
1225 | * rename don't use btrfs_join_transaction, so, once we | 1320 | * rename don't use btrfs_join_transaction, so, once we |
@@ -1261,13 +1356,22 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, | |||
1261 | mutex_lock(&root->fs_info->reloc_mutex); | 1356 | mutex_lock(&root->fs_info->reloc_mutex); |
1262 | 1357 | ||
1263 | ret = btrfs_run_delayed_items(trans, root); | 1358 | ret = btrfs_run_delayed_items(trans, root); |
1264 | BUG_ON(ret); | 1359 | if (ret) { |
1360 | mutex_unlock(&root->fs_info->reloc_mutex); | ||
1361 | goto cleanup_transaction; | ||
1362 | } | ||
1265 | 1363 | ||
1266 | ret = create_pending_snapshots(trans, root->fs_info); | 1364 | ret = create_pending_snapshots(trans, root->fs_info); |
1267 | BUG_ON(ret); | 1365 | if (ret) { |
1366 | mutex_unlock(&root->fs_info->reloc_mutex); | ||
1367 | goto cleanup_transaction; | ||
1368 | } | ||
1268 | 1369 | ||
1269 | ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); | 1370 | ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); |
1270 | BUG_ON(ret); | 1371 | if (ret) { |
1372 | mutex_unlock(&root->fs_info->reloc_mutex); | ||
1373 | goto cleanup_transaction; | ||
1374 | } | ||
1271 | 1375 | ||
1272 | /* | 1376 | /* |
1273 | * make sure none of the code above managed to slip in a | 1377 | * make sure none of the code above managed to slip in a |
@@ -1294,7 +1398,10 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, | |||
1294 | mutex_lock(&root->fs_info->tree_log_mutex); | 1398 | mutex_lock(&root->fs_info->tree_log_mutex); |
1295 | 1399 | ||
1296 | ret = commit_fs_roots(trans, root); | 1400 | ret = commit_fs_roots(trans, root); |
1297 | BUG_ON(ret); | 1401 | if (ret) { |
1402 | mutex_unlock(&root->fs_info->tree_log_mutex); | ||
1403 | goto cleanup_transaction; | ||
1404 | } | ||
1298 | 1405 | ||
1299 | /* commit_fs_roots gets rid of all the tree log roots, it is now | 1406 | /* commit_fs_roots gets rid of all the tree log roots, it is now |
1300 | * safe to free the root of tree log roots | 1407 | * safe to free the root of tree log roots |
@@ -1302,7 +1409,10 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, | |||
1302 | btrfs_free_log_root_tree(trans, root->fs_info); | 1409 | btrfs_free_log_root_tree(trans, root->fs_info); |
1303 | 1410 | ||
1304 | ret = commit_cowonly_roots(trans, root); | 1411 | ret = commit_cowonly_roots(trans, root); |
1305 | BUG_ON(ret); | 1412 | if (ret) { |
1413 | mutex_unlock(&root->fs_info->tree_log_mutex); | ||
1414 | goto cleanup_transaction; | ||
1415 | } | ||
1306 | 1416 | ||
1307 | btrfs_prepare_extent_commit(trans, root); | 1417 | btrfs_prepare_extent_commit(trans, root); |
1308 | 1418 | ||
@@ -1336,8 +1446,18 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, | |||
1336 | wake_up(&root->fs_info->transaction_wait); | 1446 | wake_up(&root->fs_info->transaction_wait); |
1337 | 1447 | ||
1338 | ret = btrfs_write_and_wait_transaction(trans, root); | 1448 | ret = btrfs_write_and_wait_transaction(trans, root); |
1339 | BUG_ON(ret); | 1449 | if (ret) { |
1340 | write_ctree_super(trans, root, 0); | 1450 | btrfs_error(root->fs_info, ret, |
1451 | "Error while writing out transaction."); | ||
1452 | mutex_unlock(&root->fs_info->tree_log_mutex); | ||
1453 | goto cleanup_transaction; | ||
1454 | } | ||
1455 | |||
1456 | ret = write_ctree_super(trans, root, 0); | ||
1457 | if (ret) { | ||
1458 | mutex_unlock(&root->fs_info->tree_log_mutex); | ||
1459 | goto cleanup_transaction; | ||
1460 | } | ||
1341 | 1461 | ||
1342 | /* | 1462 | /* |
1343 | * the super is written, we can safely allow the tree-loggers | 1463 | * the super is written, we can safely allow the tree-loggers |
@@ -1373,6 +1493,15 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans, | |||
1373 | btrfs_run_delayed_iputs(root); | 1493 | btrfs_run_delayed_iputs(root); |
1374 | 1494 | ||
1375 | return ret; | 1495 | return ret; |
1496 | |||
1497 | cleanup_transaction: | ||
1498 | btrfs_printk(root->fs_info, "Skipping commit of aborted transaction.\n"); | ||
1499 | // WARN_ON(1); | ||
1500 | if (current->journal_info == trans) | ||
1501 | current->journal_info = NULL; | ||
1502 | cleanup_transaction(trans, root); | ||
1503 | |||
1504 | return ret; | ||
1376 | } | 1505 | } |
1377 | 1506 | ||
1378 | /* | 1507 | /* |
@@ -1388,6 +1517,8 @@ int btrfs_clean_old_snapshots(struct btrfs_root *root) | |||
1388 | spin_unlock(&fs_info->trans_lock); | 1517 | spin_unlock(&fs_info->trans_lock); |
1389 | 1518 | ||
1390 | while (!list_empty(&list)) { | 1519 | while (!list_empty(&list)) { |
1520 | int ret; | ||
1521 | |||
1391 | root = list_entry(list.next, struct btrfs_root, root_list); | 1522 | root = list_entry(list.next, struct btrfs_root, root_list); |
1392 | list_del(&root->root_list); | 1523 | list_del(&root->root_list); |
1393 | 1524 | ||
@@ -1395,9 +1526,10 @@ int btrfs_clean_old_snapshots(struct btrfs_root *root) | |||
1395 | 1526 | ||
1396 | if (btrfs_header_backref_rev(root->node) < | 1527 | if (btrfs_header_backref_rev(root->node) < |
1397 | BTRFS_MIXED_BACKREF_REV) | 1528 | BTRFS_MIXED_BACKREF_REV) |
1398 | btrfs_drop_snapshot(root, NULL, 0, 0); | 1529 | ret = btrfs_drop_snapshot(root, NULL, 0, 0); |
1399 | else | 1530 | else |
1400 | btrfs_drop_snapshot(root, NULL, 1, 0); | 1531 | ret =btrfs_drop_snapshot(root, NULL, 1, 0); |
1532 | BUG_ON(ret < 0); | ||
1401 | } | 1533 | } |
1402 | return 0; | 1534 | return 0; |
1403 | } | 1535 | } |
diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h index 02564e6230ac..fe27379e368b 100644 --- a/fs/btrfs/transaction.h +++ b/fs/btrfs/transaction.h | |||
@@ -43,6 +43,7 @@ struct btrfs_transaction { | |||
43 | wait_queue_head_t commit_wait; | 43 | wait_queue_head_t commit_wait; |
44 | struct list_head pending_snapshots; | 44 | struct list_head pending_snapshots; |
45 | struct btrfs_delayed_ref_root delayed_refs; | 45 | struct btrfs_delayed_ref_root delayed_refs; |
46 | int aborted; | ||
46 | }; | 47 | }; |
47 | 48 | ||
48 | struct btrfs_trans_handle { | 49 | struct btrfs_trans_handle { |
@@ -55,6 +56,7 @@ struct btrfs_trans_handle { | |||
55 | struct btrfs_transaction *transaction; | 56 | struct btrfs_transaction *transaction; |
56 | struct btrfs_block_rsv *block_rsv; | 57 | struct btrfs_block_rsv *block_rsv; |
57 | struct btrfs_block_rsv *orig_rsv; | 58 | struct btrfs_block_rsv *orig_rsv; |
59 | int aborted; | ||
58 | }; | 60 | }; |
59 | 61 | ||
60 | struct btrfs_pending_snapshot { | 62 | struct btrfs_pending_snapshot { |
@@ -114,4 +116,5 @@ int btrfs_wait_marked_extents(struct btrfs_root *root, | |||
114 | struct extent_io_tree *dirty_pages, int mark); | 116 | struct extent_io_tree *dirty_pages, int mark); |
115 | int btrfs_transaction_blocked(struct btrfs_fs_info *info); | 117 | int btrfs_transaction_blocked(struct btrfs_fs_info *info); |
116 | int btrfs_transaction_in_commit(struct btrfs_fs_info *info); | 118 | int btrfs_transaction_in_commit(struct btrfs_fs_info *info); |
119 | void put_transaction(struct btrfs_transaction *transaction); | ||
117 | #endif | 120 | #endif |
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c index 966cc74f5d6c..d017283ae6f5 100644 --- a/fs/btrfs/tree-log.c +++ b/fs/btrfs/tree-log.c | |||
@@ -212,14 +212,13 @@ int btrfs_pin_log_trans(struct btrfs_root *root) | |||
212 | * indicate we're done making changes to the log tree | 212 | * indicate we're done making changes to the log tree |
213 | * and wake up anyone waiting to do a sync | 213 | * and wake up anyone waiting to do a sync |
214 | */ | 214 | */ |
215 | int btrfs_end_log_trans(struct btrfs_root *root) | 215 | void btrfs_end_log_trans(struct btrfs_root *root) |
216 | { | 216 | { |
217 | if (atomic_dec_and_test(&root->log_writers)) { | 217 | if (atomic_dec_and_test(&root->log_writers)) { |
218 | smp_mb(); | 218 | smp_mb(); |
219 | if (waitqueue_active(&root->log_writer_wait)) | 219 | if (waitqueue_active(&root->log_writer_wait)) |
220 | wake_up(&root->log_writer_wait); | 220 | wake_up(&root->log_writer_wait); |
221 | } | 221 | } |
222 | return 0; | ||
223 | } | 222 | } |
224 | 223 | ||
225 | 224 | ||
@@ -378,12 +377,11 @@ insert: | |||
378 | u32 found_size; | 377 | u32 found_size; |
379 | found_size = btrfs_item_size_nr(path->nodes[0], | 378 | found_size = btrfs_item_size_nr(path->nodes[0], |
380 | path->slots[0]); | 379 | path->slots[0]); |
381 | if (found_size > item_size) { | 380 | if (found_size > item_size) |
382 | btrfs_truncate_item(trans, root, path, item_size, 1); | 381 | btrfs_truncate_item(trans, root, path, item_size, 1); |
383 | } else if (found_size < item_size) { | 382 | else if (found_size < item_size) |
384 | ret = btrfs_extend_item(trans, root, path, | 383 | btrfs_extend_item(trans, root, path, |
385 | item_size - found_size); | 384 | item_size - found_size); |
386 | } | ||
387 | } else if (ret) { | 385 | } else if (ret) { |
388 | return ret; | 386 | return ret; |
389 | } | 387 | } |
@@ -1763,7 +1761,7 @@ static noinline int walk_down_log_tree(struct btrfs_trans_handle *trans, | |||
1763 | BTRFS_TREE_LOG_OBJECTID); | 1761 | BTRFS_TREE_LOG_OBJECTID); |
1764 | ret = btrfs_free_and_pin_reserved_extent(root, | 1762 | ret = btrfs_free_and_pin_reserved_extent(root, |
1765 | bytenr, blocksize); | 1763 | bytenr, blocksize); |
1766 | BUG_ON(ret); | 1764 | BUG_ON(ret); /* -ENOMEM or logic errors */ |
1767 | } | 1765 | } |
1768 | free_extent_buffer(next); | 1766 | free_extent_buffer(next); |
1769 | continue; | 1767 | continue; |
@@ -1871,20 +1869,26 @@ static int walk_log_tree(struct btrfs_trans_handle *trans, | |||
1871 | wret = walk_down_log_tree(trans, log, path, &level, wc); | 1869 | wret = walk_down_log_tree(trans, log, path, &level, wc); |
1872 | if (wret > 0) | 1870 | if (wret > 0) |
1873 | break; | 1871 | break; |
1874 | if (wret < 0) | 1872 | if (wret < 0) { |
1875 | ret = wret; | 1873 | ret = wret; |
1874 | goto out; | ||
1875 | } | ||
1876 | 1876 | ||
1877 | wret = walk_up_log_tree(trans, log, path, &level, wc); | 1877 | wret = walk_up_log_tree(trans, log, path, &level, wc); |
1878 | if (wret > 0) | 1878 | if (wret > 0) |
1879 | break; | 1879 | break; |
1880 | if (wret < 0) | 1880 | if (wret < 0) { |
1881 | ret = wret; | 1881 | ret = wret; |
1882 | goto out; | ||
1883 | } | ||
1882 | } | 1884 | } |
1883 | 1885 | ||
1884 | /* was the root node processed? if not, catch it here */ | 1886 | /* was the root node processed? if not, catch it here */ |
1885 | if (path->nodes[orig_level]) { | 1887 | if (path->nodes[orig_level]) { |
1886 | wc->process_func(log, path->nodes[orig_level], wc, | 1888 | ret = wc->process_func(log, path->nodes[orig_level], wc, |
1887 | btrfs_header_generation(path->nodes[orig_level])); | 1889 | btrfs_header_generation(path->nodes[orig_level])); |
1890 | if (ret) | ||
1891 | goto out; | ||
1888 | if (wc->free) { | 1892 | if (wc->free) { |
1889 | struct extent_buffer *next; | 1893 | struct extent_buffer *next; |
1890 | 1894 | ||
@@ -1900,10 +1904,11 @@ static int walk_log_tree(struct btrfs_trans_handle *trans, | |||
1900 | BTRFS_TREE_LOG_OBJECTID); | 1904 | BTRFS_TREE_LOG_OBJECTID); |
1901 | ret = btrfs_free_and_pin_reserved_extent(log, next->start, | 1905 | ret = btrfs_free_and_pin_reserved_extent(log, next->start, |
1902 | next->len); | 1906 | next->len); |
1903 | BUG_ON(ret); | 1907 | BUG_ON(ret); /* -ENOMEM or logic errors */ |
1904 | } | 1908 | } |
1905 | } | 1909 | } |
1906 | 1910 | ||
1911 | out: | ||
1907 | for (i = 0; i <= orig_level; i++) { | 1912 | for (i = 0; i <= orig_level; i++) { |
1908 | if (path->nodes[i]) { | 1913 | if (path->nodes[i]) { |
1909 | free_extent_buffer(path->nodes[i]); | 1914 | free_extent_buffer(path->nodes[i]); |
@@ -1963,8 +1968,8 @@ static int wait_log_commit(struct btrfs_trans_handle *trans, | |||
1963 | return 0; | 1968 | return 0; |
1964 | } | 1969 | } |
1965 | 1970 | ||
1966 | static int wait_for_writer(struct btrfs_trans_handle *trans, | 1971 | static void wait_for_writer(struct btrfs_trans_handle *trans, |
1967 | struct btrfs_root *root) | 1972 | struct btrfs_root *root) |
1968 | { | 1973 | { |
1969 | DEFINE_WAIT(wait); | 1974 | DEFINE_WAIT(wait); |
1970 | while (root->fs_info->last_trans_log_full_commit != | 1975 | while (root->fs_info->last_trans_log_full_commit != |
@@ -1978,7 +1983,6 @@ static int wait_for_writer(struct btrfs_trans_handle *trans, | |||
1978 | mutex_lock(&root->log_mutex); | 1983 | mutex_lock(&root->log_mutex); |
1979 | finish_wait(&root->log_writer_wait, &wait); | 1984 | finish_wait(&root->log_writer_wait, &wait); |
1980 | } | 1985 | } |
1981 | return 0; | ||
1982 | } | 1986 | } |
1983 | 1987 | ||
1984 | /* | 1988 | /* |
@@ -2046,7 +2050,11 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans, | |||
2046 | * wait for them until later. | 2050 | * wait for them until later. |
2047 | */ | 2051 | */ |
2048 | ret = btrfs_write_marked_extents(log, &log->dirty_log_pages, mark); | 2052 | ret = btrfs_write_marked_extents(log, &log->dirty_log_pages, mark); |
2049 | BUG_ON(ret); | 2053 | if (ret) { |
2054 | btrfs_abort_transaction(trans, root, ret); | ||
2055 | mutex_unlock(&root->log_mutex); | ||
2056 | goto out; | ||
2057 | } | ||
2050 | 2058 | ||
2051 | btrfs_set_root_node(&log->root_item, log->node); | 2059 | btrfs_set_root_node(&log->root_item, log->node); |
2052 | 2060 | ||
@@ -2077,7 +2085,11 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans, | |||
2077 | } | 2085 | } |
2078 | 2086 | ||
2079 | if (ret) { | 2087 | if (ret) { |
2080 | BUG_ON(ret != -ENOSPC); | 2088 | if (ret != -ENOSPC) { |
2089 | btrfs_abort_transaction(trans, root, ret); | ||
2090 | mutex_unlock(&log_root_tree->log_mutex); | ||
2091 | goto out; | ||
2092 | } | ||
2081 | root->fs_info->last_trans_log_full_commit = trans->transid; | 2093 | root->fs_info->last_trans_log_full_commit = trans->transid; |
2082 | btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark); | 2094 | btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark); |
2083 | mutex_unlock(&log_root_tree->log_mutex); | 2095 | mutex_unlock(&log_root_tree->log_mutex); |
@@ -2117,7 +2129,11 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans, | |||
2117 | ret = btrfs_write_and_wait_marked_extents(log_root_tree, | 2129 | ret = btrfs_write_and_wait_marked_extents(log_root_tree, |
2118 | &log_root_tree->dirty_log_pages, | 2130 | &log_root_tree->dirty_log_pages, |
2119 | EXTENT_DIRTY | EXTENT_NEW); | 2131 | EXTENT_DIRTY | EXTENT_NEW); |
2120 | BUG_ON(ret); | 2132 | if (ret) { |
2133 | btrfs_abort_transaction(trans, root, ret); | ||
2134 | mutex_unlock(&log_root_tree->log_mutex); | ||
2135 | goto out_wake_log_root; | ||
2136 | } | ||
2121 | btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark); | 2137 | btrfs_wait_marked_extents(log, &log->dirty_log_pages, mark); |
2122 | 2138 | ||
2123 | btrfs_set_super_log_root(root->fs_info->super_for_commit, | 2139 | btrfs_set_super_log_root(root->fs_info->super_for_commit, |
@@ -2326,7 +2342,9 @@ out_unlock: | |||
2326 | if (ret == -ENOSPC) { | 2342 | if (ret == -ENOSPC) { |
2327 | root->fs_info->last_trans_log_full_commit = trans->transid; | 2343 | root->fs_info->last_trans_log_full_commit = trans->transid; |
2328 | ret = 0; | 2344 | ret = 0; |
2329 | } | 2345 | } else if (ret < 0) |
2346 | btrfs_abort_transaction(trans, root, ret); | ||
2347 | |||
2330 | btrfs_end_log_trans(root); | 2348 | btrfs_end_log_trans(root); |
2331 | 2349 | ||
2332 | return err; | 2350 | return err; |
@@ -2357,7 +2375,8 @@ int btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans, | |||
2357 | if (ret == -ENOSPC) { | 2375 | if (ret == -ENOSPC) { |
2358 | root->fs_info->last_trans_log_full_commit = trans->transid; | 2376 | root->fs_info->last_trans_log_full_commit = trans->transid; |
2359 | ret = 0; | 2377 | ret = 0; |
2360 | } | 2378 | } else if (ret < 0 && ret != -ENOENT) |
2379 | btrfs_abort_transaction(trans, root, ret); | ||
2361 | btrfs_end_log_trans(root); | 2380 | btrfs_end_log_trans(root); |
2362 | 2381 | ||
2363 | return ret; | 2382 | return ret; |
@@ -3169,13 +3188,20 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree) | |||
3169 | fs_info->log_root_recovering = 1; | 3188 | fs_info->log_root_recovering = 1; |
3170 | 3189 | ||
3171 | trans = btrfs_start_transaction(fs_info->tree_root, 0); | 3190 | trans = btrfs_start_transaction(fs_info->tree_root, 0); |
3172 | BUG_ON(IS_ERR(trans)); | 3191 | if (IS_ERR(trans)) { |
3192 | ret = PTR_ERR(trans); | ||
3193 | goto error; | ||
3194 | } | ||
3173 | 3195 | ||
3174 | wc.trans = trans; | 3196 | wc.trans = trans; |
3175 | wc.pin = 1; | 3197 | wc.pin = 1; |
3176 | 3198 | ||
3177 | ret = walk_log_tree(trans, log_root_tree, &wc); | 3199 | ret = walk_log_tree(trans, log_root_tree, &wc); |
3178 | BUG_ON(ret); | 3200 | if (ret) { |
3201 | btrfs_error(fs_info, ret, "Failed to pin buffers while " | ||
3202 | "recovering log root tree."); | ||
3203 | goto error; | ||
3204 | } | ||
3179 | 3205 | ||
3180 | again: | 3206 | again: |
3181 | key.objectid = BTRFS_TREE_LOG_OBJECTID; | 3207 | key.objectid = BTRFS_TREE_LOG_OBJECTID; |
@@ -3184,8 +3210,12 @@ again: | |||
3184 | 3210 | ||
3185 | while (1) { | 3211 | while (1) { |
3186 | ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0); | 3212 | ret = btrfs_search_slot(NULL, log_root_tree, &key, path, 0, 0); |
3187 | if (ret < 0) | 3213 | |
3188 | break; | 3214 | if (ret < 0) { |
3215 | btrfs_error(fs_info, ret, | ||
3216 | "Couldn't find tree log root."); | ||
3217 | goto error; | ||
3218 | } | ||
3189 | if (ret > 0) { | 3219 | if (ret > 0) { |
3190 | if (path->slots[0] == 0) | 3220 | if (path->slots[0] == 0) |
3191 | break; | 3221 | break; |
@@ -3199,14 +3229,24 @@ again: | |||
3199 | 3229 | ||
3200 | log = btrfs_read_fs_root_no_radix(log_root_tree, | 3230 | log = btrfs_read_fs_root_no_radix(log_root_tree, |
3201 | &found_key); | 3231 | &found_key); |
3202 | BUG_ON(IS_ERR(log)); | 3232 | if (IS_ERR(log)) { |
3233 | ret = PTR_ERR(log); | ||
3234 | btrfs_error(fs_info, ret, | ||
3235 | "Couldn't read tree log root."); | ||
3236 | goto error; | ||
3237 | } | ||
3203 | 3238 | ||
3204 | tmp_key.objectid = found_key.offset; | 3239 | tmp_key.objectid = found_key.offset; |
3205 | tmp_key.type = BTRFS_ROOT_ITEM_KEY; | 3240 | tmp_key.type = BTRFS_ROOT_ITEM_KEY; |
3206 | tmp_key.offset = (u64)-1; | 3241 | tmp_key.offset = (u64)-1; |
3207 | 3242 | ||
3208 | wc.replay_dest = btrfs_read_fs_root_no_name(fs_info, &tmp_key); | 3243 | wc.replay_dest = btrfs_read_fs_root_no_name(fs_info, &tmp_key); |
3209 | BUG_ON(IS_ERR_OR_NULL(wc.replay_dest)); | 3244 | if (IS_ERR(wc.replay_dest)) { |
3245 | ret = PTR_ERR(wc.replay_dest); | ||
3246 | btrfs_error(fs_info, ret, "Couldn't read target root " | ||
3247 | "for tree log recovery."); | ||
3248 | goto error; | ||
3249 | } | ||
3210 | 3250 | ||
3211 | wc.replay_dest->log_root = log; | 3251 | wc.replay_dest->log_root = log; |
3212 | btrfs_record_root_in_trans(trans, wc.replay_dest); | 3252 | btrfs_record_root_in_trans(trans, wc.replay_dest); |
@@ -3254,6 +3294,10 @@ again: | |||
3254 | 3294 | ||
3255 | kfree(log_root_tree); | 3295 | kfree(log_root_tree); |
3256 | return 0; | 3296 | return 0; |
3297 | |||
3298 | error: | ||
3299 | btrfs_free_path(path); | ||
3300 | return ret; | ||
3257 | } | 3301 | } |
3258 | 3302 | ||
3259 | /* | 3303 | /* |
diff --git a/fs/btrfs/tree-log.h b/fs/btrfs/tree-log.h index 2270ac58d746..862ac813f6b8 100644 --- a/fs/btrfs/tree-log.h +++ b/fs/btrfs/tree-log.h | |||
@@ -38,7 +38,7 @@ int btrfs_del_inode_ref_in_log(struct btrfs_trans_handle *trans, | |||
38 | struct btrfs_root *root, | 38 | struct btrfs_root *root, |
39 | const char *name, int name_len, | 39 | const char *name, int name_len, |
40 | struct inode *inode, u64 dirid); | 40 | struct inode *inode, u64 dirid); |
41 | int btrfs_end_log_trans(struct btrfs_root *root); | 41 | void btrfs_end_log_trans(struct btrfs_root *root); |
42 | int btrfs_pin_log_trans(struct btrfs_root *root); | 42 | int btrfs_pin_log_trans(struct btrfs_root *root); |
43 | int btrfs_log_inode_parent(struct btrfs_trans_handle *trans, | 43 | int btrfs_log_inode_parent(struct btrfs_trans_handle *trans, |
44 | struct btrfs_root *root, struct inode *inode, | 44 | struct btrfs_root *root, struct inode *inode, |
diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c index 58aad63e1ad3..d64cd6cbdbb6 100644 --- a/fs/btrfs/volumes.c +++ b/fs/btrfs/volumes.c | |||
@@ -67,7 +67,7 @@ static void free_fs_devices(struct btrfs_fs_devices *fs_devices) | |||
67 | kfree(fs_devices); | 67 | kfree(fs_devices); |
68 | } | 68 | } |
69 | 69 | ||
70 | int btrfs_cleanup_fs_uuids(void) | 70 | void btrfs_cleanup_fs_uuids(void) |
71 | { | 71 | { |
72 | struct btrfs_fs_devices *fs_devices; | 72 | struct btrfs_fs_devices *fs_devices; |
73 | 73 | ||
@@ -77,7 +77,6 @@ int btrfs_cleanup_fs_uuids(void) | |||
77 | list_del(&fs_devices->list); | 77 | list_del(&fs_devices->list); |
78 | free_fs_devices(fs_devices); | 78 | free_fs_devices(fs_devices); |
79 | } | 79 | } |
80 | return 0; | ||
81 | } | 80 | } |
82 | 81 | ||
83 | static noinline struct btrfs_device *__find_device(struct list_head *head, | 82 | static noinline struct btrfs_device *__find_device(struct list_head *head, |
@@ -130,7 +129,7 @@ static void requeue_list(struct btrfs_pending_bios *pending_bios, | |||
130 | * the list if the block device is congested. This way, multiple devices | 129 | * the list if the block device is congested. This way, multiple devices |
131 | * can make progress from a single worker thread. | 130 | * can make progress from a single worker thread. |
132 | */ | 131 | */ |
133 | static noinline int run_scheduled_bios(struct btrfs_device *device) | 132 | static noinline void run_scheduled_bios(struct btrfs_device *device) |
134 | { | 133 | { |
135 | struct bio *pending; | 134 | struct bio *pending; |
136 | struct backing_dev_info *bdi; | 135 | struct backing_dev_info *bdi; |
@@ -316,7 +315,6 @@ loop_lock: | |||
316 | 315 | ||
317 | done: | 316 | done: |
318 | blk_finish_plug(&plug); | 317 | blk_finish_plug(&plug); |
319 | return 0; | ||
320 | } | 318 | } |
321 | 319 | ||
322 | static void pending_bios_fn(struct btrfs_work *work) | 320 | static void pending_bios_fn(struct btrfs_work *work) |
@@ -455,7 +453,7 @@ error: | |||
455 | return ERR_PTR(-ENOMEM); | 453 | return ERR_PTR(-ENOMEM); |
456 | } | 454 | } |
457 | 455 | ||
458 | int btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices) | 456 | void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices) |
459 | { | 457 | { |
460 | struct btrfs_device *device, *next; | 458 | struct btrfs_device *device, *next; |
461 | 459 | ||
@@ -503,7 +501,6 @@ again: | |||
503 | fs_devices->latest_trans = latest_transid; | 501 | fs_devices->latest_trans = latest_transid; |
504 | 502 | ||
505 | mutex_unlock(&uuid_mutex); | 503 | mutex_unlock(&uuid_mutex); |
506 | return 0; | ||
507 | } | 504 | } |
508 | 505 | ||
509 | static void __free_device(struct work_struct *work) | 506 | static void __free_device(struct work_struct *work) |
@@ -552,10 +549,10 @@ static int __btrfs_close_devices(struct btrfs_fs_devices *fs_devices) | |||
552 | fs_devices->num_can_discard--; | 549 | fs_devices->num_can_discard--; |
553 | 550 | ||
554 | new_device = kmalloc(sizeof(*new_device), GFP_NOFS); | 551 | new_device = kmalloc(sizeof(*new_device), GFP_NOFS); |
555 | BUG_ON(!new_device); | 552 | BUG_ON(!new_device); /* -ENOMEM */ |
556 | memcpy(new_device, device, sizeof(*new_device)); | 553 | memcpy(new_device, device, sizeof(*new_device)); |
557 | new_device->name = kstrdup(device->name, GFP_NOFS); | 554 | new_device->name = kstrdup(device->name, GFP_NOFS); |
558 | BUG_ON(device->name && !new_device->name); | 555 | BUG_ON(device->name && !new_device->name); /* -ENOMEM */ |
559 | new_device->bdev = NULL; | 556 | new_device->bdev = NULL; |
560 | new_device->writeable = 0; | 557 | new_device->writeable = 0; |
561 | new_device->in_fs_metadata = 0; | 558 | new_device->in_fs_metadata = 0; |
@@ -1039,8 +1036,10 @@ again: | |||
1039 | leaf = path->nodes[0]; | 1036 | leaf = path->nodes[0]; |
1040 | extent = btrfs_item_ptr(leaf, path->slots[0], | 1037 | extent = btrfs_item_ptr(leaf, path->slots[0], |
1041 | struct btrfs_dev_extent); | 1038 | struct btrfs_dev_extent); |
1039 | } else { | ||
1040 | btrfs_error(root->fs_info, ret, "Slot search failed"); | ||
1041 | goto out; | ||
1042 | } | 1042 | } |
1043 | BUG_ON(ret); | ||
1044 | 1043 | ||
1045 | if (device->bytes_used > 0) { | 1044 | if (device->bytes_used > 0) { |
1046 | u64 len = btrfs_dev_extent_length(leaf, extent); | 1045 | u64 len = btrfs_dev_extent_length(leaf, extent); |
@@ -1050,7 +1049,10 @@ again: | |||
1050 | spin_unlock(&root->fs_info->free_chunk_lock); | 1049 | spin_unlock(&root->fs_info->free_chunk_lock); |
1051 | } | 1050 | } |
1052 | ret = btrfs_del_item(trans, root, path); | 1051 | ret = btrfs_del_item(trans, root, path); |
1053 | 1052 | if (ret) { | |
1053 | btrfs_error(root->fs_info, ret, | ||
1054 | "Failed to remove dev extent item"); | ||
1055 | } | ||
1054 | out: | 1056 | out: |
1055 | btrfs_free_path(path); | 1057 | btrfs_free_path(path); |
1056 | return ret; | 1058 | return ret; |
@@ -1078,7 +1080,8 @@ int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans, | |||
1078 | key.type = BTRFS_DEV_EXTENT_KEY; | 1080 | key.type = BTRFS_DEV_EXTENT_KEY; |
1079 | ret = btrfs_insert_empty_item(trans, root, path, &key, | 1081 | ret = btrfs_insert_empty_item(trans, root, path, &key, |
1080 | sizeof(*extent)); | 1082 | sizeof(*extent)); |
1081 | BUG_ON(ret); | 1083 | if (ret) |
1084 | goto out; | ||
1082 | 1085 | ||
1083 | leaf = path->nodes[0]; | 1086 | leaf = path->nodes[0]; |
1084 | extent = btrfs_item_ptr(leaf, path->slots[0], | 1087 | extent = btrfs_item_ptr(leaf, path->slots[0], |
@@ -1093,6 +1096,7 @@ int btrfs_alloc_dev_extent(struct btrfs_trans_handle *trans, | |||
1093 | 1096 | ||
1094 | btrfs_set_dev_extent_length(leaf, extent, num_bytes); | 1097 | btrfs_set_dev_extent_length(leaf, extent, num_bytes); |
1095 | btrfs_mark_buffer_dirty(leaf); | 1098 | btrfs_mark_buffer_dirty(leaf); |
1099 | out: | ||
1096 | btrfs_free_path(path); | 1100 | btrfs_free_path(path); |
1097 | return ret; | 1101 | return ret; |
1098 | } | 1102 | } |
@@ -1118,7 +1122,7 @@ static noinline int find_next_chunk(struct btrfs_root *root, | |||
1118 | if (ret < 0) | 1122 | if (ret < 0) |
1119 | goto error; | 1123 | goto error; |
1120 | 1124 | ||
1121 | BUG_ON(ret == 0); | 1125 | BUG_ON(ret == 0); /* Corruption */ |
1122 | 1126 | ||
1123 | ret = btrfs_previous_item(root, path, 0, BTRFS_CHUNK_ITEM_KEY); | 1127 | ret = btrfs_previous_item(root, path, 0, BTRFS_CHUNK_ITEM_KEY); |
1124 | if (ret) { | 1128 | if (ret) { |
@@ -1162,7 +1166,7 @@ static noinline int find_next_devid(struct btrfs_root *root, u64 *objectid) | |||
1162 | if (ret < 0) | 1166 | if (ret < 0) |
1163 | goto error; | 1167 | goto error; |
1164 | 1168 | ||
1165 | BUG_ON(ret == 0); | 1169 | BUG_ON(ret == 0); /* Corruption */ |
1166 | 1170 | ||
1167 | ret = btrfs_previous_item(root, path, BTRFS_DEV_ITEMS_OBJECTID, | 1171 | ret = btrfs_previous_item(root, path, BTRFS_DEV_ITEMS_OBJECTID, |
1168 | BTRFS_DEV_ITEM_KEY); | 1172 | BTRFS_DEV_ITEM_KEY); |
@@ -1596,7 +1600,7 @@ next_slot: | |||
1596 | (unsigned long)btrfs_device_fsid(dev_item), | 1600 | (unsigned long)btrfs_device_fsid(dev_item), |
1597 | BTRFS_UUID_SIZE); | 1601 | BTRFS_UUID_SIZE); |
1598 | device = btrfs_find_device(root, devid, dev_uuid, fs_uuid); | 1602 | device = btrfs_find_device(root, devid, dev_uuid, fs_uuid); |
1599 | BUG_ON(!device); | 1603 | BUG_ON(!device); /* Logic error */ |
1600 | 1604 | ||
1601 | if (device->fs_devices->seeding) { | 1605 | if (device->fs_devices->seeding) { |
1602 | btrfs_set_device_generation(leaf, dev_item, | 1606 | btrfs_set_device_generation(leaf, dev_item, |
@@ -1706,7 +1710,7 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path) | |||
1706 | if (seeding_dev) { | 1710 | if (seeding_dev) { |
1707 | sb->s_flags &= ~MS_RDONLY; | 1711 | sb->s_flags &= ~MS_RDONLY; |
1708 | ret = btrfs_prepare_sprout(root); | 1712 | ret = btrfs_prepare_sprout(root); |
1709 | BUG_ON(ret); | 1713 | BUG_ON(ret); /* -ENOMEM */ |
1710 | } | 1714 | } |
1711 | 1715 | ||
1712 | device->fs_devices = root->fs_info->fs_devices; | 1716 | device->fs_devices = root->fs_info->fs_devices; |
@@ -1744,11 +1748,15 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path) | |||
1744 | 1748 | ||
1745 | if (seeding_dev) { | 1749 | if (seeding_dev) { |
1746 | ret = init_first_rw_device(trans, root, device); | 1750 | ret = init_first_rw_device(trans, root, device); |
1747 | BUG_ON(ret); | 1751 | if (ret) |
1752 | goto error_trans; | ||
1748 | ret = btrfs_finish_sprout(trans, root); | 1753 | ret = btrfs_finish_sprout(trans, root); |
1749 | BUG_ON(ret); | 1754 | if (ret) |
1755 | goto error_trans; | ||
1750 | } else { | 1756 | } else { |
1751 | ret = btrfs_add_device(trans, root, device); | 1757 | ret = btrfs_add_device(trans, root, device); |
1758 | if (ret) | ||
1759 | goto error_trans; | ||
1752 | } | 1760 | } |
1753 | 1761 | ||
1754 | /* | 1762 | /* |
@@ -1758,17 +1766,31 @@ int btrfs_init_new_device(struct btrfs_root *root, char *device_path) | |||
1758 | btrfs_clear_space_info_full(root->fs_info); | 1766 | btrfs_clear_space_info_full(root->fs_info); |
1759 | 1767 | ||
1760 | unlock_chunks(root); | 1768 | unlock_chunks(root); |
1761 | btrfs_commit_transaction(trans, root); | 1769 | ret = btrfs_commit_transaction(trans, root); |
1762 | 1770 | ||
1763 | if (seeding_dev) { | 1771 | if (seeding_dev) { |
1764 | mutex_unlock(&uuid_mutex); | 1772 | mutex_unlock(&uuid_mutex); |
1765 | up_write(&sb->s_umount); | 1773 | up_write(&sb->s_umount); |
1766 | 1774 | ||
1775 | if (ret) /* transaction commit */ | ||
1776 | return ret; | ||
1777 | |||
1767 | ret = btrfs_relocate_sys_chunks(root); | 1778 | ret = btrfs_relocate_sys_chunks(root); |
1768 | BUG_ON(ret); | 1779 | if (ret < 0) |
1780 | btrfs_error(root->fs_info, ret, | ||
1781 | "Failed to relocate sys chunks after " | ||
1782 | "device initialization. This can be fixed " | ||
1783 | "using the \"btrfs balance\" command."); | ||
1769 | } | 1784 | } |
1770 | 1785 | ||
1771 | return ret; | 1786 | return ret; |
1787 | |||
1788 | error_trans: | ||
1789 | unlock_chunks(root); | ||
1790 | btrfs_abort_transaction(trans, root, ret); | ||
1791 | btrfs_end_transaction(trans, root); | ||
1792 | kfree(device->name); | ||
1793 | kfree(device); | ||
1772 | error: | 1794 | error: |
1773 | blkdev_put(bdev, FMODE_EXCL); | 1795 | blkdev_put(bdev, FMODE_EXCL); |
1774 | if (seeding_dev) { | 1796 | if (seeding_dev) { |
@@ -1876,10 +1898,20 @@ static int btrfs_free_chunk(struct btrfs_trans_handle *trans, | |||
1876 | key.type = BTRFS_CHUNK_ITEM_KEY; | 1898 | key.type = BTRFS_CHUNK_ITEM_KEY; |
1877 | 1899 | ||
1878 | ret = btrfs_search_slot(trans, root, &key, path, -1, 1); | 1900 | ret = btrfs_search_slot(trans, root, &key, path, -1, 1); |
1879 | BUG_ON(ret); | 1901 | if (ret < 0) |
1902 | goto out; | ||
1903 | else if (ret > 0) { /* Logic error or corruption */ | ||
1904 | btrfs_error(root->fs_info, -ENOENT, | ||
1905 | "Failed lookup while freeing chunk."); | ||
1906 | ret = -ENOENT; | ||
1907 | goto out; | ||
1908 | } | ||
1880 | 1909 | ||
1881 | ret = btrfs_del_item(trans, root, path); | 1910 | ret = btrfs_del_item(trans, root, path); |
1882 | 1911 | if (ret < 0) | |
1912 | btrfs_error(root->fs_info, ret, | ||
1913 | "Failed to delete chunk item."); | ||
1914 | out: | ||
1883 | btrfs_free_path(path); | 1915 | btrfs_free_path(path); |
1884 | return ret; | 1916 | return ret; |
1885 | } | 1917 | } |
@@ -2041,7 +2073,7 @@ again: | |||
2041 | ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); | 2073 | ret = btrfs_search_slot(NULL, chunk_root, &key, path, 0, 0); |
2042 | if (ret < 0) | 2074 | if (ret < 0) |
2043 | goto error; | 2075 | goto error; |
2044 | BUG_ON(ret == 0); | 2076 | BUG_ON(ret == 0); /* Corruption */ |
2045 | 2077 | ||
2046 | ret = btrfs_previous_item(chunk_root, path, key.objectid, | 2078 | ret = btrfs_previous_item(chunk_root, path, key.objectid, |
2047 | key.type); | 2079 | key.type); |
@@ -3328,13 +3360,15 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans, | |||
3328 | write_lock(&em_tree->lock); | 3360 | write_lock(&em_tree->lock); |
3329 | ret = add_extent_mapping(em_tree, em); | 3361 | ret = add_extent_mapping(em_tree, em); |
3330 | write_unlock(&em_tree->lock); | 3362 | write_unlock(&em_tree->lock); |
3331 | BUG_ON(ret); | ||
3332 | free_extent_map(em); | 3363 | free_extent_map(em); |
3364 | if (ret) | ||
3365 | goto error; | ||
3333 | 3366 | ||
3334 | ret = btrfs_make_block_group(trans, extent_root, 0, type, | 3367 | ret = btrfs_make_block_group(trans, extent_root, 0, type, |
3335 | BTRFS_FIRST_CHUNK_TREE_OBJECTID, | 3368 | BTRFS_FIRST_CHUNK_TREE_OBJECTID, |
3336 | start, num_bytes); | 3369 | start, num_bytes); |
3337 | BUG_ON(ret); | 3370 | if (ret) |
3371 | goto error; | ||
3338 | 3372 | ||
3339 | for (i = 0; i < map->num_stripes; ++i) { | 3373 | for (i = 0; i < map->num_stripes; ++i) { |
3340 | struct btrfs_device *device; | 3374 | struct btrfs_device *device; |
@@ -3347,7 +3381,10 @@ static int __btrfs_alloc_chunk(struct btrfs_trans_handle *trans, | |||
3347 | info->chunk_root->root_key.objectid, | 3381 | info->chunk_root->root_key.objectid, |
3348 | BTRFS_FIRST_CHUNK_TREE_OBJECTID, | 3382 | BTRFS_FIRST_CHUNK_TREE_OBJECTID, |
3349 | start, dev_offset, stripe_size); | 3383 | start, dev_offset, stripe_size); |
3350 | BUG_ON(ret); | 3384 | if (ret) { |
3385 | btrfs_abort_transaction(trans, extent_root, ret); | ||
3386 | goto error; | ||
3387 | } | ||
3351 | } | 3388 | } |
3352 | 3389 | ||
3353 | kfree(devices_info); | 3390 | kfree(devices_info); |
@@ -3383,7 +3420,8 @@ static int __finish_chunk_alloc(struct btrfs_trans_handle *trans, | |||
3383 | device = map->stripes[index].dev; | 3420 | device = map->stripes[index].dev; |
3384 | device->bytes_used += stripe_size; | 3421 | device->bytes_used += stripe_size; |
3385 | ret = btrfs_update_device(trans, device); | 3422 | ret = btrfs_update_device(trans, device); |
3386 | BUG_ON(ret); | 3423 | if (ret) |
3424 | goto out_free; | ||
3387 | index++; | 3425 | index++; |
3388 | } | 3426 | } |
3389 | 3427 | ||
@@ -3420,16 +3458,19 @@ static int __finish_chunk_alloc(struct btrfs_trans_handle *trans, | |||
3420 | key.offset = chunk_offset; | 3458 | key.offset = chunk_offset; |
3421 | 3459 | ||
3422 | ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size); | 3460 | ret = btrfs_insert_item(trans, chunk_root, &key, chunk, item_size); |
3423 | BUG_ON(ret); | ||
3424 | 3461 | ||
3425 | if (map->type & BTRFS_BLOCK_GROUP_SYSTEM) { | 3462 | if (ret == 0 && map->type & BTRFS_BLOCK_GROUP_SYSTEM) { |
3463 | /* | ||
3464 | * TODO: Cleanup of inserted chunk root in case of | ||
3465 | * failure. | ||
3466 | */ | ||
3426 | ret = btrfs_add_system_chunk(chunk_root, &key, chunk, | 3467 | ret = btrfs_add_system_chunk(chunk_root, &key, chunk, |
3427 | item_size); | 3468 | item_size); |
3428 | BUG_ON(ret); | ||
3429 | } | 3469 | } |
3430 | 3470 | ||
3471 | out_free: | ||
3431 | kfree(chunk); | 3472 | kfree(chunk); |
3432 | return 0; | 3473 | return ret; |
3433 | } | 3474 | } |
3434 | 3475 | ||
3435 | /* | 3476 | /* |
@@ -3461,7 +3502,8 @@ int btrfs_alloc_chunk(struct btrfs_trans_handle *trans, | |||
3461 | 3502 | ||
3462 | ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset, | 3503 | ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset, |
3463 | chunk_size, stripe_size); | 3504 | chunk_size, stripe_size); |
3464 | BUG_ON(ret); | 3505 | if (ret) |
3506 | return ret; | ||
3465 | return 0; | 3507 | return 0; |
3466 | } | 3508 | } |
3467 | 3509 | ||
@@ -3493,7 +3535,8 @@ static noinline int init_first_rw_device(struct btrfs_trans_handle *trans, | |||
3493 | 3535 | ||
3494 | ret = __btrfs_alloc_chunk(trans, extent_root, &map, &chunk_size, | 3536 | ret = __btrfs_alloc_chunk(trans, extent_root, &map, &chunk_size, |
3495 | &stripe_size, chunk_offset, alloc_profile); | 3537 | &stripe_size, chunk_offset, alloc_profile); |
3496 | BUG_ON(ret); | 3538 | if (ret) |
3539 | return ret; | ||
3497 | 3540 | ||
3498 | sys_chunk_offset = chunk_offset + chunk_size; | 3541 | sys_chunk_offset = chunk_offset + chunk_size; |
3499 | 3542 | ||
@@ -3504,10 +3547,12 @@ static noinline int init_first_rw_device(struct btrfs_trans_handle *trans, | |||
3504 | ret = __btrfs_alloc_chunk(trans, extent_root, &sys_map, | 3547 | ret = __btrfs_alloc_chunk(trans, extent_root, &sys_map, |
3505 | &sys_chunk_size, &sys_stripe_size, | 3548 | &sys_chunk_size, &sys_stripe_size, |
3506 | sys_chunk_offset, alloc_profile); | 3549 | sys_chunk_offset, alloc_profile); |
3507 | BUG_ON(ret); | 3550 | if (ret) |
3551 | goto abort; | ||
3508 | 3552 | ||
3509 | ret = btrfs_add_device(trans, fs_info->chunk_root, device); | 3553 | ret = btrfs_add_device(trans, fs_info->chunk_root, device); |
3510 | BUG_ON(ret); | 3554 | if (ret) |
3555 | goto abort; | ||
3511 | 3556 | ||
3512 | /* | 3557 | /* |
3513 | * Modifying chunk tree needs allocating new blocks from both | 3558 | * Modifying chunk tree needs allocating new blocks from both |
@@ -3517,13 +3562,20 @@ static noinline int init_first_rw_device(struct btrfs_trans_handle *trans, | |||
3517 | */ | 3562 | */ |
3518 | ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset, | 3563 | ret = __finish_chunk_alloc(trans, extent_root, map, chunk_offset, |
3519 | chunk_size, stripe_size); | 3564 | chunk_size, stripe_size); |
3520 | BUG_ON(ret); | 3565 | if (ret) |
3566 | goto abort; | ||
3521 | 3567 | ||
3522 | ret = __finish_chunk_alloc(trans, extent_root, sys_map, | 3568 | ret = __finish_chunk_alloc(trans, extent_root, sys_map, |
3523 | sys_chunk_offset, sys_chunk_size, | 3569 | sys_chunk_offset, sys_chunk_size, |
3524 | sys_stripe_size); | 3570 | sys_stripe_size); |
3525 | BUG_ON(ret); | 3571 | if (ret) |
3572 | goto abort; | ||
3573 | |||
3526 | return 0; | 3574 | return 0; |
3575 | |||
3576 | abort: | ||
3577 | btrfs_abort_transaction(trans, root, ret); | ||
3578 | return ret; | ||
3527 | } | 3579 | } |
3528 | 3580 | ||
3529 | int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset) | 3581 | int btrfs_chunk_readonly(struct btrfs_root *root, u64 chunk_offset) |
@@ -3874,7 +3926,7 @@ int btrfs_rmap_block(struct btrfs_mapping_tree *map_tree, | |||
3874 | do_div(length, map->num_stripes); | 3926 | do_div(length, map->num_stripes); |
3875 | 3927 | ||
3876 | buf = kzalloc(sizeof(u64) * map->num_stripes, GFP_NOFS); | 3928 | buf = kzalloc(sizeof(u64) * map->num_stripes, GFP_NOFS); |
3877 | BUG_ON(!buf); | 3929 | BUG_ON(!buf); /* -ENOMEM */ |
3878 | 3930 | ||
3879 | for (i = 0; i < map->num_stripes; i++) { | 3931 | for (i = 0; i < map->num_stripes; i++) { |
3880 | if (devid && map->stripes[i].dev->devid != devid) | 3932 | if (devid && map->stripes[i].dev->devid != devid) |
@@ -3967,7 +4019,7 @@ struct async_sched { | |||
3967 | * This will add one bio to the pending list for a device and make sure | 4019 | * This will add one bio to the pending list for a device and make sure |
3968 | * the work struct is scheduled. | 4020 | * the work struct is scheduled. |
3969 | */ | 4021 | */ |
3970 | static noinline int schedule_bio(struct btrfs_root *root, | 4022 | static noinline void schedule_bio(struct btrfs_root *root, |
3971 | struct btrfs_device *device, | 4023 | struct btrfs_device *device, |
3972 | int rw, struct bio *bio) | 4024 | int rw, struct bio *bio) |
3973 | { | 4025 | { |
@@ -3979,7 +4031,7 @@ static noinline int schedule_bio(struct btrfs_root *root, | |||
3979 | bio_get(bio); | 4031 | bio_get(bio); |
3980 | btrfsic_submit_bio(rw, bio); | 4032 | btrfsic_submit_bio(rw, bio); |
3981 | bio_put(bio); | 4033 | bio_put(bio); |
3982 | return 0; | 4034 | return; |
3983 | } | 4035 | } |
3984 | 4036 | ||
3985 | /* | 4037 | /* |
@@ -4013,7 +4065,6 @@ static noinline int schedule_bio(struct btrfs_root *root, | |||
4013 | if (should_queue) | 4065 | if (should_queue) |
4014 | btrfs_queue_worker(&root->fs_info->submit_workers, | 4066 | btrfs_queue_worker(&root->fs_info->submit_workers, |
4015 | &device->work); | 4067 | &device->work); |
4016 | return 0; | ||
4017 | } | 4068 | } |
4018 | 4069 | ||
4019 | int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio, | 4070 | int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio, |
@@ -4036,7 +4087,8 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio, | |||
4036 | 4087 | ||
4037 | ret = btrfs_map_block(map_tree, rw, logical, &map_length, &bbio, | 4088 | ret = btrfs_map_block(map_tree, rw, logical, &map_length, &bbio, |
4038 | mirror_num); | 4089 | mirror_num); |
4039 | BUG_ON(ret); | 4090 | if (ret) /* -ENOMEM */ |
4091 | return ret; | ||
4040 | 4092 | ||
4041 | total_devs = bbio->num_stripes; | 4093 | total_devs = bbio->num_stripes; |
4042 | if (map_length < length) { | 4094 | if (map_length < length) { |
@@ -4055,7 +4107,7 @@ int btrfs_map_bio(struct btrfs_root *root, int rw, struct bio *bio, | |||
4055 | while (dev_nr < total_devs) { | 4107 | while (dev_nr < total_devs) { |
4056 | if (dev_nr < total_devs - 1) { | 4108 | if (dev_nr < total_devs - 1) { |
4057 | bio = bio_clone(first_bio, GFP_NOFS); | 4109 | bio = bio_clone(first_bio, GFP_NOFS); |
4058 | BUG_ON(!bio); | 4110 | BUG_ON(!bio); /* -ENOMEM */ |
4059 | } else { | 4111 | } else { |
4060 | bio = first_bio; | 4112 | bio = first_bio; |
4061 | } | 4113 | } |
@@ -4209,13 +4261,13 @@ static int read_one_chunk(struct btrfs_root *root, struct btrfs_key *key, | |||
4209 | write_lock(&map_tree->map_tree.lock); | 4261 | write_lock(&map_tree->map_tree.lock); |
4210 | ret = add_extent_mapping(&map_tree->map_tree, em); | 4262 | ret = add_extent_mapping(&map_tree->map_tree, em); |
4211 | write_unlock(&map_tree->map_tree.lock); | 4263 | write_unlock(&map_tree->map_tree.lock); |
4212 | BUG_ON(ret); | 4264 | BUG_ON(ret); /* Tree corruption */ |
4213 | free_extent_map(em); | 4265 | free_extent_map(em); |
4214 | 4266 | ||
4215 | return 0; | 4267 | return 0; |
4216 | } | 4268 | } |
4217 | 4269 | ||
4218 | static int fill_device_from_item(struct extent_buffer *leaf, | 4270 | static void fill_device_from_item(struct extent_buffer *leaf, |
4219 | struct btrfs_dev_item *dev_item, | 4271 | struct btrfs_dev_item *dev_item, |
4220 | struct btrfs_device *device) | 4272 | struct btrfs_device *device) |
4221 | { | 4273 | { |
@@ -4232,8 +4284,6 @@ static int fill_device_from_item(struct extent_buffer *leaf, | |||
4232 | 4284 | ||
4233 | ptr = (unsigned long)btrfs_device_uuid(dev_item); | 4285 | ptr = (unsigned long)btrfs_device_uuid(dev_item); |
4234 | read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); | 4286 | read_extent_buffer(leaf, device->uuid, ptr, BTRFS_UUID_SIZE); |
4235 | |||
4236 | return 0; | ||
4237 | } | 4287 | } |
4238 | 4288 | ||
4239 | static int open_seed_devices(struct btrfs_root *root, u8 *fsid) | 4289 | static int open_seed_devices(struct btrfs_root *root, u8 *fsid) |
diff --git a/fs/btrfs/volumes.h b/fs/btrfs/volumes.h index 19ac95048b88..bb6b03f97aaa 100644 --- a/fs/btrfs/volumes.h +++ b/fs/btrfs/volumes.h | |||
@@ -260,12 +260,12 @@ int btrfs_open_devices(struct btrfs_fs_devices *fs_devices, | |||
260 | int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder, | 260 | int btrfs_scan_one_device(const char *path, fmode_t flags, void *holder, |
261 | struct btrfs_fs_devices **fs_devices_ret); | 261 | struct btrfs_fs_devices **fs_devices_ret); |
262 | int btrfs_close_devices(struct btrfs_fs_devices *fs_devices); | 262 | int btrfs_close_devices(struct btrfs_fs_devices *fs_devices); |
263 | int btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices); | 263 | void btrfs_close_extra_devices(struct btrfs_fs_devices *fs_devices); |
264 | int btrfs_add_device(struct btrfs_trans_handle *trans, | 264 | int btrfs_add_device(struct btrfs_trans_handle *trans, |
265 | struct btrfs_root *root, | 265 | struct btrfs_root *root, |
266 | struct btrfs_device *device); | 266 | struct btrfs_device *device); |
267 | int btrfs_rm_device(struct btrfs_root *root, char *device_path); | 267 | int btrfs_rm_device(struct btrfs_root *root, char *device_path); |
268 | int btrfs_cleanup_fs_uuids(void); | 268 | void btrfs_cleanup_fs_uuids(void); |
269 | int btrfs_num_copies(struct btrfs_mapping_tree *map_tree, u64 logical, u64 len); | 269 | int btrfs_num_copies(struct btrfs_mapping_tree *map_tree, u64 logical, u64 len); |
270 | int btrfs_grow_device(struct btrfs_trans_handle *trans, | 270 | int btrfs_grow_device(struct btrfs_trans_handle *trans, |
271 | struct btrfs_device *device, u64 new_size); | 271 | struct btrfs_device *device, u64 new_size); |