Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'md-6.8-20240216' of https://git.kernel.org/pub/scm/linux/kernel/git/song/md into block-6.8
Pull MD fixes from Song:
"1. Fix issues reported for dm-raid [1], by Yu Kuai. Please note that
this PR only contains the first half of the set [2]. We still need
more fixes in dm and md code (the rest of the set, or alternative
fixes).
2. Fix active_io leak, by Yu Kuai. The fix was posted in the same set
[2]. But it actually fixes a separate issue [3].
[1] https://lore.kernel.org/linux-raid/e5e8afe2-e9a8-49a2-5ab0-958d4065c55e@redhat.com/
[2] https://lore.kernel.org/linux-raid/20240201092559.910982-1-yukuai1@huaweicloud.com/
[3] https://lore.kernel.org/linux-raid/20240130172524.0000417b@linux.intel.com/ "
* tag 'md-6.8-20240216' of https://git.kernel.org/pub/scm/linux/kernel/git/song/md:
md: Don't suspend the array for interrupted reshape
md: Don't register sync_thread for reshape directly
md: Make sure md_do_sync() will set MD_RECOVERY_DONE
md: Don't ignore read-only array in md_check_recovery()
md: Don't ignore suspended array in md_check_recovery()
md: Fix missing release of 'active_io' for flush
+48
-67
+44
-26
drivers/md/md.c
+44
-26
drivers/md/md.c
···
579
579
rcu_read_lock();
580
580
}
581
581
rcu_read_unlock();
582
-
if (atomic_dec_and_test(&mddev->flush_pending))
582
+
if (atomic_dec_and_test(&mddev->flush_pending)) {
583
+
/* The pair is percpu_ref_get() from md_flush_request() */
584
+
percpu_ref_put(&mddev->active_io);
585
+
583
586
queue_work(md_wq, &mddev->flush_work);
587
+
}
584
588
}
585
589
586
590
static void md_submit_flush_data(struct work_struct *ws)
···
8792
8788
int ret;
8793
8789
8794
8790
/* just incase thread restarts... */
8795
-
if (test_bit(MD_RECOVERY_DONE, &mddev->recovery) ||
8796
-
test_bit(MD_RECOVERY_WAIT, &mddev->recovery))
8791
+
if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
8797
8792
return;
8798
-
if (!md_is_rdwr(mddev)) {/* never try to sync a read-only array */
8793
+
8794
+
if (test_bit(MD_RECOVERY_INTR, &mddev->recovery))
8795
+
goto skip;
8796
+
8797
+
if (test_bit(MD_RECOVERY_WAIT, &mddev->recovery) ||
8798
+
!md_is_rdwr(mddev)) {/* never try to sync a read-only array */
8799
8799
set_bit(MD_RECOVERY_INTR, &mddev->recovery);
8800
-
return;
8800
+
goto skip;
8801
8801
}
8802
8802
8803
8803
if (mddev_is_clustered(mddev)) {
···
9376
9368
struct mddev *mddev = container_of(ws, struct mddev, sync_work);
9377
9369
int spares = 0;
9378
9370
bool suspend = false;
9371
+
char *name;
9379
9372
9380
-
if (md_spares_need_change(mddev))
9373
+
/*
9374
+
* If reshape is still in progress, spares won't be added or removed
9375
+
* from conf until reshape is done.
9376
+
*/
9377
+
if (mddev->reshape_position == MaxSector &&
9378
+
md_spares_need_change(mddev)) {
9381
9379
suspend = true;
9380
+
mddev_suspend(mddev, false);
9381
+
}
9382
9382
9383
-
suspend ? mddev_suspend_and_lock_nointr(mddev) :
9384
-
mddev_lock_nointr(mddev);
9385
-
9383
+
mddev_lock_nointr(mddev);
9386
9384
if (!md_is_rdwr(mddev)) {
9387
9385
/*
9388
9386
* On a read-only array we can:
···
9414
9400
if (spares)
9415
9401
md_bitmap_write_all(mddev->bitmap);
9416
9402
9403
+
name = test_bit(MD_RECOVERY_RESHAPE, &mddev->recovery) ?
9404
+
"reshape" : "resync";
9417
9405
rcu_assign_pointer(mddev->sync_thread,
9418
-
md_register_thread(md_do_sync, mddev, "resync"));
9406
+
md_register_thread(md_do_sync, mddev, name));
9419
9407
if (!mddev->sync_thread) {
9420
9408
pr_warn("%s: could not start resync thread...\n",
9421
9409
mdname(mddev));
···
9461
9445
sysfs_notify_dirent_safe(mddev->sysfs_action);
9462
9446
}
9463
9447
9448
+
static void unregister_sync_thread(struct mddev *mddev)
9449
+
{
9450
+
if (!test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
9451
+
/* resync/recovery still happening */
9452
+
clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9453
+
return;
9454
+
}
9455
+
9456
+
if (WARN_ON_ONCE(!mddev->sync_thread))
9457
+
return;
9458
+
9459
+
md_reap_sync_thread(mddev);
9460
+
}
9461
+
9464
9462
/*
9465
9463
* This routine is regularly called by all per-raid-array threads to
9466
9464
* deal with generic issues like resync and super-block update.
···
9499
9469
*/
9500
9470
void md_check_recovery(struct mddev *mddev)
9501
9471
{
9502
-
if (READ_ONCE(mddev->suspended))
9503
-
return;
9504
-
9505
9472
if (mddev->bitmap)
9506
9473
md_bitmap_daemon_work(mddev);
9507
9474
···
9512
9485
}
9513
9486
9514
9487
if (!md_is_rdwr(mddev) &&
9515
-
!test_bit(MD_RECOVERY_NEEDED, &mddev->recovery))
9488
+
!test_bit(MD_RECOVERY_NEEDED, &mddev->recovery) &&
9489
+
!test_bit(MD_RECOVERY_DONE, &mddev->recovery))
9516
9490
return;
9517
9491
if ( ! (
9518
9492
(mddev->sb_flags & ~ (1<<MD_SB_CHANGE_PENDING)) ||
···
9535
9507
struct md_rdev *rdev;
9536
9508
9537
9509
if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
9538
-
/* sync_work already queued. */
9539
-
clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9510
+
unregister_sync_thread(mddev);
9540
9511
goto unlock;
9541
9512
}
9542
9513
···
9598
9571
* still set.
9599
9572
*/
9600
9573
if (test_bit(MD_RECOVERY_RUNNING, &mddev->recovery)) {
9601
-
if (!test_bit(MD_RECOVERY_DONE, &mddev->recovery)) {
9602
-
/* resync/recovery still happening */
9603
-
clear_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
9604
-
goto unlock;
9605
-
}
9606
-
9607
-
if (WARN_ON_ONCE(!mddev->sync_thread))
9608
-
goto unlock;
9609
-
9610
-
md_reap_sync_thread(mddev);
9574
+
unregister_sync_thread(mddev);
9611
9575
goto unlock;
9612
9576
}
9613
9577
+2
-14
drivers/md/raid10.c
+2
-14
drivers/md/raid10.c
···
4175
4175
clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
4176
4176
clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4177
4177
set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
4178
-
set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
4179
-
rcu_assign_pointer(mddev->sync_thread,
4180
-
md_register_thread(md_do_sync, mddev, "reshape"));
4181
-
if (!mddev->sync_thread)
4182
-
goto out_free_conf;
4178
+
set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4183
4179
}
4184
4180
4185
4181
return 0;
···
4569
4573
clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
4570
4574
clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
4571
4575
set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
4572
-
set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
4573
-
4574
-
rcu_assign_pointer(mddev->sync_thread,
4575
-
md_register_thread(md_do_sync, mddev, "reshape"));
4576
-
if (!mddev->sync_thread) {
4577
-
ret = -EAGAIN;
4578
-
goto abort;
4579
-
}
4576
+
set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
4580
4577
conf->reshape_checkpoint = jiffies;
4581
-
md_wakeup_thread(mddev->sync_thread);
4582
4578
md_new_event();
4583
4579
return 0;
4584
4580
+2
-27
drivers/md/raid5.c
+2
-27
drivers/md/raid5.c
···
7936
7936
clear_bit(MD_RECOVERY_SYNC, &mddev->recovery);
7937
7937
clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
7938
7938
set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
7939
-
set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
7940
-
rcu_assign_pointer(mddev->sync_thread,
7941
-
md_register_thread(md_do_sync, mddev, "reshape"));
7942
-
if (!mddev->sync_thread)
7943
-
goto abort;
7939
+
set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
7944
7940
}
7945
7941
7946
7942
/* Ok, everything is just fine now */
···
8502
8506
clear_bit(MD_RECOVERY_CHECK, &mddev->recovery);
8503
8507
clear_bit(MD_RECOVERY_DONE, &mddev->recovery);
8504
8508
set_bit(MD_RECOVERY_RESHAPE, &mddev->recovery);
8505
-
set_bit(MD_RECOVERY_RUNNING, &mddev->recovery);
8506
-
rcu_assign_pointer(mddev->sync_thread,
8507
-
md_register_thread(md_do_sync, mddev, "reshape"));
8508
-
if (!mddev->sync_thread) {
8509
-
mddev->recovery = 0;
8510
-
spin_lock_irq(&conf->device_lock);
8511
-
write_seqcount_begin(&conf->gen_lock);
8512
-
mddev->raid_disks = conf->raid_disks = conf->previous_raid_disks;
8513
-
mddev->new_chunk_sectors =
8514
-
conf->chunk_sectors = conf->prev_chunk_sectors;
8515
-
mddev->new_layout = conf->algorithm = conf->prev_algo;
8516
-
rdev_for_each(rdev, mddev)
8517
-
rdev->new_data_offset = rdev->data_offset;
8518
-
smp_wmb();
8519
-
conf->generation --;
8520
-
conf->reshape_progress = MaxSector;
8521
-
mddev->reshape_position = MaxSector;
8522
-
write_seqcount_end(&conf->gen_lock);
8523
-
spin_unlock_irq(&conf->device_lock);
8524
-
return -EAGAIN;
8525
-
}
8509
+
set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
8526
8510
conf->reshape_checkpoint = jiffies;
8527
-
md_wakeup_thread(mddev->sync_thread);
8528
8511
md_new_event();
8529
8512
return 0;
8530
8513
}