Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'dm-4.8-fixes-2' of git://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm
Pull device mapper fixes from Mike Snitzer:
- a stable fix for DM round robin multipath path selector to disable
preemption before using this_cpu_ptr()
- a slight increase in DM crypt's mempool reserves to make swap ontop
of DM crypt more performant
- a few DM raid fixes to issues found while testing changes that were
merged in v4.8-rc1
* tag 'dm-4.8-fixes-2' of git://git.kernel.org/pub/scm/linux/kernel/git/device-mapper/linux-dm:
dm raid: support raid0 with missing metadata devices
dm raid: enhance attempt_restore_of_faulty_devices() to support more devices
dm raid: fix restoring of failed devices regression
dm raid: fix frozen recovery regression
dm crypt: increase mempool reserve to better support swapping
dm round robin: do not use this_cpu_ptr() without having preemption disabled
+54
-39
+1
-1
drivers/md/dm-crypt.c
+1
-1
drivers/md/dm-crypt.c
+48
-36
drivers/md/dm-raid.c
+48
-36
drivers/md/dm-raid.c
···
191
191
#define RT_FLAG_RS_BITMAP_LOADED 2
192
192
#define RT_FLAG_UPDATE_SBS 3
193
193
#define RT_FLAG_RESHAPE_RS 4
194
-
#define RT_FLAG_KEEP_RS_FROZEN 5
195
194
196
195
/* Array elements of 64 bit needed for rebuild/failed disk bits */
197
196
#define DISKS_ARRAY_ELEMS ((MAX_RAID_DEVICES + (sizeof(uint64_t) * 8 - 1)) / sizeof(uint64_t) / 8)
···
860
861
{
861
862
unsigned long min_region_size = rs->ti->len / (1 << 21);
862
863
864
+
if (rs_is_raid0(rs))
865
+
return 0;
866
+
863
867
if (!region_size) {
864
868
/*
865
869
* Choose a reasonable default. All figures in sectors.
···
932
930
rebuild_cnt++;
933
931
934
932
switch (rs->raid_type->level) {
933
+
case 0:
934
+
break;
935
935
case 1:
936
936
if (rebuild_cnt >= rs->md.raid_disks)
937
937
goto too_many;
···
2339
2335
case 0:
2340
2336
break;
2341
2337
default:
2338
+
/*
2339
+
* We have to keep any raid0 data/metadata device pairs or
2340
+
* the MD raid0 personality will fail to start the array.
2341
+
*/
2342
+
if (rs_is_raid0(rs))
2343
+
continue;
2344
+
2342
2345
dev = container_of(rdev, struct raid_dev, rdev);
2343
2346
if (dev->meta_dev)
2344
2347
dm_put_device(ti, dev->meta_dev);
···
2590
2579
} else {
2591
2580
/* Process raid1 without delta_disks */
2592
2581
mddev->raid_disks = rs->raid_disks;
2593
-
set_bit(RT_FLAG_KEEP_RS_FROZEN, &rs->runtime_flags);
2594
2582
reshape = false;
2595
2583
}
2596
2584
} else {
···
2600
2590
if (reshape) {
2601
2591
set_bit(RT_FLAG_RESHAPE_RS, &rs->runtime_flags);
2602
2592
set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags);
2603
-
set_bit(RT_FLAG_KEEP_RS_FROZEN, &rs->runtime_flags);
2604
2593
} else if (mddev->raid_disks < rs->raid_disks)
2605
2594
/* Create new superblocks and bitmaps, if any new disks */
2606
2595
set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags);
···
2911
2902
goto bad;
2912
2903
2913
2904
set_bit(RT_FLAG_UPDATE_SBS, &rs->runtime_flags);
2914
-
set_bit(RT_FLAG_KEEP_RS_FROZEN, &rs->runtime_flags);
2915
2905
/* Takeover ain't recovery, so disable recovery */
2916
2906
rs_setup_recovery(rs, MaxSector);
2917
2907
rs_set_new(rs);
···
3394
3386
{
3395
3387
struct raid_set *rs = ti->private;
3396
3388
3397
-
if (test_and_clear_bit(RT_FLAG_RS_RESUMED, &rs->runtime_flags)) {
3398
-
if (!rs->md.suspended)
3399
-
mddev_suspend(&rs->md);
3400
-
rs->md.ro = 1;
3401
-
}
3389
+
if (!rs->md.suspended)
3390
+
mddev_suspend(&rs->md);
3391
+
3392
+
rs->md.ro = 1;
3402
3393
}
3403
3394
3404
3395
static void attempt_restore_of_faulty_devices(struct raid_set *rs)
3405
3396
{
3406
3397
int i;
3407
-
uint64_t failed_devices, cleared_failed_devices = 0;
3398
+
uint64_t cleared_failed_devices[DISKS_ARRAY_ELEMS];
3408
3399
unsigned long flags;
3400
+
bool cleared = false;
3409
3401
struct dm_raid_superblock *sb;
3402
+
struct mddev *mddev = &rs->md;
3410
3403
struct md_rdev *r;
3404
+
3405
+
/* RAID personalities have to provide hot add/remove methods or we need to bail out. */
3406
+
if (!mddev->pers || !mddev->pers->hot_add_disk || !mddev->pers->hot_remove_disk)
3407
+
return;
3408
+
3409
+
memset(cleared_failed_devices, 0, sizeof(cleared_failed_devices));
3411
3410
3412
3411
for (i = 0; i < rs->md.raid_disks; i++) {
3413
3412
r = &rs->dev[i].rdev;
···
3435
3420
* ourselves.
3436
3421
*/
3437
3422
if ((r->raid_disk >= 0) &&
3438
-
(r->mddev->pers->hot_remove_disk(r->mddev, r) != 0))
3423
+
(mddev->pers->hot_remove_disk(mddev, r) != 0))
3439
3424
/* Failed to revive this device, try next */
3440
3425
continue;
3441
3426
···
3445
3430
clear_bit(Faulty, &r->flags);
3446
3431
clear_bit(WriteErrorSeen, &r->flags);
3447
3432
clear_bit(In_sync, &r->flags);
3448
-
if (r->mddev->pers->hot_add_disk(r->mddev, r)) {
3433
+
if (mddev->pers->hot_add_disk(mddev, r)) {
3449
3434
r->raid_disk = -1;
3450
3435
r->saved_raid_disk = -1;
3451
3436
r->flags = flags;
3452
3437
} else {
3453
3438
r->recovery_offset = 0;
3454
-
cleared_failed_devices |= 1 << i;
3439
+
set_bit(i, (void *) cleared_failed_devices);
3440
+
cleared = true;
3455
3441
}
3456
3442
}
3457
3443
}
3458
-
if (cleared_failed_devices) {
3444
+
3445
+
/* If any failed devices could be cleared, update all sbs failed_devices bits */
3446
+
if (cleared) {
3447
+
uint64_t failed_devices[DISKS_ARRAY_ELEMS];
3448
+
3459
3449
rdev_for_each(r, &rs->md) {
3460
3450
sb = page_address(r->sb_page);
3461
-
failed_devices = le64_to_cpu(sb->failed_devices);
3462
-
failed_devices &= ~cleared_failed_devices;
3463
-
sb->failed_devices = cpu_to_le64(failed_devices);
3451
+
sb_retrieve_failed_devices(sb, failed_devices);
3452
+
3453
+
for (i = 0; i < DISKS_ARRAY_ELEMS; i++)
3454
+
failed_devices[i] &= ~cleared_failed_devices[i];
3455
+
3456
+
sb_update_failed_devices(sb, failed_devices);
3464
3457
}
3465
3458
}
3466
3459
}
···
3633
3610
* devices are reachable again.
3634
3611
*/
3635
3612
attempt_restore_of_faulty_devices(rs);
3636
-
} else {
3637
-
mddev->ro = 0;
3638
-
mddev->in_sync = 0;
3639
-
3640
-
/*
3641
-
* When passing in flags to the ctr, we expect userspace
3642
-
* to reset them because they made it to the superblocks
3643
-
* and reload the mapping anyway.
3644
-
*
3645
-
* -> only unfreeze recovery in case of a table reload or
3646
-
* we'll have a bogus recovery/reshape position
3647
-
* retrieved from the superblock by the ctr because
3648
-
* the ongoing recovery/reshape will change it after read.
3649
-
*/
3650
-
if (!test_bit(RT_FLAG_KEEP_RS_FROZEN, &rs->runtime_flags))
3651
-
clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
3652
-
3653
-
if (mddev->suspended)
3654
-
mddev_resume(mddev);
3655
3613
}
3614
+
3615
+
mddev->ro = 0;
3616
+
mddev->in_sync = 0;
3617
+
3618
+
clear_bit(MD_RECOVERY_FROZEN, &mddev->recovery);
3619
+
3620
+
if (mddev->suspended)
3621
+
mddev_resume(mddev);
3656
3622
}
3657
3623
3658
3624
static struct target_type raid_target = {
+5
-2
drivers/md/dm-round-robin.c
+5
-2
drivers/md/dm-round-robin.c
···
210
210
struct path_info *pi = NULL;
211
211
struct dm_path *current_path = NULL;
212
212
213
+
local_irq_save(flags);
213
214
current_path = *this_cpu_ptr(s->current_path);
214
215
if (current_path) {
215
216
percpu_counter_dec(&s->repeat_count);
216
-
if (percpu_counter_read_positive(&s->repeat_count) > 0)
217
+
if (percpu_counter_read_positive(&s->repeat_count) > 0) {
218
+
local_irq_restore(flags);
217
219
return current_path;
220
+
}
218
221
}
219
222
220
-
spin_lock_irqsave(&s->lock, flags);
223
+
spin_lock(&s->lock);
221
224
if (!list_empty(&s->valid_paths)) {
222
225
pi = list_entry(s->valid_paths.next, struct path_info, list);
223
226
list_move_tail(&pi->list, &s->valid_paths);