Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'md-3.10-fixes' of git://neil.brown.name/md
Pull md bugfixes from Neil Brown:
"A few bugfixes for md
Some tagged for -stable"
* tag 'md-3.10-fixes' of git://neil.brown.name/md:
md/raid1,5,10: Disable WRITE SAME until a recovery strategy is in place
md/raid1,raid10: use freeze_array in place of raise_barrier in various places.
md/raid1: consider WRITE as successful only if at least one non-Faulty and non-rebuilding drive completed it.
md: md_stop_writes() should always freeze recovery.
+47
-26
+1
-1
drivers/md/md.c
+1
-1
drivers/md/md.c
···
5268
5268
5269
5269
static void __md_stop_writes(struct mddev *mddev)
5270
5270
{
5271
+
set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5271
5272
if (mddev->sync_thread) {
5272
-
set_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
5273
5273
set_bit(MD_RECOVERY_INTR, &mddev->recovery);
5274
5274
md_reap_sync_thread(mddev);
5275
5275
}
+24
-14
drivers/md/raid1.c
+24
-14
drivers/md/raid1.c
···
417
417
418
418
r1_bio->bios[mirror] = NULL;
419
419
to_put = bio;
420
-
set_bit(R1BIO_Uptodate, &r1_bio->state);
420
+
/*
421
+
* Do not set R1BIO_Uptodate if the current device is
422
+
* rebuilding or Faulty. This is because we cannot use
423
+
* such device for properly reading the data back (we could
424
+
* potentially use it, if the current write would have felt
425
+
* before rdev->recovery_offset, but for simplicity we don't
426
+
* check this here.
427
+
*/
428
+
if (test_bit(In_sync, &conf->mirrors[mirror].rdev->flags) &&
429
+
!test_bit(Faulty, &conf->mirrors[mirror].rdev->flags))
430
+
set_bit(R1BIO_Uptodate, &r1_bio->state);
421
431
422
432
/* Maybe we can clear some bad blocks. */
423
433
if (is_badblock(conf->mirrors[mirror].rdev,
···
880
870
wake_up(&conf->wait_barrier);
881
871
}
882
872
883
-
static void freeze_array(struct r1conf *conf)
873
+
static void freeze_array(struct r1conf *conf, int extra)
884
874
{
885
875
/* stop syncio and normal IO and wait for everything to
886
876
* go quite.
887
877
* We increment barrier and nr_waiting, and then
888
-
* wait until nr_pending match nr_queued+1
878
+
* wait until nr_pending match nr_queued+extra
889
879
* This is called in the context of one normal IO request
890
880
* that has failed. Thus any sync request that might be pending
891
881
* will be blocked by nr_pending, and we need to wait for
892
882
* pending IO requests to complete or be queued for re-try.
893
-
* Thus the number queued (nr_queued) plus this request (1)
883
+
* Thus the number queued (nr_queued) plus this request (extra)
894
884
* must match the number of pending IOs (nr_pending) before
895
885
* we continue.
896
886
*/
···
898
888
conf->barrier++;
899
889
conf->nr_waiting++;
900
890
wait_event_lock_irq_cmd(conf->wait_barrier,
901
-
conf->nr_pending == conf->nr_queued+1,
891
+
conf->nr_pending == conf->nr_queued+extra,
902
892
conf->resync_lock,
903
893
flush_pending_writes(conf));
904
894
spin_unlock_irq(&conf->resync_lock);
···
1554
1544
* we wait for all outstanding requests to complete.
1555
1545
*/
1556
1546
synchronize_sched();
1557
-
raise_barrier(conf);
1558
-
lower_barrier(conf);
1547
+
freeze_array(conf, 0);
1548
+
unfreeze_array(conf);
1559
1549
clear_bit(Unmerged, &rdev->flags);
1560
1550
}
1561
1551
md_integrity_add_rdev(rdev, mddev);
···
1605
1595
*/
1606
1596
struct md_rdev *repl =
1607
1597
conf->mirrors[conf->raid_disks + number].rdev;
1608
-
raise_barrier(conf);
1598
+
freeze_array(conf, 0);
1609
1599
clear_bit(Replacement, &repl->flags);
1610
1600
p->rdev = repl;
1611
1601
conf->mirrors[conf->raid_disks + number].rdev = NULL;
1612
-
lower_barrier(conf);
1602
+
unfreeze_array(conf);
1613
1603
clear_bit(WantReplacement, &rdev->flags);
1614
1604
} else
1615
1605
clear_bit(WantReplacement, &rdev->flags);
···
2205
2195
* frozen
2206
2196
*/
2207
2197
if (mddev->ro == 0) {
2208
-
freeze_array(conf);
2198
+
freeze_array(conf, 1);
2209
2199
fix_read_error(conf, r1_bio->read_disk,
2210
2200
r1_bio->sector, r1_bio->sectors);
2211
2201
unfreeze_array(conf);
···
2790
2780
return PTR_ERR(conf);
2791
2781
2792
2782
if (mddev->queue)
2793
-
blk_queue_max_write_same_sectors(mddev->queue,
2794
-
mddev->chunk_sectors);
2783
+
blk_queue_max_write_same_sectors(mddev->queue, 0);
2784
+
2795
2785
rdev_for_each(rdev, mddev) {
2796
2786
if (!mddev->gendisk)
2797
2787
continue;
···
2973
2963
return -ENOMEM;
2974
2964
}
2975
2965
2976
-
raise_barrier(conf);
2966
+
freeze_array(conf, 0);
2977
2967
2978
2968
/* ok, everything is stopped */
2979
2969
oldpool = conf->r1bio_pool;
···
3004
2994
conf->raid_disks = mddev->raid_disks = raid_disks;
3005
2995
mddev->delta_disks = 0;
3006
2996
3007
-
lower_barrier(conf);
2997
+
unfreeze_array(conf);
3008
2998
3009
2999
set_bit(MD_RECOVERY_NEEDED, &mddev->recovery);
3010
3000
md_wakeup_thread(mddev->thread);
+19
-10
drivers/md/raid10.c
+19
-10
drivers/md/raid10.c
···
490
490
sector_t first_bad;
491
491
int bad_sectors;
492
492
493
-
set_bit(R10BIO_Uptodate, &r10_bio->state);
493
+
/*
494
+
* Do not set R10BIO_Uptodate if the current device is
495
+
* rebuilding or Faulty. This is because we cannot use
496
+
* such device for properly reading the data back (we could
497
+
* potentially use it, if the current write would have felt
498
+
* before rdev->recovery_offset, but for simplicity we don't
499
+
* check this here.
500
+
*/
501
+
if (test_bit(In_sync, &rdev->flags) &&
502
+
!test_bit(Faulty, &rdev->flags))
503
+
set_bit(R10BIO_Uptodate, &r10_bio->state);
494
504
495
505
/* Maybe we can clear some bad blocks. */
496
506
if (is_badblock(rdev,
···
1065
1055
wake_up(&conf->wait_barrier);
1066
1056
}
1067
1057
1068
-
static void freeze_array(struct r10conf *conf)
1058
+
static void freeze_array(struct r10conf *conf, int extra)
1069
1059
{
1070
1060
/* stop syncio and normal IO and wait for everything to
1071
1061
* go quiet.
1072
1062
* We increment barrier and nr_waiting, and then
1073
-
* wait until nr_pending match nr_queued+1
1063
+
* wait until nr_pending match nr_queued+extra
1074
1064
* This is called in the context of one normal IO request
1075
1065
* that has failed. Thus any sync request that might be pending
1076
1066
* will be blocked by nr_pending, and we need to wait for
1077
1067
* pending IO requests to complete or be queued for re-try.
1078
-
* Thus the number queued (nr_queued) plus this request (1)
1068
+
* Thus the number queued (nr_queued) plus this request (extra)
1079
1069
* must match the number of pending IOs (nr_pending) before
1080
1070
* we continue.
1081
1071
*/
···
1083
1073
conf->barrier++;
1084
1074
conf->nr_waiting++;
1085
1075
wait_event_lock_irq_cmd(conf->wait_barrier,
1086
-
conf->nr_pending == conf->nr_queued+1,
1076
+
conf->nr_pending == conf->nr_queued+extra,
1087
1077
conf->resync_lock,
1088
1078
flush_pending_writes(conf));
1089
1079
···
1847
1837
* we wait for all outstanding requests to complete.
1848
1838
*/
1849
1839
synchronize_sched();
1850
-
raise_barrier(conf, 0);
1851
-
lower_barrier(conf);
1840
+
freeze_array(conf, 0);
1841
+
unfreeze_array(conf);
1852
1842
clear_bit(Unmerged, &rdev->flags);
1853
1843
}
1854
1844
md_integrity_add_rdev(rdev, mddev);
···
2622
2612
r10_bio->devs[slot].bio = NULL;
2623
2613
2624
2614
if (mddev->ro == 0) {
2625
-
freeze_array(conf);
2615
+
freeze_array(conf, 1);
2626
2616
fix_read_error(conf, mddev, r10_bio);
2627
2617
unfreeze_array(conf);
2628
2618
} else
···
3619
3609
if (mddev->queue) {
3620
3610
blk_queue_max_discard_sectors(mddev->queue,
3621
3611
mddev->chunk_sectors);
3622
-
blk_queue_max_write_same_sectors(mddev->queue,
3623
-
mddev->chunk_sectors);
3612
+
blk_queue_max_write_same_sectors(mddev->queue, 0);
3624
3613
blk_queue_io_min(mddev->queue, chunk_size);
3625
3614
if (conf->geo.raid_disks % conf->geo.near_copies)
3626
3615
blk_queue_io_opt(mddev->queue, chunk_size * conf->geo.raid_disks);
+3
-1
drivers/md/raid5.c
+3
-1
drivers/md/raid5.c
···
5466
5466
if (mddev->major_version == 0 &&
5467
5467
mddev->minor_version > 90)
5468
5468
rdev->recovery_offset = reshape_offset;
5469
-
5469
+
5470
5470
if (rdev->recovery_offset < reshape_offset) {
5471
5471
/* We need to check old and new layout */
5472
5472
if (!only_parity(rdev->raid_disk,
···
5588
5588
* guarantee discard_zerors_data
5589
5589
*/
5590
5590
mddev->queue->limits.discard_zeroes_data = 0;
5591
+
5592
+
blk_queue_max_write_same_sectors(mddev->queue, 0);
5591
5593
5592
5594
rdev_for_each(rdev, mddev) {
5593
5595
disk_stack_limits(mddev->gendisk, rdev->bdev,