2 * Copyright (C) 2001-2003 Sistina Software (UK) Limited.
4 * This file is released under the GPL.
7 #include <linux/device-mapper.h>
9 #include <linux/module.h>
10 #include <linux/init.h>
11 #include <linux/blkdev.h>
12 #include <linux/bio.h>
13 #include <linux/slab.h>
14 #include <linux/log2.h>
16 #define DM_MSG_PREFIX "striped"
17 #define DM_IO_ERROR_THRESHOLD 15
21 sector_t physical_start
;
30 /* The size of this target / num. stripes */
31 sector_t stripe_width
;
35 /* Needed for handling events */
38 /* Work struct used for triggering events*/
39 struct work_struct trigger_event
;
41 struct stripe stripe
[0];
45 * An event is triggered whenever a drive
46 * drops out of a stripe volume.
48 static void trigger_event(struct work_struct
*work
)
50 struct stripe_c
*sc
= container_of(work
, struct stripe_c
,
52 dm_table_event(sc
->ti
->table
);
55 static inline struct stripe_c
*alloc_context(unsigned int stripes
)
59 if (dm_array_too_big(sizeof(struct stripe_c
), sizeof(struct stripe
),
63 len
= sizeof(struct stripe_c
) + (sizeof(struct stripe
) * stripes
);
65 return kmalloc(len
, GFP_KERNEL
);
69 * Parse a single <dev> <sector> pair
71 static int get_stripe(struct dm_target
*ti
, struct stripe_c
*sc
,
72 unsigned int stripe
, char **argv
)
74 unsigned long long start
;
77 if (sscanf(argv
[1], "%llu%c", &start
, &dummy
) != 1)
80 if (dm_get_device(ti
, argv
[0], dm_table_get_mode(ti
->table
),
81 &sc
->stripe
[stripe
].dev
))
84 sc
->stripe
[stripe
].physical_start
= start
;
90 * Construct a striped mapping.
91 * <number of stripes> <chunk size> [<dev_path> <offset>]+
93 static int stripe_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
103 ti
->error
= "Not enough arguments";
107 if (kstrtouint(argv
[0], 10, &stripes
) || !stripes
) {
108 ti
->error
= "Invalid stripe count";
112 if (kstrtouint(argv
[1], 10, &chunk_size
) || !chunk_size
) {
113 ti
->error
= "Invalid chunk_size";
118 if (sector_div(width
, chunk_size
)) {
119 ti
->error
= "Target length not divisible by "
124 if (sector_div(width
, stripes
)) {
125 ti
->error
= "Target length not divisible by "
131 * Do we have enough arguments for that many stripes ?
133 if (argc
!= (2 + 2 * stripes
)) {
134 ti
->error
= "Not enough destinations "
139 sc
= alloc_context(stripes
);
141 ti
->error
= "Memory allocation for striped context "
146 INIT_WORK(&sc
->trigger_event
, trigger_event
);
148 /* Set pointer to dm target; used in trigger_event */
150 sc
->stripes
= stripes
;
151 sc
->stripe_width
= width
;
153 if (stripes
& (stripes
- 1))
154 sc
->stripes_shift
= -1;
156 sc
->stripes_shift
= __ffs(stripes
);
158 r
= dm_set_target_max_io_len(ti
, chunk_size
);
162 ti
->num_flush_requests
= stripes
;
163 ti
->num_discard_requests
= stripes
;
165 sc
->chunk_size
= chunk_size
;
168 * Get the stripe destinations.
170 for (i
= 0; i
< stripes
; i
++) {
173 r
= get_stripe(ti
, sc
, i
, argv
);
175 ti
->error
= "Couldn't parse stripe destination";
177 dm_put_device(ti
, sc
->stripe
[i
].dev
);
181 atomic_set(&(sc
->stripe
[i
].error_count
), 0);
189 static void stripe_dtr(struct dm_target
*ti
)
192 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
194 for (i
= 0; i
< sc
->stripes
; i
++)
195 dm_put_device(ti
, sc
->stripe
[i
].dev
);
197 flush_work_sync(&sc
->trigger_event
);
201 static void stripe_map_sector(struct stripe_c
*sc
, sector_t sector
,
202 uint32_t *stripe
, sector_t
*result
)
204 sector_t chunk
= dm_target_offset(sc
->ti
, sector
);
205 sector_t chunk_offset
= sector_div(chunk
, sc
->chunk_size
);
207 if (sc
->stripes_shift
< 0)
208 *stripe
= sector_div(chunk
, sc
->stripes
);
210 *stripe
= chunk
& (sc
->stripes
- 1);
211 chunk
>>= sc
->stripes_shift
;
214 *result
= (chunk
* sc
->chunk_size
) + chunk_offset
;
217 static void stripe_map_range_sector(struct stripe_c
*sc
, sector_t sector
,
218 uint32_t target_stripe
, sector_t
*result
)
222 stripe_map_sector(sc
, sector
, &stripe
, result
);
223 if (stripe
== target_stripe
)
228 *result
-= sector_div(sector
, sc
->chunk_size
);
230 if (target_stripe
< stripe
)
231 *result
+= sc
->chunk_size
; /* next chunk */
234 static int stripe_map_discard(struct stripe_c
*sc
, struct bio
*bio
,
235 uint32_t target_stripe
)
239 stripe_map_range_sector(sc
, bio
->bi_sector
, target_stripe
, &begin
);
240 stripe_map_range_sector(sc
, bio
->bi_sector
+ bio_sectors(bio
),
241 target_stripe
, &end
);
243 bio
->bi_bdev
= sc
->stripe
[target_stripe
].dev
->bdev
;
244 bio
->bi_sector
= begin
+ sc
->stripe
[target_stripe
].physical_start
;
245 bio
->bi_size
= to_bytes(end
- begin
);
246 return DM_MAPIO_REMAPPED
;
248 /* The range doesn't map to the target stripe */
250 return DM_MAPIO_SUBMITTED
;
254 static int stripe_map(struct dm_target
*ti
, struct bio
*bio
,
255 union map_info
*map_context
)
257 struct stripe_c
*sc
= ti
->private;
259 unsigned target_request_nr
;
261 if (bio
->bi_rw
& REQ_FLUSH
) {
262 target_request_nr
= map_context
->target_request_nr
;
263 BUG_ON(target_request_nr
>= sc
->stripes
);
264 bio
->bi_bdev
= sc
->stripe
[target_request_nr
].dev
->bdev
;
265 return DM_MAPIO_REMAPPED
;
267 if (unlikely(bio
->bi_rw
& REQ_DISCARD
)) {
268 target_request_nr
= map_context
->target_request_nr
;
269 BUG_ON(target_request_nr
>= sc
->stripes
);
270 return stripe_map_discard(sc
, bio
, target_request_nr
);
273 stripe_map_sector(sc
, bio
->bi_sector
, &stripe
, &bio
->bi_sector
);
275 bio
->bi_sector
+= sc
->stripe
[stripe
].physical_start
;
276 bio
->bi_bdev
= sc
->stripe
[stripe
].dev
->bdev
;
278 return DM_MAPIO_REMAPPED
;
285 * #stripes [stripe_name <stripe_name>] [group word count]
286 * [error count 'A|D' <error count 'A|D'>]
289 * #stripes [stripe chunk size]
290 * [stripe_name physical_start <stripe_name physical_start>]
294 static int stripe_status(struct dm_target
*ti
,
295 status_type_t type
, char *result
, unsigned int maxlen
)
297 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
298 char buffer
[sc
->stripes
+ 1];
303 case STATUSTYPE_INFO
:
304 DMEMIT("%d ", sc
->stripes
);
305 for (i
= 0; i
< sc
->stripes
; i
++) {
306 DMEMIT("%s ", sc
->stripe
[i
].dev
->name
);
307 buffer
[i
] = atomic_read(&(sc
->stripe
[i
].error_count
)) ?
311 DMEMIT("1 %s", buffer
);
314 case STATUSTYPE_TABLE
:
315 DMEMIT("%d %llu", sc
->stripes
,
316 (unsigned long long)sc
->chunk_size
);
317 for (i
= 0; i
< sc
->stripes
; i
++)
318 DMEMIT(" %s %llu", sc
->stripe
[i
].dev
->name
,
319 (unsigned long long)sc
->stripe
[i
].physical_start
);
325 static int stripe_end_io(struct dm_target
*ti
, struct bio
*bio
,
326 int error
, union map_info
*map_context
)
329 char major_minor
[16];
330 struct stripe_c
*sc
= ti
->private;
333 return 0; /* I/O complete */
335 if ((error
== -EWOULDBLOCK
) && (bio
->bi_rw
& REQ_RAHEAD
))
338 if (error
== -EOPNOTSUPP
)
341 memset(major_minor
, 0, sizeof(major_minor
));
342 sprintf(major_minor
, "%d:%d",
343 MAJOR(disk_devt(bio
->bi_bdev
->bd_disk
)),
344 MINOR(disk_devt(bio
->bi_bdev
->bd_disk
)));
347 * Test to see which stripe drive triggered the event
348 * and increment error count for all stripes on that device.
349 * If the error count for a given device exceeds the threshold
350 * value we will no longer trigger any further events.
352 for (i
= 0; i
< sc
->stripes
; i
++)
353 if (!strcmp(sc
->stripe
[i
].dev
->name
, major_minor
)) {
354 atomic_inc(&(sc
->stripe
[i
].error_count
));
355 if (atomic_read(&(sc
->stripe
[i
].error_count
)) <
356 DM_IO_ERROR_THRESHOLD
)
357 schedule_work(&sc
->trigger_event
);
363 static int stripe_iterate_devices(struct dm_target
*ti
,
364 iterate_devices_callout_fn fn
, void *data
)
366 struct stripe_c
*sc
= ti
->private;
371 ret
= fn(ti
, sc
->stripe
[i
].dev
,
372 sc
->stripe
[i
].physical_start
,
373 sc
->stripe_width
, data
);
374 } while (!ret
&& ++i
< sc
->stripes
);
379 static void stripe_io_hints(struct dm_target
*ti
,
380 struct queue_limits
*limits
)
382 struct stripe_c
*sc
= ti
->private;
383 unsigned chunk_size
= sc
->chunk_size
<< SECTOR_SHIFT
;
385 blk_limits_io_min(limits
, chunk_size
);
386 blk_limits_io_opt(limits
, chunk_size
* sc
->stripes
);
389 static int stripe_merge(struct dm_target
*ti
, struct bvec_merge_data
*bvm
,
390 struct bio_vec
*biovec
, int max_size
)
392 struct stripe_c
*sc
= ti
->private;
393 sector_t bvm_sector
= bvm
->bi_sector
;
395 struct request_queue
*q
;
397 stripe_map_sector(sc
, bvm_sector
, &stripe
, &bvm_sector
);
399 q
= bdev_get_queue(sc
->stripe
[stripe
].dev
->bdev
);
400 if (!q
->merge_bvec_fn
)
403 bvm
->bi_bdev
= sc
->stripe
[stripe
].dev
->bdev
;
404 bvm
->bi_sector
= sc
->stripe
[stripe
].physical_start
+ bvm_sector
;
406 return min(max_size
, q
->merge_bvec_fn(q
, bvm
, biovec
));
409 static struct target_type stripe_target
= {
411 .version
= {1, 5, 0},
412 .module
= THIS_MODULE
,
416 .end_io
= stripe_end_io
,
417 .status
= stripe_status
,
418 .iterate_devices
= stripe_iterate_devices
,
419 .io_hints
= stripe_io_hints
,
420 .merge
= stripe_merge
,
423 int __init
dm_stripe_init(void)
427 r
= dm_register_target(&stripe_target
);
429 DMWARN("target registration failed");
436 void dm_stripe_exit(void)
438 dm_unregister_target(&stripe_target
);