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

btrfs: drop create parameter to btrfs_get_extent()

We only pass this as 1 from __extent_writepage_io(). The parameter
basically means "pretend I didn't pass in a page". This is silly since
we can simply not pass in the page. Get rid of the parameter from
btrfs_get_extent(), and since it's used as a get_extent_t callback,
remove it from get_extent_t and btree_get_extent(), neither of which
need it.

While we're here, let's document btrfs_get_extent().

Signed-off-by: Omar Sandoval <osandov@fb.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

authored by

Omar Sandoval and committed by
David Sterba 39b07b5d f95d713b

+64 -62
+1 -1
fs/btrfs/ctree.h
··· 2875 2875 struct btrfs_root *root); 2876 2876 struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, 2877 2877 struct page *page, size_t pg_offset, 2878 - u64 start, u64 end, int create); 2878 + u64 start, u64 end); 2879 2879 int btrfs_update_inode(struct btrfs_trans_handle *trans, 2880 2880 struct btrfs_root *root, 2881 2881 struct inode *inode);
+2 -2
fs/btrfs/disk-io.c
··· 202 202 * that covers the entire device 203 203 */ 204 204 struct extent_map *btree_get_extent(struct btrfs_inode *inode, 205 - struct page *page, size_t pg_offset, u64 start, u64 len, 206 - int create) 205 + struct page *page, size_t pg_offset, 206 + u64 start, u64 len) 207 207 { 208 208 struct extent_map_tree *em_tree = &inode->extent_tree; 209 209 struct extent_map *em;
+2 -2
fs/btrfs/disk-io.h
··· 134 134 int btree_lock_page_hook(struct page *page, void *data, 135 135 void (*flush_fn)(void *)); 136 136 struct extent_map *btree_get_extent(struct btrfs_inode *inode, 137 - struct page *page, size_t pg_offset, u64 start, u64 len, 138 - int create); 137 + struct page *page, size_t pg_offset, 138 + u64 start, u64 len); 139 139 int btrfs_get_num_tolerated_disk_barrier_failures(u64 flags); 140 140 int __init btrfs_end_io_wq_init(void); 141 141 void __cold btrfs_end_io_wq_exit(void);
+3 -3
fs/btrfs/extent_io.c
··· 3043 3043 *em_cached = NULL; 3044 3044 } 3045 3045 3046 - em = get_extent(BTRFS_I(inode), page, pg_offset, start, len, 0); 3046 + em = get_extent(BTRFS_I(inode), page, pg_offset, start, len); 3047 3047 if (em_cached && !IS_ERR_OR_NULL(em)) { 3048 3048 BUG_ON(*em_cached); 3049 3049 refcount_inc(&em->refs); ··· 3466 3466 page_end, 1); 3467 3467 break; 3468 3468 } 3469 - em = btrfs_get_extent(BTRFS_I(inode), page, pg_offset, cur, 3470 - end - cur + 1, 1); 3469 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, cur, 3470 + end - cur + 1); 3471 3471 if (IS_ERR_OR_NULL(em)) { 3472 3472 SetPageError(page); 3473 3473 ret = PTR_ERR_OR_ZERO(em);
+2 -4
fs/btrfs/extent_io.h
··· 183 183 struct extent_map_tree; 184 184 185 185 typedef struct extent_map *(get_extent_t)(struct btrfs_inode *inode, 186 - struct page *page, 187 - size_t pg_offset, 188 - u64 start, u64 len, 189 - int create); 186 + struct page *page, size_t pg_offset, 187 + u64 start, u64 len); 190 188 191 189 int try_release_extent_mapping(struct page *page, gfp_t mask); 192 190 int try_release_extent_buffer(struct page *page);
+8 -9
fs/btrfs/file.c
··· 477 477 u64 em_len; 478 478 int ret = 0; 479 479 480 - em = btrfs_get_extent(inode, NULL, 0, search_start, 481 - search_len, 0); 480 + em = btrfs_get_extent(inode, NULL, 0, search_start, search_len); 482 481 if (IS_ERR(em)) 483 482 return PTR_ERR(em); 484 483 ··· 2389 2390 2390 2391 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 2391 2392 round_down(*start, fs_info->sectorsize), 2392 - round_up(*len, fs_info->sectorsize), 0); 2393 + round_up(*len, fs_info->sectorsize)); 2393 2394 if (IS_ERR(em)) 2394 2395 return PTR_ERR(em); 2395 2396 ··· 2956 2957 int ret; 2957 2958 2958 2959 offset = round_down(offset, sectorsize); 2959 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 2960 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 2960 2961 if (IS_ERR(em)) 2961 2962 return PTR_ERR(em); 2962 2963 ··· 2989 2990 2990 2991 inode_dio_wait(inode); 2991 2992 2992 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 2993 - alloc_start, alloc_end - alloc_start, 0); 2993 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, alloc_start, 2994 + alloc_end - alloc_start); 2994 2995 if (IS_ERR(em)) { 2995 2996 ret = PTR_ERR(em); 2996 2997 goto out; ··· 3033 3034 3034 3035 if (BTRFS_BYTES_TO_BLKS(fs_info, offset) == 3035 3036 BTRFS_BYTES_TO_BLKS(fs_info, offset + len - 1)) { 3036 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 3037 - alloc_start, sectorsize, 0); 3037 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, alloc_start, 3038 + sectorsize); 3038 3039 if (IS_ERR(em)) { 3039 3040 ret = PTR_ERR(em); 3040 3041 goto out; ··· 3272 3273 INIT_LIST_HEAD(&reserve_list); 3273 3274 while (cur_offset < alloc_end) { 3274 3275 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, cur_offset, 3275 - alloc_end - cur_offset, 0); 3276 + alloc_end - cur_offset); 3276 3277 if (IS_ERR(em)) { 3277 3278 ret = PTR_ERR(em); 3278 3279 break;
+24 -17
fs/btrfs/inode.c
··· 4504 4504 cur_offset = hole_start; 4505 4505 while (1) { 4506 4506 em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, cur_offset, 4507 - block_end - cur_offset, 0); 4507 + block_end - cur_offset); 4508 4508 if (IS_ERR(em)) { 4509 4509 err = PTR_ERR(em); 4510 4510 em = NULL; ··· 6283 6283 return ret; 6284 6284 } 6285 6285 6286 - /* 6287 - * a bit scary, this does extent mapping from logical file offset to the disk. 6288 - * the ugly parts come from merging extents from the disk with the in-ram 6289 - * representation. This gets more complex because of the data=ordered code, 6290 - * where the in-ram extents might be locked pending data=ordered completion. 6286 + /** 6287 + * btrfs_get_extent - Lookup the first extent overlapping a range in a file. 6288 + * @inode: file to search in 6289 + * @page: page to read extent data into if the extent is inline 6290 + * @pg_offset: offset into @page to copy to 6291 + * @start: file offset 6292 + * @len: length of range starting at @start 6291 6293 * 6292 - * This also copies inline extents directly into the page. 6294 + * This returns the first &struct extent_map which overlaps with the given 6295 + * range, reading it from the B-tree and caching it if necessary. Note that 6296 + * there may be more extents which overlap the given range after the returned 6297 + * extent_map. 6298 + * 6299 + * If @page is not NULL and the extent is inline, this also reads the extent 6300 + * data directly into the page and marks the extent up to date in the io_tree. 6301 + * 6302 + * Return: ERR_PTR on error, non-NULL extent_map on success. 6293 6303 */ 6294 6304 struct extent_map *btrfs_get_extent(struct btrfs_inode *inode, 6295 - struct page *page, 6296 - size_t pg_offset, u64 start, u64 len, 6297 - int create) 6305 + struct page *page, size_t pg_offset, 6306 + u64 start, u64 len) 6298 6307 { 6299 6308 struct btrfs_fs_info *fs_info = inode->root->fs_info; 6300 6309 int ret; ··· 6320 6311 struct extent_map *em = NULL; 6321 6312 struct extent_map_tree *em_tree = &inode->extent_tree; 6322 6313 struct extent_io_tree *io_tree = &inode->io_tree; 6323 - const bool new_inline = !page || create; 6324 6314 6325 6315 read_lock(&em_tree->lock); 6326 6316 em = lookup_extent_mapping(em_tree, start, len); ··· 6442 6434 goto insert; 6443 6435 } 6444 6436 6445 - btrfs_extent_item_to_extent_map(inode, path, item, 6446 - new_inline, em); 6437 + btrfs_extent_item_to_extent_map(inode, path, item, !page, em); 6447 6438 6448 6439 if (extent_type == BTRFS_FILE_EXTENT_REG || 6449 6440 extent_type == BTRFS_FILE_EXTENT_PREALLOC) { ··· 6454 6447 size_t extent_offset; 6455 6448 size_t copy_size; 6456 6449 6457 - if (new_inline) 6450 + if (!page) 6458 6451 goto out; 6459 6452 6460 6453 size = btrfs_file_extent_ram_bytes(leaf, item); ··· 6537 6530 u64 delalloc_end; 6538 6531 int err = 0; 6539 6532 6540 - em = btrfs_get_extent(inode, NULL, 0, start, len, 0); 6533 + em = btrfs_get_extent(inode, NULL, 0, start, len); 6541 6534 if (IS_ERR(em)) 6542 6535 return em; 6543 6536 /* ··· 7162 7155 goto err; 7163 7156 } 7164 7157 7165 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len, 0); 7158 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len); 7166 7159 if (IS_ERR(em)) { 7167 7160 ret = PTR_ERR(em); 7168 7161 goto unlock_err; ··· 10173 10166 struct btrfs_block_group *bg; 10174 10167 u64 len = isize - start; 10175 10168 10176 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len, 0); 10169 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len); 10177 10170 if (IS_ERR(em)) { 10178 10171 ret = PTR_ERR(em); 10179 10172 goto out;
+1 -1
fs/btrfs/ioctl.c
··· 1128 1128 1129 1129 /* get the big lock and read metadata off disk */ 1130 1130 lock_extent_bits(io_tree, start, end, &cached); 1131 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len, 0); 1131 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, start, len); 1132 1132 unlock_extent_cached(io_tree, start, end, &cached); 1133 1133 1134 1134 if (IS_ERR(em))
+21 -23
fs/btrfs/tests/inode-tests.c
··· 263 263 264 264 /* First with no extents */ 265 265 BTRFS_I(inode)->root = root; 266 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 0, sectorsize, 0); 266 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 0, sectorsize); 267 267 if (IS_ERR(em)) { 268 268 em = NULL; 269 269 test_err("got an error when we shouldn't have"); ··· 283 283 */ 284 284 setup_file_extents(root, sectorsize); 285 285 286 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 0, (u64)-1, 0); 286 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 0, (u64)-1); 287 287 if (IS_ERR(em)) { 288 288 test_err("got an error when we shouldn't have"); 289 289 goto out; ··· 305 305 offset = em->start + em->len; 306 306 free_extent_map(em); 307 307 308 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 308 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 309 309 if (IS_ERR(em)) { 310 310 test_err("got an error when we shouldn't have"); 311 311 goto out; ··· 333 333 offset = em->start + em->len; 334 334 free_extent_map(em); 335 335 336 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 336 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 337 337 if (IS_ERR(em)) { 338 338 test_err("got an error when we shouldn't have"); 339 339 goto out; ··· 356 356 free_extent_map(em); 357 357 358 358 /* Regular extent */ 359 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 359 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 360 360 if (IS_ERR(em)) { 361 361 test_err("got an error when we shouldn't have"); 362 362 goto out; ··· 384 384 free_extent_map(em); 385 385 386 386 /* The next 3 are split extents */ 387 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 387 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 388 388 if (IS_ERR(em)) { 389 389 test_err("got an error when we shouldn't have"); 390 390 goto out; ··· 413 413 offset = em->start + em->len; 414 414 free_extent_map(em); 415 415 416 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 416 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 417 417 if (IS_ERR(em)) { 418 418 test_err("got an error when we shouldn't have"); 419 419 goto out; ··· 435 435 offset = em->start + em->len; 436 436 free_extent_map(em); 437 437 438 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 438 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 439 439 if (IS_ERR(em)) { 440 440 test_err("got an error when we shouldn't have"); 441 441 goto out; ··· 469 469 free_extent_map(em); 470 470 471 471 /* Prealloc extent */ 472 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 472 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 473 473 if (IS_ERR(em)) { 474 474 test_err("got an error when we shouldn't have"); 475 475 goto out; ··· 498 498 free_extent_map(em); 499 499 500 500 /* The next 3 are a half written prealloc extent */ 501 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 501 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 502 502 if (IS_ERR(em)) { 503 503 test_err("got an error when we shouldn't have"); 504 504 goto out; ··· 528 528 offset = em->start + em->len; 529 529 free_extent_map(em); 530 530 531 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 531 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 532 532 if (IS_ERR(em)) { 533 533 test_err("got an error when we shouldn't have"); 534 534 goto out; ··· 561 561 offset = em->start + em->len; 562 562 free_extent_map(em); 563 563 564 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 564 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 565 565 if (IS_ERR(em)) { 566 566 test_err("got an error when we shouldn't have"); 567 567 goto out; ··· 596 596 free_extent_map(em); 597 597 598 598 /* Now for the compressed extent */ 599 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 599 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 600 600 if (IS_ERR(em)) { 601 601 test_err("got an error when we shouldn't have"); 602 602 goto out; ··· 630 630 free_extent_map(em); 631 631 632 632 /* Split compressed extent */ 633 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 633 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 634 634 if (IS_ERR(em)) { 635 635 test_err("got an error when we shouldn't have"); 636 636 goto out; ··· 665 665 offset = em->start + em->len; 666 666 free_extent_map(em); 667 667 668 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 668 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 669 669 if (IS_ERR(em)) { 670 670 test_err("got an error when we shouldn't have"); 671 671 goto out; ··· 692 692 offset = em->start + em->len; 693 693 free_extent_map(em); 694 694 695 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 695 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 696 696 if (IS_ERR(em)) { 697 697 test_err("got an error when we shouldn't have"); 698 698 goto out; ··· 727 727 free_extent_map(em); 728 728 729 729 /* A hole between regular extents but no hole extent */ 730 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset + 6, 731 - sectorsize, 0); 730 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset + 6, sectorsize); 732 731 if (IS_ERR(em)) { 733 732 test_err("got an error when we shouldn't have"); 734 733 goto out; ··· 754 755 offset = em->start + em->len; 755 756 free_extent_map(em); 756 757 757 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, SZ_4M, 0); 758 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, SZ_4M); 758 759 if (IS_ERR(em)) { 759 760 test_err("got an error when we shouldn't have"); 760 761 goto out; ··· 787 788 offset = em->start + em->len; 788 789 free_extent_map(em); 789 790 790 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize, 0); 791 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, offset, sectorsize); 791 792 if (IS_ERR(em)) { 792 793 test_err("got an error when we shouldn't have"); 793 794 goto out; ··· 871 872 insert_inode_item_key(root); 872 873 insert_extent(root, sectorsize, sectorsize, sectorsize, 0, sectorsize, 873 874 sectorsize, BTRFS_FILE_EXTENT_REG, 0, 1); 874 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 0, 2 * sectorsize, 0); 875 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, 0, 2 * sectorsize); 875 876 if (IS_ERR(em)) { 876 877 test_err("got an error when we shouldn't have"); 877 878 goto out; ··· 893 894 } 894 895 free_extent_map(em); 895 896 896 - em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, sectorsize, 897 - 2 * sectorsize, 0); 897 + em = btrfs_get_extent(BTRFS_I(inode), NULL, 0, sectorsize, 2 * sectorsize); 898 898 if (IS_ERR(em)) { 899 899 test_err("got an error when we shouldn't have"); 900 900 goto out;