Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'md-next-20231208' of https://git.kernel.org/pub/scm/linux/kernel/git/song/md into for-6.8/block
Pull MD updates from Song:
"1. Fix/Cleanup RCU usage from conf->disks[i].rdev, by Yu Kuai;
2. Fix raid5 hang issue, by Junxiao Bi;
3. Add Yu Kuai as Reviewer of the md subsystem."
* tag 'md-next-20231208' of https://git.kernel.org/pub/scm/linux/kernel/git/song/md:
md: synchronize flush io with array reconfiguration
MAINTAINERS: SOFTWARE RAID: Add Yu Kuai as Reviewer
md/md-multipath: remove rcu protection to access rdev from conf
md/raid5: remove rcu protection to access rdev from conf
md/raid1: remove rcu protection to access rdev from conf
md/raid10: remove rcu protection to access rdev from conf
md: remove flag RemoveSynchronized
Revert "md/raid5: Wait for MD_SB_CHANGE_PENDING in raid5d"
md: bypass block throttle for superblock update
+189
-442
+1
MAINTAINERS
+1
MAINTAINERS
+12
-20
drivers/md/md-multipath.c
+12
-20
drivers/md/md-multipath.c
···
32
32
* now we use the first available disk.
33
33
*/
34
34
35
-
rcu_read_lock();
36
35
for (i = 0; i < disks; i++) {
37
-
struct md_rdev *rdev = rcu_dereference(conf->multipaths[i].rdev);
36
+
struct md_rdev *rdev = conf->multipaths[i].rdev;
37
+
38
38
if (rdev && test_bit(In_sync, &rdev->flags) &&
39
39
!test_bit(Faulty, &rdev->flags)) {
40
40
atomic_inc(&rdev->nr_pending);
41
-
rcu_read_unlock();
42
41
return i;
43
42
}
44
43
}
45
-
rcu_read_unlock();
46
44
47
45
pr_crit_ratelimited("multipath_map(): no more operational IO paths?\n");
48
46
return (-1);
···
135
137
struct mpconf *conf = mddev->private;
136
138
int i;
137
139
140
+
lockdep_assert_held(&mddev->lock);
141
+
138
142
seq_printf (seq, " [%d/%d] [", conf->raid_disks,
139
143
conf->raid_disks - mddev->degraded);
140
-
rcu_read_lock();
141
144
for (i = 0; i < conf->raid_disks; i++) {
142
-
struct md_rdev *rdev = rcu_dereference(conf->multipaths[i].rdev);
143
-
seq_printf (seq, "%s", rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
145
+
struct md_rdev *rdev = READ_ONCE(conf->multipaths[i].rdev);
146
+
147
+
seq_printf(seq, "%s",
148
+
rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
144
149
}
145
-
rcu_read_unlock();
146
150
seq_putc(seq, ']');
147
151
}
148
152
···
182
182
conf->raid_disks - mddev->degraded);
183
183
}
184
184
185
-
static void print_multipath_conf (struct mpconf *conf)
185
+
static void print_multipath_conf(struct mpconf *conf)
186
186
{
187
187
int i;
188
188
struct multipath_info *tmp;
···
195
195
pr_debug(" --- wd:%d rd:%d\n", conf->raid_disks - conf->mddev->degraded,
196
196
conf->raid_disks);
197
197
198
+
lockdep_assert_held(&conf->mddev->reconfig_mutex);
198
199
for (i = 0; i < conf->raid_disks; i++) {
199
200
tmp = conf->multipaths + i;
200
201
if (tmp->rdev)
···
232
231
rdev->raid_disk = path;
233
232
set_bit(In_sync, &rdev->flags);
234
233
spin_unlock_irq(&conf->device_lock);
235
-
rcu_assign_pointer(p->rdev, rdev);
234
+
WRITE_ONCE(p->rdev, rdev);
236
235
err = 0;
237
236
break;
238
237
}
···
258
257
err = -EBUSY;
259
258
goto abort;
260
259
}
261
-
p->rdev = NULL;
262
-
if (!test_bit(RemoveSynchronized, &rdev->flags)) {
263
-
synchronize_rcu();
264
-
if (atomic_read(&rdev->nr_pending)) {
265
-
/* lost the race, try later */
266
-
err = -EBUSY;
267
-
p->rdev = rdev;
268
-
goto abort;
269
-
}
270
-
}
260
+
WRITE_ONCE(p->rdev, NULL);
271
261
err = md_integrity_register(mddev);
272
262
}
273
263
abort:
+26
-40
drivers/md/md.c
+26
-40
drivers/md/md.c
···
529
529
rdev_dec_pending(rdev, mddev);
530
530
531
531
if (atomic_dec_and_test(&mddev->flush_pending)) {
532
+
/* The pair is percpu_ref_get() from md_flush_request() */
533
+
percpu_ref_put(&mddev->active_io);
534
+
532
535
/* The pre-request flush has finished */
533
536
queue_work(md_wq, &mddev->flush_work);
534
537
}
···
551
548
rdev_for_each_rcu(rdev, mddev)
552
549
if (rdev->raid_disk >= 0 &&
553
550
!test_bit(Faulty, &rdev->flags)) {
554
-
/* Take two references, one is dropped
555
-
* when request finishes, one after
556
-
* we reclaim rcu_read_lock
557
-
*/
558
551
struct bio *bi;
559
-
atomic_inc(&rdev->nr_pending);
552
+
560
553
atomic_inc(&rdev->nr_pending);
561
554
rcu_read_unlock();
562
555
bi = bio_alloc_bioset(rdev->bdev, 0,
···
563
564
atomic_inc(&mddev->flush_pending);
564
565
submit_bio(bi);
565
566
rcu_read_lock();
566
-
rdev_dec_pending(rdev, mddev);
567
567
}
568
568
rcu_read_unlock();
569
569
if (atomic_dec_and_test(&mddev->flush_pending))
···
615
617
/* new request after previous flush is completed */
616
618
if (ktime_after(req_start, mddev->prev_flush_start)) {
617
619
WARN_ON(mddev->flush_bio);
620
+
/*
621
+
* Grab a reference to make sure mddev_suspend() will wait for
622
+
* this flush to be done.
623
+
*
624
+
* md_flush_reqeust() is called under md_handle_request() and
625
+
* 'active_io' is already grabbed, hence percpu_ref_is_zero()
626
+
* won't pass, percpu_ref_tryget_live() can't be used because
627
+
* percpu_ref_kill() can be called by mddev_suspend()
628
+
* concurrently.
629
+
*/
630
+
WARN_ON(percpu_ref_is_zero(&mddev->active_io));
631
+
percpu_ref_get(&mddev->active_io);
618
632
mddev->flush_bio = bio;
619
633
bio = NULL;
620
634
}
···
1023
1013
return;
1024
1014
1025
1015
bio = bio_alloc_bioset(rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev,
1026
-
1,
1027
-
REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH | REQ_FUA,
1028
-
GFP_NOIO, &mddev->sync_set);
1016
+
1,
1017
+
REQ_OP_WRITE | REQ_SYNC | REQ_IDLE | REQ_META
1018
+
| REQ_PREFLUSH | REQ_FUA,
1019
+
GFP_NOIO, &mddev->sync_set);
1029
1020
1030
1021
atomic_inc(&rdev->nr_pending);
1031
1022
···
9254
9243
struct md_rdev *rdev;
9255
9244
int spares = 0;
9256
9245
int removed = 0;
9257
-
bool remove_some = false;
9258
9246
9259
9247
if (this && test_bit(MD_RECOVERY_RUNNING, &mddev->recovery))
9260
9248
/* Mustn't remove devices when resync thread is running */
9261
9249
return 0;
9262
9250
9263
9251
rdev_for_each(rdev, mddev) {
9264
-
if ((this == NULL || rdev == this) &&
9265
-
rdev->raid_disk >= 0 &&
9266
-
!test_bit(Blocked, &rdev->flags) &&
9267
-
test_bit(Faulty, &rdev->flags) &&
9268
-
atomic_read(&rdev->nr_pending)==0) {
9269
-
/* Faulty non-Blocked devices with nr_pending == 0
9270
-
* never get nr_pending incremented,
9271
-
* never get Faulty cleared, and never get Blocked set.
9272
-
* So we can synchronize_rcu now rather than once per device
9273
-
*/
9274
-
remove_some = true;
9275
-
set_bit(RemoveSynchronized, &rdev->flags);
9252
+
if ((this == NULL || rdev == this) && rdev_removeable(rdev) &&
9253
+
!mddev->pers->hot_remove_disk(mddev, rdev)) {
9254
+
sysfs_unlink_rdev(mddev, rdev);
9255
+
rdev->saved_raid_disk = rdev->raid_disk;
9256
+
rdev->raid_disk = -1;
9257
+
removed++;
9276
9258
}
9277
-
}
9278
-
9279
-
if (remove_some)
9280
-
synchronize_rcu();
9281
-
rdev_for_each(rdev, mddev) {
9282
-
if ((this == NULL || rdev == this) &&
9283
-
(test_bit(RemoveSynchronized, &rdev->flags) ||
9284
-
rdev_removeable(rdev))) {
9285
-
if (mddev->pers->hot_remove_disk(
9286
-
mddev, rdev) == 0) {
9287
-
sysfs_unlink_rdev(mddev, rdev);
9288
-
rdev->saved_raid_disk = rdev->raid_disk;
9289
-
rdev->raid_disk = -1;
9290
-
removed++;
9291
-
}
9292
-
}
9293
-
if (remove_some && test_bit(RemoveSynchronized, &rdev->flags))
9294
-
clear_bit(RemoveSynchronized, &rdev->flags);
9295
9259
}
9296
9260
9297
9261
if (removed && mddev->kobj.sd)
-5
drivers/md/md.h
-5
drivers/md/md.h
···
190
190
* than other devices in the array
191
191
*/
192
192
ClusterRemove,
193
-
RemoveSynchronized, /* synchronize_rcu() was called after
194
-
* this device was known to be faulty,
195
-
* so it is safe to remove without
196
-
* another synchronize_rcu() call.
197
-
*/
198
193
ExternalBbl, /* External metadata provides bad
199
194
* block management for a disk
200
195
*/
+23
-48
drivers/md/raid1.c
+23
-48
drivers/md/raid1.c
···
609
609
int choose_first;
610
610
int choose_next_idle;
611
611
612
-
rcu_read_lock();
613
612
/*
614
613
* Check if we can balance. We can balance on the whole
615
614
* device if no resync is going on, or below the resync window.
···
641
642
unsigned int pending;
642
643
bool nonrot;
643
644
644
-
rdev = rcu_dereference(conf->mirrors[disk].rdev);
645
+
rdev = conf->mirrors[disk].rdev;
645
646
if (r1_bio->bios[disk] == IO_BLOCKED
646
647
|| rdev == NULL
647
648
|| test_bit(Faulty, &rdev->flags))
···
772
773
}
773
774
774
775
if (best_disk >= 0) {
775
-
rdev = rcu_dereference(conf->mirrors[best_disk].rdev);
776
+
rdev = conf->mirrors[best_disk].rdev;
776
777
if (!rdev)
777
778
goto retry;
778
779
atomic_inc(&rdev->nr_pending);
···
783
784
784
785
conf->mirrors[best_disk].next_seq_sect = this_sector + sectors;
785
786
}
786
-
rcu_read_unlock();
787
787
*max_sectors = sectors;
788
788
789
789
return best_disk;
···
1233
1235
1234
1236
if (r1bio_existed) {
1235
1237
/* Need to get the block device name carefully */
1236
-
struct md_rdev *rdev;
1237
-
rcu_read_lock();
1238
-
rdev = rcu_dereference(conf->mirrors[r1_bio->read_disk].rdev);
1238
+
struct md_rdev *rdev = conf->mirrors[r1_bio->read_disk].rdev;
1239
+
1239
1240
if (rdev)
1240
1241
snprintf(b, sizeof(b), "%pg", rdev->bdev);
1241
1242
else
1242
1243
strcpy(b, "???");
1243
-
rcu_read_unlock();
1244
1244
}
1245
1245
1246
1246
/*
···
1392
1396
1393
1397
disks = conf->raid_disks * 2;
1394
1398
blocked_rdev = NULL;
1395
-
rcu_read_lock();
1396
1399
max_sectors = r1_bio->sectors;
1397
1400
for (i = 0; i < disks; i++) {
1398
-
struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
1401
+
struct md_rdev *rdev = conf->mirrors[i].rdev;
1399
1402
1400
1403
/*
1401
1404
* The write-behind io is only attempted on drives marked as
···
1460
1465
}
1461
1466
r1_bio->bios[i] = bio;
1462
1467
}
1463
-
rcu_read_unlock();
1464
1468
1465
1469
if (unlikely(blocked_rdev)) {
1466
1470
/* Wait for this device to become unblocked */
···
1611
1617
struct r1conf *conf = mddev->private;
1612
1618
int i;
1613
1619
1620
+
lockdep_assert_held(&mddev->lock);
1621
+
1614
1622
seq_printf(seq, " [%d/%d] [", conf->raid_disks,
1615
1623
conf->raid_disks - mddev->degraded);
1616
-
rcu_read_lock();
1617
1624
for (i = 0; i < conf->raid_disks; i++) {
1618
-
struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
1625
+
struct md_rdev *rdev = READ_ONCE(conf->mirrors[i].rdev);
1626
+
1619
1627
seq_printf(seq, "%s",
1620
1628
rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
1621
1629
}
1622
-
rcu_read_unlock();
1623
1630
seq_printf(seq, "]");
1624
1631
}
1625
1632
···
1686
1691
pr_debug(" --- wd:%d rd:%d\n", conf->raid_disks - conf->mddev->degraded,
1687
1692
conf->raid_disks);
1688
1693
1689
-
rcu_read_lock();
1694
+
lockdep_assert_held(&conf->mddev->reconfig_mutex);
1690
1695
for (i = 0; i < conf->raid_disks; i++) {
1691
-
struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
1696
+
struct md_rdev *rdev = conf->mirrors[i].rdev;
1692
1697
if (rdev)
1693
1698
pr_debug(" disk %d, wo:%d, o:%d, dev:%pg\n",
1694
1699
i, !test_bit(In_sync, &rdev->flags),
1695
1700
!test_bit(Faulty, &rdev->flags),
1696
1701
rdev->bdev);
1697
1702
}
1698
-
rcu_read_unlock();
1699
1703
}
1700
1704
1701
1705
static void close_sync(struct r1conf *conf)
···
1804
1810
*/
1805
1811
if (rdev->saved_raid_disk < 0)
1806
1812
conf->fullsync = 1;
1807
-
rcu_assign_pointer(p->rdev, rdev);
1813
+
WRITE_ONCE(p->rdev, rdev);
1808
1814
break;
1809
1815
}
1810
1816
if (test_bit(WantReplacement, &p->rdev->flags) &&
···
1820
1826
rdev->raid_disk = repl_slot;
1821
1827
err = 0;
1822
1828
conf->fullsync = 1;
1823
-
rcu_assign_pointer(p[conf->raid_disks].rdev, rdev);
1829
+
WRITE_ONCE(p[conf->raid_disks].rdev, rdev);
1824
1830
}
1825
1831
1826
1832
print_conf(conf);
···
1856
1862
err = -EBUSY;
1857
1863
goto abort;
1858
1864
}
1859
-
p->rdev = NULL;
1860
-
if (!test_bit(RemoveSynchronized, &rdev->flags)) {
1861
-
synchronize_rcu();
1862
-
if (atomic_read(&rdev->nr_pending)) {
1863
-
/* lost the race, try later */
1864
-
err = -EBUSY;
1865
-
p->rdev = rdev;
1866
-
goto abort;
1867
-
}
1868
-
}
1865
+
WRITE_ONCE(p->rdev, NULL);
1869
1866
if (conf->mirrors[conf->raid_disks + number].rdev) {
1870
1867
/* We just removed a device that is being replaced.
1871
1868
* Move down the replacement. We drain all IO before
···
1877
1892
goto abort;
1878
1893
}
1879
1894
clear_bit(Replacement, &repl->flags);
1880
-
p->rdev = repl;
1895
+
WRITE_ONCE(p->rdev, repl);
1881
1896
conf->mirrors[conf->raid_disks + number].rdev = NULL;
1882
1897
unfreeze_array(conf);
1883
1898
}
···
2275
2290
sector_t first_bad;
2276
2291
int bad_sectors;
2277
2292
2278
-
rcu_read_lock();
2279
-
rdev = rcu_dereference(conf->mirrors[d].rdev);
2293
+
rdev = conf->mirrors[d].rdev;
2280
2294
if (rdev &&
2281
2295
(test_bit(In_sync, &rdev->flags) ||
2282
2296
(!test_bit(Faulty, &rdev->flags) &&
···
2283
2299
is_badblock(rdev, sect, s,
2284
2300
&first_bad, &bad_sectors) == 0) {
2285
2301
atomic_inc(&rdev->nr_pending);
2286
-
rcu_read_unlock();
2287
2302
if (sync_page_io(rdev, sect, s<<9,
2288
2303
conf->tmppage, REQ_OP_READ, false))
2289
2304
success = 1;
2290
2305
rdev_dec_pending(rdev, mddev);
2291
2306
if (success)
2292
2307
break;
2293
-
} else
2294
-
rcu_read_unlock();
2308
+
}
2309
+
2295
2310
d++;
2296
2311
if (d == conf->raid_disks * 2)
2297
2312
d = 0;
···
2309
2326
if (d==0)
2310
2327
d = conf->raid_disks * 2;
2311
2328
d--;
2312
-
rcu_read_lock();
2313
-
rdev = rcu_dereference(conf->mirrors[d].rdev);
2329
+
rdev = conf->mirrors[d].rdev;
2314
2330
if (rdev &&
2315
2331
!test_bit(Faulty, &rdev->flags)) {
2316
2332
atomic_inc(&rdev->nr_pending);
2317
-
rcu_read_unlock();
2318
2333
r1_sync_page_io(rdev, sect, s,
2319
2334
conf->tmppage, WRITE);
2320
2335
rdev_dec_pending(rdev, mddev);
2321
-
} else
2322
-
rcu_read_unlock();
2336
+
}
2323
2337
}
2324
2338
d = start;
2325
2339
while (d != read_disk) {
2326
2340
if (d==0)
2327
2341
d = conf->raid_disks * 2;
2328
2342
d--;
2329
-
rcu_read_lock();
2330
-
rdev = rcu_dereference(conf->mirrors[d].rdev);
2343
+
rdev = conf->mirrors[d].rdev;
2331
2344
if (rdev &&
2332
2345
!test_bit(Faulty, &rdev->flags)) {
2333
2346
atomic_inc(&rdev->nr_pending);
2334
-
rcu_read_unlock();
2335
2347
if (r1_sync_page_io(rdev, sect, s,
2336
2348
conf->tmppage, READ)) {
2337
2349
atomic_add(s, &rdev->corrected_errors);
···
2337
2359
rdev->bdev);
2338
2360
}
2339
2361
rdev_dec_pending(rdev, mddev);
2340
-
} else
2341
-
rcu_read_unlock();
2362
+
}
2342
2363
}
2343
2364
sectors -= s;
2344
2365
sect += s;
···
2718
2741
2719
2742
r1_bio = raid1_alloc_init_r1buf(conf);
2720
2743
2721
-
rcu_read_lock();
2722
2744
/*
2723
2745
* If we get a correctably read error during resync or recovery,
2724
2746
* we might want to read from a different device. So we
···
2738
2762
struct md_rdev *rdev;
2739
2763
bio = r1_bio->bios[i];
2740
2764
2741
-
rdev = rcu_dereference(conf->mirrors[i].rdev);
2765
+
rdev = conf->mirrors[i].rdev;
2742
2766
if (rdev == NULL ||
2743
2767
test_bit(Faulty, &rdev->flags)) {
2744
2768
if (i < conf->raid_disks)
···
2796
2820
bio->bi_opf |= MD_FAILFAST;
2797
2821
}
2798
2822
}
2799
-
rcu_read_unlock();
2800
2823
if (disk < 0)
2801
2824
disk = wonly;
2802
2825
r1_bio->read_disk = disk;
+58
-164
drivers/md/raid10.c
+58
-164
drivers/md/raid10.c
···
743
743
struct geom *geo = &conf->geo;
744
744
745
745
raid10_find_phys(conf, r10_bio);
746
-
rcu_read_lock();
747
746
best_dist_slot = -1;
748
747
min_pending = UINT_MAX;
749
748
best_dist_rdev = NULL;
···
774
775
if (r10_bio->devs[slot].bio == IO_BLOCKED)
775
776
continue;
776
777
disk = r10_bio->devs[slot].devnum;
777
-
rdev = rcu_dereference(conf->mirrors[disk].replacement);
778
+
rdev = conf->mirrors[disk].replacement;
778
779
if (rdev == NULL || test_bit(Faulty, &rdev->flags) ||
779
780
r10_bio->devs[slot].addr + sectors >
780
-
rdev->recovery_offset) {
781
-
/*
782
-
* Read replacement first to prevent reading both rdev
783
-
* and replacement as NULL during replacement replace
784
-
* rdev.
785
-
*/
786
-
smp_mb();
787
-
rdev = rcu_dereference(conf->mirrors[disk].rdev);
788
-
}
781
+
rdev->recovery_offset)
782
+
rdev = conf->mirrors[disk].rdev;
789
783
if (rdev == NULL ||
790
784
test_bit(Faulty, &rdev->flags))
791
785
continue;
···
868
876
r10_bio->read_slot = slot;
869
877
} else
870
878
rdev = NULL;
871
-
rcu_read_unlock();
872
879
*max_sectors = best_good_sectors;
873
880
874
881
return rdev;
···
1189
1198
*/
1190
1199
gfp = GFP_NOIO | __GFP_HIGH;
1191
1200
1192
-
rcu_read_lock();
1193
1201
disk = r10_bio->devs[slot].devnum;
1194
-
err_rdev = rcu_dereference(conf->mirrors[disk].rdev);
1202
+
err_rdev = conf->mirrors[disk].rdev;
1195
1203
if (err_rdev)
1196
1204
snprintf(b, sizeof(b), "%pg", err_rdev->bdev);
1197
1205
else {
···
1198
1208
/* This never gets dereferenced */
1199
1209
err_rdev = r10_bio->devs[slot].rdev;
1200
1210
}
1201
-
rcu_read_unlock();
1202
1211
}
1203
1212
1204
1213
if (!regular_request_wait(mddev, conf, bio, r10_bio->sectors))
···
1268
1279
int devnum = r10_bio->devs[n_copy].devnum;
1269
1280
struct bio *mbio;
1270
1281
1271
-
if (replacement) {
1272
-
rdev = conf->mirrors[devnum].replacement;
1273
-
if (rdev == NULL) {
1274
-
/* Replacement just got moved to main 'rdev' */
1275
-
smp_mb();
1276
-
rdev = conf->mirrors[devnum].rdev;
1277
-
}
1278
-
} else
1279
-
rdev = conf->mirrors[devnum].rdev;
1282
+
rdev = replacement ? conf->mirrors[devnum].replacement :
1283
+
conf->mirrors[devnum].rdev;
1280
1284
1281
1285
mbio = bio_alloc_clone(rdev->bdev, bio, GFP_NOIO, &mddev->bio_set);
1282
1286
if (replacement)
···
1303
1321
}
1304
1322
}
1305
1323
1306
-
static struct md_rdev *dereference_rdev_and_rrdev(struct raid10_info *mirror,
1307
-
struct md_rdev **prrdev)
1308
-
{
1309
-
struct md_rdev *rdev, *rrdev;
1310
-
1311
-
rrdev = rcu_dereference(mirror->replacement);
1312
-
/*
1313
-
* Read replacement first to prevent reading both rdev and
1314
-
* replacement as NULL during replacement replace rdev.
1315
-
*/
1316
-
smp_mb();
1317
-
rdev = rcu_dereference(mirror->rdev);
1318
-
if (rdev == rrdev)
1319
-
rrdev = NULL;
1320
-
1321
-
*prrdev = rrdev;
1322
-
return rdev;
1323
-
}
1324
-
1325
1324
static void wait_blocked_dev(struct mddev *mddev, struct r10bio *r10_bio)
1326
1325
{
1327
1326
int i;
···
1311
1348
1312
1349
retry_wait:
1313
1350
blocked_rdev = NULL;
1314
-
rcu_read_lock();
1315
1351
for (i = 0; i < conf->copies; i++) {
1316
1352
struct md_rdev *rdev, *rrdev;
1317
1353
1318
-
rdev = dereference_rdev_and_rrdev(&conf->mirrors[i], &rrdev);
1354
+
rdev = conf->mirrors[i].rdev;
1355
+
rrdev = conf->mirrors[i].replacement;
1319
1356
if (rdev && unlikely(test_bit(Blocked, &rdev->flags))) {
1320
1357
atomic_inc(&rdev->nr_pending);
1321
1358
blocked_rdev = rdev;
···
1354
1391
}
1355
1392
}
1356
1393
}
1357
-
rcu_read_unlock();
1358
1394
1359
1395
if (unlikely(blocked_rdev)) {
1360
1396
/* Have to wait for this device to get unblocked, then retry */
···
1436
1474
1437
1475
wait_blocked_dev(mddev, r10_bio);
1438
1476
1439
-
rcu_read_lock();
1440
1477
max_sectors = r10_bio->sectors;
1441
1478
1442
1479
for (i = 0; i < conf->copies; i++) {
1443
1480
int d = r10_bio->devs[i].devnum;
1444
1481
struct md_rdev *rdev, *rrdev;
1445
1482
1446
-
rdev = dereference_rdev_and_rrdev(&conf->mirrors[d], &rrdev);
1483
+
rdev = conf->mirrors[d].rdev;
1484
+
rrdev = conf->mirrors[d].replacement;
1447
1485
if (rdev && (test_bit(Faulty, &rdev->flags)))
1448
1486
rdev = NULL;
1449
1487
if (rrdev && (test_bit(Faulty, &rrdev->flags)))
···
1497
1535
atomic_inc(&rrdev->nr_pending);
1498
1536
}
1499
1537
}
1500
-
rcu_read_unlock();
1501
1538
1502
1539
if (max_sectors < r10_bio->sectors)
1503
1540
r10_bio->sectors = max_sectors;
···
1586
1625
set_bit(R10BIO_Uptodate, &r10_bio->state);
1587
1626
1588
1627
dev = find_bio_disk(conf, r10_bio, bio, &slot, &repl);
1589
-
if (repl)
1590
-
rdev = conf->mirrors[dev].replacement;
1591
-
if (!rdev) {
1592
-
/*
1593
-
* raid10_remove_disk uses smp_mb to make sure rdev is set to
1594
-
* replacement before setting replacement to NULL. It can read
1595
-
* rdev first without barrier protect even replacement is NULL
1596
-
*/
1597
-
smp_rmb();
1598
-
rdev = conf->mirrors[dev].rdev;
1599
-
}
1628
+
rdev = repl ? conf->mirrors[dev].replacement :
1629
+
conf->mirrors[dev].rdev;
1600
1630
1601
1631
raid_end_discard_bio(r10_bio);
1602
1632
rdev_dec_pending(rdev, conf->mddev);
···
1737
1785
* inc refcount on their rdev. Record them by setting
1738
1786
* bios[x] to bio
1739
1787
*/
1740
-
rcu_read_lock();
1741
1788
for (disk = 0; disk < geo->raid_disks; disk++) {
1742
1789
struct md_rdev *rdev, *rrdev;
1743
1790
1744
-
rdev = dereference_rdev_and_rrdev(&conf->mirrors[disk], &rrdev);
1791
+
rdev = conf->mirrors[disk].rdev;
1792
+
rrdev = conf->mirrors[disk].replacement;
1745
1793
r10_bio->devs[disk].bio = NULL;
1746
1794
r10_bio->devs[disk].repl_bio = NULL;
1747
1795
···
1761
1809
atomic_inc(&rrdev->nr_pending);
1762
1810
}
1763
1811
}
1764
-
rcu_read_unlock();
1765
1812
1766
1813
atomic_set(&r10_bio->remaining, 1);
1767
1814
for (disk = 0; disk < geo->raid_disks; disk++) {
···
1890
1939
struct r10conf *conf = mddev->private;
1891
1940
int i;
1892
1941
1942
+
lockdep_assert_held(&mddev->lock);
1943
+
1893
1944
if (conf->geo.near_copies < conf->geo.raid_disks)
1894
1945
seq_printf(seq, " %dK chunks", mddev->chunk_sectors / 2);
1895
1946
if (conf->geo.near_copies > 1)
···
1906
1953
}
1907
1954
seq_printf(seq, " [%d/%d] [", conf->geo.raid_disks,
1908
1955
conf->geo.raid_disks - mddev->degraded);
1909
-
rcu_read_lock();
1910
1956
for (i = 0; i < conf->geo.raid_disks; i++) {
1911
-
struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
1957
+
struct md_rdev *rdev = READ_ONCE(conf->mirrors[i].rdev);
1958
+
1912
1959
seq_printf(seq, "%s", rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
1913
1960
}
1914
-
rcu_read_unlock();
1915
1961
seq_printf(seq, "]");
1916
1962
}
1917
1963
···
1932
1980
ncopies = conf->geo.near_copies;
1933
1981
}
1934
1982
1935
-
rcu_read_lock();
1936
1983
do {
1937
1984
int n = conf->copies;
1938
1985
int cnt = 0;
···
1939
1988
while (n--) {
1940
1989
struct md_rdev *rdev;
1941
1990
if (this != ignore &&
1942
-
(rdev = rcu_dereference(conf->mirrors[this].rdev)) &&
1991
+
(rdev = conf->mirrors[this].rdev) &&
1943
1992
test_bit(In_sync, &rdev->flags))
1944
1993
cnt++;
1945
1994
this = (this+1) % disks;
···
1950
1999
} while (first != 0);
1951
2000
has_enough = 1;
1952
2001
out:
1953
-
rcu_read_unlock();
1954
2002
return has_enough;
1955
2003
}
1956
2004
···
2022
2072
pr_debug(" --- wd:%d rd:%d\n", conf->geo.raid_disks - conf->mddev->degraded,
2023
2073
conf->geo.raid_disks);
2024
2074
2025
-
/* This is only called with ->reconfix_mutex held, so
2026
-
* rcu protection of rdev is not needed */
2075
+
lockdep_assert_held(&conf->mddev->reconfig_mutex);
2027
2076
for (i = 0; i < conf->geo.raid_disks; i++) {
2028
2077
rdev = conf->mirrors[i].rdev;
2029
2078
if (rdev)
···
2139
2190
err = 0;
2140
2191
if (rdev->saved_raid_disk != mirror)
2141
2192
conf->fullsync = 1;
2142
-
rcu_assign_pointer(p->rdev, rdev);
2193
+
WRITE_ONCE(p->rdev, rdev);
2143
2194
break;
2144
2195
}
2145
2196
···
2153
2204
disk_stack_limits(mddev->gendisk, rdev->bdev,
2154
2205
rdev->data_offset << 9);
2155
2206
conf->fullsync = 1;
2156
-
rcu_assign_pointer(p->replacement, rdev);
2207
+
WRITE_ONCE(p->replacement, rdev);
2157
2208
}
2158
2209
2159
2210
print_conf(conf);
···
2195
2246
err = -EBUSY;
2196
2247
goto abort;
2197
2248
}
2198
-
*rdevp = NULL;
2199
-
if (!test_bit(RemoveSynchronized, &rdev->flags)) {
2200
-
synchronize_rcu();
2201
-
if (atomic_read(&rdev->nr_pending)) {
2202
-
/* lost the race, try later */
2203
-
err = -EBUSY;
2204
-
*rdevp = rdev;
2205
-
goto abort;
2206
-
}
2207
-
}
2249
+
WRITE_ONCE(*rdevp, NULL);
2208
2250
if (p->replacement) {
2209
2251
/* We must have just cleared 'rdev' */
2210
-
p->rdev = p->replacement;
2252
+
WRITE_ONCE(p->rdev, p->replacement);
2211
2253
clear_bit(Replacement, &p->replacement->flags);
2212
-
smp_mb(); /* Make sure other CPUs may see both as identical
2213
-
* but will never see neither -- if they are careful.
2214
-
*/
2215
-
p->replacement = NULL;
2254
+
WRITE_ONCE(p->replacement, NULL);
2216
2255
}
2217
2256
2218
2257
clear_bit(WantReplacement, &rdev->flags);
···
2700
2763
if (s > (PAGE_SIZE>>9))
2701
2764
s = PAGE_SIZE >> 9;
2702
2765
2703
-
rcu_read_lock();
2704
2766
do {
2705
2767
sector_t first_bad;
2706
2768
int bad_sectors;
2707
2769
2708
2770
d = r10_bio->devs[sl].devnum;
2709
-
rdev = rcu_dereference(conf->mirrors[d].rdev);
2771
+
rdev = conf->mirrors[d].rdev;
2710
2772
if (rdev &&
2711
2773
test_bit(In_sync, &rdev->flags) &&
2712
2774
!test_bit(Faulty, &rdev->flags) &&
2713
2775
is_badblock(rdev, r10_bio->devs[sl].addr + sect, s,
2714
2776
&first_bad, &bad_sectors) == 0) {
2715
2777
atomic_inc(&rdev->nr_pending);
2716
-
rcu_read_unlock();
2717
2778
success = sync_page_io(rdev,
2718
2779
r10_bio->devs[sl].addr +
2719
2780
sect,
···
2719
2784
conf->tmppage,
2720
2785
REQ_OP_READ, false);
2721
2786
rdev_dec_pending(rdev, mddev);
2722
-
rcu_read_lock();
2723
2787
if (success)
2724
2788
break;
2725
2789
}
···
2726
2792
if (sl == conf->copies)
2727
2793
sl = 0;
2728
2794
} while (sl != slot);
2729
-
rcu_read_unlock();
2730
2795
2731
2796
if (!success) {
2732
2797
/* Cannot read from anywhere, just mark the block
···
2749
2816
2750
2817
start = sl;
2751
2818
/* write it back and re-read */
2752
-
rcu_read_lock();
2753
2819
while (sl != slot) {
2754
2820
if (sl==0)
2755
2821
sl = conf->copies;
2756
2822
sl--;
2757
2823
d = r10_bio->devs[sl].devnum;
2758
-
rdev = rcu_dereference(conf->mirrors[d].rdev);
2824
+
rdev = conf->mirrors[d].rdev;
2759
2825
if (!rdev ||
2760
2826
test_bit(Faulty, &rdev->flags) ||
2761
2827
!test_bit(In_sync, &rdev->flags))
2762
2828
continue;
2763
2829
2764
2830
atomic_inc(&rdev->nr_pending);
2765
-
rcu_read_unlock();
2766
2831
if (r10_sync_page_io(rdev,
2767
2832
r10_bio->devs[sl].addr +
2768
2833
sect,
···
2779
2848
rdev->bdev);
2780
2849
}
2781
2850
rdev_dec_pending(rdev, mddev);
2782
-
rcu_read_lock();
2783
2851
}
2784
2852
sl = start;
2785
2853
while (sl != slot) {
···
2786
2856
sl = conf->copies;
2787
2857
sl--;
2788
2858
d = r10_bio->devs[sl].devnum;
2789
-
rdev = rcu_dereference(conf->mirrors[d].rdev);
2859
+
rdev = conf->mirrors[d].rdev;
2790
2860
if (!rdev ||
2791
2861
test_bit(Faulty, &rdev->flags) ||
2792
2862
!test_bit(In_sync, &rdev->flags))
2793
2863
continue;
2794
2864
2795
2865
atomic_inc(&rdev->nr_pending);
2796
-
rcu_read_unlock();
2797
2866
switch (r10_sync_page_io(rdev,
2798
2867
r10_bio->devs[sl].addr +
2799
2868
sect,
···
2820
2891
}
2821
2892
2822
2893
rdev_dec_pending(rdev, mddev);
2823
-
rcu_read_lock();
2824
2894
}
2825
-
rcu_read_unlock();
2826
2895
2827
2896
sectors -= s;
2828
2897
sect += s;
···
3294
3367
/* Completed a full sync so the replacements
3295
3368
* are now fully recovered.
3296
3369
*/
3297
-
rcu_read_lock();
3298
3370
for (i = 0; i < conf->geo.raid_disks; i++) {
3299
3371
struct md_rdev *rdev =
3300
-
rcu_dereference(conf->mirrors[i].replacement);
3372
+
conf->mirrors[i].replacement;
3373
+
3301
3374
if (rdev)
3302
3375
rdev->recovery_offset = MaxSector;
3303
3376
}
3304
-
rcu_read_unlock();
3305
3377
}
3306
3378
conf->fullsync = 0;
3307
3379
}
···
3381
3455
struct raid10_info *mirror = &conf->mirrors[i];
3382
3456
struct md_rdev *mrdev, *mreplace;
3383
3457
3384
-
rcu_read_lock();
3385
-
mrdev = rcu_dereference(mirror->rdev);
3386
-
mreplace = rcu_dereference(mirror->replacement);
3458
+
mrdev = mirror->rdev;
3459
+
mreplace = mirror->replacement;
3387
3460
3388
3461
if (mrdev && (test_bit(Faulty, &mrdev->flags) ||
3389
3462
test_bit(In_sync, &mrdev->flags)))
···
3390
3465
if (mreplace && test_bit(Faulty, &mreplace->flags))
3391
3466
mreplace = NULL;
3392
3467
3393
-
if (!mrdev && !mreplace) {
3394
-
rcu_read_unlock();
3468
+
if (!mrdev && !mreplace)
3395
3469
continue;
3396
-
}
3397
3470
3398
3471
still_degraded = 0;
3399
3472
/* want to reconstruct this device */
3400
3473
rb2 = r10_bio;
3401
3474
sect = raid10_find_virt(conf, sector_nr, i);
3402
-
if (sect >= mddev->resync_max_sectors) {
3475
+
if (sect >= mddev->resync_max_sectors)
3403
3476
/* last stripe is not complete - don't
3404
3477
* try to recover this sector.
3405
3478
*/
3406
-
rcu_read_unlock();
3407
3479
continue;
3408
-
}
3409
3480
/* Unless we are doing a full sync, or a replacement
3410
3481
* we only need to recover the block if it is set in
3411
3482
* the bitmap
···
3417
3496
* that there will never be anything to do here
3418
3497
*/
3419
3498
chunks_skipped = -1;
3420
-
rcu_read_unlock();
3421
3499
continue;
3422
3500
}
3423
3501
if (mrdev)
3424
3502
atomic_inc(&mrdev->nr_pending);
3425
3503
if (mreplace)
3426
3504
atomic_inc(&mreplace->nr_pending);
3427
-
rcu_read_unlock();
3428
3505
3429
3506
r10_bio = raid10_alloc_init_r10buf(conf);
3430
3507
r10_bio->state = 0;
···
3441
3522
/* Need to check if the array will still be
3442
3523
* degraded
3443
3524
*/
3444
-
rcu_read_lock();
3445
3525
for (j = 0; j < conf->geo.raid_disks; j++) {
3446
-
struct md_rdev *rdev = rcu_dereference(
3447
-
conf->mirrors[j].rdev);
3526
+
struct md_rdev *rdev = conf->mirrors[j].rdev;
3527
+
3448
3528
if (rdev == NULL || test_bit(Faulty, &rdev->flags)) {
3449
3529
still_degraded = 1;
3450
3530
break;
···
3458
3540
int k;
3459
3541
int d = r10_bio->devs[j].devnum;
3460
3542
sector_t from_addr, to_addr;
3461
-
struct md_rdev *rdev =
3462
-
rcu_dereference(conf->mirrors[d].rdev);
3543
+
struct md_rdev *rdev = conf->mirrors[d].rdev;
3463
3544
sector_t sector, first_bad;
3464
3545
int bad_sectors;
3465
3546
if (!rdev ||
···
3537
3620
atomic_inc(&r10_bio->remaining);
3538
3621
break;
3539
3622
}
3540
-
rcu_read_unlock();
3541
3623
if (j == conf->copies) {
3542
3624
/* Cannot recover, so abort the recovery or
3543
3625
* record a bad block */
···
3663
3747
3664
3748
bio = r10_bio->devs[i].bio;
3665
3749
bio->bi_status = BLK_STS_IOERR;
3666
-
rcu_read_lock();
3667
-
rdev = rcu_dereference(conf->mirrors[d].rdev);
3668
-
if (rdev == NULL || test_bit(Faulty, &rdev->flags)) {
3669
-
rcu_read_unlock();
3750
+
rdev = conf->mirrors[d].rdev;
3751
+
if (rdev == NULL || test_bit(Faulty, &rdev->flags))
3670
3752
continue;
3671
-
}
3753
+
3672
3754
sector = r10_bio->devs[i].addr;
3673
3755
if (is_badblock(rdev, sector, max_sync,
3674
3756
&first_bad, &bad_sectors)) {
···
3676
3762
bad_sectors -= (sector - first_bad);
3677
3763
if (max_sync > bad_sectors)
3678
3764
max_sync = bad_sectors;
3679
-
rcu_read_unlock();
3680
3765
continue;
3681
3766
}
3682
3767
}
···
3691
3778
bio_set_dev(bio, rdev->bdev);
3692
3779
count++;
3693
3780
3694
-
rdev = rcu_dereference(conf->mirrors[d].replacement);
3695
-
if (rdev == NULL || test_bit(Faulty, &rdev->flags)) {
3696
-
rcu_read_unlock();
3781
+
rdev = conf->mirrors[d].replacement;
3782
+
if (rdev == NULL || test_bit(Faulty, &rdev->flags))
3697
3783
continue;
3698
-
}
3784
+
3699
3785
atomic_inc(&rdev->nr_pending);
3700
3786
3701
3787
/* Need to set up for writing to the replacement */
···
3711
3799
bio->bi_iter.bi_sector = sector + rdev->data_offset;
3712
3800
bio_set_dev(bio, rdev->bdev);
3713
3801
count++;
3714
-
rcu_read_unlock();
3715
3802
}
3716
3803
3717
3804
if (count < 2) {
···
4420
4509
int degraded, degraded2;
4421
4510
int i;
4422
4511
4423
-
rcu_read_lock();
4424
4512
degraded = 0;
4425
4513
/* 'prev' section first */
4426
4514
for (i = 0; i < conf->prev.raid_disks; i++) {
4427
-
struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
4515
+
struct md_rdev *rdev = conf->mirrors[i].rdev;
4516
+
4428
4517
if (!rdev || test_bit(Faulty, &rdev->flags))
4429
4518
degraded++;
4430
4519
else if (!test_bit(In_sync, &rdev->flags))
···
4434
4523
*/
4435
4524
degraded++;
4436
4525
}
4437
-
rcu_read_unlock();
4438
4526
if (conf->geo.raid_disks == conf->prev.raid_disks)
4439
4527
return degraded;
4440
-
rcu_read_lock();
4441
4528
degraded2 = 0;
4442
4529
for (i = 0; i < conf->geo.raid_disks; i++) {
4443
-
struct md_rdev *rdev = rcu_dereference(conf->mirrors[i].rdev);
4530
+
struct md_rdev *rdev = conf->mirrors[i].rdev;
4531
+
4444
4532
if (!rdev || test_bit(Faulty, &rdev->flags))
4445
4533
degraded2++;
4446
4534
else if (!test_bit(In_sync, &rdev->flags)) {
···
4452
4542
degraded2++;
4453
4543
}
4454
4544
}
4455
-
rcu_read_unlock();
4456
4545
if (degraded2 > degraded)
4457
4546
return degraded2;
4458
4547
return degraded;
···
4883
4974
blist = read_bio;
4884
4975
read_bio->bi_next = NULL;
4885
4976
4886
-
rcu_read_lock();
4887
4977
for (s = 0; s < conf->copies*2; s++) {
4888
4978
struct bio *b;
4889
4979
int d = r10_bio->devs[s/2].devnum;
4890
4980
struct md_rdev *rdev2;
4891
4981
if (s&1) {
4892
-
rdev2 = rcu_dereference(conf->mirrors[d].replacement);
4982
+
rdev2 = conf->mirrors[d].replacement;
4893
4983
b = r10_bio->devs[s/2].repl_bio;
4894
4984
} else {
4895
-
rdev2 = rcu_dereference(conf->mirrors[d].rdev);
4985
+
rdev2 = conf->mirrors[d].rdev;
4896
4986
b = r10_bio->devs[s/2].bio;
4897
4987
}
4898
4988
if (!rdev2 || test_bit(Faulty, &rdev2->flags))
···
4925
5017
sector_nr += len >> 9;
4926
5018
nr_sectors += len >> 9;
4927
5019
}
4928
-
rcu_read_unlock();
4929
5020
r10_bio->sectors = nr_sectors;
4930
5021
4931
5022
/* Now submit the read */
···
4977
5070
struct bio *b;
4978
5071
int d = r10_bio->devs[s/2].devnum;
4979
5072
struct md_rdev *rdev;
4980
-
rcu_read_lock();
4981
5073
if (s&1) {
4982
-
rdev = rcu_dereference(conf->mirrors[d].replacement);
5074
+
rdev = conf->mirrors[d].replacement;
4983
5075
b = r10_bio->devs[s/2].repl_bio;
4984
5076
} else {
4985
-
rdev = rcu_dereference(conf->mirrors[d].rdev);
5077
+
rdev = conf->mirrors[d].rdev;
4986
5078
b = r10_bio->devs[s/2].bio;
4987
5079
}
4988
-
if (!rdev || test_bit(Faulty, &rdev->flags)) {
4989
-
rcu_read_unlock();
5080
+
if (!rdev || test_bit(Faulty, &rdev->flags))
4990
5081
continue;
4991
-
}
5082
+
4992
5083
atomic_inc(&rdev->nr_pending);
4993
-
rcu_read_unlock();
4994
5084
md_sync_acct_bio(b, r10_bio->sectors);
4995
5085
atomic_inc(&r10_bio->remaining);
4996
5086
b->bi_next = NULL;
···
5058
5154
if (s > (PAGE_SIZE >> 9))
5059
5155
s = PAGE_SIZE >> 9;
5060
5156
5061
-
rcu_read_lock();
5062
5157
while (!success) {
5063
5158
int d = r10b->devs[slot].devnum;
5064
-
struct md_rdev *rdev = rcu_dereference(conf->mirrors[d].rdev);
5159
+
struct md_rdev *rdev = conf->mirrors[d].rdev;
5065
5160
sector_t addr;
5066
5161
if (rdev == NULL ||
5067
5162
test_bit(Faulty, &rdev->flags) ||
···
5069
5166
5070
5167
addr = r10b->devs[slot].addr + idx * PAGE_SIZE;
5071
5168
atomic_inc(&rdev->nr_pending);
5072
-
rcu_read_unlock();
5073
5169
success = sync_page_io(rdev,
5074
5170
addr,
5075
5171
s << 9,
5076
5172
pages[idx],
5077
5173
REQ_OP_READ, false);
5078
5174
rdev_dec_pending(rdev, mddev);
5079
-
rcu_read_lock();
5080
5175
if (success)
5081
5176
break;
5082
5177
failed:
···
5084
5183
if (slot == first_slot)
5085
5184
break;
5086
5185
}
5087
-
rcu_read_unlock();
5088
5186
if (!success) {
5089
5187
/* couldn't read this block, must give up */
5090
5188
set_bit(MD_RECOVERY_INTR,
···
5109
5209
struct md_rdev *rdev = NULL;
5110
5210
5111
5211
d = find_bio_disk(conf, r10_bio, bio, &slot, &repl);
5112
-
if (repl)
5113
-
rdev = conf->mirrors[d].replacement;
5114
-
if (!rdev) {
5115
-
smp_mb();
5116
-
rdev = conf->mirrors[d].rdev;
5117
-
}
5212
+
rdev = repl ? conf->mirrors[d].replacement :
5213
+
conf->mirrors[d].rdev;
5118
5214
5119
5215
if (bio->bi_status) {
5120
5216
/* FIXME should record badblock */
···
5145
5249
mddev->resync_max_sectors = mddev->array_sectors;
5146
5250
} else {
5147
5251
int d;
5148
-
rcu_read_lock();
5149
5252
for (d = conf->geo.raid_disks ;
5150
5253
d < conf->geo.raid_disks - mddev->delta_disks;
5151
5254
d++) {
5152
-
struct md_rdev *rdev = rcu_dereference(conf->mirrors[d].rdev);
5255
+
struct md_rdev *rdev = conf->mirrors[d].rdev;
5153
5256
if (rdev)
5154
5257
clear_bit(In_sync, &rdev->flags);
5155
-
rdev = rcu_dereference(conf->mirrors[d].replacement);
5258
+
rdev = conf->mirrors[d].replacement;
5156
5259
if (rdev)
5157
5260
clear_bit(In_sync, &rdev->flags);
5158
5261
}
5159
-
rcu_read_unlock();
5160
5262
}
5161
5263
mddev->layout = mddev->new_layout;
5162
5264
mddev->chunk_sectors = 1 << conf->geo.chunk_shift;
+2
-9
drivers/md/raid5-cache.c
+2
-9
drivers/md/raid5-cache.c
···
1890
1890
continue;
1891
1891
1892
1892
/* in case device is broken */
1893
-
rcu_read_lock();
1894
-
rdev = rcu_dereference(conf->disks[disk_index].rdev);
1893
+
rdev = conf->disks[disk_index].rdev;
1895
1894
if (rdev) {
1896
1895
atomic_inc(&rdev->nr_pending);
1897
-
rcu_read_unlock();
1898
1896
sync_page_io(rdev, sh->sector, PAGE_SIZE,
1899
1897
sh->dev[disk_index].page, REQ_OP_WRITE,
1900
1898
false);
1901
1899
rdev_dec_pending(rdev, rdev->mddev);
1902
-
rcu_read_lock();
1903
1900
}
1904
-
rrdev = rcu_dereference(conf->disks[disk_index].replacement);
1901
+
rrdev = conf->disks[disk_index].replacement;
1905
1902
if (rrdev) {
1906
1903
atomic_inc(&rrdev->nr_pending);
1907
-
rcu_read_unlock();
1908
1904
sync_page_io(rrdev, sh->sector, PAGE_SIZE,
1909
1905
sh->dev[disk_index].page, REQ_OP_WRITE,
1910
1906
false);
1911
1907
rdev_dec_pending(rrdev, rrdev->mddev);
1912
-
rcu_read_lock();
1913
1908
}
1914
-
rcu_read_unlock();
1915
1909
}
1916
1910
ctx->data_parity_stripes++;
1917
1911
out:
···
2942
2948
if (!log)
2943
2949
return false;
2944
2950
2945
-
WARN_ON_ONCE(!rcu_read_lock_held());
2946
2951
tree_index = r5c_tree_index(conf, sect);
2947
2952
slot = radix_tree_lookup(&log->big_stripe_tree, tree_index);
2948
2953
return slot != NULL;
+4
-12
drivers/md/raid5-ppl.c
+4
-12
drivers/md/raid5-ppl.c
···
620
620
struct md_rdev *rdev;
621
621
struct block_device *bdev = NULL;
622
622
623
-
rcu_read_lock();
624
-
rdev = rcu_dereference(conf->disks[i].rdev);
623
+
rdev = conf->disks[i].rdev;
625
624
if (rdev && !test_bit(Faulty, &rdev->flags))
626
625
bdev = rdev->bdev;
627
-
rcu_read_unlock();
628
626
629
627
if (bdev) {
630
628
struct bio *bio;
···
880
882
(unsigned long long)r_sector, dd_idx,
881
883
(unsigned long long)sector);
882
884
883
-
/* Array has not started so rcu dereference is safe */
884
-
rdev = rcu_dereference_protected(
885
-
conf->disks[dd_idx].rdev, 1);
885
+
rdev = conf->disks[dd_idx].rdev;
886
886
if (!rdev || (!test_bit(In_sync, &rdev->flags) &&
887
887
sector >= rdev->recovery_offset)) {
888
888
pr_debug("%s:%*s data member disk %d missing\n",
···
932
936
0, &disk, &sh);
933
937
BUG_ON(sh.pd_idx != le32_to_cpu(e->parity_disk));
934
938
935
-
/* Array has not started so rcu dereference is safe */
936
-
parity_rdev = rcu_dereference_protected(
937
-
conf->disks[sh.pd_idx].rdev, 1);
939
+
parity_rdev = conf->disks[sh.pd_idx].rdev;
938
940
939
941
BUG_ON(parity_rdev->bdev->bd_dev != log->rdev->bdev->bd_dev);
940
942
pr_debug("%s:%*s write parity at sector %llu, disk %pg\n",
···
1398
1404
1399
1405
for (i = 0; i < ppl_conf->count; i++) {
1400
1406
struct ppl_log *log = &ppl_conf->child_logs[i];
1401
-
/* Array has not started so rcu dereference is safe */
1402
-
struct md_rdev *rdev =
1403
-
rcu_dereference_protected(conf->disks[i].rdev, 1);
1407
+
struct md_rdev *rdev = conf->disks[i].rdev;
1404
1408
1405
1409
mutex_init(&log->io_mutex);
1406
1410
spin_lock_init(&log->io_list_lock);
+61
-142
drivers/md/raid5.c
+61
-142
drivers/md/raid5.c
···
36
36
*/
37
37
38
38
#include <linux/blkdev.h>
39
-
#include <linux/delay.h>
40
39
#include <linux/kthread.h>
41
40
#include <linux/raid/pq.h>
42
41
#include <linux/async_tx.h>
···
693
694
int degraded, degraded2;
694
695
int i;
695
696
696
-
rcu_read_lock();
697
697
degraded = 0;
698
698
for (i = 0; i < conf->previous_raid_disks; i++) {
699
-
struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
699
+
struct md_rdev *rdev = READ_ONCE(conf->disks[i].rdev);
700
+
700
701
if (rdev && test_bit(Faulty, &rdev->flags))
701
-
rdev = rcu_dereference(conf->disks[i].replacement);
702
+
rdev = READ_ONCE(conf->disks[i].replacement);
702
703
if (!rdev || test_bit(Faulty, &rdev->flags))
703
704
degraded++;
704
705
else if (test_bit(In_sync, &rdev->flags))
···
716
717
if (conf->raid_disks >= conf->previous_raid_disks)
717
718
degraded++;
718
719
}
719
-
rcu_read_unlock();
720
720
if (conf->raid_disks == conf->previous_raid_disks)
721
721
return degraded;
722
-
rcu_read_lock();
723
722
degraded2 = 0;
724
723
for (i = 0; i < conf->raid_disks; i++) {
725
-
struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
724
+
struct md_rdev *rdev = READ_ONCE(conf->disks[i].rdev);
725
+
726
726
if (rdev && test_bit(Faulty, &rdev->flags))
727
-
rdev = rcu_dereference(conf->disks[i].replacement);
727
+
rdev = READ_ONCE(conf->disks[i].replacement);
728
728
if (!rdev || test_bit(Faulty, &rdev->flags))
729
729
degraded2++;
730
730
else if (test_bit(In_sync, &rdev->flags))
···
737
739
if (conf->raid_disks <= conf->previous_raid_disks)
738
740
degraded2++;
739
741
}
740
-
rcu_read_unlock();
741
742
if (degraded2 > degraded)
742
743
return degraded2;
743
744
return degraded;
···
1181
1184
bi = &dev->req;
1182
1185
rbi = &dev->rreq; /* For writing to replacement */
1183
1186
1184
-
rcu_read_lock();
1185
-
rrdev = rcu_dereference(conf->disks[i].replacement);
1186
-
smp_mb(); /* Ensure that if rrdev is NULL, rdev won't be */
1187
-
rdev = rcu_dereference(conf->disks[i].rdev);
1188
-
if (!rdev) {
1189
-
rdev = rrdev;
1190
-
rrdev = NULL;
1191
-
}
1187
+
rdev = conf->disks[i].rdev;
1188
+
rrdev = conf->disks[i].replacement;
1192
1189
if (op_is_write(op)) {
1193
1190
if (replace_only)
1194
1191
rdev = NULL;
···
1203
1212
rrdev = NULL;
1204
1213
if (rrdev)
1205
1214
atomic_inc(&rrdev->nr_pending);
1206
-
rcu_read_unlock();
1207
1215
1208
1216
/* We have already checked bad blocks for reads. Now
1209
1217
* need to check for writes. We never accept write errors
···
2721
2731
conf->slab_cache = NULL;
2722
2732
}
2723
2733
2724
-
/*
2725
-
* This helper wraps rcu_dereference_protected() and can be used when
2726
-
* it is known that the nr_pending of the rdev is elevated.
2727
-
*/
2728
-
static struct md_rdev *rdev_pend_deref(struct md_rdev __rcu *rdev)
2729
-
{
2730
-
return rcu_dereference_protected(rdev,
2731
-
atomic_read(&rcu_access_pointer(rdev)->nr_pending));
2732
-
}
2733
-
2734
-
/*
2735
-
* This helper wraps rcu_dereference_protected() and should be used
2736
-
* when it is known that the mddev_lock() is held. This is safe
2737
-
* seeing raid5_remove_disk() has the same lock held.
2738
-
*/
2739
-
static struct md_rdev *rdev_mdlock_deref(struct mddev *mddev,
2740
-
struct md_rdev __rcu *rdev)
2741
-
{
2742
-
return rcu_dereference_protected(rdev,
2743
-
lockdep_is_held(&mddev->reconfig_mutex));
2744
-
}
2745
-
2746
2734
static void raid5_end_read_request(struct bio * bi)
2747
2735
{
2748
2736
struct stripe_head *sh = bi->bi_private;
···
2746
2778
* In that case it moved down to 'rdev'.
2747
2779
* rdev is not removed until all requests are finished.
2748
2780
*/
2749
-
rdev = rdev_pend_deref(conf->disks[i].replacement);
2781
+
rdev = conf->disks[i].replacement;
2750
2782
if (!rdev)
2751
-
rdev = rdev_pend_deref(conf->disks[i].rdev);
2783
+
rdev = conf->disks[i].rdev;
2752
2784
2753
2785
if (use_new_offset(conf, sh))
2754
2786
s = sh->sector + rdev->new_data_offset;
···
2861
2893
2862
2894
for (i = 0 ; i < disks; i++) {
2863
2895
if (bi == &sh->dev[i].req) {
2864
-
rdev = rdev_pend_deref(conf->disks[i].rdev);
2896
+
rdev = conf->disks[i].rdev;
2865
2897
break;
2866
2898
}
2867
2899
if (bi == &sh->dev[i].rreq) {
2868
-
rdev = rdev_pend_deref(conf->disks[i].replacement);
2900
+
rdev = conf->disks[i].replacement;
2869
2901
if (rdev)
2870
2902
replacement = 1;
2871
2903
else
···
2873
2905
* replaced it. rdev is not removed
2874
2906
* until all requests are finished.
2875
2907
*/
2876
-
rdev = rdev_pend_deref(conf->disks[i].rdev);
2908
+
rdev = conf->disks[i].rdev;
2877
2909
break;
2878
2910
}
2879
2911
}
···
3635
3667
int bitmap_end = 0;
3636
3668
3637
3669
if (test_bit(R5_ReadError, &sh->dev[i].flags)) {
3638
-
struct md_rdev *rdev;
3639
-
rcu_read_lock();
3640
-
rdev = rcu_dereference(conf->disks[i].rdev);
3670
+
struct md_rdev *rdev = conf->disks[i].rdev;
3671
+
3641
3672
if (rdev && test_bit(In_sync, &rdev->flags) &&
3642
3673
!test_bit(Faulty, &rdev->flags))
3643
3674
atomic_inc(&rdev->nr_pending);
3644
3675
else
3645
3676
rdev = NULL;
3646
-
rcu_read_unlock();
3647
3677
if (rdev) {
3648
3678
if (!rdev_set_badblocks(
3649
3679
rdev,
···
3759
3793
/* During recovery devices cannot be removed, so
3760
3794
* locking and refcounting of rdevs is not needed
3761
3795
*/
3762
-
rcu_read_lock();
3763
3796
for (i = 0; i < conf->raid_disks; i++) {
3764
-
struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
3797
+
struct md_rdev *rdev = conf->disks[i].rdev;
3798
+
3765
3799
if (rdev
3766
3800
&& !test_bit(Faulty, &rdev->flags)
3767
3801
&& !test_bit(In_sync, &rdev->flags)
3768
3802
&& !rdev_set_badblocks(rdev, sh->sector,
3769
3803
RAID5_STRIPE_SECTORS(conf), 0))
3770
3804
abort = 1;
3771
-
rdev = rcu_dereference(conf->disks[i].replacement);
3805
+
rdev = conf->disks[i].replacement;
3806
+
3772
3807
if (rdev
3773
3808
&& !test_bit(Faulty, &rdev->flags)
3774
3809
&& !test_bit(In_sync, &rdev->flags)
···
3777
3810
RAID5_STRIPE_SECTORS(conf), 0))
3778
3811
abort = 1;
3779
3812
}
3780
-
rcu_read_unlock();
3781
3813
if (abort)
3782
3814
conf->recovery_disabled =
3783
3815
conf->mddev->recovery_disabled;
···
3789
3823
struct md_rdev *rdev;
3790
3824
int rv = 0;
3791
3825
3792
-
rcu_read_lock();
3793
-
rdev = rcu_dereference(sh->raid_conf->disks[disk_idx].replacement);
3826
+
rdev = sh->raid_conf->disks[disk_idx].replacement;
3794
3827
if (rdev
3795
3828
&& !test_bit(Faulty, &rdev->flags)
3796
3829
&& !test_bit(In_sync, &rdev->flags)
3797
3830
&& (rdev->recovery_offset <= sh->sector
3798
3831
|| rdev->mddev->recovery_cp <= sh->sector))
3799
3832
rv = 1;
3800
-
rcu_read_unlock();
3801
3833
return rv;
3802
3834
}
3803
3835
···
4672
4708
s->log_failed = r5l_log_disk_error(conf);
4673
4709
4674
4710
/* Now to look around and see what can be done */
4675
-
rcu_read_lock();
4676
4711
for (i=disks; i--; ) {
4677
4712
struct md_rdev *rdev;
4678
4713
sector_t first_bad;
···
4716
4753
/* Prefer to use the replacement for reads, but only
4717
4754
* if it is recovered enough and has no bad blocks.
4718
4755
*/
4719
-
rdev = rcu_dereference(conf->disks[i].replacement);
4756
+
rdev = conf->disks[i].replacement;
4720
4757
if (rdev && !test_bit(Faulty, &rdev->flags) &&
4721
4758
rdev->recovery_offset >= sh->sector + RAID5_STRIPE_SECTORS(conf) &&
4722
4759
!is_badblock(rdev, sh->sector, RAID5_STRIPE_SECTORS(conf),
···
4727
4764
set_bit(R5_NeedReplace, &dev->flags);
4728
4765
else
4729
4766
clear_bit(R5_NeedReplace, &dev->flags);
4730
-
rdev = rcu_dereference(conf->disks[i].rdev);
4767
+
rdev = conf->disks[i].rdev;
4731
4768
clear_bit(R5_ReadRepl, &dev->flags);
4732
4769
}
4733
4770
if (rdev && test_bit(Faulty, &rdev->flags))
···
4774
4811
if (test_bit(R5_WriteError, &dev->flags)) {
4775
4812
/* This flag does not apply to '.replacement'
4776
4813
* only to .rdev, so make sure to check that*/
4777
-
struct md_rdev *rdev2 = rcu_dereference(
4778
-
conf->disks[i].rdev);
4814
+
struct md_rdev *rdev2 = conf->disks[i].rdev;
4815
+
4779
4816
if (rdev2 == rdev)
4780
4817
clear_bit(R5_Insync, &dev->flags);
4781
4818
if (rdev2 && !test_bit(Faulty, &rdev2->flags)) {
···
4787
4824
if (test_bit(R5_MadeGood, &dev->flags)) {
4788
4825
/* This flag does not apply to '.replacement'
4789
4826
* only to .rdev, so make sure to check that*/
4790
-
struct md_rdev *rdev2 = rcu_dereference(
4791
-
conf->disks[i].rdev);
4827
+
struct md_rdev *rdev2 = conf->disks[i].rdev;
4828
+
4792
4829
if (rdev2 && !test_bit(Faulty, &rdev2->flags)) {
4793
4830
s->handle_bad_blocks = 1;
4794
4831
atomic_inc(&rdev2->nr_pending);
···
4796
4833
clear_bit(R5_MadeGood, &dev->flags);
4797
4834
}
4798
4835
if (test_bit(R5_MadeGoodRepl, &dev->flags)) {
4799
-
struct md_rdev *rdev2 = rcu_dereference(
4800
-
conf->disks[i].replacement);
4836
+
struct md_rdev *rdev2 = conf->disks[i].replacement;
4837
+
4801
4838
if (rdev2 && !test_bit(Faulty, &rdev2->flags)) {
4802
4839
s->handle_bad_blocks = 1;
4803
4840
atomic_inc(&rdev2->nr_pending);
···
4818
4855
if (rdev && !test_bit(Faulty, &rdev->flags))
4819
4856
do_recovery = 1;
4820
4857
else if (!rdev) {
4821
-
rdev = rcu_dereference(
4822
-
conf->disks[i].replacement);
4858
+
rdev = conf->disks[i].replacement;
4823
4859
if (rdev && !test_bit(Faulty, &rdev->flags))
4824
4860
do_recovery = 1;
4825
4861
}
···
4845
4883
else
4846
4884
s->replacing = 1;
4847
4885
}
4848
-
rcu_read_unlock();
4849
4886
}
4850
4887
4851
4888
/*
···
5301
5340
struct r5dev *dev = &sh->dev[i];
5302
5341
if (test_and_clear_bit(R5_WriteError, &dev->flags)) {
5303
5342
/* We own a safe reference to the rdev */
5304
-
rdev = rdev_pend_deref(conf->disks[i].rdev);
5343
+
rdev = conf->disks[i].rdev;
5305
5344
if (!rdev_set_badblocks(rdev, sh->sector,
5306
5345
RAID5_STRIPE_SECTORS(conf), 0))
5307
5346
md_error(conf->mddev, rdev);
5308
5347
rdev_dec_pending(rdev, conf->mddev);
5309
5348
}
5310
5349
if (test_and_clear_bit(R5_MadeGood, &dev->flags)) {
5311
-
rdev = rdev_pend_deref(conf->disks[i].rdev);
5350
+
rdev = conf->disks[i].rdev;
5312
5351
rdev_clear_badblocks(rdev, sh->sector,
5313
5352
RAID5_STRIPE_SECTORS(conf), 0);
5314
5353
rdev_dec_pending(rdev, conf->mddev);
5315
5354
}
5316
5355
if (test_and_clear_bit(R5_MadeGoodRepl, &dev->flags)) {
5317
-
rdev = rdev_pend_deref(conf->disks[i].replacement);
5356
+
rdev = conf->disks[i].replacement;
5318
5357
if (!rdev)
5319
5358
/* rdev have been moved down */
5320
-
rdev = rdev_pend_deref(conf->disks[i].rdev);
5359
+
rdev = conf->disks[i].rdev;
5321
5360
rdev_clear_badblocks(rdev, sh->sector,
5322
5361
RAID5_STRIPE_SECTORS(conf), 0);
5323
5362
rdev_dec_pending(rdev, conf->mddev);
···
5476
5515
&dd_idx, NULL);
5477
5516
end_sector = sector + bio_sectors(raid_bio);
5478
5517
5479
-
rcu_read_lock();
5480
5518
if (r5c_big_stripe_cached(conf, sector))
5481
-
goto out_rcu_unlock;
5519
+
return 0;
5482
5520
5483
-
rdev = rcu_dereference(conf->disks[dd_idx].replacement);
5521
+
rdev = conf->disks[dd_idx].replacement;
5484
5522
if (!rdev || test_bit(Faulty, &rdev->flags) ||
5485
5523
rdev->recovery_offset < end_sector) {
5486
-
rdev = rcu_dereference(conf->disks[dd_idx].rdev);
5524
+
rdev = conf->disks[dd_idx].rdev;
5487
5525
if (!rdev)
5488
-
goto out_rcu_unlock;
5526
+
return 0;
5489
5527
if (test_bit(Faulty, &rdev->flags) ||
5490
5528
!(test_bit(In_sync, &rdev->flags) ||
5491
5529
rdev->recovery_offset >= end_sector))
5492
-
goto out_rcu_unlock;
5530
+
return 0;
5493
5531
}
5494
5532
5495
5533
atomic_inc(&rdev->nr_pending);
5496
-
rcu_read_unlock();
5497
5534
5498
5535
if (is_badblock(rdev, sector, bio_sectors(raid_bio), &first_bad,
5499
5536
&bad_sectors)) {
···
5535
5576
raid_bio->bi_iter.bi_sector);
5536
5577
submit_bio_noacct(align_bio);
5537
5578
return 1;
5538
-
5539
-
out_rcu_unlock:
5540
-
rcu_read_unlock();
5541
-
return 0;
5542
5579
}
5543
5580
5544
5581
static struct bio *chunk_aligned_read(struct mddev *mddev, struct bio *raid_bio)
···
6537
6582
* Note in case of > 1 drive failures it's possible we're rebuilding
6538
6583
* one drive while leaving another faulty drive in array.
6539
6584
*/
6540
-
rcu_read_lock();
6541
6585
for (i = 0; i < conf->raid_disks; i++) {
6542
-
struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
6586
+
struct md_rdev *rdev = conf->disks[i].rdev;
6543
6587
6544
6588
if (rdev == NULL || test_bit(Faulty, &rdev->flags))
6545
6589
still_degraded = 1;
6546
6590
}
6547
-
rcu_read_unlock();
6548
6591
6549
6592
md_bitmap_start_sync(mddev->bitmap, sector_nr, &sync_blocks, still_degraded);
6550
6593
···
6773
6820
spin_unlock_irq(&conf->device_lock);
6774
6821
md_check_recovery(mddev);
6775
6822
spin_lock_irq(&conf->device_lock);
6776
-
6777
-
/*
6778
-
* Waiting on MD_SB_CHANGE_PENDING below may deadlock
6779
-
* seeing md_check_recovery() is needed to clear
6780
-
* the flag when using mdmon.
6781
-
*/
6782
-
continue;
6783
6823
}
6784
-
6785
-
wait_event_lock_irq(mddev->sb_wait,
6786
-
!test_bit(MD_SB_CHANGE_PENDING, &mddev->sb_flags),
6787
-
conf->device_lock);
6788
6824
}
6789
6825
pr_debug("%d stripes handled\n", handled);
6790
6826
···
7853
7911
7854
7912
for (i = 0; i < conf->raid_disks && conf->previous_raid_disks;
7855
7913
i++) {
7856
-
rdev = rdev_mdlock_deref(mddev, conf->disks[i].rdev);
7857
-
if (!rdev && conf->disks[i].replacement) {
7858
-
/* The replacement is all we have yet */
7859
-
rdev = rdev_mdlock_deref(mddev,
7860
-
conf->disks[i].replacement);
7861
-
conf->disks[i].replacement = NULL;
7862
-
clear_bit(Replacement, &rdev->flags);
7863
-
rcu_assign_pointer(conf->disks[i].rdev, rdev);
7864
-
}
7914
+
rdev = conf->disks[i].rdev;
7865
7915
if (!rdev)
7866
7916
continue;
7867
-
if (rcu_access_pointer(conf->disks[i].replacement) &&
7917
+
if (conf->disks[i].replacement &&
7868
7918
conf->reshape_progress != MaxSector) {
7869
7919
/* replacements and reshape simply do not mix. */
7870
7920
pr_warn("md: cannot handle concurrent replacement and reshape.\n");
···
8040
8106
struct r5conf *conf = mddev->private;
8041
8107
int i;
8042
8108
8109
+
lockdep_assert_held(&mddev->lock);
8110
+
8043
8111
seq_printf(seq, " level %d, %dk chunk, algorithm %d", mddev->level,
8044
8112
conf->chunk_sectors / 2, mddev->layout);
8045
8113
seq_printf (seq, " [%d/%d] [", conf->raid_disks, conf->raid_disks - mddev->degraded);
8046
-
rcu_read_lock();
8047
8114
for (i = 0; i < conf->raid_disks; i++) {
8048
-
struct md_rdev *rdev = rcu_dereference(conf->disks[i].rdev);
8115
+
struct md_rdev *rdev = READ_ONCE(conf->disks[i].rdev);
8116
+
8049
8117
seq_printf (seq, "%s", rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
8050
8118
}
8051
-
rcu_read_unlock();
8052
8119
seq_printf (seq, "]");
8053
8120
}
8054
8121
···
8087
8152
unsigned long flags;
8088
8153
8089
8154
for (i = 0; i < conf->raid_disks; i++) {
8090
-
rdev = rdev_mdlock_deref(mddev, conf->disks[i].rdev);
8091
-
replacement = rdev_mdlock_deref(mddev,
8092
-
conf->disks[i].replacement);
8155
+
rdev = conf->disks[i].rdev;
8156
+
replacement = conf->disks[i].replacement;
8093
8157
if (replacement
8094
8158
&& replacement->recovery_offset == MaxSector
8095
8159
&& !test_bit(Faulty, &replacement->flags)
···
8127
8193
struct r5conf *conf = mddev->private;
8128
8194
int err = 0;
8129
8195
int number = rdev->raid_disk;
8130
-
struct md_rdev __rcu **rdevp;
8196
+
struct md_rdev **rdevp;
8131
8197
struct disk_info *p;
8132
8198
struct md_rdev *tmp;
8133
8199
···
8150
8216
if (unlikely(number >= conf->pool_size))
8151
8217
return 0;
8152
8218
p = conf->disks + number;
8153
-
if (rdev == rcu_access_pointer(p->rdev))
8219
+
if (rdev == p->rdev)
8154
8220
rdevp = &p->rdev;
8155
-
else if (rdev == rcu_access_pointer(p->replacement))
8221
+
else if (rdev == p->replacement)
8156
8222
rdevp = &p->replacement;
8157
8223
else
8158
8224
return 0;
···
8172
8238
if (!test_bit(Faulty, &rdev->flags) &&
8173
8239
mddev->recovery_disabled != conf->recovery_disabled &&
8174
8240
!has_failed(conf) &&
8175
-
(!rcu_access_pointer(p->replacement) ||
8176
-
rcu_access_pointer(p->replacement) == rdev) &&
8241
+
(!p->replacement || p->replacement == rdev) &&
8177
8242
number < conf->raid_disks) {
8178
8243
err = -EBUSY;
8179
8244
goto abort;
8180
8245
}
8181
-
*rdevp = NULL;
8182
-
if (!test_bit(RemoveSynchronized, &rdev->flags)) {
8183
-
lockdep_assert_held(&mddev->reconfig_mutex);
8184
-
synchronize_rcu();
8185
-
if (atomic_read(&rdev->nr_pending)) {
8186
-
/* lost the race, try later */
8187
-
err = -EBUSY;
8188
-
rcu_assign_pointer(*rdevp, rdev);
8189
-
}
8190
-
}
8246
+
WRITE_ONCE(*rdevp, NULL);
8191
8247
if (!err) {
8192
8248
err = log_modify(conf, rdev, false);
8193
8249
if (err)
8194
8250
goto abort;
8195
8251
}
8196
8252
8197
-
tmp = rcu_access_pointer(p->replacement);
8253
+
tmp = p->replacement;
8198
8254
if (tmp) {
8199
8255
/* We must have just cleared 'rdev' */
8200
-
rcu_assign_pointer(p->rdev, tmp);
8256
+
WRITE_ONCE(p->rdev, tmp);
8201
8257
clear_bit(Replacement, &tmp->flags);
8202
-
smp_mb(); /* Make sure other CPUs may see both as identical
8203
-
* but will never see neither - if they are careful
8204
-
*/
8205
-
rcu_assign_pointer(p->replacement, NULL);
8258
+
WRITE_ONCE(p->replacement, NULL);
8206
8259
8207
8260
if (!err)
8208
8261
err = log_modify(conf, tmp, true);
···
8257
8336
rdev->raid_disk = disk;
8258
8337
if (rdev->saved_raid_disk != disk)
8259
8338
conf->fullsync = 1;
8260
-
rcu_assign_pointer(p->rdev, rdev);
8339
+
WRITE_ONCE(p->rdev, rdev);
8261
8340
8262
8341
err = log_modify(conf, rdev, true);
8263
8342
···
8266
8345
}
8267
8346
for (disk = first; disk <= last; disk++) {
8268
8347
p = conf->disks + disk;
8269
-
tmp = rdev_mdlock_deref(mddev, p->rdev);
8348
+
tmp = p->rdev;
8270
8349
if (test_bit(WantReplacement, &tmp->flags) &&
8271
8350
mddev->reshape_position == MaxSector &&
8272
8351
p->replacement == NULL) {
···
8275
8354
rdev->raid_disk = disk;
8276
8355
err = 0;
8277
8356
conf->fullsync = 1;
8278
-
rcu_assign_pointer(p->replacement, rdev);
8357
+
WRITE_ONCE(p->replacement, rdev);
8279
8358
break;
8280
8359
}
8281
8360
}
···
8408
8487
if (mddev->recovery_cp < MaxSector)
8409
8488
return -EBUSY;
8410
8489
for (i = 0; i < conf->raid_disks; i++)
8411
-
if (rdev_mdlock_deref(mddev, conf->disks[i].replacement))
8490
+
if (conf->disks[i].replacement)
8412
8491
return -EBUSY;
8413
8492
8414
8493
rdev_for_each(rdev, mddev) {
···
8579
8658
for (d = conf->raid_disks ;
8580
8659
d < conf->raid_disks - mddev->delta_disks;
8581
8660
d++) {
8582
-
rdev = rdev_mdlock_deref(mddev,
8583
-
conf->disks[d].rdev);
8661
+
rdev = conf->disks[d].rdev;
8584
8662
if (rdev)
8585
8663
clear_bit(In_sync, &rdev->flags);
8586
-
rdev = rdev_mdlock_deref(mddev,
8587
-
conf->disks[d].replacement);
8664
+
rdev = conf->disks[d].replacement;
8588
8665
if (rdev)
8589
8666
clear_bit(In_sync, &rdev->flags);
8590
8667
}