Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge git://git.kernel.org/pub/scm/linux/kernel/git/agk/linux-2.6-dm
* git://git.kernel.org/pub/scm/linux/kernel/git/agk/linux-2.6-dm:
dm crypt: use bio_add_page
dm: merge max_hw_sector
dm: trigger change uevent on rename
dm crypt: fix write endio
dm mpath: hp requires scsi
dm: table detect io beyond device
+68
-32
+1
-1
drivers/md/Kconfig
+1
-1
drivers/md/Kconfig
···
269
269
270
270
config DM_MULTIPATH_HP
271
271
tristate "HP MSA multipath support (EXPERIMENTAL)"
272
-
depends on DM_MULTIPATH && BLK_DEV_DM && EXPERIMENTAL
272
+
depends on DM_MULTIPATH && BLK_DEV_DM && SCSI && EXPERIMENTAL
273
273
---help---
274
274
Multipath support for HP MSA (Active/Passive) series hardware.
275
275
+15
-16
drivers/md/dm-crypt.c
+15
-16
drivers/md/dm-crypt.c
···
398
398
struct bio *clone;
399
399
unsigned int nr_iovecs = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;
400
400
gfp_t gfp_mask = GFP_NOIO | __GFP_HIGHMEM;
401
-
unsigned int i;
401
+
unsigned i, len;
402
+
struct page *page;
402
403
403
404
clone = bio_alloc_bioset(GFP_NOIO, nr_iovecs, cc->bs);
404
405
if (!clone)
···
408
407
clone_init(io, clone);
409
408
410
409
for (i = 0; i < nr_iovecs; i++) {
411
-
struct bio_vec *bv = bio_iovec_idx(clone, i);
412
-
413
-
bv->bv_page = mempool_alloc(cc->page_pool, gfp_mask);
414
-
if (!bv->bv_page)
410
+
page = mempool_alloc(cc->page_pool, gfp_mask);
411
+
if (!page)
415
412
break;
416
413
417
414
/*
···
420
421
if (i == (MIN_BIO_PAGES - 1))
421
422
gfp_mask = (gfp_mask | __GFP_NOWARN) & ~__GFP_WAIT;
422
423
423
-
bv->bv_offset = 0;
424
-
if (size > PAGE_SIZE)
425
-
bv->bv_len = PAGE_SIZE;
426
-
else
427
-
bv->bv_len = size;
424
+
len = (size > PAGE_SIZE) ? PAGE_SIZE : size;
428
425
429
-
clone->bi_size += bv->bv_len;
430
-
clone->bi_vcnt++;
431
-
size -= bv->bv_len;
426
+
if (!bio_add_page(clone, page, len, 0)) {
427
+
mempool_free(page, cc->page_pool);
428
+
break;
429
+
}
430
+
431
+
size -= len;
432
432
}
433
433
434
434
if (!clone->bi_size) {
···
509
511
struct crypt_config *cc = io->target->private;
510
512
unsigned read_io = bio_data_dir(clone) == READ;
511
513
514
+
if (unlikely(!bio_flagged(clone, BIO_UPTODATE) && !error))
515
+
error = -EIO;
516
+
512
517
/*
513
518
* free the processed pages
514
519
*/
···
520
519
goto out;
521
520
}
522
521
523
-
if (unlikely(!bio_flagged(clone, BIO_UPTODATE))) {
524
-
error = -EIO;
522
+
if (unlikely(error))
525
523
goto out;
526
-
}
527
524
528
525
bio_put(clone);
529
526
kcryptd_queue_crypt(io);
+5
-7
drivers/md/dm-ioctl.c
+5
-7
drivers/md/dm-ioctl.c
···
332
332
dm_table_put(table);
333
333
}
334
334
335
+
dm_kobject_uevent(hc->md);
336
+
335
337
dm_put(hc->md);
336
338
up_write(&_hash_lock);
337
339
kfree(old_name);
···
1252
1250
if (!table)
1253
1251
goto out_argv;
1254
1252
1255
-
if (tmsg->sector >= dm_table_get_size(table)) {
1253
+
ti = dm_table_find_target(table, tmsg->sector);
1254
+
if (!dm_target_is_valid(ti)) {
1256
1255
DMWARN("Target message sector outside device.");
1257
1256
r = -EINVAL;
1258
-
goto out_table;
1259
-
}
1260
-
1261
-
ti = dm_table_find_target(table, tmsg->sector);
1262
-
if (ti->type->message)
1257
+
} else if (ti->type->message)
1263
1258
r = ti->type->message(ti, argc, argv);
1264
1259
else {
1265
1260
DMWARN("Target type does not support messages");
1266
1261
r = -EINVAL;
1267
1262
}
1268
1263
1269
-
out_table:
1270
1264
dm_table_put(table);
1271
1265
out_argv:
1272
1266
kfree(argv);
+15
-1
drivers/md/dm-table.c
+15
-1
drivers/md/dm-table.c
···
99
99
lhs->max_segment_size =
100
100
min_not_zero(lhs->max_segment_size, rhs->max_segment_size);
101
101
102
+
lhs->max_hw_sectors =
103
+
min_not_zero(lhs->max_hw_sectors, rhs->max_hw_sectors);
104
+
102
105
lhs->seg_boundary_mask =
103
106
min_not_zero(lhs->seg_boundary_mask, rhs->seg_boundary_mask);
104
107
···
192
189
193
190
/*
194
191
* Allocate both the target array and offset array at once.
192
+
* Append an empty entry to catch sectors beyond the end of
193
+
* the device.
195
194
*/
196
-
n_highs = (sector_t *) dm_vcalloc(num, sizeof(struct dm_target) +
195
+
n_highs = (sector_t *) dm_vcalloc(num + 1, sizeof(struct dm_target) +
197
196
sizeof(sector_t));
198
197
if (!n_highs)
199
198
return -ENOMEM;
···
569
564
rs->max_segment_size =
570
565
min_not_zero(rs->max_segment_size, q->max_segment_size);
571
566
567
+
rs->max_hw_sectors =
568
+
min_not_zero(rs->max_hw_sectors, q->max_hw_sectors);
569
+
572
570
rs->seg_boundary_mask =
573
571
min_not_zero(rs->seg_boundary_mask,
574
572
q->seg_boundary_mask);
···
709
701
{
710
702
if (!rs->max_sectors)
711
703
rs->max_sectors = SAFE_MAX_SECTORS;
704
+
if (!rs->max_hw_sectors)
705
+
rs->max_hw_sectors = SAFE_MAX_SECTORS;
712
706
if (!rs->max_phys_segments)
713
707
rs->max_phys_segments = MAX_PHYS_SEGMENTS;
714
708
if (!rs->max_hw_segments)
···
877
867
878
868
/*
879
869
* Search the btree for the correct target.
870
+
*
871
+
* Caller should check returned pointer with dm_target_is_valid()
872
+
* to trap I/O beyond end of device.
880
873
*/
881
874
struct dm_target *dm_table_find_target(struct dm_table *t, sector_t sector)
882
875
{
···
909
896
q->max_hw_segments = t->limits.max_hw_segments;
910
897
q->hardsect_size = t->limits.hardsect_size;
911
898
q->max_segment_size = t->limits.max_segment_size;
899
+
q->max_hw_sectors = t->limits.max_hw_sectors;
912
900
q->seg_boundary_mask = t->limits.seg_boundary_mask;
913
901
q->bounce_pfn = t->limits.bounce_pfn;
914
902
if (t->limits.no_cluster)
+24
-7
drivers/md/dm.c
+24
-7
drivers/md/dm.c
···
672
672
return clone;
673
673
}
674
674
675
-
static void __clone_and_map(struct clone_info *ci)
675
+
static int __clone_and_map(struct clone_info *ci)
676
676
{
677
677
struct bio *clone, *bio = ci->bio;
678
-
struct dm_target *ti = dm_table_find_target(ci->map, ci->sector);
679
-
sector_t len = 0, max = max_io_len(ci->md, ci->sector, ti);
678
+
struct dm_target *ti;
679
+
sector_t len = 0, max;
680
680
struct dm_target_io *tio;
681
+
682
+
ti = dm_table_find_target(ci->map, ci->sector);
683
+
if (!dm_target_is_valid(ti))
684
+
return -EIO;
685
+
686
+
max = max_io_len(ci->md, ci->sector, ti);
681
687
682
688
/*
683
689
* Allocate a target io object.
···
742
736
do {
743
737
if (offset) {
744
738
ti = dm_table_find_target(ci->map, ci->sector);
739
+
if (!dm_target_is_valid(ti))
740
+
return -EIO;
741
+
745
742
max = max_io_len(ci->md, ci->sector, ti);
746
743
747
744
tio = alloc_tio(ci->md);
···
768
759
769
760
ci->idx++;
770
761
}
762
+
763
+
return 0;
771
764
}
772
765
773
766
/*
···
778
767
static int __split_bio(struct mapped_device *md, struct bio *bio)
779
768
{
780
769
struct clone_info ci;
770
+
int error = 0;
781
771
782
772
ci.map = dm_get_table(md);
783
773
if (unlikely(!ci.map))
···
796
784
ci.idx = bio->bi_idx;
797
785
798
786
start_io_acct(ci.io);
799
-
while (ci.sector_count)
800
-
__clone_and_map(&ci);
787
+
while (ci.sector_count && !error)
788
+
error = __clone_and_map(&ci);
801
789
802
790
/* drop the extra reference count */
803
-
dec_pending(ci.io, 0);
791
+
dec_pending(ci.io, error);
804
792
dm_table_put(ci.map);
805
793
806
794
return 0;
···
1514
1502
1515
1503
dm_table_unplug_all(map);
1516
1504
1517
-
kobject_uevent(&md->disk->kobj, KOBJ_CHANGE);
1505
+
dm_kobject_uevent(md);
1518
1506
1519
1507
r = 0;
1520
1508
···
1528
1516
/*-----------------------------------------------------------------
1529
1517
* Event notification.
1530
1518
*---------------------------------------------------------------*/
1519
+
void dm_kobject_uevent(struct mapped_device *md)
1520
+
{
1521
+
kobject_uevent(&md->disk->kobj, KOBJ_CHANGE);
1522
+
}
1523
+
1531
1524
uint32_t dm_next_uevent_seq(struct mapped_device *md)
1532
1525
{
1533
1526
return atomic_add_return(1, &md->uevent_seq);
+7
drivers/md/dm.h
+7
drivers/md/dm.h
···
112
112
int dm_table_any_congested(struct dm_table *t, int bdi_bits);
113
113
void dm_table_unplug_all(struct dm_table *t);
114
114
115
+
/*
116
+
* To check the return value from dm_table_find_target().
117
+
*/
118
+
#define dm_target_is_valid(t) ((t)->table)
119
+
115
120
/*-----------------------------------------------------------------
116
121
* A registry of target types.
117
122
*---------------------------------------------------------------*/
···
186
181
union map_info *dm_get_mapinfo(struct bio *bio);
187
182
int dm_open_count(struct mapped_device *md);
188
183
int dm_lock_for_deletion(struct mapped_device *md);
184
+
185
+
void dm_kobject_uevent(struct mapped_device *md);
189
186
190
187
#endif
+1
include/linux/device-mapper.h
+1
include/linux/device-mapper.h
···
115
115
unsigned short max_hw_segments;
116
116
unsigned short hardsect_size;
117
117
unsigned int max_segment_size;
118
+
unsigned int max_hw_sectors;
118
119
unsigned long seg_boundary_mask;
119
120
unsigned long bounce_pfn;
120
121
unsigned char no_cluster; /* inverted so that 0 is default */