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

Configure Feed

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

Merge tag 'md-7.1-20260428' of https://git.kernel.org/pub/scm/linux/kernel/git/mdraid/linux into block-7.1

Pull MD fixes from Yu Kuai:

"Bug Fixes:
- Fix a raid5 UAF on IO across the reshape position.
- Avoid failing RAID1/RAID10 devices for invalid IO errors.
- Fix RAID10 divide-by-zero when far_copies is zero.
- Restore bitmap grow through sysfs.

Cleanups:
- Use mddev_is_dm() instead of open-coding gendisk checks.
- Use ATTRIBUTE_GROUPS() for md default sysfs attributes.
- Replace open-coded wait loops with wait_event helpers."

* tag 'md-7.1-20260428' of https://git.kernel.org/pub/scm/linux/kernel/git/mdraid/linux:
md: use ATTRIBUTE_GROUPS() for md default sysfs attributes
md: use mddev_is_dm() instead of open-coding gendisk checks
md/raid1: replace wait loop with wait_event_idle() in raid1_write_request()
md/md-bitmap: add a none backend for bitmap grow
md/md-bitmap: split bitmap sysfs groups
md: factor bitmap creation away from sysfs handling
md: use mddev_lock_nointr() in mddev_suspend_and_lock_nointr()
md: replace wait loop with wait_event() in md_handle_request()
md/raid10: fix divide-by-zero in setup_geo() with zero far_copies
md/raid1,raid10: don't fail devices for invalid IO errors
MAINTAINERS: Add Xiao Ni as md/raid reviewer
md/raid5: Fix UAF on IO across the reshape position

Jens Axboe 7e36e03d 0898a817

+252 -110
+1
MAINTAINERS
··· 24764 24764 M: Song Liu <song@kernel.org> 24765 24765 M: Yu Kuai <yukuai@fnnas.com> 24766 24766 R: Li Nan <linan122@huawei.com> 24767 + R: Xiao Ni <xiao@kernel.org> 24767 24768 L: linux-raid@vger.kernel.org 24768 24769 S: Supported 24769 24770 Q: https://patchwork.kernel.org/project/linux-raid/list/
+120 -13
drivers/md/md-bitmap.c
··· 216 216 }; 217 217 218 218 static struct workqueue_struct *md_bitmap_wq; 219 + static struct attribute_group md_bitmap_internal_group; 219 220 220 221 static int __bitmap_resize(struct bitmap *bitmap, sector_t blocks, 221 222 int chunksize, bool init); ··· 2581 2580 return __bitmap_resize(bitmap, blocks, chunksize, false); 2582 2581 } 2583 2582 2583 + static bool bitmap_none_enabled(void *data, bool flush) 2584 + { 2585 + return false; 2586 + } 2587 + 2588 + static int bitmap_none_create(struct mddev *mddev) 2589 + { 2590 + return 0; 2591 + } 2592 + 2593 + static int bitmap_none_load(struct mddev *mddev) 2594 + { 2595 + return 0; 2596 + } 2597 + 2598 + static void bitmap_none_destroy(struct mddev *mddev) 2599 + { 2600 + } 2601 + 2602 + static int bitmap_none_get_stats(void *data, struct md_bitmap_stats *stats) 2603 + { 2604 + return -ENOENT; 2605 + } 2606 + 2584 2607 static ssize_t 2585 2608 location_show(struct mddev *mddev, char *page) 2586 2609 { ··· 2643 2618 goto out; 2644 2619 } 2645 2620 2646 - bitmap_destroy(mddev); 2621 + sysfs_unmerge_group(&mddev->kobj, &md_bitmap_internal_group); 2622 + md_bitmap_destroy_nosysfs(mddev); 2623 + mddev->bitmap_id = ID_BITMAP_NONE; 2624 + if (!mddev_set_bitmap_ops_nosysfs(mddev)) 2625 + goto none_err; 2647 2626 mddev->bitmap_info.offset = 0; 2648 2627 if (mddev->bitmap_info.file) { 2649 2628 struct file *f = mddev->bitmap_info.file; ··· 2683 2654 } 2684 2655 2685 2656 mddev->bitmap_info.offset = offset; 2686 - rv = bitmap_create(mddev); 2687 - if (rv) 2688 - goto out; 2657 + md_bitmap_destroy_nosysfs(mddev); 2658 + mddev->bitmap_id = ID_BITMAP; 2659 + if (!mddev_set_bitmap_ops_nosysfs(mddev)) 2660 + goto bitmap_err; 2689 2661 2690 - rv = bitmap_load(mddev); 2662 + rv = md_bitmap_create_nosysfs(mddev); 2663 + if (rv) 2664 + goto create_err; 2665 + 2666 + rv = mddev->bitmap_ops->load(mddev); 2691 2667 if (rv) { 2692 2668 mddev->bitmap_info.offset = 0; 2693 - bitmap_destroy(mddev); 2694 - goto out; 2669 + goto load_err; 2695 2670 } 2671 + 2672 + rv = sysfs_merge_group(&mddev->kobj, 2673 + &md_bitmap_internal_group); 2674 + if (rv) 2675 + goto merge_err; 2696 2676 } 2697 2677 } 2698 2678 if (!mddev->external) { ··· 2717 2679 if (rv) 2718 2680 return rv; 2719 2681 return len; 2682 + 2683 + merge_err: 2684 + mddev->bitmap_info.offset = 0; 2685 + load_err: 2686 + md_bitmap_destroy_nosysfs(mddev); 2687 + create_err: 2688 + mddev->bitmap_info.offset = 0; 2689 + mddev->bitmap_id = ID_BITMAP_NONE; 2690 + if (!mddev_set_bitmap_ops_nosysfs(mddev)) 2691 + rv = -ENOENT; 2692 + goto out; 2693 + bitmap_err: 2694 + rv = -ENOENT; 2695 + none_err: 2696 + mddev->bitmap_info.offset = 0; 2697 + goto out; 2720 2698 } 2721 2699 2722 2700 static struct md_sysfs_entry bitmap_location = ··· 3009 2955 __ATTR(max_backlog_used, S_IRUGO | S_IWUSR, 3010 2956 behind_writes_used_show, behind_writes_used_reset); 3011 2957 3012 - static struct attribute *md_bitmap_attrs[] = { 2958 + static struct attribute *md_bitmap_common_attrs[] = { 3013 2959 &bitmap_location.attr, 2960 + NULL 2961 + }; 2962 + 2963 + static struct attribute *md_bitmap_internal_attrs[] = { 3014 2964 &bitmap_space.attr, 3015 2965 &bitmap_timeout.attr, 3016 2966 &bitmap_backlog.attr, ··· 3025 2967 NULL 3026 2968 }; 3027 2969 3028 - static struct attribute_group md_bitmap_group = { 2970 + static struct attribute_group md_bitmap_common_group = { 3029 2971 .name = "bitmap", 3030 - .attrs = md_bitmap_attrs, 2972 + .attrs = md_bitmap_common_attrs, 2973 + }; 2974 + 2975 + static struct attribute_group md_bitmap_internal_group = { 2976 + .name = "bitmap", 2977 + .attrs = md_bitmap_internal_attrs, 2978 + }; 2979 + 2980 + static const struct attribute_group *bitmap_groups[] = { 2981 + &md_bitmap_common_group, 2982 + &md_bitmap_internal_group, 2983 + NULL, 2984 + }; 2985 + 2986 + static const struct attribute_group *bitmap_none_groups[] = { 2987 + &md_bitmap_common_group, 2988 + NULL, 2989 + }; 2990 + 2991 + static struct bitmap_operations bitmap_none_ops = { 2992 + .head = { 2993 + .type = MD_BITMAP, 2994 + .id = ID_BITMAP_NONE, 2995 + .name = "none", 2996 + }, 2997 + 2998 + .enabled = bitmap_none_enabled, 2999 + .create = bitmap_none_create, 3000 + .load = bitmap_none_load, 3001 + .destroy = bitmap_none_destroy, 3002 + .get_stats = bitmap_none_get_stats, 3003 + 3004 + .groups = bitmap_none_groups, 3031 3005 }; 3032 3006 3033 3007 static struct bitmap_operations bitmap_ops = { ··· 3103 3013 .set_pages = bitmap_set_pages, 3104 3014 .free = md_bitmap_free, 3105 3015 3106 - .group = &md_bitmap_group, 3016 + .groups = bitmap_groups, 3107 3017 }; 3108 3018 3109 3019 int md_bitmap_init(void) 3110 3020 { 3021 + int err; 3022 + 3111 3023 md_bitmap_wq = alloc_workqueue("md_bitmap", WQ_MEM_RECLAIM | WQ_UNBOUND, 3112 3024 0); 3113 3025 if (!md_bitmap_wq) 3114 3026 return -ENOMEM; 3115 3027 3116 - return register_md_submodule(&bitmap_ops.head); 3028 + err = register_md_submodule(&bitmap_none_ops.head); 3029 + if (err) 3030 + goto err_wq; 3031 + 3032 + err = register_md_submodule(&bitmap_ops.head); 3033 + if (err) 3034 + goto err_none; 3035 + 3036 + return 0; 3037 + 3038 + err_none: 3039 + unregister_md_submodule(&bitmap_none_ops.head); 3040 + err_wq: 3041 + destroy_workqueue(md_bitmap_wq); 3042 + return err; 3117 3043 } 3118 3044 3119 3045 void md_bitmap_exit(void) 3120 3046 { 3121 - destroy_workqueue(md_bitmap_wq); 3122 3047 unregister_md_submodule(&bitmap_ops.head); 3048 + unregister_md_submodule(&bitmap_none_ops.head); 3049 + destroy_workqueue(md_bitmap_wq); 3123 3050 }
+1 -1
drivers/md/md-bitmap.h
··· 125 125 void (*set_pages)(void *data, unsigned long pages); 126 126 void (*free)(void *data); 127 127 128 - struct attribute_group *group; 128 + const struct attribute_group **groups; 129 129 }; 130 130 131 131 /* the bitmap API */
+6 -1
drivers/md/md-llbitmap.c
··· 1738 1738 .attrs = md_llbitmap_attrs, 1739 1739 }; 1740 1740 1741 + static const struct attribute_group *md_llbitmap_groups[] = { 1742 + &md_llbitmap_group, 1743 + NULL, 1744 + }; 1745 + 1741 1746 static struct bitmap_operations llbitmap_ops = { 1742 1747 .head = { 1743 1748 .type = MD_BITMAP, ··· 1779 1774 .dirty_bits = llbitmap_dirty_bits, 1780 1775 .write_all = llbitmap_write_all, 1781 1776 1782 - .group = &md_llbitmap_group, 1777 + .groups = md_llbitmap_groups, 1783 1778 }; 1784 1779 1785 1780 int md_llbitmap_init(void)
+102 -80
drivers/md/md.c
··· 396 396 { 397 397 check_suspended: 398 398 if (is_suspended(mddev, bio)) { 399 - DEFINE_WAIT(__wait); 400 399 /* Bail out if REQ_NOWAIT is set for the bio */ 401 400 if (bio->bi_opf & REQ_NOWAIT) { 402 401 bio_wouldblock_error(bio); 403 402 return true; 404 403 } 405 - for (;;) { 406 - prepare_to_wait(&mddev->sb_wait, &__wait, 407 - TASK_UNINTERRUPTIBLE); 408 - if (!is_suspended(mddev, bio)) 409 - break; 410 - schedule(); 411 - } 412 - finish_wait(&mddev->sb_wait, &__wait); 404 + wait_event(mddev->sb_wait, !is_suspended(mddev, bio)); 413 405 } 414 406 if (!percpu_ref_tryget_live(&mddev->active_io)) 415 407 goto check_suspended; 416 408 417 409 if (!mddev->pers->make_request(mddev, bio)) { 418 410 percpu_ref_put(&mddev->active_io); 419 - if (!mddev->gendisk && mddev->pers->prepare_suspend) 411 + if (mddev_is_dm(mddev) && mddev->pers->prepare_suspend) 420 412 return false; 421 413 goto check_suspended; 422 414 } ··· 679 687 680 688 static void no_op(struct percpu_ref *r) {} 681 689 682 - static bool mddev_set_bitmap_ops(struct mddev *mddev) 690 + static void md_bitmap_sysfs_add(struct mddev *mddev) 683 691 { 684 - struct bitmap_operations *old = mddev->bitmap_ops; 692 + if (sysfs_update_groups(&mddev->kobj, mddev->bitmap_ops->groups)) 693 + pr_warn("md: cannot register extra bitmap attributes for %s\n", 694 + mdname(mddev)); 695 + else 696 + /* 697 + * Inform user with KOBJ_CHANGE about new bitmap 698 + * attributes. 699 + */ 700 + kobject_uevent(&mddev->kobj, KOBJ_CHANGE); 701 + } 702 + 703 + static void md_bitmap_sysfs_del(struct mddev *mddev) 704 + { 705 + int nr_groups = 0; 706 + 707 + for (nr_groups = 0; mddev->bitmap_ops->groups[nr_groups]; nr_groups++) 708 + ; 709 + 710 + while (--nr_groups >= 1) 711 + sysfs_unmerge_group(&mddev->kobj, 712 + mddev->bitmap_ops->groups[nr_groups]); 713 + sysfs_remove_group(&mddev->kobj, mddev->bitmap_ops->groups[0]); 714 + } 715 + 716 + bool mddev_set_bitmap_ops_nosysfs(struct mddev *mddev) 717 + { 685 718 struct md_submodule_head *head; 686 719 687 - if (mddev->bitmap_id == ID_BITMAP_NONE || 688 - (old && old->head.id == mddev->bitmap_id)) 720 + if (mddev->bitmap_ops && 721 + mddev->bitmap_ops->head.id == mddev->bitmap_id) 689 722 return true; 690 723 691 724 xa_lock(&md_submodule); ··· 728 711 729 712 mddev->bitmap_ops = (void *)head; 730 713 xa_unlock(&md_submodule); 731 - 732 - if (!mddev_is_dm(mddev) && mddev->bitmap_ops->group) { 733 - if (sysfs_create_group(&mddev->kobj, mddev->bitmap_ops->group)) 734 - pr_warn("md: cannot register extra bitmap attributes for %s\n", 735 - mdname(mddev)); 736 - else 737 - /* 738 - * Inform user with KOBJ_CHANGE about new bitmap 739 - * attributes. 740 - */ 741 - kobject_uevent(&mddev->kobj, KOBJ_CHANGE); 742 - } 743 714 return true; 744 715 745 716 err: 746 717 xa_unlock(&md_submodule); 747 718 return false; 748 - } 749 - 750 - static void mddev_clear_bitmap_ops(struct mddev *mddev) 751 - { 752 - if (!mddev_is_dm(mddev) && mddev->bitmap_ops && 753 - mddev->bitmap_ops->group) 754 - sysfs_remove_group(&mddev->kobj, mddev->bitmap_ops->group); 755 - 756 - mddev->bitmap_ops = NULL; 757 719 } 758 720 759 721 int mddev_init(struct mddev *mddev) ··· 4275 4279 4276 4280 xa_lock(&md_submodule); 4277 4281 xa_for_each(&md_submodule, i, head) { 4278 - if (head->type != MD_BITMAP) 4282 + if (head->type != MD_BITMAP || head->id == ID_BITMAP_NONE) 4279 4283 continue; 4280 4284 4281 4285 if (mddev->bitmap_id == head->id) ··· 6055 6059 &md_logical_block_size.attr, 6056 6060 NULL, 6057 6061 }; 6058 - 6059 - static const struct attribute_group md_default_group = { 6060 - .attrs = md_default_attrs, 6061 - }; 6062 + ATTRIBUTE_GROUPS(md_default); 6062 6063 6063 6064 static struct attribute *md_redundancy_attrs[] = { 6064 6065 &md_scan_mode.attr, ··· 6078 6085 static const struct attribute_group md_redundancy_group = { 6079 6086 .name = NULL, 6080 6087 .attrs = md_redundancy_attrs, 6081 - }; 6082 - 6083 - static const struct attribute_group *md_attr_groups[] = { 6084 - &md_default_group, 6085 - NULL, 6086 6088 }; 6087 6089 6088 6090 static ssize_t ··· 6162 6174 static const struct kobj_type md_ktype = { 6163 6175 .release = md_kobj_release, 6164 6176 .sysfs_ops = &md_sysfs_ops, 6165 - .default_groups = md_attr_groups, 6177 + .default_groups = md_default_groups, 6166 6178 }; 6167 6179 6168 6180 int mdp_major = 0; ··· 6527 6539 return id; 6528 6540 } 6529 6541 6530 - static int md_bitmap_create(struct mddev *mddev) 6542 + int md_bitmap_create_nosysfs(struct mddev *mddev) 6531 6543 { 6532 6544 enum md_submodule_id orig_id = mddev->bitmap_id; 6533 6545 enum md_submodule_id sb_id; ··· 6536 6548 if (mddev->bitmap_id == ID_BITMAP_NONE) 6537 6549 return -EINVAL; 6538 6550 6539 - if (!mddev_set_bitmap_ops(mddev)) 6551 + if (!mddev_set_bitmap_ops_nosysfs(mddev)) { 6552 + mddev->bitmap_id = orig_id; 6540 6553 return -ENOENT; 6554 + } 6541 6555 6542 6556 err = mddev->bitmap_ops->create(mddev); 6543 6557 if (!err) ··· 6550 6560 * doesn't match, and mdadm is not the latest version to set 6551 6561 * bitmap_type, set bitmap_ops based on the disk version. 6552 6562 */ 6553 - mddev_clear_bitmap_ops(mddev); 6563 + mddev->bitmap_ops = NULL; 6554 6564 6555 6565 sb_id = md_bitmap_get_id_from_sb(mddev); 6556 - if (sb_id == ID_BITMAP_NONE || sb_id == orig_id) 6566 + if (sb_id == ID_BITMAP_NONE || sb_id == orig_id) { 6567 + mddev->bitmap_id = orig_id; 6557 6568 return err; 6569 + } 6558 6570 6559 6571 pr_info("md: %s: bitmap version mismatch, switching from %d to %d\n", 6560 6572 mdname(mddev), orig_id, sb_id); 6561 6573 6562 6574 mddev->bitmap_id = sb_id; 6563 - if (!mddev_set_bitmap_ops(mddev)) { 6575 + if (!mddev_set_bitmap_ops_nosysfs(mddev)) { 6564 6576 mddev->bitmap_id = orig_id; 6565 6577 return -ENOENT; 6566 6578 } 6567 6579 6568 6580 err = mddev->bitmap_ops->create(mddev); 6569 6581 if (err) { 6570 - mddev_clear_bitmap_ops(mddev); 6582 + mddev->bitmap_ops = NULL; 6571 6583 mddev->bitmap_id = orig_id; 6572 6584 } 6573 6585 6574 6586 return err; 6575 6587 } 6576 6588 6577 - static void md_bitmap_destroy(struct mddev *mddev) 6589 + static int md_bitmap_create(struct mddev *mddev) 6590 + { 6591 + int err; 6592 + 6593 + err = md_bitmap_create_nosysfs(mddev); 6594 + if (err) 6595 + return err; 6596 + 6597 + if (!mddev_is_dm(mddev) && mddev->bitmap_ops->groups) 6598 + md_bitmap_sysfs_add(mddev); 6599 + 6600 + return 0; 6601 + } 6602 + 6603 + void md_bitmap_destroy_nosysfs(struct mddev *mddev) 6578 6604 { 6579 6605 if (!md_bitmap_registered(mddev)) 6580 6606 return; 6581 6607 6582 6608 mddev->bitmap_ops->destroy(mddev); 6583 - mddev_clear_bitmap_ops(mddev); 6609 + mddev->bitmap_ops = NULL; 6610 + } 6611 + 6612 + static void md_bitmap_destroy(struct mddev *mddev) 6613 + { 6614 + if (!mddev_is_dm(mddev) && mddev->bitmap_ops && 6615 + mddev->bitmap_ops->groups) 6616 + md_bitmap_sysfs_del(mddev); 6617 + 6618 + md_bitmap_destroy_nosysfs(mddev); 6619 + } 6620 + 6621 + static void md_bitmap_set_none(struct mddev *mddev) 6622 + { 6623 + mddev->bitmap_id = ID_BITMAP_NONE; 6624 + if (!mddev_set_bitmap_ops_nosysfs(mddev)) 6625 + return; 6626 + 6627 + if (!mddev_is_dm(mddev) && mddev->bitmap_ops->groups) 6628 + md_bitmap_sysfs_add(mddev); 6584 6629 } 6585 6630 6586 6631 int md_run(struct mddev *mddev) ··· 6738 6713 } 6739 6714 6740 6715 /* dm-raid expect sync_thread to be frozen until resume */ 6741 - if (mddev->gendisk) 6716 + if (!mddev_is_dm(mddev)) 6742 6717 mddev->recovery = 0; 6743 6718 6744 6719 /* may be over-ridden by personality */ ··· 6826 6801 6827 6802 if (mddev->sb_flags) 6828 6803 md_update_sb(mddev, 0); 6804 + 6805 + if (IS_ENABLED(CONFIG_MD_BITMAP) && !mddev->bitmap_info.file && 6806 + !mddev->bitmap_info.offset) 6807 + md_bitmap_set_none(mddev); 6829 6808 6830 6809 md_new_event(); 6831 6810 return 0; ··· 7776 7747 { 7777 7748 int err = 0; 7778 7749 7779 - if (!md_bitmap_registered(mddev)) 7750 + if (!md_bitmap_registered(mddev) || 7751 + mddev->bitmap_id == ID_BITMAP_NONE) 7780 7752 return -EINVAL; 7781 7753 7782 7754 if (mddev->pers) { ··· 7842 7812 7843 7813 if (err) { 7844 7814 md_bitmap_destroy(mddev); 7815 + md_bitmap_set_none(mddev); 7845 7816 fd = -1; 7846 7817 } 7847 7818 } else if (fd < 0) { 7848 7819 md_bitmap_destroy(mddev); 7820 + md_bitmap_set_none(mddev); 7849 7821 } 7850 7822 } 7851 7823 ··· 8154 8122 mddev->bitmap_info.default_offset; 8155 8123 mddev->bitmap_info.space = 8156 8124 mddev->bitmap_info.default_space; 8125 + mddev->bitmap_id = ID_BITMAP; 8157 8126 rv = md_bitmap_create(mddev); 8158 8127 if (!rv) 8159 8128 rv = mddev->bitmap_ops->load(mddev); 8160 8129 8161 - if (rv) 8130 + if (rv) { 8162 8131 md_bitmap_destroy(mddev); 8132 + mddev->bitmap_info.offset = 0; 8133 + md_bitmap_set_none(mddev); 8134 + } 8163 8135 } else { 8164 8136 struct md_bitmap_stats stats; 8165 8137 ··· 8191 8155 } 8192 8156 md_bitmap_destroy(mddev); 8193 8157 mddev->bitmap_info.offset = 0; 8158 + md_bitmap_set_none(mddev); 8194 8159 } 8195 8160 } 8196 8161 md_update_sb(mddev, 1); ··· 9378 9341 9379 9342 static void md_end_clone_io(struct bio *bio) 9380 9343 { 9381 - struct md_io_clone *md_io_clone = bio->bi_private; 9344 + struct md_io_clone *md_io_clone = container_of(bio, struct md_io_clone, 9345 + bio_clone); 9382 9346 struct bio *orig_bio = md_io_clone->orig_bio; 9383 9347 struct mddev *mddev = md_io_clone->mddev; 9348 + struct completion *reshape_completion = bio->bi_private; 9384 9349 9385 9350 if (bio_data_dir(orig_bio) == WRITE && md_bitmap_enabled(mddev, false)) 9386 9351 md_bitmap_end(mddev, md_io_clone); ··· 9394 9355 bio_end_io_acct(orig_bio, md_io_clone->start_time); 9395 9356 9396 9357 bio_put(bio); 9397 - bio_endio(orig_bio); 9358 + if (unlikely(reshape_completion)) 9359 + complete(reshape_completion); 9360 + else 9361 + bio_endio(orig_bio); 9398 9362 percpu_ref_put(&mddev->active_io); 9399 9363 } 9400 9364 ··· 9422 9380 } 9423 9381 9424 9382 clone->bi_end_io = md_end_clone_io; 9425 - clone->bi_private = md_io_clone; 9383 + clone->bi_private = NULL; 9426 9384 *bio = clone; 9427 9385 } 9428 9386 ··· 9432 9390 md_clone_bio(mddev, bio); 9433 9391 } 9434 9392 EXPORT_SYMBOL_GPL(md_account_bio); 9435 - 9436 - void md_free_cloned_bio(struct bio *bio) 9437 - { 9438 - struct md_io_clone *md_io_clone = bio->bi_private; 9439 - struct bio *orig_bio = md_io_clone->orig_bio; 9440 - struct mddev *mddev = md_io_clone->mddev; 9441 - 9442 - if (bio_data_dir(orig_bio) == WRITE && md_bitmap_enabled(mddev, false)) 9443 - md_bitmap_end(mddev, md_io_clone); 9444 - 9445 - if (bio->bi_status && !orig_bio->bi_status) 9446 - orig_bio->bi_status = bio->bi_status; 9447 - 9448 - if (md_io_clone->start_time) 9449 - bio_end_io_acct(orig_bio, md_io_clone->start_time); 9450 - 9451 - bio_put(bio); 9452 - percpu_ref_put(&mddev->active_io); 9453 - } 9454 - EXPORT_SYMBOL_GPL(md_free_cloned_bio); 9455 9393 9456 9394 /* md_allow_write(mddev) 9457 9395 * Calling this ensures that the array is marked 'active' so that writes
+4 -2
drivers/md/md.h
··· 920 920 void md_submit_discard_bio(struct mddev *mddev, struct md_rdev *rdev, 921 921 struct bio *bio, sector_t start, sector_t size); 922 922 void md_account_bio(struct mddev *mddev, struct bio **bio); 923 - void md_free_cloned_bio(struct bio *bio); 924 923 925 924 extern bool __must_check md_flush_request(struct mddev *mddev, struct bio *bio); 926 925 void md_write_metadata(struct mddev *mddev, struct md_rdev *rdev, ··· 934 935 extern void md_wait_for_blocked_rdev(struct md_rdev *rdev, struct mddev *mddev); 935 936 extern void md_set_array_sectors(struct mddev *mddev, sector_t array_sectors); 936 937 extern int md_check_no_bitmap(struct mddev *mddev); 938 + bool mddev_set_bitmap_ops_nosysfs(struct mddev *mddev); 939 + int md_bitmap_create_nosysfs(struct mddev *mddev); 940 + void md_bitmap_destroy_nosysfs(struct mddev *mddev); 937 941 extern int md_integrity_register(struct mddev *mddev); 938 942 extern int strict_strtoul_scaled(const char *cp, unsigned long *res, int scale); 939 943 ··· 1017 1015 static inline void mddev_suspend_and_lock_nointr(struct mddev *mddev) 1018 1016 { 1019 1017 mddev_suspend(mddev, false); 1020 - mutex_lock(&mddev->reconfig_mutex); 1018 + mddev_lock_nointr(mddev); 1021 1019 } 1022 1020 1023 1021 static inline void mddev_unlock_and_resume(struct mddev *mddev)
+6 -1
drivers/md/raid1-10.c
··· 293 293 * bio with REQ_RAHEAD or REQ_NOWAIT can fail at anytime, before such IO is 294 294 * submitted to the underlying disks, hence don't record badblocks or retry 295 295 * in this case. 296 + * 297 + * BLK_STS_INVAL means the bio was not valid for the underlying device. This 298 + * is a user error, not a device failure, so retrying or recording bad blocks 299 + * would be wrong. 296 300 */ 297 301 static inline bool raid1_should_handle_error(struct bio *bio) 298 302 { 299 - return !(bio->bi_opf & (REQ_RAHEAD | REQ_NOWAIT)); 303 + return !(bio->bi_opf & (REQ_RAHEAD | REQ_NOWAIT)) && 304 + bio->bi_status != BLK_STS_INVAL; 300 305 }
+4 -11
drivers/md/raid1.c
··· 1510 1510 mddev->cluster_ops->area_resyncing(mddev, WRITE, 1511 1511 bio->bi_iter.bi_sector, bio_end_sector(bio))) { 1512 1512 1513 - DEFINE_WAIT(w); 1514 1513 if (bio->bi_opf & REQ_NOWAIT) { 1515 1514 bio_wouldblock_error(bio); 1516 1515 return; 1517 1516 } 1518 - for (;;) { 1519 - prepare_to_wait(&conf->wait_barrier, 1520 - &w, TASK_IDLE); 1521 - if (!mddev->cluster_ops->area_resyncing(mddev, WRITE, 1522 - bio->bi_iter.bi_sector, 1523 - bio_end_sector(bio))) 1524 - break; 1525 - schedule(); 1526 - } 1527 - finish_wait(&conf->wait_barrier, &w); 1517 + wait_event_idle(conf->wait_barrier, 1518 + !mddev->cluster_ops->area_resyncing(mddev, WRITE, 1519 + bio->bi_iter.bi_sector, 1520 + bio_end_sector(bio))); 1528 1521 } 1529 1522 1530 1523 /*
+2
drivers/md/raid10.c
··· 3791 3791 nc = layout & 255; 3792 3792 fc = (layout >> 8) & 255; 3793 3793 fo = layout & (1<<16); 3794 + if (!nc || !fc) 3795 + return -1; 3794 3796 geo->raid_disks = disks; 3795 3797 geo->near_copies = nc; 3796 3798 geo->far_copies = fc;
+6 -1
drivers/md/raid5.c
··· 6217 6217 6218 6218 mempool_free(ctx, conf->ctx_pool); 6219 6219 if (res == STRIPE_WAIT_RESHAPE) { 6220 - md_free_cloned_bio(bi); 6220 + DECLARE_COMPLETION_ONSTACK(done); 6221 + WRITE_ONCE(bi->bi_private, &done); 6222 + 6223 + bio_endio(bi); 6224 + 6225 + wait_for_completion(&done); 6221 6226 return false; 6222 6227 } 6223 6228