Merge tag 'md-6.19-20251111' of gitolite.kernel.org:pub/scm/linux/kernel/git/mdraid/linux into for-6.19/block

+10

Documentation/admin-guide/md.rst

··· 238 238 the number of devices in a raid4/5/6, or to support external 239 239 metadata formats which mandate such clipping. 240 240 241 + logical_block_size 242 + Configure the array's logical block size in bytes. This attribute 243 + is only supported for 1.x meta. Write the value before starting 244 + array. The final array LBS uses the maximum between this 245 + configuration and LBS of all combined devices. Note that 246 + LBS cannot exceed PAGE_SIZE before RAID supports folio. 247 + WARNING: Arrays created on new kernel cannot be assembled at old 248 + kernel due to padding check, Set module parameter 'check_new_feature' 249 + to false to bypass, but data loss may occur. 250 + 241 251 reshape_position 242 252 This is either ``none`` or a sector number within the devices of 243 253 the array where ``reshape`` is up to. If this is set, the three

+2 -2

MAINTAINERS

··· 4300 4300 F: fs/befs/ 4301 4301 4302 4302 BFQ I/O SCHEDULER 4303 - M: Yu Kuai <yukuai3@huawei.com> 4303 + M: Yu Kuai <yukuai@fnnas.com> 4304 4304 L: linux-block@vger.kernel.org 4305 4305 S: Odd Fixes 4306 4306 F: Documentation/block/bfq-iosched.rst ··· 23842 23842 23843 23843 SOFTWARE RAID (Multiple Disks) SUPPORT 23844 23844 M: Song Liu <song@kernel.org> 23845 - M: Yu Kuai <yukuai3@huawei.com> 23845 + M: Yu Kuai <yukuai@fnnas.com> 23846 23846 L: linux-raid@vger.kernel.org 23847 23847 S: Supported 23848 23848 Q: https://patchwork.kernel.org/project/linux-raid/list/

+2

drivers/md/md-linear.c

··· 72 72 73 73 md_init_stacking_limits(&lim); 74 74 lim.max_hw_sectors = mddev->chunk_sectors; 75 + lim.logical_block_size = mddev->logical_block_size; 75 76 lim.max_write_zeroes_sectors = mddev->chunk_sectors; 76 77 lim.max_hw_wzeroes_unmap_sectors = mddev->chunk_sectors; 77 78 lim.io_min = mddev->chunk_sectors << 9; 79 + lim.features |= BLK_FEAT_ATOMIC_WRITES; 78 80 err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY); 79 81 if (err) 80 82 return err;

+1 -1

drivers/md/md-llbitmap.c

··· 378 378 case BitClean: 379 379 pctl->state[pos] = BitDirty; 380 380 break; 381 - }; 381 + } 382 382 } 383 383 } 384 384

+187 -60

drivers/md/md.c

··· 99 99 struct md_rdev *this); 100 100 static void mddev_detach(struct mddev *mddev); 101 101 static void export_rdev(struct md_rdev *rdev, struct mddev *mddev); 102 - static void md_wakeup_thread_directly(struct md_thread __rcu *thread); 102 + static void md_wakeup_thread_directly(struct md_thread __rcu **thread); 103 103 104 104 /* 105 105 * Default number of read corrections we'll attempt on an rdev ··· 339 339 */ 340 340 static bool create_on_open = true; 341 341 static bool legacy_async_del_gendisk = true; 342 + static bool check_new_feature = true; 342 343 343 344 /* 344 345 * We have a system wide 'event count' that is incremented ··· 731 730 732 731 int mddev_init(struct mddev *mddev) 733 732 { 733 + int err = 0; 734 + 734 735 if (!IS_ENABLED(CONFIG_MD_BITMAP)) 735 736 mddev->bitmap_id = ID_BITMAP_NONE; 736 737 else ··· 744 741 745 742 if (percpu_ref_init(&mddev->writes_pending, no_op, 746 743 PERCPU_REF_ALLOW_REINIT, GFP_KERNEL)) { 747 - percpu_ref_exit(&mddev->active_io); 748 - return -ENOMEM; 744 + err = -ENOMEM; 745 + goto exit_acitve_io; 749 746 } 747 + 748 + err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS); 749 + if (err) 750 + goto exit_writes_pending; 751 + 752 + err = bioset_init(&mddev->sync_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS); 753 + if (err) 754 + goto exit_bio_set; 755 + 756 + err = bioset_init(&mddev->io_clone_set, BIO_POOL_SIZE, 757 + offsetof(struct md_io_clone, bio_clone), 0); 758 + if (err) 759 + goto exit_sync_set; 750 760 751 761 /* We want to start with the refcount at zero */ 752 762 percpu_ref_put(&mddev->writes_pending); ··· 789 773 INIT_WORK(&mddev->del_work, mddev_delayed_delete); 790 774 791 775 return 0; 776 + 777 + exit_sync_set: 778 + bioset_exit(&mddev->sync_set); 779 + exit_bio_set: 780 + bioset_exit(&mddev->bio_set); 781 + exit_writes_pending: 782 + percpu_ref_exit(&mddev->writes_pending); 783 + exit_acitve_io: 784 + percpu_ref_exit(&mddev->active_io); 785 + return err; 792 786 } 793 787 EXPORT_SYMBOL_GPL(mddev_init); 794 788 795 789 void mddev_destroy(struct mddev *mddev) 796 790 { 791 + bioset_exit(&mddev->bio_set); 792 + bioset_exit(&mddev->sync_set); 793 + bioset_exit(&mddev->io_clone_set); 797 794 percpu_ref_exit(&mddev->active_io); 798 795 percpu_ref_exit(&mddev->writes_pending); 799 796 } ··· 970 941 * do_md_stop. dm raid only uses md_stop to stop. So dm raid 971 942 * doesn't need to check MD_DELETED when getting reconfig lock 972 943 */ 973 - if (test_bit(MD_DELETED, &mddev->flags)) 944 + if (test_bit(MD_DELETED, &mddev->flags) && 945 + !test_and_set_bit(MD_DO_DELETE, &mddev->flags)) { 946 + kobject_del(&mddev->kobj); 974 947 del_gendisk(mddev->gendisk); 948 + } 975 949 } 976 950 } 977 951 EXPORT_SYMBOL_GPL(mddev_unlock); ··· 1852 1820 } 1853 1821 if (sb->pad0 || 1854 1822 sb->pad3[0] || 1855 - memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1]))) 1856 - /* Some padding is non-zero, might be a new feature */ 1857 - return -EINVAL; 1823 + memcmp(sb->pad3, sb->pad3+1, sizeof(sb->pad3) - sizeof(sb->pad3[1]))) { 1824 + pr_warn("Some padding is non-zero on %pg, might be a new feature\n", 1825 + rdev->bdev); 1826 + if (check_new_feature) 1827 + return -EINVAL; 1828 + pr_warn("check_new_feature is disabled, data corruption possible\n"); 1829 + } 1858 1830 1859 1831 rdev->preferred_minor = 0xffff; 1860 1832 rdev->data_offset = le64_to_cpu(sb->data_offset); ··· 1999 1963 mddev->layout = le32_to_cpu(sb->layout); 2000 1964 mddev->raid_disks = le32_to_cpu(sb->raid_disks); 2001 1965 mddev->dev_sectors = le64_to_cpu(sb->size); 1966 + mddev->logical_block_size = le32_to_cpu(sb->logical_block_size); 2002 1967 mddev->events = ev1; 2003 1968 mddev->bitmap_info.offset = 0; 2004 1969 mddev->bitmap_info.space = 0; ··· 2209 2172 sb->chunksize = cpu_to_le32(mddev->chunk_sectors); 2210 2173 sb->level = cpu_to_le32(mddev->level); 2211 2174 sb->layout = cpu_to_le32(mddev->layout); 2175 + sb->logical_block_size = cpu_to_le32(mddev->logical_block_size); 2212 2176 if (test_bit(FailFast, &rdev->flags)) 2213 2177 sb->devflags |= FailFast1; 2214 2178 else ··· 5172 5134 * Thread might be blocked waiting for metadata update which will now 5173 5135 * never happen 5174 5136 */ 5175 - md_wakeup_thread_directly(mddev->sync_thread); 5137 + md_wakeup_thread_directly(&mddev->sync_thread); 5176 5138 if (work_pending(&mddev->sync_work)) 5177 5139 flush_work(&mddev->sync_work); 5178 5140 ··· 5938 5900 __ATTR(serialize_policy, S_IRUGO | S_IWUSR, serialize_policy_show, 5939 5901 serialize_policy_store); 5940 5902 5903 + static int mddev_set_logical_block_size(struct mddev *mddev, 5904 + unsigned int lbs) 5905 + { 5906 + int err = 0; 5907 + struct queue_limits lim; 5908 + 5909 + if (queue_logical_block_size(mddev->gendisk->queue) >= lbs) { 5910 + pr_err("%s: Cannot set LBS smaller than mddev LBS %u\n", 5911 + mdname(mddev), lbs); 5912 + return -EINVAL; 5913 + } 5914 + 5915 + lim = queue_limits_start_update(mddev->gendisk->queue); 5916 + lim.logical_block_size = lbs; 5917 + pr_info("%s: logical_block_size is changed, data may be lost\n", 5918 + mdname(mddev)); 5919 + err = queue_limits_commit_update(mddev->gendisk->queue, &lim); 5920 + if (err) 5921 + return err; 5922 + 5923 + mddev->logical_block_size = lbs; 5924 + /* New lbs will be written to superblock after array is running */ 5925 + set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags); 5926 + return 0; 5927 + } 5928 + 5929 + static ssize_t 5930 + lbs_show(struct mddev *mddev, char *page) 5931 + { 5932 + return sprintf(page, "%u\n", mddev->logical_block_size); 5933 + } 5934 + 5935 + static ssize_t 5936 + lbs_store(struct mddev *mddev, const char *buf, size_t len) 5937 + { 5938 + unsigned int lbs; 5939 + int err = -EBUSY; 5940 + 5941 + /* Only 1.x meta supports configurable LBS */ 5942 + if (mddev->major_version == 0) 5943 + return -EINVAL; 5944 + 5945 + if (mddev->pers) 5946 + return -EBUSY; 5947 + 5948 + err = kstrtouint(buf, 10, &lbs); 5949 + if (err < 0) 5950 + return -EINVAL; 5951 + 5952 + err = mddev_lock(mddev); 5953 + if (err) 5954 + goto unlock; 5955 + 5956 + err = mddev_set_logical_block_size(mddev, lbs); 5957 + 5958 + unlock: 5959 + mddev_unlock(mddev); 5960 + return err ?: len; 5961 + } 5962 + 5963 + static struct md_sysfs_entry md_logical_block_size = 5964 + __ATTR(logical_block_size, 0644, lbs_show, lbs_store); 5941 5965 5942 5966 static struct attribute *md_default_attrs[] = { 5943 5967 &md_level.attr, ··· 6022 5922 &md_consistency_policy.attr, 6023 5923 &md_fail_last_dev.attr, 6024 5924 &md_serialize_policy.attr, 5925 + &md_logical_block_size.attr, 6025 5926 NULL, 6026 5927 }; 6027 5928 ··· 6153 6052 return -EINVAL; 6154 6053 } 6155 6054 6055 + /* 6056 + * Before RAID adding folio support, the logical_block_size 6057 + * should be smaller than the page size. 6058 + */ 6059 + if (lim->logical_block_size > PAGE_SIZE) { 6060 + pr_err("%s: logical_block_size must not larger than PAGE_SIZE\n", 6061 + mdname(mddev)); 6062 + return -EINVAL; 6063 + } 6064 + mddev->logical_block_size = lim->logical_block_size; 6065 + 6156 6066 return 0; 6157 6067 } 6158 6068 EXPORT_SYMBOL_GPL(mddev_stack_rdev_limits); ··· 6175 6063 6176 6064 if (mddev_is_dm(mddev)) 6177 6065 return 0; 6066 + 6067 + if (queue_logical_block_size(rdev->bdev->bd_disk->queue) > 6068 + queue_logical_block_size(mddev->gendisk->queue)) { 6069 + pr_err("%s: incompatible logical_block_size, can not add\n", 6070 + mdname(mddev)); 6071 + return -EINVAL; 6072 + } 6178 6073 6179 6074 lim = queue_limits_start_update(mddev->gendisk->queue); 6180 6075 queue_limits_stack_bdev(&lim, rdev->bdev, rdev->data_offset, ··· 6503 6384 nowait = nowait && bdev_nowait(rdev->bdev); 6504 6385 } 6505 6386 6506 - if (!bioset_initialized(&mddev->bio_set)) { 6507 - err = bioset_init(&mddev->bio_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS); 6508 - if (err) 6509 - return err; 6510 - } 6511 - if (!bioset_initialized(&mddev->sync_set)) { 6512 - err = bioset_init(&mddev->sync_set, BIO_POOL_SIZE, 0, BIOSET_NEED_BVECS); 6513 - if (err) 6514 - goto exit_bio_set; 6515 - } 6516 - 6517 - if (!bioset_initialized(&mddev->io_clone_set)) { 6518 - err = bioset_init(&mddev->io_clone_set, BIO_POOL_SIZE, 6519 - offsetof(struct md_io_clone, bio_clone), 0); 6520 - if (err) 6521 - goto exit_sync_set; 6522 - } 6523 - 6524 6387 pers = get_pers(mddev->level, mddev->clevel); 6525 - if (!pers) { 6526 - err = -EINVAL; 6527 - goto abort; 6528 - } 6388 + if (!pers) 6389 + return -EINVAL; 6529 6390 if (mddev->level != pers->head.id) { 6530 6391 mddev->level = pers->head.id; 6531 6392 mddev->new_level = pers->head.id; ··· 6516 6417 pers->start_reshape == NULL) { 6517 6418 /* This personality cannot handle reshaping... */ 6518 6419 put_pers(pers); 6519 - err = -EINVAL; 6520 - goto abort; 6420 + return -EINVAL; 6521 6421 } 6522 6422 6523 6423 if (pers->sync_request) { ··· 6643 6545 mddev->private = NULL; 6644 6546 put_pers(pers); 6645 6547 md_bitmap_destroy(mddev); 6646 - abort: 6647 - bioset_exit(&mddev->io_clone_set); 6648 - exit_sync_set: 6649 - bioset_exit(&mddev->sync_set); 6650 - exit_bio_set: 6651 - bioset_exit(&mddev->bio_set); 6652 6548 return err; 6653 6549 } 6654 6550 EXPORT_SYMBOL_GPL(md_run); ··· 6775 6683 mddev->chunk_sectors = 0; 6776 6684 mddev->ctime = mddev->utime = 0; 6777 6685 mddev->layout = 0; 6686 + mddev->logical_block_size = 0; 6778 6687 mddev->max_disks = 0; 6779 6688 mddev->events = 0; 6780 6689 mddev->can_decrease_events = 0; ··· 6868 6775 mddev->private = NULL; 6869 6776 put_pers(pers); 6870 6777 clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery); 6871 - 6872 - bioset_exit(&mddev->bio_set); 6873 - bioset_exit(&mddev->sync_set); 6874 - bioset_exit(&mddev->io_clone_set); 6875 6778 } 6876 6779 6877 6780 void md_stop(struct mddev *mddev) ··· 6957 6868 if (mddev->pers) { 6958 6869 if (!md_is_rdwr(mddev)) 6959 6870 set_disk_ro(disk, 0); 6871 + 6872 + if (mode == 2 && mddev->pers->sync_request && 6873 + mddev->to_remove == NULL) 6874 + mddev->to_remove = &md_redundancy_group; 6960 6875 6961 6876 __md_stop_writes(mddev); 6962 6877 __md_stop(mddev); ··· 8466 8373 return 0; 8467 8374 } 8468 8375 8469 - static void md_wakeup_thread_directly(struct md_thread __rcu *thread) 8376 + static void md_wakeup_thread_directly(struct md_thread __rcu **thread) 8470 8377 { 8471 8378 struct md_thread *t; 8472 8379 8473 8380 rcu_read_lock(); 8474 - t = rcu_dereference(thread); 8381 + t = rcu_dereference(*thread); 8475 8382 if (t) 8476 8383 wake_up_process(t->tsk); 8477 8384 rcu_read_unlock(); 8478 8385 } 8479 8386 8480 - void md_wakeup_thread(struct md_thread __rcu *thread) 8387 + void __md_wakeup_thread(struct md_thread __rcu *thread) 8481 8388 { 8482 8389 struct md_thread *t; 8483 8390 8484 - rcu_read_lock(); 8485 8391 t = rcu_dereference(thread); 8486 8392 if (t) { 8487 8393 pr_debug("md: waking up MD thread %s.\n", t->tsk->comm); ··· 8488 8396 if (wq_has_sleeper(&t->wqueue)) 8489 8397 wake_up(&t->wqueue); 8490 8398 } 8491 - rcu_read_unlock(); 8492 8399 } 8493 - EXPORT_SYMBOL(md_wakeup_thread); 8400 + EXPORT_SYMBOL(__md_wakeup_thread); 8494 8401 8495 8402 struct md_thread *md_register_thread(void (*run) (struct md_thread *), 8496 8403 struct mddev *mddev, const char *name) ··· 10069 9978 md_reap_sync_thread(mddev); 10070 9979 } 10071 9980 9981 + static bool md_should_do_recovery(struct mddev *mddev) 9982 + { 9983 + /* 9984 + * As long as one of the following flags is set, 9985 + * recovery needs to do or cleanup. 9986 + */ 9987 + if (test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) || 9988 + test_bit(MD_RECOVERY_DONE, &mddev->recovery)) 9989 + return true; 9990 + 9991 + /* 9992 + * If no flags are set and it is in read-only status, 9993 + * there is nothing to do. 9994 + */ 9995 + if (!md_is_rdwr(mddev)) 9996 + return false; 9997 + 9998 + /* 9999 + * MD_SB_CHANGE_PENDING indicates that the array is switching from clean to 10000 + * active, and no action is needed for now. 10001 + * All other MD_SB_* flags require to update the superblock. 10002 + */ 10003 + if (mddev->sb_flags & ~ (1<<MD_SB_CHANGE_PENDING)) 10004 + return true; 10005 + 10006 + /* 10007 + * If the array is not using external metadata and there has been no data 10008 + * written for some time, then the array's status needs to be set to 10009 + * in_sync. 10010 + */ 10011 + if (mddev->external == 0 && mddev->safemode == 1) 10012 + return true; 10013 + 10014 + /* 10015 + * When the system is about to restart or the process receives an signal, 10016 + * the array needs to be synchronized as soon as possible. 10017 + * Once the data synchronization is completed, need to change the array 10018 + * status to in_sync. 10019 + */ 10020 + if (mddev->safemode == 2 && !mddev->in_sync && 10021 + mddev->resync_offset == MaxSector) 10022 + return true; 10023 + 10024 + return false; 10025 + } 10026 + 10072 10027 /* 10073 10028 * This routine is regularly called by all per-raid-array threads to 10074 10029 * deal with generic issues like resync and super-block update. ··· 10151 10014 flush_signals(current); 10152 10015 } 10153 10016 10154 - if (!md_is_rdwr(mddev) && 10155 - !test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) && 10156 - !test_bit(MD_RECOVERY_DONE, &mddev->recovery)) 10157 - return; 10158 - if ( ! ( 10159 - (mddev->sb_flags & ~ (1<<MD_SB_CHANGE_PENDING)) || 10160 - test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) || 10161 - test_bit(MD_RECOVERY_DONE, &mddev->recovery) || 10162 - (mddev->external == 0 && mddev->safemode == 1) || 10163 - (mddev->safemode == 2 10164 - && !mddev->in_sync && mddev->resync_offset == MaxSector) 10165 - )) 10017 + if (!md_should_do_recovery(mddev)) 10166 10018 return; 10167 10019 10168 10020 if (mddev_trylock(mddev)) { ··· 10823 10697 module_param_call(new_array, add_named_array, NULL, NULL, S_IWUSR); 10824 10698 module_param(create_on_open, bool, S_IRUSR|S_IWUSR); 10825 10699 module_param(legacy_async_del_gendisk, bool, 0600); 10700 + module_param(check_new_feature, bool, 0600); 10826 10701 10827 10702 MODULE_LICENSE("GPL"); 10828 10703 MODULE_DESCRIPTION("MD RAID framework");

+9 -1

drivers/md/md.h

··· 354 354 MD_HAS_MULTIPLE_PPLS, 355 355 MD_NOT_READY, 356 356 MD_BROKEN, 357 + MD_DO_DELETE, 357 358 MD_DELETED, 358 359 }; 359 360 ··· 433 432 sector_t array_sectors; /* exported array size */ 434 433 int external_size; /* size managed 435 434 * externally */ 435 + unsigned int logical_block_size; 436 436 __u64 events; 437 437 /* If the last 'event' was simply a clean->dirty transition, and 438 438 * we didn't write it to the spares, then it is safe and simple ··· 884 882 885 883 #define THREAD_WAKEUP 0 886 884 885 + #define md_wakeup_thread(thread) do { \ 886 + rcu_read_lock(); \ 887 + __md_wakeup_thread(thread); \ 888 + rcu_read_unlock(); \ 889 + } while (0) 890 + 887 891 static inline void safe_put_page(struct page *p) 888 892 { 889 893 if (p) put_page(p); ··· 903 895 struct mddev *mddev, 904 896 const char *name); 905 897 extern void md_unregister_thread(struct mddev *mddev, struct md_thread __rcu **threadp); 906 - extern void md_wakeup_thread(struct md_thread __rcu *thread); 898 + extern void __md_wakeup_thread(struct md_thread __rcu *thread); 907 899 extern void md_check_recovery(struct mddev *mddev); 908 900 extern void md_reap_sync_thread(struct mddev *mddev); 909 901 extern enum sync_action md_sync_action(struct mddev *mddev);

+8 -9

drivers/md/raid0.c

··· 68 68 struct strip_zone *zone; 69 69 int cnt; 70 70 struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL); 71 - unsigned blksize = 512; 71 + unsigned int blksize = queue_logical_block_size(mddev->gendisk->queue); 72 72 73 73 *private_conf = ERR_PTR(-ENOMEM); 74 74 if (!conf) ··· 83 83 sectors = rdev1->sectors; 84 84 sector_div(sectors, mddev->chunk_sectors); 85 85 rdev1->sectors = sectors * mddev->chunk_sectors; 86 - 87 - blksize = max(blksize, queue_logical_block_size( 88 - rdev1->bdev->bd_disk->queue)); 89 86 90 87 rdev_for_each(rdev2, mddev) { 91 88 pr_debug("md/raid0:%s: comparing %pg(%llu)" ··· 380 383 lim.max_hw_sectors = mddev->chunk_sectors; 381 384 lim.max_write_zeroes_sectors = mddev->chunk_sectors; 382 385 lim.max_hw_wzeroes_unmap_sectors = mddev->chunk_sectors; 386 + lim.logical_block_size = mddev->logical_block_size; 383 387 lim.io_min = mddev->chunk_sectors << 9; 384 388 lim.io_opt = lim.io_min * mddev->raid_disks; 385 389 lim.chunk_sectors = mddev->chunk_sectors; ··· 403 405 if (md_check_no_bitmap(mddev)) 404 406 return -EINVAL; 405 407 408 + if (!mddev_is_dm(mddev)) { 409 + ret = raid0_set_limits(mddev); 410 + if (ret) 411 + return ret; 412 + } 413 + 406 414 /* if private is not null, we are here after takeover */ 407 415 if (mddev->private == NULL) { 408 416 ret = create_strip_zones(mddev, &conf); ··· 417 413 mddev->private = conf; 418 414 } 419 415 conf = mddev->private; 420 - if (!mddev_is_dm(mddev)) { 421 - ret = raid0_set_limits(mddev); 422 - if (ret) 423 - return ret; 424 - } 425 416 426 417 /* calculate array device size */ 427 418 md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));

+1

drivers/md/raid1.c

··· 3213 3213 md_init_stacking_limits(&lim); 3214 3214 lim.max_write_zeroes_sectors = 0; 3215 3215 lim.max_hw_wzeroes_unmap_sectors = 0; 3216 + lim.logical_block_size = mddev->logical_block_size; 3216 3217 lim.features |= BLK_FEAT_ATOMIC_WRITES; 3217 3218 err = mddev_stack_rdev_limits(mddev, &lim, MDDEV_STACK_INTEGRITY); 3218 3219 if (err)

+1

drivers/md/raid10.c

··· 4000 4000 md_init_stacking_limits(&lim); 4001 4001 lim.max_write_zeroes_sectors = 0; 4002 4002 lim.max_hw_wzeroes_unmap_sectors = 0; 4003 + lim.logical_block_size = mddev->logical_block_size; 4003 4004 lim.io_min = mddev->chunk_sectors << 9; 4004 4005 lim.chunk_sectors = mddev->chunk_sectors; 4005 4006 lim.io_opt = lim.io_min * raid10_nr_stripes(conf);

+1 -1

drivers/md/raid5-cache.c

··· 3104 3104 goto out_mempool; 3105 3105 3106 3106 spin_lock_init(&log->tree_lock); 3107 - INIT_RADIX_TREE(&log->big_stripe_tree, GFP_NOWAIT | __GFP_NOWARN); 3107 + INIT_RADIX_TREE(&log->big_stripe_tree, GFP_NOWAIT); 3108 3108 3109 3109 thread = md_register_thread(r5l_reclaim_thread, log->rdev->mddev, 3110 3110 "reclaim");

+1

drivers/md/raid5.c

··· 7745 7745 stripe = roundup_pow_of_two(data_disks * (mddev->chunk_sectors << 9)); 7746 7746 7747 7747 md_init_stacking_limits(&lim); 7748 + lim.logical_block_size = mddev->logical_block_size; 7748 7749 lim.io_min = mddev->chunk_sectors << 9; 7749 7750 lim.io_opt = lim.io_min * (conf->raid_disks - conf->max_degraded); 7750 7751 lim.features |= BLK_FEAT_RAID_PARTIAL_STRIPES_EXPENSIVE;

+2 -1

include/uapi/linux/raid/md_p.h

··· 291 291 __le64 resync_offset; /* data before this offset (from data_offset) known to be in sync */ 292 292 __le32 sb_csum; /* checksum up to devs[max_dev] */ 293 293 __le32 max_dev; /* size of devs[] array to consider */ 294 - __u8 pad3[64-32]; /* set to 0 when writing */ 294 + __le32 logical_block_size; /* same as q->limits->logical_block_size */ 295 + __u8 pad3[64-36]; /* set to 0 when writing */ 295 296 296 297 /* device state information. Indexed by dev_number. 297 298 * 2 bytes per device

Configure Feed

Configure Feed