2 * Copyright (C) 2001-2003 Sistina Software (UK) Limited.
4 * This file is released under the GPL.
8 #include <linux/device-mapper.h>
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/blkdev.h>
13 #include <linux/bio.h>
14 #include <linux/dax.h>
15 #include <linux/slab.h>
16 #include <linux/log2.h>
18 #define DM_MSG_PREFIX "striped"
19 #define DM_IO_ERROR_THRESHOLD 15
23 sector_t physical_start
;
32 /* The size of this target / num. stripes */
33 sector_t stripe_width
;
38 /* Needed for handling events */
41 /* Work struct used for triggering events*/
42 struct work_struct trigger_event
;
44 struct stripe stripe
[0];
48 * An event is triggered whenever a drive
49 * drops out of a stripe volume.
51 static void trigger_event(struct work_struct
*work
)
53 struct stripe_c
*sc
= container_of(work
, struct stripe_c
,
55 dm_table_event(sc
->ti
->table
);
58 static inline struct stripe_c
*alloc_context(unsigned int stripes
)
62 if (dm_array_too_big(sizeof(struct stripe_c
), sizeof(struct stripe
),
66 len
= sizeof(struct stripe_c
) + (sizeof(struct stripe
) * stripes
);
68 return kmalloc(len
, GFP_KERNEL
);
72 * Parse a single <dev> <sector> pair
74 static int get_stripe(struct dm_target
*ti
, struct stripe_c
*sc
,
75 unsigned int stripe
, char **argv
)
77 unsigned long long start
;
81 if (sscanf(argv
[1], "%llu%c", &start
, &dummy
) != 1)
84 ret
= dm_get_device(ti
, argv
[0], dm_table_get_mode(ti
->table
),
85 &sc
->stripe
[stripe
].dev
);
89 sc
->stripe
[stripe
].physical_start
= start
;
95 * Construct a striped mapping.
96 * <number of stripes> <chunk size> [<dev_path> <offset>]+
98 static int stripe_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
101 sector_t width
, tmp_len
;
108 ti
->error
= "Not enough arguments";
112 if (kstrtouint(argv
[0], 10, &stripes
) || !stripes
) {
113 ti
->error
= "Invalid stripe count";
117 if (kstrtouint(argv
[1], 10, &chunk_size
) || !chunk_size
) {
118 ti
->error
= "Invalid chunk_size";
123 if (sector_div(width
, stripes
)) {
124 ti
->error
= "Target length not divisible by "
130 if (sector_div(tmp_len
, chunk_size
)) {
131 ti
->error
= "Target length not divisible by "
137 * Do we have enough arguments for that many stripes ?
139 if (argc
!= (2 + 2 * stripes
)) {
140 ti
->error
= "Not enough destinations "
145 sc
= alloc_context(stripes
);
147 ti
->error
= "Memory allocation for striped context "
152 INIT_WORK(&sc
->trigger_event
, trigger_event
);
154 /* Set pointer to dm target; used in trigger_event */
156 sc
->stripes
= stripes
;
157 sc
->stripe_width
= width
;
159 if (stripes
& (stripes
- 1))
160 sc
->stripes_shift
= -1;
162 sc
->stripes_shift
= __ffs(stripes
);
164 r
= dm_set_target_max_io_len(ti
, chunk_size
);
170 ti
->num_flush_bios
= stripes
;
171 ti
->num_discard_bios
= stripes
;
172 ti
->num_write_same_bios
= stripes
;
173 ti
->num_write_zeroes_bios
= stripes
;
175 sc
->chunk_size
= chunk_size
;
176 if (chunk_size
& (chunk_size
- 1))
177 sc
->chunk_size_shift
= -1;
179 sc
->chunk_size_shift
= __ffs(chunk_size
);
182 * Get the stripe destinations.
184 for (i
= 0; i
< stripes
; i
++) {
187 r
= get_stripe(ti
, sc
, i
, argv
);
189 ti
->error
= "Couldn't parse stripe destination";
191 dm_put_device(ti
, sc
->stripe
[i
].dev
);
195 atomic_set(&(sc
->stripe
[i
].error_count
), 0);
203 static void stripe_dtr(struct dm_target
*ti
)
206 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
208 for (i
= 0; i
< sc
->stripes
; i
++)
209 dm_put_device(ti
, sc
->stripe
[i
].dev
);
211 flush_work(&sc
->trigger_event
);
215 static void stripe_map_sector(struct stripe_c
*sc
, sector_t sector
,
216 uint32_t *stripe
, sector_t
*result
)
218 sector_t chunk
= dm_target_offset(sc
->ti
, sector
);
219 sector_t chunk_offset
;
221 if (sc
->chunk_size_shift
< 0)
222 chunk_offset
= sector_div(chunk
, sc
->chunk_size
);
224 chunk_offset
= chunk
& (sc
->chunk_size
- 1);
225 chunk
>>= sc
->chunk_size_shift
;
228 if (sc
->stripes_shift
< 0)
229 *stripe
= sector_div(chunk
, sc
->stripes
);
231 *stripe
= chunk
& (sc
->stripes
- 1);
232 chunk
>>= sc
->stripes_shift
;
235 if (sc
->chunk_size_shift
< 0)
236 chunk
*= sc
->chunk_size
;
238 chunk
<<= sc
->chunk_size_shift
;
240 *result
= chunk
+ chunk_offset
;
243 static void stripe_map_range_sector(struct stripe_c
*sc
, sector_t sector
,
244 uint32_t target_stripe
, sector_t
*result
)
248 stripe_map_sector(sc
, sector
, &stripe
, result
);
249 if (stripe
== target_stripe
)
254 if (sc
->chunk_size_shift
< 0)
255 *result
-= sector_div(sector
, sc
->chunk_size
);
257 *result
= sector
& ~(sector_t
)(sc
->chunk_size
- 1);
259 if (target_stripe
< stripe
)
260 *result
+= sc
->chunk_size
; /* next chunk */
263 static int stripe_map_range(struct stripe_c
*sc
, struct bio
*bio
,
264 uint32_t target_stripe
)
268 stripe_map_range_sector(sc
, bio
->bi_iter
.bi_sector
,
269 target_stripe
, &begin
);
270 stripe_map_range_sector(sc
, bio_end_sector(bio
),
271 target_stripe
, &end
);
273 bio
->bi_bdev
= sc
->stripe
[target_stripe
].dev
->bdev
;
274 bio
->bi_iter
.bi_sector
= begin
+
275 sc
->stripe
[target_stripe
].physical_start
;
276 bio
->bi_iter
.bi_size
= to_bytes(end
- begin
);
277 return DM_MAPIO_REMAPPED
;
279 /* The range doesn't map to the target stripe */
281 return DM_MAPIO_SUBMITTED
;
285 static int stripe_map(struct dm_target
*ti
, struct bio
*bio
)
287 struct stripe_c
*sc
= ti
->private;
289 unsigned target_bio_nr
;
291 if (bio
->bi_opf
& REQ_PREFLUSH
) {
292 target_bio_nr
= dm_bio_get_target_bio_nr(bio
);
293 BUG_ON(target_bio_nr
>= sc
->stripes
);
294 bio
->bi_bdev
= sc
->stripe
[target_bio_nr
].dev
->bdev
;
295 return DM_MAPIO_REMAPPED
;
297 if (unlikely(bio_op(bio
) == REQ_OP_DISCARD
) ||
298 unlikely(bio_op(bio
) == REQ_OP_WRITE_ZEROES
) ||
299 unlikely(bio_op(bio
) == REQ_OP_WRITE_SAME
)) {
300 target_bio_nr
= dm_bio_get_target_bio_nr(bio
);
301 BUG_ON(target_bio_nr
>= sc
->stripes
);
302 return stripe_map_range(sc
, bio
, target_bio_nr
);
305 stripe_map_sector(sc
, bio
->bi_iter
.bi_sector
,
306 &stripe
, &bio
->bi_iter
.bi_sector
);
308 bio
->bi_iter
.bi_sector
+= sc
->stripe
[stripe
].physical_start
;
309 bio
->bi_bdev
= sc
->stripe
[stripe
].dev
->bdev
;
311 return DM_MAPIO_REMAPPED
;
314 static long stripe_dax_direct_access(struct dm_target
*ti
, pgoff_t pgoff
,
315 long nr_pages
, void **kaddr
, pfn_t
*pfn
)
317 sector_t dev_sector
, sector
= pgoff
* PAGE_SECTORS
;
318 struct stripe_c
*sc
= ti
->private;
319 struct dax_device
*dax_dev
;
320 struct block_device
*bdev
;
324 stripe_map_sector(sc
, sector
, &stripe
, &dev_sector
);
325 dev_sector
+= sc
->stripe
[stripe
].physical_start
;
326 dax_dev
= sc
->stripe
[stripe
].dev
->dax_dev
;
327 bdev
= sc
->stripe
[stripe
].dev
->bdev
;
329 ret
= bdev_dax_pgoff(bdev
, dev_sector
, nr_pages
* PAGE_SIZE
, &pgoff
);
332 return dax_direct_access(dax_dev
, pgoff
, nr_pages
, kaddr
, pfn
);
339 * #stripes [stripe_name <stripe_name>] [group word count]
340 * [error count 'A|D' <error count 'A|D'>]
343 * #stripes [stripe chunk size]
344 * [stripe_name physical_start <stripe_name physical_start>]
348 static void stripe_status(struct dm_target
*ti
, status_type_t type
,
349 unsigned status_flags
, char *result
, unsigned maxlen
)
351 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
352 char buffer
[sc
->stripes
+ 1];
357 case STATUSTYPE_INFO
:
358 DMEMIT("%d ", sc
->stripes
);
359 for (i
= 0; i
< sc
->stripes
; i
++) {
360 DMEMIT("%s ", sc
->stripe
[i
].dev
->name
);
361 buffer
[i
] = atomic_read(&(sc
->stripe
[i
].error_count
)) ?
365 DMEMIT("1 %s", buffer
);
368 case STATUSTYPE_TABLE
:
369 DMEMIT("%d %llu", sc
->stripes
,
370 (unsigned long long)sc
->chunk_size
);
371 for (i
= 0; i
< sc
->stripes
; i
++)
372 DMEMIT(" %s %llu", sc
->stripe
[i
].dev
->name
,
373 (unsigned long long)sc
->stripe
[i
].physical_start
);
378 static int stripe_end_io(struct dm_target
*ti
, struct bio
*bio
, int error
)
381 char major_minor
[16];
382 struct stripe_c
*sc
= ti
->private;
385 return 0; /* I/O complete */
387 if ((error
== -EWOULDBLOCK
) && (bio
->bi_opf
& REQ_RAHEAD
))
390 if (error
== -EOPNOTSUPP
)
393 memset(major_minor
, 0, sizeof(major_minor
));
394 sprintf(major_minor
, "%d:%d",
395 MAJOR(disk_devt(bio
->bi_bdev
->bd_disk
)),
396 MINOR(disk_devt(bio
->bi_bdev
->bd_disk
)));
399 * Test to see which stripe drive triggered the event
400 * and increment error count for all stripes on that device.
401 * If the error count for a given device exceeds the threshold
402 * value we will no longer trigger any further events.
404 for (i
= 0; i
< sc
->stripes
; i
++)
405 if (!strcmp(sc
->stripe
[i
].dev
->name
, major_minor
)) {
406 atomic_inc(&(sc
->stripe
[i
].error_count
));
407 if (atomic_read(&(sc
->stripe
[i
].error_count
)) <
408 DM_IO_ERROR_THRESHOLD
)
409 schedule_work(&sc
->trigger_event
);
415 static int stripe_iterate_devices(struct dm_target
*ti
,
416 iterate_devices_callout_fn fn
, void *data
)
418 struct stripe_c
*sc
= ti
->private;
423 ret
= fn(ti
, sc
->stripe
[i
].dev
,
424 sc
->stripe
[i
].physical_start
,
425 sc
->stripe_width
, data
);
426 } while (!ret
&& ++i
< sc
->stripes
);
431 static void stripe_io_hints(struct dm_target
*ti
,
432 struct queue_limits
*limits
)
434 struct stripe_c
*sc
= ti
->private;
435 unsigned chunk_size
= sc
->chunk_size
<< SECTOR_SHIFT
;
437 blk_limits_io_min(limits
, chunk_size
);
438 blk_limits_io_opt(limits
, chunk_size
* sc
->stripes
);
441 static struct target_type stripe_target
= {
443 .version
= {1, 6, 0},
444 .features
= DM_TARGET_PASSES_INTEGRITY
,
445 .module
= THIS_MODULE
,
449 .end_io
= stripe_end_io
,
450 .status
= stripe_status
,
451 .iterate_devices
= stripe_iterate_devices
,
452 .io_hints
= stripe_io_hints
,
453 .direct_access
= stripe_dax_direct_access
,
456 int __init
dm_stripe_init(void)
460 r
= dm_register_target(&stripe_target
);
462 DMWARN("target registration failed");
467 void dm_stripe_exit(void)
469 dm_unregister_target(&stripe_target
);