Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'md-3.5-fixes' of git://neil.brown.name/md
Pull three md bugfixes from NeilBrown:
"One of the bugs was introduced in 3.5-rc1. Others have been there for
longer."
* tag 'md-3.5-fixes' of git://neil.brown.name/md:
md/raid1: close some possible races on write errors during resync
md: avoid crash when stopping md array races with closing other open fds.
md: fix bug in handling of new_data_offset
+32
-15
+24
-13
drivers/md/md.c
+24
-13
drivers/md/md.c
···
2931
2931
* can be sane */
2932
2932
return -EBUSY;
2933
2933
rdev->data_offset = offset;
2934
+
rdev->new_data_offset = offset;
2934
2935
return len;
2935
2936
}
2936
2937
···
3927
3926
return sprintf(page, "%s\n", array_states[st]);
3928
3927
}
3929
3928
3930
-
static int do_md_stop(struct mddev * mddev, int ro, int is_open);
3931
-
static int md_set_readonly(struct mddev * mddev, int is_open);
3929
+
static int do_md_stop(struct mddev * mddev, int ro, struct block_device *bdev);
3930
+
static int md_set_readonly(struct mddev * mddev, struct block_device *bdev);
3932
3931
static int do_md_run(struct mddev * mddev);
3933
3932
static int restart_array(struct mddev *mddev);
3934
3933
···
3944
3943
/* stopping an active array */
3945
3944
if (atomic_read(&mddev->openers) > 0)
3946
3945
return -EBUSY;
3947
-
err = do_md_stop(mddev, 0, 0);
3946
+
err = do_md_stop(mddev, 0, NULL);
3948
3947
break;
3949
3948
case inactive:
3950
3949
/* stopping an active array */
3951
3950
if (mddev->pers) {
3952
3951
if (atomic_read(&mddev->openers) > 0)
3953
3952
return -EBUSY;
3954
-
err = do_md_stop(mddev, 2, 0);
3953
+
err = do_md_stop(mddev, 2, NULL);
3955
3954
} else
3956
3955
err = 0; /* already inactive */
3957
3956
break;
···
3959
3958
break; /* not supported yet */
3960
3959
case readonly:
3961
3960
if (mddev->pers)
3962
-
err = md_set_readonly(mddev, 0);
3961
+
err = md_set_readonly(mddev, NULL);
3963
3962
else {
3964
3963
mddev->ro = 1;
3965
3964
set_disk_ro(mddev->gendisk, 1);
···
3969
3968
case read_auto:
3970
3969
if (mddev->pers) {
3971
3970
if (mddev->ro == 0)
3972
-
err = md_set_readonly(mddev, 0);
3971
+
err = md_set_readonly(mddev, NULL);
3973
3972
else if (mddev->ro == 1)
3974
3973
err = restart_array(mddev);
3975
3974
if (err == 0) {
···
5352
5351
}
5353
5352
EXPORT_SYMBOL_GPL(md_stop);
5354
5353
5355
-
static int md_set_readonly(struct mddev *mddev, int is_open)
5354
+
static int md_set_readonly(struct mddev *mddev, struct block_device *bdev)
5356
5355
{
5357
5356
int err = 0;
5358
5357
mutex_lock(&mddev->open_mutex);
5359
-
if (atomic_read(&mddev->openers) > is_open) {
5358
+
if (atomic_read(&mddev->openers) > !!bdev) {
5360
5359
printk("md: %s still in use.\n",mdname(mddev));
5361
5360
err = -EBUSY;
5362
5361
goto out;
5363
5362
}
5363
+
if (bdev)
5364
+
sync_blockdev(bdev);
5364
5365
if (mddev->pers) {
5365
5366
__md_stop_writes(mddev);
5366
5367
···
5384
5381
* 0 - completely stop and dis-assemble array
5385
5382
* 2 - stop but do not disassemble array
5386
5383
*/
5387
-
static int do_md_stop(struct mddev * mddev, int mode, int is_open)
5384
+
static int do_md_stop(struct mddev * mddev, int mode,
5385
+
struct block_device *bdev)
5388
5386
{
5389
5387
struct gendisk *disk = mddev->gendisk;
5390
5388
struct md_rdev *rdev;
5391
5389
5392
5390
mutex_lock(&mddev->open_mutex);
5393
-
if (atomic_read(&mddev->openers) > is_open ||
5391
+
if (atomic_read(&mddev->openers) > !!bdev ||
5394
5392
mddev->sysfs_active) {
5395
5393
printk("md: %s still in use.\n",mdname(mddev));
5396
5394
mutex_unlock(&mddev->open_mutex);
5397
5395
return -EBUSY;
5398
5396
}
5397
+
if (bdev)
5398
+
/* It is possible IO was issued on some other
5399
+
* open file which was closed before we took ->open_mutex.
5400
+
* As that was not the last close __blkdev_put will not
5401
+
* have called sync_blockdev, so we must.
5402
+
*/
5403
+
sync_blockdev(bdev);
5399
5404
5400
5405
if (mddev->pers) {
5401
5406
if (mddev->ro)
···
5477
5466
err = do_md_run(mddev);
5478
5467
if (err) {
5479
5468
printk(KERN_WARNING "md: do_md_run() returned %d\n", err);
5480
-
do_md_stop(mddev, 0, 0);
5469
+
do_md_stop(mddev, 0, NULL);
5481
5470
}
5482
5471
}
5483
5472
···
6492
6481
goto done_unlock;
6493
6482
6494
6483
case STOP_ARRAY:
6495
-
err = do_md_stop(mddev, 0, 1);
6484
+
err = do_md_stop(mddev, 0, bdev);
6496
6485
goto done_unlock;
6497
6486
6498
6487
case STOP_ARRAY_RO:
6499
-
err = md_set_readonly(mddev, 1);
6488
+
err = md_set_readonly(mddev, bdev);
6500
6489
goto done_unlock;
6501
6490
6502
6491
case BLKROSET:
+8
-2
drivers/md/raid1.c
+8
-2
drivers/md/raid1.c
···
1818
1818
1819
1819
if (atomic_dec_and_test(&r1_bio->remaining)) {
1820
1820
/* if we're here, all write(s) have completed, so clean up */
1821
-
md_done_sync(mddev, r1_bio->sectors, 1);
1822
-
put_buf(r1_bio);
1821
+
int s = r1_bio->sectors;
1822
+
if (test_bit(R1BIO_MadeGood, &r1_bio->state) ||
1823
+
test_bit(R1BIO_WriteError, &r1_bio->state))
1824
+
reschedule_retry(r1_bio);
1825
+
else {
1826
+
put_buf(r1_bio);
1827
+
md_done_sync(mddev, s, 1);
1828
+
}
1823
1829
}
1824
1830
}
1825
1831