aboutsummaryrefslogtreecommitdiffstats
path: root/fs/btrfs
diff options
context:
space:
mode:
authorChris Mason <chris.mason@oracle.com>2011-07-19 12:04:14 -0400
committerChris Mason <chris.mason@oracle.com>2011-07-27 12:46:45 -0400
commita65917156e345946dbde3d7effd28124c6d6a8c2 (patch)
treedc5478189be0f6a321bfc23ee0545f71de67763b /fs/btrfs
parent199c36eaa95077a47ae1bc55532fc0fbeb80cc95 (diff)
Btrfs: stop using highmem for extent_buffers
The extent_buffers have a very complex interface where we use HIGHMEM for metadata and try to cache a kmap mapping to access the memory. The next commit adds reader/writer locks, and concurrent use of this kmap cache would make it even more complex. This commit drops the ability to use HIGHMEM with extent buffers, and rips out all of the related code. Signed-off-by: Chris Mason <chris.mason@oracle.com>
Diffstat (limited to 'fs/btrfs')
-rw-r--r--fs/btrfs/ctree.c189
-rw-r--r--fs/btrfs/disk-io.c7
-rw-r--r--fs/btrfs/extent_io.c67
-rw-r--r--fs/btrfs/extent_io.h11
-rw-r--r--fs/btrfs/file-item.c32
-rw-r--r--fs/btrfs/inode.c24
-rw-r--r--fs/btrfs/struct-funcs.c100
7 files changed, 52 insertions, 378 deletions
diff --git a/fs/btrfs/ctree.c b/fs/btrfs/ctree.c
index 2e667868e0d2..d2431284b913 100644
--- a/fs/btrfs/ctree.c
+++ b/fs/btrfs/ctree.c
@@ -626,14 +626,6 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
626 for (i = start_slot; i < end_slot; i++) { 626 for (i = start_slot; i < end_slot; i++) {
627 int close = 1; 627 int close = 1;
628 628
629 if (!parent->map_token) {
630 map_extent_buffer(parent,
631 btrfs_node_key_ptr_offset(i),
632 sizeof(struct btrfs_key_ptr),
633 &parent->map_token, &parent->kaddr,
634 &parent->map_start, &parent->map_len,
635 KM_USER1);
636 }
637 btrfs_node_key(parent, &disk_key, i); 629 btrfs_node_key(parent, &disk_key, i);
638 if (!progress_passed && comp_keys(&disk_key, progress) < 0) 630 if (!progress_passed && comp_keys(&disk_key, progress) < 0)
639 continue; 631 continue;
@@ -656,11 +648,6 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
656 last_block = blocknr; 648 last_block = blocknr;
657 continue; 649 continue;
658 } 650 }
659 if (parent->map_token) {
660 unmap_extent_buffer(parent, parent->map_token,
661 KM_USER1);
662 parent->map_token = NULL;
663 }
664 651
665 cur = btrfs_find_tree_block(root, blocknr, blocksize); 652 cur = btrfs_find_tree_block(root, blocknr, blocksize);
666 if (cur) 653 if (cur)
@@ -701,11 +688,6 @@ int btrfs_realloc_node(struct btrfs_trans_handle *trans,
701 btrfs_tree_unlock(cur); 688 btrfs_tree_unlock(cur);
702 free_extent_buffer(cur); 689 free_extent_buffer(cur);
703 } 690 }
704 if (parent->map_token) {
705 unmap_extent_buffer(parent, parent->map_token,
706 KM_USER1);
707 parent->map_token = NULL;
708 }
709 return err; 691 return err;
710} 692}
711 693
@@ -746,7 +728,6 @@ static noinline int generic_bin_search(struct extent_buffer *eb,
746 struct btrfs_disk_key *tmp = NULL; 728 struct btrfs_disk_key *tmp = NULL;
747 struct btrfs_disk_key unaligned; 729 struct btrfs_disk_key unaligned;
748 unsigned long offset; 730 unsigned long offset;
749 char *map_token = NULL;
750 char *kaddr = NULL; 731 char *kaddr = NULL;
751 unsigned long map_start = 0; 732 unsigned long map_start = 0;
752 unsigned long map_len = 0; 733 unsigned long map_len = 0;
@@ -756,18 +737,13 @@ static noinline int generic_bin_search(struct extent_buffer *eb,
756 mid = (low + high) / 2; 737 mid = (low + high) / 2;
757 offset = p + mid * item_size; 738 offset = p + mid * item_size;
758 739
759 if (!map_token || offset < map_start || 740 if (!kaddr || offset < map_start ||
760 (offset + sizeof(struct btrfs_disk_key)) > 741 (offset + sizeof(struct btrfs_disk_key)) >
761 map_start + map_len) { 742 map_start + map_len) {
762 if (map_token) {
763 unmap_extent_buffer(eb, map_token, KM_USER0);
764 map_token = NULL;
765 }
766 743
767 err = map_private_extent_buffer(eb, offset, 744 err = map_private_extent_buffer(eb, offset,
768 sizeof(struct btrfs_disk_key), 745 sizeof(struct btrfs_disk_key),
769 &map_token, &kaddr, 746 &kaddr, &map_start, &map_len);
770 &map_start, &map_len, KM_USER0);
771 747
772 if (!err) { 748 if (!err) {
773 tmp = (struct btrfs_disk_key *)(kaddr + offset - 749 tmp = (struct btrfs_disk_key *)(kaddr + offset -
@@ -790,14 +766,10 @@ static noinline int generic_bin_search(struct extent_buffer *eb,
790 high = mid; 766 high = mid;
791 else { 767 else {
792 *slot = mid; 768 *slot = mid;
793 if (map_token)
794 unmap_extent_buffer(eb, map_token, KM_USER0);
795 return 0; 769 return 0;
796 } 770 }
797 } 771 }
798 *slot = low; 772 *slot = low;
799 if (map_token)
800 unmap_extent_buffer(eb, map_token, KM_USER0);
801 return 1; 773 return 1;
802} 774}
803 775
@@ -1228,7 +1200,6 @@ static void reada_for_search(struct btrfs_root *root,
1228 u32 nr; 1200 u32 nr;
1229 u32 blocksize; 1201 u32 blocksize;
1230 u32 nscan = 0; 1202 u32 nscan = 0;
1231 bool map = true;
1232 1203
1233 if (level != 1) 1204 if (level != 1)
1234 return; 1205 return;
@@ -1250,19 +1221,8 @@ static void reada_for_search(struct btrfs_root *root,
1250 1221
1251 nritems = btrfs_header_nritems(node); 1222 nritems = btrfs_header_nritems(node);
1252 nr = slot; 1223 nr = slot;
1253 if (node->map_token || path->skip_locking)
1254 map = false;
1255 1224
1256 while (1) { 1225 while (1) {
1257 if (map && !node->map_token) {
1258 unsigned long offset = btrfs_node_key_ptr_offset(nr);
1259 map_private_extent_buffer(node, offset,
1260 sizeof(struct btrfs_key_ptr),
1261 &node->map_token,
1262 &node->kaddr,
1263 &node->map_start,
1264 &node->map_len, KM_USER1);
1265 }
1266 if (direction < 0) { 1226 if (direction < 0) {
1267 if (nr == 0) 1227 if (nr == 0)
1268 break; 1228 break;
@@ -1281,11 +1241,6 @@ static void reada_for_search(struct btrfs_root *root,
1281 if ((search <= target && target - search <= 65536) || 1241 if ((search <= target && target - search <= 65536) ||
1282 (search > target && search - target <= 65536)) { 1242 (search > target && search - target <= 65536)) {
1283 gen = btrfs_node_ptr_generation(node, nr); 1243 gen = btrfs_node_ptr_generation(node, nr);
1284 if (map && node->map_token) {
1285 unmap_extent_buffer(node, node->map_token,
1286 KM_USER1);
1287 node->map_token = NULL;
1288 }
1289 readahead_tree_block(root, search, blocksize, gen); 1244 readahead_tree_block(root, search, blocksize, gen);
1290 nread += blocksize; 1245 nread += blocksize;
1291 } 1246 }
@@ -1293,10 +1248,6 @@ static void reada_for_search(struct btrfs_root *root,
1293 if ((nread > 65536 || nscan > 32)) 1248 if ((nread > 65536 || nscan > 32))
1294 break; 1249 break;
1295 } 1250 }
1296 if (map && node->map_token) {
1297 unmap_extent_buffer(node, node->map_token, KM_USER1);
1298 node->map_token = NULL;
1299 }
1300} 1251}
1301 1252
1302/* 1253/*
@@ -2253,14 +2204,6 @@ static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
2253 if (path->slots[0] == i) 2204 if (path->slots[0] == i)
2254 push_space += data_size; 2205 push_space += data_size;
2255 2206
2256 if (!left->map_token) {
2257 map_extent_buffer(left, (unsigned long)item,
2258 sizeof(struct btrfs_item),
2259 &left->map_token, &left->kaddr,
2260 &left->map_start, &left->map_len,
2261 KM_USER1);
2262 }
2263
2264 this_item_size = btrfs_item_size(left, item); 2207 this_item_size = btrfs_item_size(left, item);
2265 if (this_item_size + sizeof(*item) + push_space > free_space) 2208 if (this_item_size + sizeof(*item) + push_space > free_space)
2266 break; 2209 break;
@@ -2271,10 +2214,6 @@ static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
2271 break; 2214 break;
2272 i--; 2215 i--;
2273 } 2216 }
2274 if (left->map_token) {
2275 unmap_extent_buffer(left, left->map_token, KM_USER1);
2276 left->map_token = NULL;
2277 }
2278 2217
2279 if (push_items == 0) 2218 if (push_items == 0)
2280 goto out_unlock; 2219 goto out_unlock;
@@ -2316,21 +2255,10 @@ static noinline int __push_leaf_right(struct btrfs_trans_handle *trans,
2316 push_space = BTRFS_LEAF_DATA_SIZE(root); 2255 push_space = BTRFS_LEAF_DATA_SIZE(root);
2317 for (i = 0; i < right_nritems; i++) { 2256 for (i = 0; i < right_nritems; i++) {
2318 item = btrfs_item_nr(right, i); 2257 item = btrfs_item_nr(right, i);
2319 if (!right->map_token) {
2320 map_extent_buffer(right, (unsigned long)item,
2321 sizeof(struct btrfs_item),
2322 &right->map_token, &right->kaddr,
2323 &right->map_start, &right->map_len,
2324 KM_USER1);
2325 }
2326 push_space -= btrfs_item_size(right, item); 2258 push_space -= btrfs_item_size(right, item);
2327 btrfs_set_item_offset(right, item, push_space); 2259 btrfs_set_item_offset(right, item, push_space);
2328 } 2260 }
2329 2261
2330 if (right->map_token) {
2331 unmap_extent_buffer(right, right->map_token, KM_USER1);
2332 right->map_token = NULL;
2333 }
2334 left_nritems -= push_items; 2262 left_nritems -= push_items;
2335 btrfs_set_header_nritems(left, left_nritems); 2263 btrfs_set_header_nritems(left, left_nritems);
2336 2264
@@ -2467,13 +2395,6 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
2467 2395
2468 for (i = 0; i < nr; i++) { 2396 for (i = 0; i < nr; i++) {
2469 item = btrfs_item_nr(right, i); 2397 item = btrfs_item_nr(right, i);
2470 if (!right->map_token) {
2471 map_extent_buffer(right, (unsigned long)item,
2472 sizeof(struct btrfs_item),
2473 &right->map_token, &right->kaddr,
2474 &right->map_start, &right->map_len,
2475 KM_USER1);
2476 }
2477 2398
2478 if (!empty && push_items > 0) { 2399 if (!empty && push_items > 0) {
2479 if (path->slots[0] < i) 2400 if (path->slots[0] < i)
@@ -2496,11 +2417,6 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
2496 push_space += this_item_size + sizeof(*item); 2417 push_space += this_item_size + sizeof(*item);
2497 } 2418 }
2498 2419
2499 if (right->map_token) {
2500 unmap_extent_buffer(right, right->map_token, KM_USER1);
2501 right->map_token = NULL;
2502 }
2503
2504 if (push_items == 0) { 2420 if (push_items == 0) {
2505 ret = 1; 2421 ret = 1;
2506 goto out; 2422 goto out;
@@ -2530,23 +2446,12 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
2530 u32 ioff; 2446 u32 ioff;
2531 2447
2532 item = btrfs_item_nr(left, i); 2448 item = btrfs_item_nr(left, i);
2533 if (!left->map_token) {
2534 map_extent_buffer(left, (unsigned long)item,
2535 sizeof(struct btrfs_item),
2536 &left->map_token, &left->kaddr,
2537 &left->map_start, &left->map_len,
2538 KM_USER1);
2539 }
2540 2449
2541 ioff = btrfs_item_offset(left, item); 2450 ioff = btrfs_item_offset(left, item);
2542 btrfs_set_item_offset(left, item, 2451 btrfs_set_item_offset(left, item,
2543 ioff - (BTRFS_LEAF_DATA_SIZE(root) - old_left_item_size)); 2452 ioff - (BTRFS_LEAF_DATA_SIZE(root) - old_left_item_size));
2544 } 2453 }
2545 btrfs_set_header_nritems(left, old_left_nritems + push_items); 2454 btrfs_set_header_nritems(left, old_left_nritems + push_items);
2546 if (left->map_token) {
2547 unmap_extent_buffer(left, left->map_token, KM_USER1);
2548 left->map_token = NULL;
2549 }
2550 2455
2551 /* fixup right node */ 2456 /* fixup right node */
2552 if (push_items > right_nritems) { 2457 if (push_items > right_nritems) {
@@ -2574,21 +2479,9 @@ static noinline int __push_leaf_left(struct btrfs_trans_handle *trans,
2574 for (i = 0; i < right_nritems; i++) { 2479 for (i = 0; i < right_nritems; i++) {
2575 item = btrfs_item_nr(right, i); 2480 item = btrfs_item_nr(right, i);
2576 2481
2577 if (!right->map_token) {
2578 map_extent_buffer(right, (unsigned long)item,
2579 sizeof(struct btrfs_item),
2580 &right->map_token, &right->kaddr,
2581 &right->map_start, &right->map_len,
2582 KM_USER1);
2583 }
2584
2585 push_space = push_space - btrfs_item_size(right, item); 2482 push_space = push_space - btrfs_item_size(right, item);
2586 btrfs_set_item_offset(right, item, push_space); 2483 btrfs_set_item_offset(right, item, push_space);
2587 } 2484 }
2588 if (right->map_token) {
2589 unmap_extent_buffer(right, right->map_token, KM_USER1);
2590 right->map_token = NULL;
2591 }
2592 2485
2593 btrfs_mark_buffer_dirty(left); 2486 btrfs_mark_buffer_dirty(left);
2594 if (right_nritems) 2487 if (right_nritems)
@@ -2729,23 +2622,10 @@ static noinline int copy_for_split(struct btrfs_trans_handle *trans,
2729 struct btrfs_item *item = btrfs_item_nr(right, i); 2622 struct btrfs_item *item = btrfs_item_nr(right, i);
2730 u32 ioff; 2623 u32 ioff;
2731 2624
2732 if (!right->map_token) {
2733 map_extent_buffer(right, (unsigned long)item,
2734 sizeof(struct btrfs_item),
2735 &right->map_token, &right->kaddr,
2736 &right->map_start, &right->map_len,
2737 KM_USER1);
2738 }
2739
2740 ioff = btrfs_item_offset(right, item); 2625 ioff = btrfs_item_offset(right, item);
2741 btrfs_set_item_offset(right, item, ioff + rt_data_off); 2626 btrfs_set_item_offset(right, item, ioff + rt_data_off);
2742 } 2627 }
2743 2628
2744 if (right->map_token) {
2745 unmap_extent_buffer(right, right->map_token, KM_USER1);
2746 right->map_token = NULL;
2747 }
2748
2749 btrfs_set_header_nritems(l, mid); 2629 btrfs_set_header_nritems(l, mid);
2750 ret = 0; 2630 ret = 0;
2751 btrfs_item_key(right, &disk_key, 0); 2631 btrfs_item_key(right, &disk_key, 0);
@@ -3264,23 +3144,10 @@ int btrfs_truncate_item(struct btrfs_trans_handle *trans,
3264 u32 ioff; 3144 u32 ioff;
3265 item = btrfs_item_nr(leaf, i); 3145 item = btrfs_item_nr(leaf, i);
3266 3146
3267 if (!leaf->map_token) {
3268 map_extent_buffer(leaf, (unsigned long)item,
3269 sizeof(struct btrfs_item),
3270 &leaf->map_token, &leaf->kaddr,
3271 &leaf->map_start, &leaf->map_len,
3272 KM_USER1);
3273 }
3274
3275 ioff = btrfs_item_offset(leaf, item); 3147 ioff = btrfs_item_offset(leaf, item);
3276 btrfs_set_item_offset(leaf, item, ioff + size_diff); 3148 btrfs_set_item_offset(leaf, item, ioff + size_diff);
3277 } 3149 }
3278 3150
3279 if (leaf->map_token) {
3280 unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
3281 leaf->map_token = NULL;
3282 }
3283
3284 /* shift the data */ 3151 /* shift the data */
3285 if (from_end) { 3152 if (from_end) {
3286 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) + 3153 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
@@ -3377,22 +3244,10 @@ int btrfs_extend_item(struct btrfs_trans_handle *trans,
3377 u32 ioff; 3244 u32 ioff;
3378 item = btrfs_item_nr(leaf, i); 3245 item = btrfs_item_nr(leaf, i);
3379 3246
3380 if (!leaf->map_token) {
3381 map_extent_buffer(leaf, (unsigned long)item,
3382 sizeof(struct btrfs_item),
3383 &leaf->map_token, &leaf->kaddr,
3384 &leaf->map_start, &leaf->map_len,
3385 KM_USER1);
3386 }
3387 ioff = btrfs_item_offset(leaf, item); 3247 ioff = btrfs_item_offset(leaf, item);
3388 btrfs_set_item_offset(leaf, item, ioff - data_size); 3248 btrfs_set_item_offset(leaf, item, ioff - data_size);
3389 } 3249 }
3390 3250
3391 if (leaf->map_token) {
3392 unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
3393 leaf->map_token = NULL;
3394 }
3395
3396 /* shift the data */ 3251 /* shift the data */
3397 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) + 3252 memmove_extent_buffer(leaf, btrfs_leaf_data(leaf) +
3398 data_end - data_size, btrfs_leaf_data(leaf) + 3253 data_end - data_size, btrfs_leaf_data(leaf) +
@@ -3494,27 +3349,13 @@ int btrfs_insert_some_items(struct btrfs_trans_handle *trans,
3494 * item0..itemN ... dataN.offset..dataN.size .. data0.size 3349 * item0..itemN ... dataN.offset..dataN.size .. data0.size
3495 */ 3350 */
3496 /* first correct the data pointers */ 3351 /* first correct the data pointers */
3497 WARN_ON(leaf->map_token);
3498 for (i = slot; i < nritems; i++) { 3352 for (i = slot; i < nritems; i++) {
3499 u32 ioff; 3353 u32 ioff;
3500 3354
3501 item = btrfs_item_nr(leaf, i); 3355 item = btrfs_item_nr(leaf, i);
3502 if (!leaf->map_token) {
3503 map_extent_buffer(leaf, (unsigned long)item,
3504 sizeof(struct btrfs_item),
3505 &leaf->map_token, &leaf->kaddr,
3506 &leaf->map_start, &leaf->map_len,
3507 KM_USER1);
3508 }
3509
3510 ioff = btrfs_item_offset(leaf, item); 3356 ioff = btrfs_item_offset(leaf, item);
3511 btrfs_set_item_offset(leaf, item, ioff - total_data); 3357 btrfs_set_item_offset(leaf, item, ioff - total_data);
3512 } 3358 }
3513 if (leaf->map_token) {
3514 unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
3515 leaf->map_token = NULL;
3516 }
3517
3518 /* shift the items */ 3359 /* shift the items */
3519 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr), 3360 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
3520 btrfs_item_nr_offset(slot), 3361 btrfs_item_nr_offset(slot),
@@ -3608,27 +3449,13 @@ int setup_items_for_insert(struct btrfs_trans_handle *trans,
3608 * item0..itemN ... dataN.offset..dataN.size .. data0.size 3449 * item0..itemN ... dataN.offset..dataN.size .. data0.size
3609 */ 3450 */
3610 /* first correct the data pointers */ 3451 /* first correct the data pointers */
3611 WARN_ON(leaf->map_token);
3612 for (i = slot; i < nritems; i++) { 3452 for (i = slot; i < nritems; i++) {
3613 u32 ioff; 3453 u32 ioff;
3614 3454
3615 item = btrfs_item_nr(leaf, i); 3455 item = btrfs_item_nr(leaf, i);
3616 if (!leaf->map_token) {
3617 map_extent_buffer(leaf, (unsigned long)item,
3618 sizeof(struct btrfs_item),
3619 &leaf->map_token, &leaf->kaddr,
3620 &leaf->map_start, &leaf->map_len,
3621 KM_USER1);
3622 }
3623
3624 ioff = btrfs_item_offset(leaf, item); 3456 ioff = btrfs_item_offset(leaf, item);
3625 btrfs_set_item_offset(leaf, item, ioff - total_data); 3457 btrfs_set_item_offset(leaf, item, ioff - total_data);
3626 } 3458 }
3627 if (leaf->map_token) {
3628 unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
3629 leaf->map_token = NULL;
3630 }
3631
3632 /* shift the items */ 3459 /* shift the items */
3633 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr), 3460 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot + nr),
3634 btrfs_item_nr_offset(slot), 3461 btrfs_item_nr_offset(slot),
@@ -3840,22 +3667,10 @@ int btrfs_del_items(struct btrfs_trans_handle *trans, struct btrfs_root *root,
3840 u32 ioff; 3667 u32 ioff;
3841 3668
3842 item = btrfs_item_nr(leaf, i); 3669 item = btrfs_item_nr(leaf, i);
3843 if (!leaf->map_token) {
3844 map_extent_buffer(leaf, (unsigned long)item,
3845 sizeof(struct btrfs_item),
3846 &leaf->map_token, &leaf->kaddr,
3847 &leaf->map_start, &leaf->map_len,
3848 KM_USER1);
3849 }
3850 ioff = btrfs_item_offset(leaf, item); 3670 ioff = btrfs_item_offset(leaf, item);
3851 btrfs_set_item_offset(leaf, item, ioff + dsize); 3671 btrfs_set_item_offset(leaf, item, ioff + dsize);
3852 } 3672 }
3853 3673
3854 if (leaf->map_token) {
3855 unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
3856 leaf->map_token = NULL;
3857 }
3858
3859 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot), 3674 memmove_extent_buffer(leaf, btrfs_item_nr_offset(slot),
3860 btrfs_item_nr_offset(slot + nr), 3675 btrfs_item_nr_offset(slot + nr),
3861 sizeof(struct btrfs_item) * 3676 sizeof(struct btrfs_item) *
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 234a08404fc2..97f22ff8326f 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -217,7 +217,6 @@ static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
217 unsigned long len; 217 unsigned long len;
218 unsigned long cur_len; 218 unsigned long cur_len;
219 unsigned long offset = BTRFS_CSUM_SIZE; 219 unsigned long offset = BTRFS_CSUM_SIZE;
220 char *map_token = NULL;
221 char *kaddr; 220 char *kaddr;
222 unsigned long map_start; 221 unsigned long map_start;
223 unsigned long map_len; 222 unsigned long map_len;
@@ -228,8 +227,7 @@ static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
228 len = buf->len - offset; 227 len = buf->len - offset;
229 while (len > 0) { 228 while (len > 0) {
230 err = map_private_extent_buffer(buf, offset, 32, 229 err = map_private_extent_buffer(buf, offset, 32,
231 &map_token, &kaddr, 230 &kaddr, &map_start, &map_len);
232 &map_start, &map_len, KM_USER0);
233 if (err) 231 if (err)
234 return 1; 232 return 1;
235 cur_len = min(len, map_len - (offset - map_start)); 233 cur_len = min(len, map_len - (offset - map_start));
@@ -237,7 +235,6 @@ static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
237 crc, cur_len); 235 crc, cur_len);
238 len -= cur_len; 236 len -= cur_len;
239 offset += cur_len; 237 offset += cur_len;
240 unmap_extent_buffer(buf, map_token, KM_USER0);
241 } 238 }
242 if (csum_size > sizeof(inline_result)) { 239 if (csum_size > sizeof(inline_result)) {
243 result = kzalloc(csum_size * sizeof(char), GFP_NOFS); 240 result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
@@ -1603,7 +1600,7 @@ struct btrfs_root *open_ctree(struct super_block *sb,
1603 goto fail_bdi; 1600 goto fail_bdi;
1604 } 1601 }
1605 1602
1606 fs_info->btree_inode->i_mapping->flags &= ~__GFP_FS; 1603 mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
1607 1604
1608 INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC); 1605 INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
1609 INIT_LIST_HEAD(&fs_info->trans_list); 1606 INIT_LIST_HEAD(&fs_info->trans_list);
diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 89bbde46bd83..76ecbb8ed0e0 100644
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -3114,7 +3114,7 @@ struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
3114 i = 0; 3114 i = 0;
3115 } 3115 }
3116 for (; i < num_pages; i++, index++) { 3116 for (; i < num_pages; i++, index++) {
3117 p = find_or_create_page(mapping, index, GFP_NOFS | __GFP_HIGHMEM); 3117 p = find_or_create_page(mapping, index, GFP_NOFS);
3118 if (!p) { 3118 if (!p) {
3119 WARN_ON(1); 3119 WARN_ON(1);
3120 goto free_eb; 3120 goto free_eb;
@@ -3487,9 +3487,8 @@ void read_extent_buffer(struct extent_buffer *eb, void *dstv,
3487 page = extent_buffer_page(eb, i); 3487 page = extent_buffer_page(eb, i);
3488 3488
3489 cur = min(len, (PAGE_CACHE_SIZE - offset)); 3489 cur = min(len, (PAGE_CACHE_SIZE - offset));
3490 kaddr = kmap_atomic(page, KM_USER1); 3490 kaddr = page_address(page);
3491 memcpy(dst, kaddr + offset, cur); 3491 memcpy(dst, kaddr + offset, cur);
3492 kunmap_atomic(kaddr, KM_USER1);
3493 3492
3494 dst += cur; 3493 dst += cur;
3495 len -= cur; 3494 len -= cur;
@@ -3499,9 +3498,9 @@ void read_extent_buffer(struct extent_buffer *eb, void *dstv,
3499} 3498}
3500 3499
3501int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start, 3500int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
3502 unsigned long min_len, char **token, char **map, 3501 unsigned long min_len, char **map,
3503 unsigned long *map_start, 3502 unsigned long *map_start,
3504 unsigned long *map_len, int km) 3503 unsigned long *map_len)
3505{ 3504{
3506 size_t offset = start & (PAGE_CACHE_SIZE - 1); 3505 size_t offset = start & (PAGE_CACHE_SIZE - 1);
3507 char *kaddr; 3506 char *kaddr;
@@ -3531,42 +3530,12 @@ int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
3531 } 3530 }
3532 3531
3533 p = extent_buffer_page(eb, i); 3532 p = extent_buffer_page(eb, i);
3534 kaddr = kmap_atomic(p, km); 3533 kaddr = page_address(p);
3535 *token = kaddr;
3536 *map = kaddr + offset; 3534 *map = kaddr + offset;
3537 *map_len = PAGE_CACHE_SIZE - offset; 3535 *map_len = PAGE_CACHE_SIZE - offset;
3538 return 0; 3536 return 0;
3539} 3537}
3540 3538
3541int map_extent_buffer(struct extent_buffer *eb, unsigned long start,
3542 unsigned long min_len,
3543 char **token, char **map,
3544 unsigned long *map_start,
3545 unsigned long *map_len, int km)
3546{
3547 int err;
3548 int save = 0;
3549 if (eb->map_token) {
3550 unmap_extent_buffer(eb, eb->map_token, km);
3551 eb->map_token = NULL;
3552 save = 1;
3553 }
3554 err = map_private_extent_buffer(eb, start, min_len, token, map,
3555 map_start, map_len, km);
3556 if (!err && save) {
3557 eb->map_token = *token;
3558 eb->kaddr = *map;
3559 eb->map_start = *map_start;
3560 eb->map_len = *map_len;
3561 }
3562 return err;
3563}
3564
3565void unmap_extent_buffer(struct extent_buffer *eb, char *token, int km)
3566{
3567 kunmap_atomic(token, km);
3568}
3569
3570int memcmp_extent_buffer(struct extent_buffer *eb, const void *ptrv, 3539int memcmp_extent_buffer(struct extent_buffer *eb, const void *ptrv,
3571 unsigned long start, 3540 unsigned long start,
3572 unsigned long len) 3541 unsigned long len)
@@ -3590,9 +3559,8 @@ int memcmp_extent_buffer(struct extent_buffer *eb, const void *ptrv,
3590 3559
3591 cur = min(len, (PAGE_CACHE_SIZE - offset)); 3560 cur = min(len, (PAGE_CACHE_SIZE - offset));
3592 3561
3593 kaddr = kmap_atomic(page, KM_USER0); 3562 kaddr = page_address(page);
3594 ret = memcmp(ptr, kaddr + offset, cur); 3563 ret = memcmp(ptr, kaddr + offset, cur);
3595 kunmap_atomic(kaddr, KM_USER0);
3596 if (ret) 3564 if (ret)
3597 break; 3565 break;
3598 3566
@@ -3625,9 +3593,8 @@ void write_extent_buffer(struct extent_buffer *eb, const void *srcv,
3625 WARN_ON(!PageUptodate(page)); 3593 WARN_ON(!PageUptodate(page));
3626 3594
3627 cur = min(len, PAGE_CACHE_SIZE - offset); 3595 cur = min(len, PAGE_CACHE_SIZE - offset);
3628 kaddr = kmap_atomic(page, KM_USER1); 3596 kaddr = page_address(page);
3629 memcpy(kaddr + offset, src, cur); 3597 memcpy(kaddr + offset, src, cur);
3630 kunmap_atomic(kaddr, KM_USER1);
3631 3598
3632 src += cur; 3599 src += cur;
3633 len -= cur; 3600 len -= cur;
@@ -3656,9 +3623,8 @@ void memset_extent_buffer(struct extent_buffer *eb, char c,
3656 WARN_ON(!PageUptodate(page)); 3623 WARN_ON(!PageUptodate(page));
3657 3624
3658 cur = min(len, PAGE_CACHE_SIZE - offset); 3625 cur = min(len, PAGE_CACHE_SIZE - offset);
3659 kaddr = kmap_atomic(page, KM_USER0); 3626 kaddr = page_address(page);
3660 memset(kaddr + offset, c, cur); 3627 memset(kaddr + offset, c, cur);
3661 kunmap_atomic(kaddr, KM_USER0);
3662 3628
3663 len -= cur; 3629 len -= cur;
3664 offset = 0; 3630 offset = 0;
@@ -3689,9 +3655,8 @@ void copy_extent_buffer(struct extent_buffer *dst, struct extent_buffer *src,
3689 3655
3690 cur = min(len, (unsigned long)(PAGE_CACHE_SIZE - offset)); 3656 cur = min(len, (unsigned long)(PAGE_CACHE_SIZE - offset));
3691 3657
3692 kaddr = kmap_atomic(page, KM_USER0); 3658 kaddr = page_address(page);
3693 read_extent_buffer(src, kaddr + offset, src_offset, cur); 3659 read_extent_buffer(src, kaddr + offset, src_offset, cur);
3694 kunmap_atomic(kaddr, KM_USER0);
3695 3660
3696 src_offset += cur; 3661 src_offset += cur;
3697 len -= cur; 3662 len -= cur;
@@ -3704,20 +3669,17 @@ static void move_pages(struct page *dst_page, struct page *src_page,
3704 unsigned long dst_off, unsigned long src_off, 3669 unsigned long dst_off, unsigned long src_off,
3705 unsigned long len) 3670 unsigned long len)
3706{ 3671{
3707 char *dst_kaddr = kmap_atomic(dst_page, KM_USER0); 3672 char *dst_kaddr = page_address(dst_page);
3708 if (dst_page == src_page) { 3673 if (dst_page == src_page) {
3709 memmove(dst_kaddr + dst_off, dst_kaddr + src_off, len); 3674 memmove(dst_kaddr + dst_off, dst_kaddr + src_off, len);
3710 } else { 3675 } else {
3711 char *src_kaddr = kmap_atomic(src_page, KM_USER1); 3676 char *src_kaddr = page_address(src_page);
3712 char *p = dst_kaddr + dst_off + len; 3677 char *p = dst_kaddr + dst_off + len;
3713 char *s = src_kaddr + src_off + len; 3678 char *s = src_kaddr + src_off + len;
3714 3679
3715 while (len--) 3680 while (len--)
3716 *--p = *--s; 3681 *--p = *--s;
3717
3718 kunmap_atomic(src_kaddr, KM_USER1);
3719 } 3682 }
3720 kunmap_atomic(dst_kaddr, KM_USER0);
3721} 3683}
3722 3684
3723static inline bool areas_overlap(unsigned long src, unsigned long dst, unsigned long len) 3685static inline bool areas_overlap(unsigned long src, unsigned long dst, unsigned long len)
@@ -3730,20 +3692,17 @@ static void copy_pages(struct page *dst_page, struct page *src_page,
3730 unsigned long dst_off, unsigned long src_off, 3692 unsigned long dst_off, unsigned long src_off,
3731 unsigned long len) 3693 unsigned long len)
3732{ 3694{
3733 char *dst_kaddr = kmap_atomic(dst_page, KM_USER0); 3695 char *dst_kaddr = page_address(dst_page);
3734 char *src_kaddr; 3696 char *src_kaddr;
3735 3697
3736 if (dst_page != src_page) { 3698 if (dst_page != src_page) {
3737 src_kaddr = kmap_atomic(src_page, KM_USER1); 3699 src_kaddr = page_address(src_page);
3738 } else { 3700 } else {
3739 src_kaddr = dst_kaddr; 3701 src_kaddr = dst_kaddr;
3740 BUG_ON(areas_overlap(src_off, dst_off, len)); 3702 BUG_ON(areas_overlap(src_off, dst_off, len));
3741 } 3703 }
3742 3704
3743 memcpy(dst_kaddr + dst_off, src_kaddr + src_off, len); 3705 memcpy(dst_kaddr + dst_off, src_kaddr + src_off, len);
3744 kunmap_atomic(dst_kaddr, KM_USER0);
3745 if (dst_page != src_page)
3746 kunmap_atomic(src_kaddr, KM_USER1);
3747} 3706}
3748 3707
3749void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset, 3708void memcpy_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
index a11a92ee2d30..b5f120cca916 100644
--- a/fs/btrfs/extent_io.h
+++ b/fs/btrfs/extent_io.h
@@ -120,8 +120,6 @@ struct extent_state {
120struct extent_buffer { 120struct extent_buffer {
121 u64 start; 121 u64 start;
122 unsigned long len; 122 unsigned long len;
123 char *map_token;
124 char *kaddr;
125 unsigned long map_start; 123 unsigned long map_start;
126 unsigned long map_len; 124 unsigned long map_len;
127 struct page *first_page; 125 struct page *first_page;
@@ -279,15 +277,10 @@ int clear_extent_buffer_uptodate(struct extent_io_tree *tree,
279int extent_buffer_uptodate(struct extent_io_tree *tree, 277int extent_buffer_uptodate(struct extent_io_tree *tree,
280 struct extent_buffer *eb, 278 struct extent_buffer *eb,
281 struct extent_state *cached_state); 279 struct extent_state *cached_state);
282int map_extent_buffer(struct extent_buffer *eb, unsigned long offset,
283 unsigned long min_len, char **token, char **map,
284 unsigned long *map_start,
285 unsigned long *map_len, int km);
286int map_private_extent_buffer(struct extent_buffer *eb, unsigned long offset, 280int map_private_extent_buffer(struct extent_buffer *eb, unsigned long offset,
287 unsigned long min_len, char **token, char **map, 281 unsigned long min_len, char **map,
288 unsigned long *map_start, 282 unsigned long *map_start,
289 unsigned long *map_len, int km); 283 unsigned long *map_len);
290void unmap_extent_buffer(struct extent_buffer *eb, char *token, int km);
291int extent_range_uptodate(struct extent_io_tree *tree, 284int extent_range_uptodate(struct extent_io_tree *tree,
292 u64 start, u64 end); 285 u64 start, u64 end);
293int extent_clear_unlock_delalloc(struct inode *inode, 286int extent_clear_unlock_delalloc(struct inode *inode,
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index 90d4ee52cd45..bb22a4435b2d 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -664,10 +664,6 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
664 struct btrfs_sector_sum *sector_sum; 664 struct btrfs_sector_sum *sector_sum;
665 u32 nritems; 665 u32 nritems;
666 u32 ins_size; 666 u32 ins_size;
667 char *eb_map;
668 char *eb_token;
669 unsigned long map_len;
670 unsigned long map_start;
671 u16 csum_size = 667 u16 csum_size =
672 btrfs_super_csum_size(&root->fs_info->super_copy); 668 btrfs_super_csum_size(&root->fs_info->super_copy);
673 669
@@ -814,30 +810,9 @@ found:
814 item_end = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); 810 item_end = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
815 item_end = (struct btrfs_csum_item *)((unsigned char *)item_end + 811 item_end = (struct btrfs_csum_item *)((unsigned char *)item_end +
816 btrfs_item_size_nr(leaf, path->slots[0])); 812 btrfs_item_size_nr(leaf, path->slots[0]));
817 eb_token = NULL;
818next_sector: 813next_sector:
819 814
820 if (!eb_token || 815 write_extent_buffer(leaf, &sector_sum->sum, (unsigned long)item, csum_size);
821 (unsigned long)item + csum_size >= map_start + map_len) {
822 int err;
823
824 if (eb_token)
825 unmap_extent_buffer(leaf, eb_token, KM_USER1);
826 eb_token = NULL;
827 err = map_private_extent_buffer(leaf, (unsigned long)item,
828 csum_size,
829 &eb_token, &eb_map,
830 &map_start, &map_len, KM_USER1);
831 if (err)
832 eb_token = NULL;
833 }
834 if (eb_token) {
835 memcpy(eb_token + ((unsigned long)item & (PAGE_CACHE_SIZE - 1)),
836 &sector_sum->sum, csum_size);
837 } else {
838 write_extent_buffer(leaf, &sector_sum->sum,
839 (unsigned long)item, csum_size);
840 }
841 816
842 total_bytes += root->sectorsize; 817 total_bytes += root->sectorsize;
843 sector_sum++; 818 sector_sum++;
@@ -850,10 +825,7 @@ next_sector:
850 goto next_sector; 825 goto next_sector;
851 } 826 }
852 } 827 }
853 if (eb_token) { 828
854 unmap_extent_buffer(leaf, eb_token, KM_USER1);
855 eb_token = NULL;
856 }
857 btrfs_mark_buffer_dirty(path->nodes[0]); 829 btrfs_mark_buffer_dirty(path->nodes[0]);
858 if (total_bytes < sums->len) { 830 if (total_bytes < sums->len) {
859 btrfs_release_path(path); 831 btrfs_release_path(path);
diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 55d68ea1866b..3b5763a2b7f9 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -2541,13 +2541,6 @@ static void btrfs_read_locked_inode(struct inode *inode)
2541 2541
2542 inode_item = btrfs_item_ptr(leaf, path->slots[0], 2542 inode_item = btrfs_item_ptr(leaf, path->slots[0],
2543 struct btrfs_inode_item); 2543 struct btrfs_inode_item);
2544 if (!leaf->map_token)
2545 map_private_extent_buffer(leaf, (unsigned long)inode_item,
2546 sizeof(struct btrfs_inode_item),
2547 &leaf->map_token, &leaf->kaddr,
2548 &leaf->map_start, &leaf->map_len,
2549 KM_USER1);
2550
2551 inode->i_mode = btrfs_inode_mode(leaf, inode_item); 2544 inode->i_mode = btrfs_inode_mode(leaf, inode_item);
2552 inode->i_nlink = btrfs_inode_nlink(leaf, inode_item); 2545 inode->i_nlink = btrfs_inode_nlink(leaf, inode_item);
2553 inode->i_uid = btrfs_inode_uid(leaf, inode_item); 2546 inode->i_uid = btrfs_inode_uid(leaf, inode_item);
@@ -2585,11 +2578,6 @@ cache_acl:
2585 if (!maybe_acls) 2578 if (!maybe_acls)
2586 cache_no_acl(inode); 2579 cache_no_acl(inode);
2587 2580
2588 if (leaf->map_token) {
2589 unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
2590 leaf->map_token = NULL;
2591 }
2592
2593 btrfs_free_path(path); 2581 btrfs_free_path(path);
2594 2582
2595 switch (inode->i_mode & S_IFMT) { 2583 switch (inode->i_mode & S_IFMT) {
@@ -2634,13 +2622,6 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
2634 struct btrfs_inode_item *item, 2622 struct btrfs_inode_item *item,
2635 struct inode *inode) 2623 struct inode *inode)
2636{ 2624{
2637 if (!leaf->map_token)
2638 map_private_extent_buffer(leaf, (unsigned long)item,
2639 sizeof(struct btrfs_inode_item),
2640 &leaf->map_token, &leaf->kaddr,
2641 &leaf->map_start, &leaf->map_len,
2642 KM_USER1);
2643
2644 btrfs_set_inode_uid(leaf, item, inode->i_uid); 2625 btrfs_set_inode_uid(leaf, item, inode->i_uid);
2645 btrfs_set_inode_gid(leaf, item, inode->i_gid); 2626 btrfs_set_inode_gid(leaf, item, inode->i_gid);
2646 btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size); 2627 btrfs_set_inode_size(leaf, item, BTRFS_I(inode)->disk_i_size);
@@ -2669,11 +2650,6 @@ static void fill_inode_item(struct btrfs_trans_handle *trans,
2669 btrfs_set_inode_rdev(leaf, item, inode->i_rdev); 2650 btrfs_set_inode_rdev(leaf, item, inode->i_rdev);
2670 btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags); 2651 btrfs_set_inode_flags(leaf, item, BTRFS_I(inode)->flags);
2671 btrfs_set_inode_block_group(leaf, item, 0); 2652 btrfs_set_inode_block_group(leaf, item, 0);
2672
2673 if (leaf->map_token) {
2674 unmap_extent_buffer(leaf, leaf->map_token, KM_USER1);
2675 leaf->map_token = NULL;
2676 }
2677} 2653}
2678 2654
2679/* 2655/*
diff --git a/fs/btrfs/struct-funcs.c b/fs/btrfs/struct-funcs.c
index c0f7ecaf1e79..bc1f6ad18442 100644
--- a/fs/btrfs/struct-funcs.c
+++ b/fs/btrfs/struct-funcs.c
@@ -50,36 +50,22 @@ u##bits btrfs_##name(struct extent_buffer *eb, \
50 unsigned long part_offset = (unsigned long)s; \ 50 unsigned long part_offset = (unsigned long)s; \
51 unsigned long offset = part_offset + offsetof(type, member); \ 51 unsigned long offset = part_offset + offsetof(type, member); \
52 type *p; \ 52 type *p; \
53 /* ugly, but we want the fast path here */ \ 53 int err; \
54 if (eb->map_token && offset >= eb->map_start && \ 54 char *kaddr; \
55 offset + sizeof(((type *)0)->member) <= eb->map_start + \ 55 unsigned long map_start; \
56 eb->map_len) { \ 56 unsigned long map_len; \
57 p = (type *)(eb->kaddr + part_offset - eb->map_start); \ 57 u##bits res; \
58 return le##bits##_to_cpu(p->member); \ 58 err = map_private_extent_buffer(eb, offset, \
59 } \ 59 sizeof(((type *)0)->member), \
60 { \ 60 &kaddr, &map_start, &map_len); \
61 int err; \ 61 if (err) { \
62 char *map_token; \ 62 __le##bits leres; \
63 char *kaddr; \ 63 read_eb_member(eb, s, type, member, &leres); \
64 int unmap_on_exit = (eb->map_token == NULL); \ 64 return le##bits##_to_cpu(leres); \
65 unsigned long map_start; \ 65 } \
66 unsigned long map_len; \ 66 p = (type *)(kaddr + part_offset - map_start); \
67 u##bits res; \ 67 res = le##bits##_to_cpu(p->member); \
68 err = map_extent_buffer(eb, offset, \ 68 return res; \
69 sizeof(((type *)0)->member), \
70 &map_token, &kaddr, \
71 &map_start, &map_len, KM_USER1); \
72 if (err) { \
73 __le##bits leres; \
74 read_eb_member(eb, s, type, member, &leres); \
75 return le##bits##_to_cpu(leres); \
76 } \
77 p = (type *)(kaddr + part_offset - map_start); \
78 res = le##bits##_to_cpu(p->member); \
79 if (unmap_on_exit) \
80 unmap_extent_buffer(eb, map_token, KM_USER1); \
81 return res; \
82 } \
83} \ 69} \
84void btrfs_set_##name(struct extent_buffer *eb, \ 70void btrfs_set_##name(struct extent_buffer *eb, \
85 type *s, u##bits val) \ 71 type *s, u##bits val) \
@@ -87,36 +73,21 @@ void btrfs_set_##name(struct extent_buffer *eb, \
87 unsigned long part_offset = (unsigned long)s; \ 73 unsigned long part_offset = (unsigned long)s; \
88 unsigned long offset = part_offset + offsetof(type, member); \ 74 unsigned long offset = part_offset + offsetof(type, member); \
89 type *p; \ 75 type *p; \
90 /* ugly, but we want the fast path here */ \ 76 int err; \
91 if (eb->map_token && offset >= eb->map_start && \ 77 char *kaddr; \
92 offset + sizeof(((type *)0)->member) <= eb->map_start + \ 78 unsigned long map_start; \
93 eb->map_len) { \ 79 unsigned long map_len; \
94 p = (type *)(eb->kaddr + part_offset - eb->map_start); \ 80 err = map_private_extent_buffer(eb, offset, \
95 p->member = cpu_to_le##bits(val); \ 81 sizeof(((type *)0)->member), \
96 return; \ 82 &kaddr, &map_start, &map_len); \
97 } \ 83 if (err) { \
98 { \ 84 __le##bits val2; \
99 int err; \ 85 val2 = cpu_to_le##bits(val); \
100 char *map_token; \ 86 write_eb_member(eb, s, type, member, &val2); \
101 char *kaddr; \ 87 return; \
102 int unmap_on_exit = (eb->map_token == NULL); \ 88 } \
103 unsigned long map_start; \ 89 p = (type *)(kaddr + part_offset - map_start); \
104 unsigned long map_len; \ 90 p->member = cpu_to_le##bits(val); \
105 err = map_extent_buffer(eb, offset, \
106 sizeof(((type *)0)->member), \
107 &map_token, &kaddr, \
108 &map_start, &map_len, KM_USER1); \
109 if (err) { \
110 __le##bits val2; \
111 val2 = cpu_to_le##bits(val); \
112 write_eb_member(eb, s, type, member, &val2); \
113 return; \
114 } \
115 p = (type *)(kaddr + part_offset - map_start); \
116 p->member = cpu_to_le##bits(val); \
117 if (unmap_on_exit) \
118 unmap_extent_buffer(eb, map_token, KM_USER1); \
119 } \
120} 91}
121 92
122#include "ctree.h" 93#include "ctree.h"
@@ -125,15 +96,6 @@ void btrfs_node_key(struct extent_buffer *eb,
125 struct btrfs_disk_key *disk_key, int nr) 96 struct btrfs_disk_key *disk_key, int nr)
126{ 97{
127 unsigned long ptr = btrfs_node_key_ptr_offset(nr); 98 unsigned long ptr = btrfs_node_key_ptr_offset(nr);
128 if (eb->map_token && ptr >= eb->map_start &&
129 ptr + sizeof(*disk_key) <= eb->map_start + eb->map_len) {
130 memcpy(disk_key, eb->kaddr + ptr - eb->map_start,
131 sizeof(*disk_key));
132 return;
133 } else if (eb->map_token) {
134 unmap_extent_buffer(eb, eb->map_token, KM_USER1);
135 eb->map_token = NULL;
136 }
137 read_eb_member(eb, (struct btrfs_key_ptr *)ptr, 99 read_eb_member(eb, (struct btrfs_key_ptr *)ptr,
138 struct btrfs_key_ptr, key, disk_key); 100 struct btrfs_key_ptr, key, disk_key);
139} 101}
generated by cgit v1.2.2 (git 2.25.0) at 2025-09-10 08:47:16 -0400