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 "
135 if (sector_div(width
, stripes
)) {
136 ti
->error
= "Target length not divisible by "
142 * Do we have enough arguments for that many stripes ?
144 if (argc
!= (2 + 2 * stripes
)) {
145 ti
->error
= "Not enough destinations "
150 sc
= alloc_context(stripes
);
152 ti
->error
= "Memory allocation for striped context "
157 INIT_WORK(&sc
->trigger_event
, trigger_event
);
159 /* Set pointer to dm target; used in trigger_event */
161 sc
->stripes
= stripes
;
162 sc
->stripe_width
= width
;
164 if (stripes
& (stripes
- 1))
165 sc
->stripes_shift
= -1;
167 sc
->stripes_shift
= ffs(stripes
) - 1;
168 sc
->stripes_mask
= ((sector_t
) stripes
) - 1;
171 ti
->split_io
= chunk_size
;
172 ti
->num_flush_requests
= stripes
;
173 ti
->num_discard_requests
= stripes
;
175 sc
->chunk_shift
= ffs(chunk_size
) - 1;
176 sc
->chunk_mask
= ((sector_t
) chunk_size
) - 1;
179 * Get the stripe destinations.
181 for (i
= 0; i
< stripes
; i
++) {
184 r
= get_stripe(ti
, sc
, i
, argv
);
186 ti
->error
= "Couldn't parse stripe destination";
188 dm_put_device(ti
, sc
->stripe
[i
].dev
);
192 atomic_set(&(sc
->stripe
[i
].error_count
), 0);
200 static void stripe_dtr(struct dm_target
*ti
)
203 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
205 for (i
= 0; i
< sc
->stripes
; i
++)
206 dm_put_device(ti
, sc
->stripe
[i
].dev
);
208 flush_work_sync(&sc
->trigger_event
);
212 static void stripe_map_sector(struct stripe_c
*sc
, sector_t sector
,
213 uint32_t *stripe
, sector_t
*result
)
215 sector_t offset
= dm_target_offset(sc
->ti
, sector
);
216 sector_t chunk
= offset
>> sc
->chunk_shift
;
218 if (sc
->stripes_shift
< 0)
219 *stripe
= sector_div(chunk
, sc
->stripes
);
221 *stripe
= chunk
& sc
->stripes_mask
;
222 chunk
>>= sc
->stripes_shift
;
225 *result
= (chunk
<< sc
->chunk_shift
) | (offset
& sc
->chunk_mask
);
228 static void stripe_map_range_sector(struct stripe_c
*sc
, sector_t sector
,
229 uint32_t target_stripe
, sector_t
*result
)
233 stripe_map_sector(sc
, sector
, &stripe
, result
);
234 if (stripe
== target_stripe
)
236 *result
&= ~sc
->chunk_mask
; /* round down */
237 if (target_stripe
< stripe
)
238 *result
+= sc
->chunk_mask
+ 1; /* next chunk */
241 static int stripe_map_discard(struct stripe_c
*sc
, struct bio
*bio
,
242 uint32_t target_stripe
)
246 stripe_map_range_sector(sc
, bio
->bi_sector
, target_stripe
, &begin
);
247 stripe_map_range_sector(sc
, bio
->bi_sector
+ bio_sectors(bio
),
248 target_stripe
, &end
);
250 bio
->bi_bdev
= sc
->stripe
[target_stripe
].dev
->bdev
;
251 bio
->bi_sector
= begin
+ sc
->stripe
[target_stripe
].physical_start
;
252 bio
->bi_size
= to_bytes(end
- begin
);
253 return DM_MAPIO_REMAPPED
;
255 /* The range doesn't map to the target stripe */
257 return DM_MAPIO_SUBMITTED
;
261 static int stripe_map(struct dm_target
*ti
, struct bio
*bio
,
262 union map_info
*map_context
)
264 struct stripe_c
*sc
= ti
->private;
266 unsigned target_request_nr
;
268 if (bio
->bi_rw
& REQ_FLUSH
) {
269 target_request_nr
= map_context
->target_request_nr
;
270 BUG_ON(target_request_nr
>= sc
->stripes
);
271 bio
->bi_bdev
= sc
->stripe
[target_request_nr
].dev
->bdev
;
272 return DM_MAPIO_REMAPPED
;
274 if (unlikely(bio
->bi_rw
& REQ_DISCARD
)) {
275 target_request_nr
= map_context
->target_request_nr
;
276 BUG_ON(target_request_nr
>= sc
->stripes
);
277 return stripe_map_discard(sc
, bio
, target_request_nr
);
280 stripe_map_sector(sc
, bio
->bi_sector
, &stripe
, &bio
->bi_sector
);
282 bio
->bi_sector
+= sc
->stripe
[stripe
].physical_start
;
283 bio
->bi_bdev
= sc
->stripe
[stripe
].dev
->bdev
;
285 return DM_MAPIO_REMAPPED
;
292 * #stripes [stripe_name <stripe_name>] [group word count]
293 * [error count 'A|D' <error count 'A|D'>]
296 * #stripes [stripe chunk size]
297 * [stripe_name physical_start <stripe_name physical_start>]
301 static int stripe_status(struct dm_target
*ti
,
302 status_type_t type
, char *result
, unsigned int maxlen
)
304 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
305 char buffer
[sc
->stripes
+ 1];
310 case STATUSTYPE_INFO
:
311 DMEMIT("%d ", sc
->stripes
);
312 for (i
= 0; i
< sc
->stripes
; i
++) {
313 DMEMIT("%s ", sc
->stripe
[i
].dev
->name
);
314 buffer
[i
] = atomic_read(&(sc
->stripe
[i
].error_count
)) ?
318 DMEMIT("1 %s", buffer
);
321 case STATUSTYPE_TABLE
:
322 DMEMIT("%d %llu", sc
->stripes
,
323 (unsigned long long)sc
->chunk_mask
+ 1);
324 for (i
= 0; i
< sc
->stripes
; i
++)
325 DMEMIT(" %s %llu", sc
->stripe
[i
].dev
->name
,
326 (unsigned long long)sc
->stripe
[i
].physical_start
);
332 static int stripe_end_io(struct dm_target
*ti
, struct bio
*bio
,
333 int error
, union map_info
*map_context
)
336 char major_minor
[16];
337 struct stripe_c
*sc
= ti
->private;
340 return 0; /* I/O complete */
342 if ((error
== -EWOULDBLOCK
) && (bio
->bi_rw
& REQ_RAHEAD
))
345 if (error
== -EOPNOTSUPP
)
348 memset(major_minor
, 0, sizeof(major_minor
));
349 sprintf(major_minor
, "%d:%d",
350 MAJOR(disk_devt(bio
->bi_bdev
->bd_disk
)),
351 MINOR(disk_devt(bio
->bi_bdev
->bd_disk
)));
354 * Test to see which stripe drive triggered the event
355 * and increment error count for all stripes on that device.
356 * If the error count for a given device exceeds the threshold
357 * value we will no longer trigger any further events.
359 for (i
= 0; i
< sc
->stripes
; i
++)
360 if (!strcmp(sc
->stripe
[i
].dev
->name
, major_minor
)) {
361 atomic_inc(&(sc
->stripe
[i
].error_count
));
362 if (atomic_read(&(sc
->stripe
[i
].error_count
)) <
363 DM_IO_ERROR_THRESHOLD
)
364 schedule_work(&sc
->trigger_event
);
370 static int stripe_iterate_devices(struct dm_target
*ti
,
371 iterate_devices_callout_fn fn
, void *data
)
373 struct stripe_c
*sc
= ti
->private;
378 ret
= fn(ti
, sc
->stripe
[i
].dev
,
379 sc
->stripe
[i
].physical_start
,
380 sc
->stripe_width
, data
);
381 } while (!ret
&& ++i
< sc
->stripes
);
386 static void stripe_io_hints(struct dm_target
*ti
,
387 struct queue_limits
*limits
)
389 struct stripe_c
*sc
= ti
->private;
390 unsigned chunk_size
= (sc
->chunk_mask
+ 1) << 9;
392 blk_limits_io_min(limits
, chunk_size
);
393 blk_limits_io_opt(limits
, chunk_size
* sc
->stripes
);
396 static int stripe_merge(struct dm_target
*ti
, struct bvec_merge_data
*bvm
,
397 struct bio_vec
*biovec
, int max_size
)
399 struct stripe_c
*sc
= ti
->private;
400 sector_t bvm_sector
= bvm
->bi_sector
;
402 struct request_queue
*q
;
404 stripe_map_sector(sc
, bvm_sector
, &stripe
, &bvm_sector
);
406 q
= bdev_get_queue(sc
->stripe
[stripe
].dev
->bdev
);
407 if (!q
->merge_bvec_fn
)
410 bvm
->bi_bdev
= sc
->stripe
[stripe
].dev
->bdev
;
411 bvm
->bi_sector
= sc
->stripe
[stripe
].physical_start
+ bvm_sector
;
413 return min(max_size
, q
->merge_bvec_fn(q
, bvm
, biovec
));
416 static struct target_type stripe_target
= {
418 .version
= {1, 4, 0},
419 .module
= THIS_MODULE
,
423 .end_io
= stripe_end_io
,
424 .status
= stripe_status
,
425 .iterate_devices
= stripe_iterate_devices
,
426 .io_hints
= stripe_io_hints
,
427 .merge
= stripe_merge
,
430 int __init
dm_stripe_init(void)
434 r
= dm_register_target(&stripe_target
);
436 DMWARN("target registration failed");
443 void dm_stripe_exit(void)
445 dm_unregister_target(&stripe_target
);