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
;
33 /* stripe chunk size */
37 /* Needed for handling events */
40 /* Work struct used for triggering events*/
41 struct work_struct trigger_event
;
43 struct stripe stripe
[0];
47 * An event is triggered whenever a drive
48 * drops out of a stripe volume.
50 static void trigger_event(struct work_struct
*work
)
52 struct stripe_c
*sc
= container_of(work
, struct stripe_c
,
54 dm_table_event(sc
->ti
->table
);
57 static inline struct stripe_c
*alloc_context(unsigned int stripes
)
61 if (dm_array_too_big(sizeof(struct stripe_c
), sizeof(struct stripe
),
65 len
= sizeof(struct stripe_c
) + (sizeof(struct stripe
) * stripes
);
67 return kmalloc(len
, GFP_KERNEL
);
71 * Parse a single <dev> <sector> pair
73 static int get_stripe(struct dm_target
*ti
, struct stripe_c
*sc
,
74 unsigned int stripe
, char **argv
)
76 unsigned long long start
;
79 if (sscanf(argv
[1], "%llu%c", &start
, &dummy
) != 1)
82 if (dm_get_device(ti
, argv
[0], dm_table_get_mode(ti
->table
),
83 &sc
->stripe
[stripe
].dev
))
86 sc
->stripe
[stripe
].physical_start
= start
;
92 * Construct a striped mapping.
93 * <number of stripes> <chunk size (2^^n)> [<dev_path> <offset>]+
95 static int stripe_ctr(struct dm_target
*ti
, unsigned int argc
, char **argv
)
105 ti
->error
= "Not enough arguments";
109 if (kstrtouint(argv
[0], 10, &stripes
) || !stripes
) {
110 ti
->error
= "Invalid stripe count";
114 if (kstrtouint(argv
[1], 10, &chunk_size
)) {
115 ti
->error
= "Invalid chunk_size";
120 * chunk_size is a power of two
122 if (!is_power_of_2(chunk_size
) ||
123 (chunk_size
< (PAGE_SIZE
>> SECTOR_SHIFT
))) {
124 ti
->error
= "Invalid chunk size";
128 if (ti
->len
& (chunk_size
- 1)) {
129 ti
->error
= "Target length not divisible by "
134 if (sector_div(width
, stripes
)) {
135 ti
->error
= "Target length not divisible by "
141 * Do we have enough arguments for that many stripes ?
143 if (argc
!= (2 + 2 * stripes
)) {
144 ti
->error
= "Not enough destinations "
149 sc
= alloc_context(stripes
);
151 ti
->error
= "Memory allocation for striped context "
156 INIT_WORK(&sc
->trigger_event
, trigger_event
);
158 /* Set pointer to dm target; used in trigger_event */
160 sc
->stripes
= stripes
;
161 sc
->stripe_width
= width
;
163 if (stripes
& (stripes
- 1))
164 sc
->stripes_shift
= -1;
166 sc
->stripes_shift
= __ffs(stripes
);
168 r
= dm_set_target_max_io_len(ti
, 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
- 1);
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
);