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
) ||
113 (chunk_size
< (PAGE_SIZE
>> SECTOR_SHIFT
))) {
114 ti
->error
= "Invalid chunk_size";
119 if (sector_div(width
, chunk_size
)) {
120 ti
->error
= "Target length not divisible by "
125 if (sector_div(width
, stripes
)) {
126 ti
->error
= "Target length not divisible by "
132 * Do we have enough arguments for that many stripes ?
134 if (argc
!= (2 + 2 * stripes
)) {
135 ti
->error
= "Not enough destinations "
140 sc
= alloc_context(stripes
);
142 ti
->error
= "Memory allocation for striped context "
147 INIT_WORK(&sc
->trigger_event
, trigger_event
);
149 /* Set pointer to dm target; used in trigger_event */
151 sc
->stripes
= stripes
;
152 sc
->stripe_width
= width
;
154 if (stripes
& (stripes
- 1))
155 sc
->stripes_shift
= -1;
157 sc
->stripes_shift
= __ffs(stripes
);
159 r
= dm_set_target_max_io_len(ti
, chunk_size
);
163 ti
->num_flush_requests
= stripes
;
164 ti
->num_discard_requests
= stripes
;
166 sc
->chunk_size
= chunk_size
;
169 * Get the stripe destinations.
171 for (i
= 0; i
< stripes
; i
++) {
174 r
= get_stripe(ti
, sc
, i
, argv
);
176 ti
->error
= "Couldn't parse stripe destination";
178 dm_put_device(ti
, sc
->stripe
[i
].dev
);
182 atomic_set(&(sc
->stripe
[i
].error_count
), 0);
190 static void stripe_dtr(struct dm_target
*ti
)
193 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
195 for (i
= 0; i
< sc
->stripes
; i
++)
196 dm_put_device(ti
, sc
->stripe
[i
].dev
);
198 flush_work_sync(&sc
->trigger_event
);
202 static void stripe_map_sector(struct stripe_c
*sc
, sector_t sector
,
203 uint32_t *stripe
, sector_t
*result
)
205 sector_t chunk
= dm_target_offset(sc
->ti
, sector
);
206 sector_t chunk_offset
= sector_div(chunk
, sc
->chunk_size
);
208 if (sc
->stripes_shift
< 0)
209 *stripe
= sector_div(chunk
, sc
->stripes
);
211 *stripe
= chunk
& (sc
->stripes
- 1);
212 chunk
>>= sc
->stripes_shift
;
215 *result
= (chunk
* sc
->chunk_size
) + chunk_offset
;
218 static void stripe_map_range_sector(struct stripe_c
*sc
, sector_t sector
,
219 uint32_t target_stripe
, sector_t
*result
)
223 stripe_map_sector(sc
, sector
, &stripe
, result
);
224 if (stripe
== target_stripe
)
229 *result
-= sector_div(sector
, sc
->chunk_size
);
231 if (target_stripe
< stripe
)
232 *result
+= sc
->chunk_size
; /* next chunk */
235 static int stripe_map_discard(struct stripe_c
*sc
, struct bio
*bio
,
236 uint32_t target_stripe
)
240 stripe_map_range_sector(sc
, bio
->bi_sector
, target_stripe
, &begin
);
241 stripe_map_range_sector(sc
, bio
->bi_sector
+ bio_sectors(bio
),
242 target_stripe
, &end
);
244 bio
->bi_bdev
= sc
->stripe
[target_stripe
].dev
->bdev
;
245 bio
->bi_sector
= begin
+ sc
->stripe
[target_stripe
].physical_start
;
246 bio
->bi_size
= to_bytes(end
- begin
);
247 return DM_MAPIO_REMAPPED
;
249 /* The range doesn't map to the target stripe */
251 return DM_MAPIO_SUBMITTED
;
255 static int stripe_map(struct dm_target
*ti
, struct bio
*bio
,
256 union map_info
*map_context
)
258 struct stripe_c
*sc
= ti
->private;
260 unsigned target_request_nr
;
262 if (bio
->bi_rw
& REQ_FLUSH
) {
263 target_request_nr
= map_context
->target_request_nr
;
264 BUG_ON(target_request_nr
>= sc
->stripes
);
265 bio
->bi_bdev
= sc
->stripe
[target_request_nr
].dev
->bdev
;
266 return DM_MAPIO_REMAPPED
;
268 if (unlikely(bio
->bi_rw
& REQ_DISCARD
)) {
269 target_request_nr
= map_context
->target_request_nr
;
270 BUG_ON(target_request_nr
>= sc
->stripes
);
271 return stripe_map_discard(sc
, bio
, target_request_nr
);
274 stripe_map_sector(sc
, bio
->bi_sector
, &stripe
, &bio
->bi_sector
);
276 bio
->bi_sector
+= sc
->stripe
[stripe
].physical_start
;
277 bio
->bi_bdev
= sc
->stripe
[stripe
].dev
->bdev
;
279 return DM_MAPIO_REMAPPED
;
286 * #stripes [stripe_name <stripe_name>] [group word count]
287 * [error count 'A|D' <error count 'A|D'>]
290 * #stripes [stripe chunk size]
291 * [stripe_name physical_start <stripe_name physical_start>]
295 static int stripe_status(struct dm_target
*ti
,
296 status_type_t type
, char *result
, unsigned int maxlen
)
298 struct stripe_c
*sc
= (struct stripe_c
*) ti
->private;
299 char buffer
[sc
->stripes
+ 1];
304 case STATUSTYPE_INFO
:
305 DMEMIT("%d ", sc
->stripes
);
306 for (i
= 0; i
< sc
->stripes
; i
++) {
307 DMEMIT("%s ", sc
->stripe
[i
].dev
->name
);
308 buffer
[i
] = atomic_read(&(sc
->stripe
[i
].error_count
)) ?
312 DMEMIT("1 %s", buffer
);
315 case STATUSTYPE_TABLE
:
316 DMEMIT("%d %llu", sc
->stripes
,
317 (unsigned long long)sc
->chunk_size
);
318 for (i
= 0; i
< sc
->stripes
; i
++)
319 DMEMIT(" %s %llu", sc
->stripe
[i
].dev
->name
,
320 (unsigned long long)sc
->stripe
[i
].physical_start
);
326 static int stripe_end_io(struct dm_target
*ti
, struct bio
*bio
,
327 int error
, union map_info
*map_context
)
330 char major_minor
[16];
331 struct stripe_c
*sc
= ti
->private;
334 return 0; /* I/O complete */
336 if ((error
== -EWOULDBLOCK
) && (bio
->bi_rw
& REQ_RAHEAD
))
339 if (error
== -EOPNOTSUPP
)
342 memset(major_minor
, 0, sizeof(major_minor
));
343 sprintf(major_minor
, "%d:%d",
344 MAJOR(disk_devt(bio
->bi_bdev
->bd_disk
)),
345 MINOR(disk_devt(bio
->bi_bdev
->bd_disk
)));
348 * Test to see which stripe drive triggered the event
349 * and increment error count for all stripes on that device.
350 * If the error count for a given device exceeds the threshold
351 * value we will no longer trigger any further events.
353 for (i
= 0; i
< sc
->stripes
; i
++)
354 if (!strcmp(sc
->stripe
[i
].dev
->name
, major_minor
)) {
355 atomic_inc(&(sc
->stripe
[i
].error_count
));
356 if (atomic_read(&(sc
->stripe
[i
].error_count
)) <
357 DM_IO_ERROR_THRESHOLD
)
358 schedule_work(&sc
->trigger_event
);
364 static int stripe_iterate_devices(struct dm_target
*ti
,
365 iterate_devices_callout_fn fn
, void *data
)
367 struct stripe_c
*sc
= ti
->private;
372 ret
= fn(ti
, sc
->stripe
[i
].dev
,
373 sc
->stripe
[i
].physical_start
,
374 sc
->stripe_width
, data
);
375 } while (!ret
&& ++i
< sc
->stripes
);
380 static void stripe_io_hints(struct dm_target
*ti
,
381 struct queue_limits
*limits
)
383 struct stripe_c
*sc
= ti
->private;
384 unsigned chunk_size
= sc
->chunk_size
<< SECTOR_SHIFT
;
386 blk_limits_io_min(limits
, chunk_size
);
387 blk_limits_io_opt(limits
, chunk_size
* sc
->stripes
);
390 static int stripe_merge(struct dm_target
*ti
, struct bvec_merge_data
*bvm
,
391 struct bio_vec
*biovec
, int max_size
)
393 struct stripe_c
*sc
= ti
->private;
394 sector_t bvm_sector
= bvm
->bi_sector
;
396 struct request_queue
*q
;
398 stripe_map_sector(sc
, bvm_sector
, &stripe
, &bvm_sector
);
400 q
= bdev_get_queue(sc
->stripe
[stripe
].dev
->bdev
);
401 if (!q
->merge_bvec_fn
)
404 bvm
->bi_bdev
= sc
->stripe
[stripe
].dev
->bdev
;
405 bvm
->bi_sector
= sc
->stripe
[stripe
].physical_start
+ bvm_sector
;
407 return min(max_size
, q
->merge_bvec_fn(q
, bvm
, biovec
));
410 static struct target_type stripe_target
= {
412 .version
= {1, 5, 0},
413 .module
= THIS_MODULE
,
417 .end_io
= stripe_end_io
,
418 .status
= stripe_status
,
419 .iterate_devices
= stripe_iterate_devices
,
420 .io_hints
= stripe_io_hints
,
421 .merge
= stripe_merge
,
424 int __init
dm_stripe_init(void)
428 r
= dm_register_target(&stripe_target
);
430 DMWARN("target registration failed");
437 void dm_stripe_exit(void)
439 dm_unregister_target(&stripe_target
);