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
;
29 sector_t stripes_mask
;
31 /* The size of this target / num. stripes */
32 sector_t stripe_width
;
34 /* stripe chunk size */
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
;
80 if (sscanf(argv
[1], "%llu%c", &start
, &dummy
) != 1)
83 if (dm_get_device(ti
, argv
[0], dm_table_get_mode(ti
->table
),
84 &sc
->stripe
[stripe
].dev
))
87 sc
->stripe
[stripe
].physical_start
= start
;
93 * Construct a striped mapping.
94 * <number of stripes> <chunk size (2^^n)> [<dev_path> <offset>]+
96 static int stripe_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
106 ti
->error
= "Not enough arguments";
110 if (kstrtouint(argv
[0], 10, &stripes
) || !stripes
) {
111 ti
->error
= "Invalid stripe count";
115 if (kstrtouint(argv
[1], 10, &chunk_size
)) {
116 ti
->error
= "Invalid chunk_size";
121 * chunk_size is a power of two
123 if (!is_power_of_2(chunk_size
) ||
124 (chunk_size
< (PAGE_SIZE
>> SECTOR_SHIFT
))) {
125 ti
->error
= "Invalid chunk size";
129 if (ti
->len
& (chunk_size
- 1)) {
130 ti
->error
= "Target length not divisible by "
136 if (sector_div(width
, stripes
)) {
137 ti
->error
= "Target length not divisible by "
143 * Do we have enough arguments for that many stripes ?
145 if (argc
!= (2 + 2 * stripes
)) {
146 ti
->error
= "Not enough destinations "
151 sc
= alloc_context(stripes
);
153 ti
->error
= "Memory allocation for striped context "
158 INIT_WORK(&sc
->trigger_event
, trigger_event
);
160 /* Set pointer to dm target; used in trigger_event */
162 sc
->stripes
= stripes
;
163 sc
->stripe_width
= width
;
165 if (stripes
& (stripes
- 1))
166 sc
->stripes_shift
= -1;
168 sc
->stripes_shift
= ffs(stripes
) - 1;
169 sc
->stripes_mask
= ((sector_t
) stripes
) - 1;
172 ti
->split_io
= chunk_size
;
173 ti
->num_flush_requests
= stripes
;
174 ti
->num_discard_requests
= stripes
;
176 sc
->chunk_shift
= ffs(chunk_size
) - 1;
177 sc
->chunk_mask
= ((sector_t
) chunk_size
) - 1;
180 * Get the stripe destinations.
182 for (i
= 0; i
< stripes
; i
++) {
185 r
= get_stripe(ti
, sc
, i
, argv
);
187 ti
->error
= "Couldn't parse stripe destination";
189 dm_put_device(ti
, sc
->stripe
[i
].dev
);
193 atomic_set(&(sc
->stripe
[i
].error_count
), 0);
201 static void stripe_dtr(struct dm_target
*ti
)
204 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
206 for (i
= 0; i
< sc
->stripes
; i
++)
207 dm_put_device(ti
, sc
->stripe
[i
].dev
);
209 flush_work_sync(&sc
->trigger_event
);
213 static void stripe_map_sector(struct stripe_c
*sc
, sector_t sector
,
214 uint32_t *stripe
, sector_t
*result
)
216 sector_t offset
= dm_target_offset(sc
->ti
, sector
);
217 sector_t chunk
= offset
>> sc
->chunk_shift
;
219 if (sc
->stripes_shift
< 0)
220 *stripe
= sector_div(chunk
, sc
->stripes
);
222 *stripe
= chunk
& sc
->stripes_mask
;
223 chunk
>>= sc
->stripes_shift
;
226 *result
= (chunk
<< sc
->chunk_shift
) | (offset
& sc
->chunk_mask
);
229 static void stripe_map_range_sector(struct stripe_c
*sc
, sector_t sector
,
230 uint32_t target_stripe
, sector_t
*result
)
234 stripe_map_sector(sc
, sector
, &stripe
, result
);
235 if (stripe
== target_stripe
)
237 *result
&= ~sc
->chunk_mask
; /* round down */
238 if (target_stripe
< stripe
)
239 *result
+= sc
->chunk_mask
+ 1; /* next chunk */
242 static int stripe_map_discard(struct stripe_c
*sc
, struct bio
*bio
,
243 uint32_t target_stripe
)
247 stripe_map_range_sector(sc
, bio
->bi_sector
, target_stripe
, &begin
);
248 stripe_map_range_sector(sc
, bio
->bi_sector
+ bio_sectors(bio
),
249 target_stripe
, &end
);
251 bio
->bi_bdev
= sc
->stripe
[target_stripe
].dev
->bdev
;
252 bio
->bi_sector
= begin
+ sc
->stripe
[target_stripe
].physical_start
;
253 bio
->bi_size
= to_bytes(end
- begin
);
254 return DM_MAPIO_REMAPPED
;
256 /* The range doesn't map to the target stripe */
258 return DM_MAPIO_SUBMITTED
;
262 static int stripe_map(struct dm_target
*ti
, struct bio
*bio
,
263 union map_info
*map_context
)
265 struct stripe_c
*sc
= ti
->private;
267 unsigned target_request_nr
;
269 if (bio
->bi_rw
& REQ_FLUSH
) {
270 target_request_nr
= map_context
->target_request_nr
;
271 BUG_ON(target_request_nr
>= sc
->stripes
);
272 bio
->bi_bdev
= sc
->stripe
[target_request_nr
].dev
->bdev
;
273 return DM_MAPIO_REMAPPED
;
275 if (unlikely(bio
->bi_rw
& REQ_DISCARD
)) {
276 target_request_nr
= map_context
->target_request_nr
;
277 BUG_ON(target_request_nr
>= sc
->stripes
);
278 return stripe_map_discard(sc
, bio
, target_request_nr
);
281 stripe_map_sector(sc
, bio
->bi_sector
, &stripe
, &bio
->bi_sector
);
283 bio
->bi_sector
+= sc
->stripe
[stripe
].physical_start
;
284 bio
->bi_bdev
= sc
->stripe
[stripe
].dev
->bdev
;
286 return DM_MAPIO_REMAPPED
;
293 * #stripes [stripe_name <stripe_name>] [group word count]
294 * [error count 'A|D' <error count 'A|D'>]
297 * #stripes [stripe chunk size]
298 * [stripe_name physical_start <stripe_name physical_start>]
302 static int stripe_status(struct dm_target
*ti
,
303 status_type_t type
, char *result
, unsigned int maxlen
)
305 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
306 char buffer
[sc
->stripes
+ 1];
311 case STATUSTYPE_INFO
:
312 DMEMIT("%d ", sc
->stripes
);
313 for (i
= 0; i
< sc
->stripes
; i
++) {
314 DMEMIT("%s ", sc
->stripe
[i
].dev
->name
);
315 buffer
[i
] = atomic_read(&(sc
->stripe
[i
].error_count
)) ?
319 DMEMIT("1 %s", buffer
);
322 case STATUSTYPE_TABLE
:
323 DMEMIT("%d %llu", sc
->stripes
,
324 (unsigned long long)sc
->chunk_mask
+ 1);
325 for (i
= 0; i
< sc
->stripes
; i
++)
326 DMEMIT(" %s %llu", sc
->stripe
[i
].dev
->name
,
327 (unsigned long long)sc
->stripe
[i
].physical_start
);
333 static int stripe_end_io(struct dm_target
*ti
, struct bio
*bio
,
334 int error
, union map_info
*map_context
)
337 char major_minor
[16];
338 struct stripe_c
*sc
= ti
->private;
341 return 0; /* I/O complete */
343 if ((error
== -EWOULDBLOCK
) && (bio
->bi_rw
& REQ_RAHEAD
))
346 if (error
== -EOPNOTSUPP
)
349 memset(major_minor
, 0, sizeof(major_minor
));
350 sprintf(major_minor
, "%d:%d",
351 MAJOR(disk_devt(bio
->bi_bdev
->bd_disk
)),
352 MINOR(disk_devt(bio
->bi_bdev
->bd_disk
)));
355 * Test to see which stripe drive triggered the event
356 * and increment error count for all stripes on that device.
357 * If the error count for a given device exceeds the threshold
358 * value we will no longer trigger any further events.
360 for (i
= 0; i
< sc
->stripes
; i
++)
361 if (!strcmp(sc
->stripe
[i
].dev
->name
, major_minor
)) {
362 atomic_inc(&(sc
->stripe
[i
].error_count
));
363 if (atomic_read(&(sc
->stripe
[i
].error_count
)) <
364 DM_IO_ERROR_THRESHOLD
)
365 schedule_work(&sc
->trigger_event
);
371 static int stripe_iterate_devices(struct dm_target
*ti
,
372 iterate_devices_callout_fn fn
, void *data
)
374 struct stripe_c
*sc
= ti
->private;
379 ret
= fn(ti
, sc
->stripe
[i
].dev
,
380 sc
->stripe
[i
].physical_start
,
381 sc
->stripe_width
, data
);
382 } while (!ret
&& ++i
< sc
->stripes
);
387 static void stripe_io_hints(struct dm_target
*ti
,
388 struct queue_limits
*limits
)
390 struct stripe_c
*sc
= ti
->private;
391 unsigned chunk_size
= (sc
->chunk_mask
+ 1) << 9;
393 blk_limits_io_min(limits
, chunk_size
);
394 blk_limits_io_opt(limits
, chunk_size
* sc
->stripes
);
397 static int stripe_merge(struct dm_target
*ti
, struct bvec_merge_data
*bvm
,
398 struct bio_vec
*biovec
, int max_size
)
400 struct stripe_c
*sc
= ti
->private;
401 sector_t bvm_sector
= bvm
->bi_sector
;
403 struct request_queue
*q
;
405 stripe_map_sector(sc
, bvm_sector
, &stripe
, &bvm_sector
);
407 q
= bdev_get_queue(sc
->stripe
[stripe
].dev
->bdev
);
408 if (!q
->merge_bvec_fn
)
411 bvm
->bi_bdev
= sc
->stripe
[stripe
].dev
->bdev
;
412 bvm
->bi_sector
= sc
->stripe
[stripe
].physical_start
+ bvm_sector
;
414 return min(max_size
, q
->merge_bvec_fn(q
, bvm
, biovec
));
417 static struct target_type stripe_target
= {
419 .version
= {1, 4, 0},
420 .module
= THIS_MODULE
,
424 .end_io
= stripe_end_io
,
425 .status
= stripe_status
,
426 .iterate_devices
= stripe_iterate_devices
,
427 .io_hints
= stripe_io_hints
,
428 .merge
= stripe_merge
,
431 int __init
dm_stripe_init(void)
435 r
= dm_register_target(&stripe_target
);
437 DMWARN("target registration failed");
444 void dm_stripe_exit(void)
446 dm_unregister_target(&stripe_target
);