tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs

Quoth Chris:
"This is later than I wanted because I got backed up running through
btrfs bugs from the Oracle QA teams. But they are all bug fixes that
we've queued and tested since rc1.

Nothing in particular stands out, this just reflects bug fixing and QA
done in parallel by all the btrfs developers. The most user visible
of these is:

Btrfs: clear the extent uptodate bits during parent transid failures

Because that helps deal with out of date drives (say an iscsi disk
that has gone away and come back). The old code wasn't always
properly retrying the other mirror for this type of failure."

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mason/linux-btrfs: (24 commits)
Btrfs: fix compiler warnings on 32 bit systems
Btrfs: increase the global block reserve estimates
Btrfs: clear the extent uptodate bits during parent transid failures
Btrfs: add extra sanity checks on the path names in btrfs_mksubvol
Btrfs: make sure we update latest_bdev
Btrfs: improve error handling for btrfs_insert_dir_item callers
Btrfs: be less strict on finding next node in clear_extent_bit
Btrfs: fix a bug on overcommit stuff
Btrfs: kick out redundant stuff in convert_extent_bit
Btrfs: skip states when they does not contain bits to clear
Btrfs: check return value of lookup_extent_mapping() correctly
Btrfs: fix deadlock on page lock when doing auto-defragment
Btrfs: fix return value check of extent_io_ops
btrfs: honor umask when creating subvol root
btrfs: silence warning in raid array setup
btrfs: fix structs where bitfields and spinlock/atomic share 8B word
btrfs: delalloc for page dirtied out-of-band in fixup worker
Btrfs: fix memory leak in load_free_space_cache()
btrfs: don't check DUP chunks twice
Btrfs: fix trim 0 bytes after a device delete
...

Linus Torvalds 855a85f7 ee325324

+250 -131
+2
fs/btrfs/backref.c
··· 892 892 if (eb != eb_in) 893 893 free_extent_buffer(eb); 894 894 ret = inode_ref_info(parent, 0, fs_root, path, &found_key); 895 + if (ret > 0) 896 + ret = -ENOENT; 895 897 if (ret) 896 898 break; 897 899 next_inum = found_key.offset;
+1 -1
fs/btrfs/check-integrity.c
··· 644 644 static int btrfsic_process_superblock(struct btrfsic_state *state, 645 645 struct btrfs_fs_devices *fs_devices) 646 646 { 647 - int ret; 647 + int ret = 0; 648 648 struct btrfs_super_block *selected_super; 649 649 struct list_head *dev_head = &fs_devices->devices; 650 650 struct btrfs_device *device;
+2
fs/btrfs/compression.c
··· 588 588 page_offset(bio->bi_io_vec->bv_page), 589 589 PAGE_CACHE_SIZE); 590 590 read_unlock(&em_tree->lock); 591 + if (!em) 592 + return -EIO; 591 593 592 594 compressed_len = em->block_len; 593 595 cb = kmalloc(compressed_bio_size(root, compressed_len), GFP_NOFS);
+1 -1
fs/btrfs/ctree.h
··· 886 886 u64 reserved; 887 887 struct btrfs_space_info *space_info; 888 888 spinlock_t lock; 889 - unsigned int full:1; 889 + unsigned int full; 890 890 }; 891 891 892 892 /*
+12
fs/btrfs/disk-io.c
··· 2260 2260 goto fail_sb_buffer; 2261 2261 } 2262 2262 2263 + if (sectorsize < PAGE_SIZE) { 2264 + printk(KERN_WARNING "btrfs: Incompatible sector size " 2265 + "found on %s\n", sb->s_id); 2266 + goto fail_sb_buffer; 2267 + } 2268 + 2263 2269 mutex_lock(&fs_info->chunk_mutex); 2264 2270 ret = btrfs_read_sys_array(tree_root); 2265 2271 mutex_unlock(&fs_info->chunk_mutex); ··· 2306 2300 } 2307 2301 2308 2302 btrfs_close_extra_devices(fs_devices); 2303 + 2304 + if (!fs_devices->latest_bdev) { 2305 + printk(KERN_CRIT "btrfs: failed to read devices on %s\n", 2306 + sb->s_id); 2307 + goto fail_tree_roots; 2308 + } 2309 2309 2310 2310 retry_root_backup: 2311 2311 blocksize = btrfs_level_size(tree_root,
+32 -19
fs/btrfs/extent-tree.c
··· 3312 3312 } 3313 3313 data_sinfo->bytes_may_use += bytes; 3314 3314 trace_btrfs_space_reservation(root->fs_info, "space_info", 3315 - (u64)data_sinfo, bytes, 1); 3315 + (u64)(unsigned long)data_sinfo, 3316 + bytes, 1); 3316 3317 spin_unlock(&data_sinfo->lock); 3317 3318 3318 3319 return 0; ··· 3334 3333 spin_lock(&data_sinfo->lock); 3335 3334 data_sinfo->bytes_may_use -= bytes; 3336 3335 trace_btrfs_space_reservation(root->fs_info, "space_info", 3337 - (u64)data_sinfo, bytes, 0); 3336 + (u64)(unsigned long)data_sinfo, 3337 + bytes, 0); 3338 3338 spin_unlock(&data_sinfo->lock); 3339 3339 } 3340 3340 ··· 3613 3611 if (space_info != delayed_rsv->space_info) 3614 3612 return -ENOSPC; 3615 3613 3614 + spin_lock(&space_info->lock); 3616 3615 spin_lock(&delayed_rsv->lock); 3617 - if (delayed_rsv->size < bytes) { 3616 + if (space_info->bytes_pinned + delayed_rsv->size < bytes) { 3618 3617 spin_unlock(&delayed_rsv->lock); 3618 + spin_unlock(&space_info->lock); 3619 3619 return -ENOSPC; 3620 3620 } 3621 3621 spin_unlock(&delayed_rsv->lock); 3622 + spin_unlock(&space_info->lock); 3622 3623 3623 3624 commit: 3624 3625 trans = btrfs_join_transaction(root); ··· 3700 3695 if (used + orig_bytes <= space_info->total_bytes) { 3701 3696 space_info->bytes_may_use += orig_bytes; 3702 3697 trace_btrfs_space_reservation(root->fs_info, 3703 - "space_info", 3704 - (u64)space_info, 3705 - orig_bytes, 1); 3698 + "space_info", 3699 + (u64)(unsigned long)space_info, 3700 + orig_bytes, 1); 3706 3701 ret = 0; 3707 3702 } else { 3708 3703 /* ··· 3771 3766 if (used + num_bytes < space_info->total_bytes + avail) { 3772 3767 space_info->bytes_may_use += orig_bytes; 3773 3768 trace_btrfs_space_reservation(root->fs_info, 3774 - "space_info", 3775 - (u64)space_info, 3776 - orig_bytes, 1); 3769 + "space_info", 3770 + (u64)(unsigned long)space_info, 3771 + orig_bytes, 1); 3777 3772 ret = 0; 3778 3773 } else { 3779 3774 wait_ordered = true; ··· 3918 3913 spin_lock(&space_info->lock); 3919 3914 space_info->bytes_may_use -= num_bytes; 3920 3915 trace_btrfs_space_reservation(fs_info, "space_info", 3921 - (u64)space_info, 3922 - num_bytes, 0); 3916 + (u64)(unsigned long)space_info, 3917 + num_bytes, 0); 3923 3918 space_info->reservation_progress++; 3924 3919 spin_unlock(&space_info->lock); 3925 3920 } ··· 4110 4105 num_bytes += div64_u64(data_used + meta_used, 50); 4111 4106 4112 4107 if (num_bytes * 3 > meta_used) 4113 - num_bytes = div64_u64(meta_used, 3); 4108 + num_bytes = div64_u64(meta_used, 3) * 2; 4114 4109 4115 4110 return ALIGN(num_bytes, fs_info->extent_root->leafsize << 10); 4116 4111 } ··· 4137 4132 block_rsv->reserved += num_bytes; 4138 4133 sinfo->bytes_may_use += num_bytes; 4139 4134 trace_btrfs_space_reservation(fs_info, "space_info", 4140 - (u64)sinfo, num_bytes, 1); 4135 + (u64)(unsigned long)sinfo, num_bytes, 1); 4141 4136 } 4142 4137 4143 4138 if (block_rsv->reserved >= block_rsv->size) { 4144 4139 num_bytes = block_rsv->reserved - block_rsv->size; 4145 4140 sinfo->bytes_may_use -= num_bytes; 4146 4141 trace_btrfs_space_reservation(fs_info, "space_info", 4147 - (u64)sinfo, num_bytes, 0); 4142 + (u64)(unsigned long)sinfo, num_bytes, 0); 4148 4143 sinfo->reservation_progress++; 4149 4144 block_rsv->reserved = block_rsv->size; 4150 4145 block_rsv->full = 1; ··· 4197 4192 if (!trans->bytes_reserved) 4198 4193 return; 4199 4194 4200 - trace_btrfs_space_reservation(root->fs_info, "transaction", (u64)trans, 4195 + trace_btrfs_space_reservation(root->fs_info, "transaction", 4196 + (u64)(unsigned long)trans, 4201 4197 trans->bytes_reserved, 0); 4202 4198 btrfs_block_rsv_release(root, trans->block_rsv, trans->bytes_reserved); 4203 4199 trans->bytes_reserved = 0; ··· 4716 4710 space_info->bytes_reserved += num_bytes; 4717 4711 if (reserve == RESERVE_ALLOC) { 4718 4712 trace_btrfs_space_reservation(cache->fs_info, 4719 - "space_info", 4720 - (u64)space_info, 4721 - num_bytes, 0); 4713 + "space_info", 4714 + (u64)(unsigned long)space_info, 4715 + num_bytes, 0); 4722 4716 space_info->bytes_may_use -= num_bytes; 4723 4717 } 4724 4718 } ··· 7892 7886 u64 start; 7893 7887 u64 end; 7894 7888 u64 trimmed = 0; 7889 + u64 total_bytes = btrfs_super_total_bytes(fs_info->super_copy); 7895 7890 int ret = 0; 7896 7891 7897 - cache = btrfs_lookup_block_group(fs_info, range->start); 7892 + /* 7893 + * try to trim all FS space, our block group may start from non-zero. 7894 + */ 7895 + if (range->len == total_bytes) 7896 + cache = btrfs_lookup_first_block_group(fs_info, range->start); 7897 + else 7898 + cache = btrfs_lookup_block_group(fs_info, range->start); 7898 7899 7899 7900 while (cache) { 7900 7901 if (cache->key.objectid >= (range->start + range->len)) {
+65 -48
fs/btrfs/extent_io.c
··· 513 513 WARN_ON(state->end < start); 514 514 last_end = state->end; 515 515 516 + if (state->end < end && !need_resched()) 517 + next_node = rb_next(&state->rb_node); 518 + else 519 + next_node = NULL; 520 + 521 + /* the state doesn't have the wanted bits, go ahead */ 522 + if (!(state->state & bits)) 523 + goto next; 524 + 516 525 /* 517 526 * | ---- desired range ---- | 518 527 * | state | or ··· 574 565 goto out; 575 566 } 576 567 577 - if (state->end < end && prealloc && !need_resched()) 578 - next_node = rb_next(&state->rb_node); 579 - else 580 - next_node = NULL; 581 - 582 568 set |= clear_state_bit(tree, state, &bits, wake); 569 + next: 583 570 if (last_end == (u64)-1) 584 571 goto out; 585 572 start = last_end + 1; 586 573 if (start <= end && next_node) { 587 574 state = rb_entry(next_node, struct extent_state, 588 575 rb_node); 589 - if (state->start == start) 590 - goto hit_next; 576 + goto hit_next; 591 577 } 592 578 goto search_again; 593 579 ··· 965 961 966 962 set_state_bits(tree, state, &bits); 967 963 clear_state_bit(tree, state, &clear_bits, 0); 968 - 969 - merge_state(tree, state); 970 964 if (last_end == (u64)-1) 971 965 goto out; 972 966 ··· 1009 1007 if (state->end <= end) { 1010 1008 set_state_bits(tree, state, &bits); 1011 1009 clear_state_bit(tree, state, &clear_bits, 0); 1012 - merge_state(tree, state); 1013 1010 if (last_end == (u64)-1) 1014 1011 goto out; 1015 1012 start = last_end + 1; ··· 1069 1068 1070 1069 set_state_bits(tree, prealloc, &bits); 1071 1070 clear_state_bit(tree, prealloc, &clear_bits, 0); 1072 - 1073 - merge_state(tree, prealloc); 1074 1071 prealloc = NULL; 1075 1072 goto out; 1076 1073 } ··· 2153 2154 "this_mirror=%d, num_copies=%d, in_validation=%d\n", read_mode, 2154 2155 failrec->this_mirror, num_copies, failrec->in_validation); 2155 2156 2156 - tree->ops->submit_bio_hook(inode, read_mode, bio, failrec->this_mirror, 2157 - failrec->bio_flags, 0); 2158 - return 0; 2157 + ret = tree->ops->submit_bio_hook(inode, read_mode, bio, 2158 + failrec->this_mirror, 2159 + failrec->bio_flags, 0); 2160 + return ret; 2159 2161 } 2160 2162 2161 2163 /* lots and lots of room for performance fixes in the end_bio funcs */ 2164 + 2165 + int end_extent_writepage(struct page *page, int err, u64 start, u64 end) 2166 + { 2167 + int uptodate = (err == 0); 2168 + struct extent_io_tree *tree; 2169 + int ret; 2170 + 2171 + tree = &BTRFS_I(page->mapping->host)->io_tree; 2172 + 2173 + if (tree->ops && tree->ops->writepage_end_io_hook) { 2174 + ret = tree->ops->writepage_end_io_hook(page, start, 2175 + end, NULL, uptodate); 2176 + if (ret) 2177 + uptodate = 0; 2178 + } 2179 + 2180 + if (!uptodate && tree->ops && 2181 + tree->ops->writepage_io_failed_hook) { 2182 + ret = tree->ops->writepage_io_failed_hook(NULL, page, 2183 + start, end, NULL); 2184 + /* Writeback already completed */ 2185 + if (ret == 0) 2186 + return 1; 2187 + } 2188 + 2189 + if (!uptodate) { 2190 + clear_extent_uptodate(tree, start, end, NULL, GFP_NOFS); 2191 + ClearPageUptodate(page); 2192 + SetPageError(page); 2193 + } 2194 + return 0; 2195 + } 2162 2196 2163 2197 /* 2164 2198 * after a writepage IO is done, we need to: ··· 2204 2172 */ 2205 2173 static void end_bio_extent_writepage(struct bio *bio, int err) 2206 2174 { 2207 - int uptodate = err == 0; 2208 2175 struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1; 2209 2176 struct extent_io_tree *tree; 2210 2177 u64 start; 2211 2178 u64 end; 2212 2179 int whole_page; 2213 - int ret; 2214 2180 2215 2181 do { 2216 2182 struct page *page = bvec->bv_page; ··· 2225 2195 2226 2196 if (--bvec >= bio->bi_io_vec) 2227 2197 prefetchw(&bvec->bv_page->flags); 2228 - if (tree->ops && tree->ops->writepage_end_io_hook) { 2229 - ret = tree->ops->writepage_end_io_hook(page, start, 2230 - end, NULL, uptodate); 2231 - if (ret) 2232 - uptodate = 0; 2233 - } 2234 2198 2235 - if (!uptodate && tree->ops && 2236 - tree->ops->writepage_io_failed_hook) { 2237 - ret = tree->ops->writepage_io_failed_hook(bio, page, 2238 - start, end, NULL); 2239 - if (ret == 0) { 2240 - uptodate = (err == 0); 2241 - continue; 2242 - } 2243 - } 2244 - 2245 - if (!uptodate) { 2246 - clear_extent_uptodate(tree, start, end, NULL, GFP_NOFS); 2247 - ClearPageUptodate(page); 2248 - SetPageError(page); 2249 - } 2199 + if (end_extent_writepage(page, err, start, end)) 2200 + continue; 2250 2201 2251 2202 if (whole_page) 2252 2203 end_page_writeback(page); ··· 2790 2779 delalloc_start = delalloc_end + 1; 2791 2780 continue; 2792 2781 } 2793 - tree->ops->fill_delalloc(inode, page, delalloc_start, 2794 - delalloc_end, &page_started, 2795 - &nr_written); 2782 + ret = tree->ops->fill_delalloc(inode, page, 2783 + delalloc_start, 2784 + delalloc_end, 2785 + &page_started, 2786 + &nr_written); 2787 + BUG_ON(ret); 2796 2788 /* 2797 2789 * delalloc_end is already one less than the total 2798 2790 * length, so we don't subtract one from ··· 2832 2818 if (tree->ops && tree->ops->writepage_start_hook) { 2833 2819 ret = tree->ops->writepage_start_hook(page, start, 2834 2820 page_end); 2835 - if (ret == -EAGAIN) { 2836 - redirty_page_for_writepage(wbc, page); 2821 + if (ret) { 2822 + /* Fixup worker will requeue */ 2823 + if (ret == -EBUSY) 2824 + wbc->pages_skipped++; 2825 + else 2826 + redirty_page_for_writepage(wbc, page); 2837 2827 update_nr_written(page, wbc, nr_written); 2838 2828 unlock_page(page); 2839 2829 ret = 0; ··· 3307 3289 len = end - start + 1; 3308 3290 write_lock(&map->lock); 3309 3291 em = lookup_extent_mapping(map, start, len); 3310 - if (IS_ERR_OR_NULL(em)) { 3292 + if (!em) { 3311 3293 write_unlock(&map->lock); 3312 3294 break; 3313 3295 } ··· 3871 3853 num_pages = num_extent_pages(eb->start, eb->len); 3872 3854 clear_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags); 3873 3855 3874 - if (eb_straddles_pages(eb)) { 3875 - clear_extent_uptodate(tree, eb->start, eb->start + eb->len - 1, 3876 - cached_state, GFP_NOFS); 3877 - } 3856 + clear_extent_uptodate(tree, eb->start, eb->start + eb->len - 1, 3857 + cached_state, GFP_NOFS); 3858 + 3878 3859 for (i = 0; i < num_pages; i++) { 3879 3860 page = extent_buffer_page(eb, i); 3880 3861 if (page)
+1
fs/btrfs/extent_io.h
··· 319 319 int repair_io_failure(struct btrfs_mapping_tree *map_tree, u64 start, 320 320 u64 length, u64 logical, struct page *page, 321 321 int mirror_num); 322 + int end_extent_writepage(struct page *page, int err, u64 start, u64 end); 322 323 #endif
+2 -2
fs/btrfs/extent_map.h
··· 26 26 unsigned long flags; 27 27 struct block_device *bdev; 28 28 atomic_t refs; 29 - unsigned int in_tree:1; 30 - unsigned int compress_type:4; 29 + unsigned int in_tree; 30 + unsigned int compress_type; 31 31 }; 32 32 33 33 struct extent_map_tree {
+12 -17
fs/btrfs/file.c
··· 1605 1605 return -EOPNOTSUPP; 1606 1606 1607 1607 /* 1608 + * Make sure we have enough space before we do the 1609 + * allocation. 1610 + */ 1611 + ret = btrfs_check_data_free_space(inode, len); 1612 + if (ret) 1613 + return ret; 1614 + 1615 + /* 1608 1616 * wait for ordered IO before we have any locks. We'll loop again 1609 1617 * below with the locks held. 1610 1618 */ ··· 1675 1667 if (em->block_start == EXTENT_MAP_HOLE || 1676 1668 (cur_offset >= inode->i_size && 1677 1669 !test_bit(EXTENT_FLAG_PREALLOC, &em->flags))) { 1678 - 1679 - /* 1680 - * Make sure we have enough space before we do the 1681 - * allocation. 1682 - */ 1683 - ret = btrfs_check_data_free_space(inode, last_byte - 1684 - cur_offset); 1685 - if (ret) { 1686 - free_extent_map(em); 1687 - break; 1688 - } 1689 - 1690 1670 ret = btrfs_prealloc_file_range(inode, mode, cur_offset, 1691 1671 last_byte - cur_offset, 1692 1672 1 << inode->i_blkbits, 1693 1673 offset + len, 1694 1674 &alloc_hint); 1695 1675 1696 - /* Let go of our reservation. */ 1697 - btrfs_free_reserved_data_space(inode, last_byte - 1698 - cur_offset); 1699 1676 if (ret < 0) { 1700 1677 free_extent_map(em); 1701 1678 break; ··· 1708 1715 &cached_state, GFP_NOFS); 1709 1716 out: 1710 1717 mutex_unlock(&inode->i_mutex); 1718 + /* Let go of our reservation. */ 1719 + btrfs_free_reserved_data_space(inode, len); 1711 1720 return ret; 1712 1721 } 1713 1722 ··· 1756 1761 start - root->sectorsize, 1757 1762 root->sectorsize, 0); 1758 1763 if (IS_ERR(em)) { 1759 - ret = -ENXIO; 1764 + ret = PTR_ERR(em); 1760 1765 goto out; 1761 1766 } 1762 1767 last_end = em->start + em->len; ··· 1768 1773 while (1) { 1769 1774 em = btrfs_get_extent_fiemap(inode, NULL, 0, start, len, 0); 1770 1775 if (IS_ERR(em)) { 1771 - ret = -ENXIO; 1776 + ret = PTR_ERR(em); 1772 1777 break; 1773 1778 } 1774 1779
+1
fs/btrfs/free-space-cache.c
··· 777 777 spin_lock(&block_group->lock); 778 778 if (block_group->disk_cache_state != BTRFS_DC_WRITTEN) { 779 779 spin_unlock(&block_group->lock); 780 + btrfs_free_path(path); 780 781 goto out; 781 782 } 782 783 spin_unlock(&block_group->lock);
+4 -2
fs/btrfs/inode-map.c
··· 438 438 trans->bytes_reserved); 439 439 if (ret) 440 440 goto out; 441 - trace_btrfs_space_reservation(root->fs_info, "ino_cache", (u64)trans, 441 + trace_btrfs_space_reservation(root->fs_info, "ino_cache", 442 + (u64)(unsigned long)trans, 442 443 trans->bytes_reserved, 1); 443 444 again: 444 445 inode = lookup_free_ino_inode(root, path); ··· 501 500 out_put: 502 501 iput(inode); 503 502 out_release: 504 - trace_btrfs_space_reservation(root->fs_info, "ino_cache", (u64)trans, 503 + trace_btrfs_space_reservation(root->fs_info, "ino_cache", 504 + (u64)(unsigned long)trans, 505 505 trans->bytes_reserved, 0); 506 506 btrfs_block_rsv_release(root, trans->block_rsv, trans->bytes_reserved); 507 507 out:
+35 -5
fs/btrfs/inode.c
··· 1555 1555 struct inode *inode; 1556 1556 u64 page_start; 1557 1557 u64 page_end; 1558 + int ret; 1558 1559 1559 1560 fixup = container_of(work, struct btrfs_writepage_fixup, work); 1560 1561 page = fixup->page; ··· 1583 1582 page_end, &cached_state, GFP_NOFS); 1584 1583 unlock_page(page); 1585 1584 btrfs_start_ordered_extent(inode, ordered, 1); 1585 + btrfs_put_ordered_extent(ordered); 1586 1586 goto again; 1587 1587 } 1588 1588 1589 - BUG(); 1589 + ret = btrfs_delalloc_reserve_space(inode, PAGE_CACHE_SIZE); 1590 + if (ret) { 1591 + mapping_set_error(page->mapping, ret); 1592 + end_extent_writepage(page, ret, page_start, page_end); 1593 + ClearPageChecked(page); 1594 + goto out; 1595 + } 1596 + 1590 1597 btrfs_set_extent_delalloc(inode, page_start, page_end, &cached_state); 1591 1598 ClearPageChecked(page); 1599 + set_page_dirty(page); 1592 1600 out: 1593 1601 unlock_extent_cached(&BTRFS_I(inode)->io_tree, page_start, page_end, 1594 1602 &cached_state, GFP_NOFS); ··· 1640 1630 fixup->work.func = btrfs_writepage_fixup_worker; 1641 1631 fixup->page = page; 1642 1632 btrfs_queue_worker(&root->fs_info->fixup_workers, &fixup->work); 1643 - return -EAGAIN; 1633 + return -EBUSY; 1644 1634 } 1645 1635 1646 1636 static int insert_reserved_file_extent(struct btrfs_trans_handle *trans, ··· 4585 4575 ret = btrfs_insert_dir_item(trans, root, name, name_len, 4586 4576 parent_inode, &key, 4587 4577 btrfs_inode_type(inode), index); 4588 - BUG_ON(ret); 4578 + if (ret) 4579 + goto fail_dir_item; 4589 4580 4590 4581 btrfs_i_size_write(parent_inode, parent_inode->i_size + 4591 4582 name_len * 2); 4592 4583 parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME; 4593 4584 ret = btrfs_update_inode(trans, root, parent_inode); 4585 + } 4586 + return ret; 4587 + 4588 + fail_dir_item: 4589 + if (unlikely(ino == BTRFS_FIRST_FREE_OBJECTID)) { 4590 + u64 local_index; 4591 + int err; 4592 + err = btrfs_del_root_ref(trans, root->fs_info->tree_root, 4593 + key.objectid, root->root_key.objectid, 4594 + parent_ino, &local_index, name, name_len); 4595 + 4596 + } else if (add_backref) { 4597 + u64 local_index; 4598 + int err; 4599 + 4600 + err = btrfs_del_inode_ref(trans, root, name, name_len, 4601 + ino, parent_ino, &local_index); 4594 4602 } 4595 4603 return ret; 4596 4604 } ··· 6724 6696 int err; 6725 6697 u64 index = 0; 6726 6698 6727 - inode = btrfs_new_inode(trans, new_root, NULL, "..", 2, new_dirid, 6728 - new_dirid, S_IFDIR | 0700, &index); 6699 + inode = btrfs_new_inode(trans, new_root, NULL, "..", 2, 6700 + new_dirid, new_dirid, 6701 + S_IFDIR | (~current_umask() & S_IRWXUGO), 6702 + &index); 6729 6703 if (IS_ERR(inode)) 6730 6704 return PTR_ERR(inode); 6731 6705 inode->i_op = &btrfs_dir_inode_operations;
+35 -24
fs/btrfs/ioctl.c
··· 861 861 int i_done; 862 862 struct btrfs_ordered_extent *ordered; 863 863 struct extent_state *cached_state = NULL; 864 + struct extent_io_tree *tree; 864 865 gfp_t mask = btrfs_alloc_write_mask(inode->i_mapping); 865 866 866 867 if (isize == 0) ··· 872 871 num_pages << PAGE_CACHE_SHIFT); 873 872 if (ret) 874 873 return ret; 875 - again: 876 - ret = 0; 877 874 i_done = 0; 875 + tree = &BTRFS_I(inode)->io_tree; 878 876 879 877 /* step one, lock all the pages */ 880 878 for (i = 0; i < num_pages; i++) { 881 879 struct page *page; 880 + again: 882 881 page = find_or_create_page(inode->i_mapping, 883 - start_index + i, mask); 882 + start_index + i, mask); 884 883 if (!page) 885 884 break; 885 + 886 + page_start = page_offset(page); 887 + page_end = page_start + PAGE_CACHE_SIZE - 1; 888 + while (1) { 889 + lock_extent(tree, page_start, page_end, GFP_NOFS); 890 + ordered = btrfs_lookup_ordered_extent(inode, 891 + page_start); 892 + unlock_extent(tree, page_start, page_end, GFP_NOFS); 893 + if (!ordered) 894 + break; 895 + 896 + unlock_page(page); 897 + btrfs_start_ordered_extent(inode, ordered, 1); 898 + btrfs_put_ordered_extent(ordered); 899 + lock_page(page); 900 + } 886 901 887 902 if (!PageUptodate(page)) { 888 903 btrfs_readpage(NULL, page); ··· 910 893 break; 911 894 } 912 895 } 896 + 913 897 isize = i_size_read(inode); 914 898 file_end = (isize - 1) >> PAGE_CACHE_SHIFT; 915 - if (!isize || page->index > file_end || 916 - page->mapping != inode->i_mapping) { 899 + if (!isize || page->index > file_end) { 917 900 /* whoops, we blew past eof, skip this page */ 918 901 unlock_page(page); 919 902 page_cache_release(page); 920 903 break; 921 904 } 905 + 906 + if (page->mapping != inode->i_mapping) { 907 + unlock_page(page); 908 + page_cache_release(page); 909 + goto again; 910 + } 911 + 922 912 pages[i] = page; 923 913 i_done++; 924 914 } ··· 948 924 lock_extent_bits(&BTRFS_I(inode)->io_tree, 949 925 page_start, page_end - 1, 0, &cached_state, 950 926 GFP_NOFS); 951 - ordered = btrfs_lookup_first_ordered_extent(inode, page_end - 1); 952 - if (ordered && 953 - ordered->file_offset + ordered->len > page_start && 954 - ordered->file_offset < page_end) { 955 - btrfs_put_ordered_extent(ordered); 956 - unlock_extent_cached(&BTRFS_I(inode)->io_tree, 957 - page_start, page_end - 1, 958 - &cached_state, GFP_NOFS); 959 - for (i = 0; i < i_done; i++) { 960 - unlock_page(pages[i]); 961 - page_cache_release(pages[i]); 962 - } 963 - btrfs_wait_ordered_range(inode, page_start, 964 - page_end - page_start); 965 - goto again; 966 - } 967 - if (ordered) 968 - btrfs_put_ordered_extent(ordered); 969 - 970 927 clear_extent_bit(&BTRFS_I(inode)->io_tree, page_start, 971 928 page_end - 1, EXTENT_DIRTY | EXTENT_DELALLOC | 972 929 EXTENT_DO_ACCOUNTING, 0, 0, &cached_state, ··· 1329 1324 namelen = strlen(name); 1330 1325 if (strchr(name, '/')) { 1331 1326 ret = -EINVAL; 1327 + goto out; 1328 + } 1329 + 1330 + if (name[0] == '.' && 1331 + (namelen == 1 || (name[1] == '.' && namelen == 2))) { 1332 + ret = -EEXIST; 1332 1333 goto out; 1333 1334 } 1334 1335
+5 -3
fs/btrfs/scrub.c
··· 1367 1367 } 1368 1368 1369 1369 static noinline_for_stack int scrub_chunk(struct scrub_dev *sdev, 1370 - u64 chunk_tree, u64 chunk_objectid, u64 chunk_offset, u64 length) 1370 + u64 chunk_tree, u64 chunk_objectid, u64 chunk_offset, u64 length, 1371 + u64 dev_offset) 1371 1372 { 1372 1373 struct btrfs_mapping_tree *map_tree = 1373 1374 &sdev->dev->dev_root->fs_info->mapping_tree; ··· 1392 1391 goto out; 1393 1392 1394 1393 for (i = 0; i < map->num_stripes; ++i) { 1395 - if (map->stripes[i].dev == sdev->dev) { 1394 + if (map->stripes[i].dev == sdev->dev && 1395 + map->stripes[i].physical == dev_offset) { 1396 1396 ret = scrub_stripe(sdev, map, i, chunk_offset, length); 1397 1397 if (ret) 1398 1398 goto out; ··· 1489 1487 break; 1490 1488 } 1491 1489 ret = scrub_chunk(sdev, chunk_tree, chunk_objectid, 1492 - chunk_offset, length); 1490 + chunk_offset, length, found_key.offset); 1493 1491 btrfs_put_block_group(cache); 1494 1492 if (ret) 1495 1493 break;
+9 -7
fs/btrfs/transaction.c
··· 327 327 328 328 if (num_bytes) { 329 329 trace_btrfs_space_reservation(root->fs_info, "transaction", 330 - (u64)h, num_bytes, 1); 330 + (u64)(unsigned long)h, 331 + num_bytes, 1); 331 332 h->block_rsv = &root->fs_info->trans_block_rsv; 332 333 h->bytes_reserved = num_bytes; 333 334 } ··· 916 915 dentry->d_name.name, dentry->d_name.len, 917 916 parent_inode, &key, 918 917 BTRFS_FT_DIR, index); 919 - BUG_ON(ret); 918 + if (ret) { 919 + pending->error = -EEXIST; 920 + dput(parent); 921 + goto fail; 922 + } 920 923 921 924 btrfs_i_size_write(parent_inode, parent_inode->i_size + 922 925 dentry->d_name.len * 2); ··· 998 993 { 999 994 struct btrfs_pending_snapshot *pending; 1000 995 struct list_head *head = &trans->transaction->pending_snapshots; 1001 - int ret; 1002 996 1003 - list_for_each_entry(pending, head, list) { 1004 - ret = create_pending_snapshot(trans, fs_info, pending); 1005 - BUG_ON(ret); 1006 - } 997 + list_for_each_entry(pending, head, list) 998 + create_pending_snapshot(trans, fs_info, pending); 1007 999 return 0; 1008 1000 } 1009 1001
+31 -2
fs/btrfs/volumes.c
··· 459 459 { 460 460 struct btrfs_device *device, *next; 461 461 462 + struct block_device *latest_bdev = NULL; 463 + u64 latest_devid = 0; 464 + u64 latest_transid = 0; 465 + 462 466 mutex_lock(&uuid_mutex); 463 467 again: 464 468 /* This is the initialized path, it is safe to release the devices. */ 465 469 list_for_each_entry_safe(device, next, &fs_devices->devices, dev_list) { 466 - if (device->in_fs_metadata) 470 + if (device->in_fs_metadata) { 471 + if (!latest_transid || 472 + device->generation > latest_transid) { 473 + latest_devid = device->devid; 474 + latest_transid = device->generation; 475 + latest_bdev = device->bdev; 476 + } 467 477 continue; 478 + } 468 479 469 480 if (device->bdev) { 470 481 blkdev_put(device->bdev, device->mode); ··· 497 486 fs_devices = fs_devices->seed; 498 487 goto again; 499 488 } 489 + 490 + fs_devices->latest_bdev = latest_bdev; 491 + fs_devices->latest_devid = latest_devid; 492 + fs_devices->latest_trans = latest_transid; 500 493 501 494 mutex_unlock(&uuid_mutex); 502 495 return 0; ··· 1968 1953 em = lookup_extent_mapping(em_tree, chunk_offset, 1); 1969 1954 read_unlock(&em_tree->lock); 1970 1955 1971 - BUG_ON(em->start > chunk_offset || 1956 + BUG_ON(!em || em->start > chunk_offset || 1972 1957 em->start + em->len < chunk_offset); 1973 1958 map = (struct map_lookup *)em->bdev; 1974 1959 ··· 4371 4356 return -ENOMEM; 4372 4357 btrfs_set_buffer_uptodate(sb); 4373 4358 btrfs_set_buffer_lockdep_class(root->root_key.objectid, sb, 0); 4359 + /* 4360 + * The sb extent buffer is artifical and just used to read the system array. 4361 + * btrfs_set_buffer_uptodate() call does not properly mark all it's 4362 + * pages up-to-date when the page is larger: extent does not cover the 4363 + * whole page and consequently check_page_uptodate does not find all 4364 + * the page's extents up-to-date (the hole beyond sb), 4365 + * write_extent_buffer then triggers a WARN_ON. 4366 + * 4367 + * Regular short extents go through mark_extent_buffer_dirty/writeback cycle, 4368 + * but sb spans only this function. Add an explicit SetPageUptodate call 4369 + * to silence the warning eg. on PowerPC 64. 4370 + */ 4371 + if (PAGE_CACHE_SIZE > BTRFS_SUPER_INFO_SIZE) 4372 + SetPageUptodate(sb->first_page); 4374 4373 4375 4374 write_extent_buffer(sb, super_copy, 0, BTRFS_SUPER_INFO_SIZE); 4376 4375 array_size = btrfs_super_sys_array_size(super_copy);