aboutsummaryrefslogtreecommitdiffstats
path: root/fs
diff options
context:
space:
mode:
Diffstat (limited to 'fs')
-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 2e667868e0d..d2431284b91 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 234a08404fc..97f22ff8326 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 89bbde46bd8..76ecbb8ed0e 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 a11a92ee2d3..b5f120cca91 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 90d4ee52cd4..bb22a4435b2 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 55d68ea1866..3b5763a2b7f 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 c0f7ecaf1e7..bc1f6ad1844 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 2024-10-19 10:20:54 -0400