blob: e610725db766f643feb7c5c7b932e2c6562e5640 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Copyright (C) 2001-2003 Sistina Software (UK) Limited.
3 *
4 * This file is released under the GPL.
5 */
6
Mikulas Patocka586e80e2008-10-21 17:44:59 +01007#include <linux/device-mapper.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07008
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>
vignesh babu6f3c3f02007-10-19 22:38:44 +010014#include <linux/log2.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
Alasdair G Kergon72d94862006-06-26 00:27:35 -070016#define DM_MSG_PREFIX "striped"
Brian Wooda25eb942008-02-08 02:11:22 +000017#define DM_IO_ERROR_THRESHOLD 15
Alasdair G Kergon72d94862006-06-26 00:27:35 -070018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019struct stripe {
20 struct dm_dev *dev;
21 sector_t physical_start;
Brian Wooda25eb942008-02-08 02:11:22 +000022
23 atomic_t error_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -070024};
25
26struct stripe_c {
27 uint32_t stripes;
28
29 /* The size of this target / num. stripes */
30 sector_t stripe_width;
31
32 /* stripe chunk size */
33 uint32_t chunk_shift;
34 sector_t chunk_mask;
35
Brian Wooda25eb942008-02-08 02:11:22 +000036 /* Needed for handling events */
37 struct dm_target *ti;
38
39 /* Work struct used for triggering events*/
40 struct work_struct kstriped_ws;
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042 struct stripe stripe[0];
43};
44
Brian Wooda25eb942008-02-08 02:11:22 +000045static struct workqueue_struct *kstriped;
46
47/*
48 * An event is triggered whenever a drive
49 * drops out of a stripe volume.
50 */
51static void trigger_event(struct work_struct *work)
52{
53 struct stripe_c *sc = container_of(work, struct stripe_c, kstriped_ws);
54
55 dm_table_event(sc->ti->table);
56
57}
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059static inline struct stripe_c *alloc_context(unsigned int stripes)
60{
61 size_t len;
62
Mikulas Patockad63a5ce2008-10-21 17:44:57 +010063 if (dm_array_too_big(sizeof(struct stripe_c), sizeof(struct stripe),
64 stripes))
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 return NULL;
66
67 len = sizeof(struct stripe_c) + (sizeof(struct stripe) * stripes);
68
69 return kmalloc(len, GFP_KERNEL);
70}
71
72/*
73 * Parse a single <dev> <sector> pair
74 */
75static int get_stripe(struct dm_target *ti, struct stripe_c *sc,
76 unsigned int stripe, char **argv)
77{
Andrew Morton4ee218c2006-03-27 01:17:48 -080078 unsigned long long start;
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
Andrew Morton4ee218c2006-03-27 01:17:48 -080080 if (sscanf(argv[1], "%llu", &start) != 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 return -EINVAL;
82
Nikanth Karthikesan8215d6e2010-03-06 02:32:27 +000083 if (dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 &sc->stripe[stripe].dev))
85 return -ENXIO;
86
87 sc->stripe[stripe].physical_start = start;
Brian Wooda25eb942008-02-08 02:11:22 +000088
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 return 0;
90}
91
92/*
93 * Construct a striped mapping.
94 * <number of stripes> <chunk size (2^^n)> [<dev_path> <offset>]+
95 */
96static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
97{
98 struct stripe_c *sc;
99 sector_t width;
100 uint32_t stripes;
101 uint32_t chunk_size;
102 char *end;
103 int r;
104 unsigned int i;
105
106 if (argc < 2) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700107 ti->error = "Not enough arguments";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 return -EINVAL;
109 }
110
111 stripes = simple_strtoul(argv[0], &end, 10);
Nikanth Karthikesan781248c2010-02-16 18:42:47 +0000112 if (!stripes || *end) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700113 ti->error = "Invalid stripe count";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 return -EINVAL;
115 }
116
117 chunk_size = simple_strtoul(argv[1], &end, 10);
118 if (*end) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700119 ti->error = "Invalid chunk_size";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 return -EINVAL;
121 }
122
123 /*
124 * chunk_size is a power of two
125 */
vignesh babu6f3c3f02007-10-19 22:38:44 +0100126 if (!is_power_of_2(chunk_size) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 (chunk_size < (PAGE_SIZE >> SECTOR_SHIFT))) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700128 ti->error = "Invalid chunk size";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 return -EINVAL;
130 }
131
Kevin Corrya22c96c2006-03-27 01:18:01 -0800132 if (ti->len & (chunk_size - 1)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700133 ti->error = "Target length not divisible by "
Kevin Corry8ba32fd2006-03-16 23:04:03 -0800134 "chunk size";
135 return -EINVAL;
136 }
137
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 width = ti->len;
139 if (sector_div(width, stripes)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700140 ti->error = "Target length not divisible by "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 "number of stripes";
142 return -EINVAL;
143 }
144
145 /*
146 * Do we have enough arguments for that many stripes ?
147 */
148 if (argc != (2 + 2 * stripes)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700149 ti->error = "Not enough destinations "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 "specified";
151 return -EINVAL;
152 }
153
154 sc = alloc_context(stripes);
155 if (!sc) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700156 ti->error = "Memory allocation for striped context "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 "failed";
158 return -ENOMEM;
159 }
160
Brian Wooda25eb942008-02-08 02:11:22 +0000161 INIT_WORK(&sc->kstriped_ws, trigger_event);
162
163 /* Set pointer to dm target; used in trigger_event */
164 sc->ti = ti;
165
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 sc->stripes = stripes;
167 sc->stripe_width = width;
168 ti->split_io = chunk_size;
Mikulas Patocka374bf7e2009-06-22 10:12:22 +0100169 ti->num_flush_requests = stripes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 sc->chunk_mask = ((sector_t) chunk_size) - 1;
172 for (sc->chunk_shift = 0; chunk_size; sc->chunk_shift++)
173 chunk_size >>= 1;
174 sc->chunk_shift--;
175
176 /*
177 * Get the stripe destinations.
178 */
179 for (i = 0; i < stripes; i++) {
180 argv += 2;
181
182 r = get_stripe(ti, sc, i, argv);
183 if (r < 0) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700184 ti->error = "Couldn't parse stripe destination";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 while (i--)
186 dm_put_device(ti, sc->stripe[i].dev);
187 kfree(sc);
188 return r;
189 }
Brian Wooda25eb942008-02-08 02:11:22 +0000190 atomic_set(&(sc->stripe[i].error_count), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 }
192
193 ti->private = sc;
Brian Wooda25eb942008-02-08 02:11:22 +0000194
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 return 0;
196}
197
198static void stripe_dtr(struct dm_target *ti)
199{
200 unsigned int i;
201 struct stripe_c *sc = (struct stripe_c *) ti->private;
202
203 for (i = 0; i < sc->stripes; i++)
204 dm_put_device(ti, sc->stripe[i].dev);
205
Brian Wooda25eb942008-02-08 02:11:22 +0000206 flush_workqueue(kstriped);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 kfree(sc);
208}
209
210static int stripe_map(struct dm_target *ti, struct bio *bio,
211 union map_info *map_context)
212{
213 struct stripe_c *sc = (struct stripe_c *) ti->private;
Mikulas Patocka374bf7e2009-06-22 10:12:22 +0100214 sector_t offset, chunk;
215 uint32_t stripe;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
Mikulas Patocka374bf7e2009-06-22 10:12:22 +0100217 if (unlikely(bio_empty_barrier(bio))) {
218 BUG_ON(map_context->flush_request >= sc->stripes);
219 bio->bi_bdev = sc->stripe[map_context->flush_request].dev->bdev;
220 return DM_MAPIO_REMAPPED;
221 }
222
223 offset = bio->bi_sector - ti->begin;
224 chunk = offset >> sc->chunk_shift;
225 stripe = sector_div(chunk, sc->stripes);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
227 bio->bi_bdev = sc->stripe[stripe].dev->bdev;
228 bio->bi_sector = sc->stripe[stripe].physical_start +
229 (chunk << sc->chunk_shift) + (offset & sc->chunk_mask);
Kiyoshi Uedad2a7ad22006-12-08 02:41:06 -0800230 return DM_MAPIO_REMAPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231}
232
Brian Wood4f7f5c62008-02-08 02:11:24 +0000233/*
234 * Stripe status:
235 *
236 * INFO
237 * #stripes [stripe_name <stripe_name>] [group word count]
238 * [error count 'A|D' <error count 'A|D'>]
239 *
240 * TABLE
241 * #stripes [stripe chunk size]
242 * [stripe_name physical_start <stripe_name physical_start>]
243 *
244 */
245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246static int stripe_status(struct dm_target *ti,
247 status_type_t type, char *result, unsigned int maxlen)
248{
249 struct stripe_c *sc = (struct stripe_c *) ti->private;
Brian Wood4f7f5c62008-02-08 02:11:24 +0000250 char buffer[sc->stripes + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 unsigned int sz = 0;
252 unsigned int i;
253
254 switch (type) {
255 case STATUSTYPE_INFO:
Brian Wood4f7f5c62008-02-08 02:11:24 +0000256 DMEMIT("%d ", sc->stripes);
257 for (i = 0; i < sc->stripes; i++) {
258 DMEMIT("%s ", sc->stripe[i].dev->name);
259 buffer[i] = atomic_read(&(sc->stripe[i].error_count)) ?
260 'D' : 'A';
261 }
262 buffer[i] = '\0';
263 DMEMIT("1 %s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 break;
265
266 case STATUSTYPE_TABLE:
Andrew Morton4ee218c2006-03-27 01:17:48 -0800267 DMEMIT("%d %llu", sc->stripes,
268 (unsigned long long)sc->chunk_mask + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 for (i = 0; i < sc->stripes; i++)
Andrew Morton4ee218c2006-03-27 01:17:48 -0800270 DMEMIT(" %s %llu", sc->stripe[i].dev->name,
271 (unsigned long long)sc->stripe[i].physical_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 break;
273 }
274 return 0;
275}
276
Brian Wooda25eb942008-02-08 02:11:22 +0000277static int stripe_end_io(struct dm_target *ti, struct bio *bio,
278 int error, union map_info *map_context)
279{
280 unsigned i;
281 char major_minor[16];
282 struct stripe_c *sc = ti->private;
283
284 if (!error)
285 return 0; /* I/O complete */
286
Jens Axboe1f98a132009-09-11 14:32:04 +0200287 if ((error == -EWOULDBLOCK) && bio_rw_flagged(bio, BIO_RW_AHEAD))
Brian Wooda25eb942008-02-08 02:11:22 +0000288 return error;
289
290 if (error == -EOPNOTSUPP)
291 return error;
292
293 memset(major_minor, 0, sizeof(major_minor));
294 sprintf(major_minor, "%d:%d",
Tejun Heof331c022008-09-03 09:01:48 +0200295 MAJOR(disk_devt(bio->bi_bdev->bd_disk)),
296 MINOR(disk_devt(bio->bi_bdev->bd_disk)));
Brian Wooda25eb942008-02-08 02:11:22 +0000297
298 /*
299 * Test to see which stripe drive triggered the event
300 * and increment error count for all stripes on that device.
301 * If the error count for a given device exceeds the threshold
302 * value we will no longer trigger any further events.
303 */
304 for (i = 0; i < sc->stripes; i++)
305 if (!strcmp(sc->stripe[i].dev->name, major_minor)) {
306 atomic_inc(&(sc->stripe[i].error_count));
307 if (atomic_read(&(sc->stripe[i].error_count)) <
308 DM_IO_ERROR_THRESHOLD)
309 queue_work(kstriped, &sc->kstriped_ws);
310 }
311
312 return error;
313}
314
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100315static int stripe_iterate_devices(struct dm_target *ti,
316 iterate_devices_callout_fn fn, void *data)
317{
318 struct stripe_c *sc = ti->private;
319 int ret = 0;
320 unsigned i = 0;
321
Mike Snitzer5dea2712009-07-23 20:30:42 +0100322 do {
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100323 ret = fn(ti, sc->stripe[i].dev,
Mike Snitzer5dea2712009-07-23 20:30:42 +0100324 sc->stripe[i].physical_start,
325 sc->stripe_width, data);
326 } while (!ret && ++i < sc->stripes);
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100327
328 return ret;
329}
330
Mike Snitzer40bea432009-09-04 20:40:25 +0100331static void stripe_io_hints(struct dm_target *ti,
332 struct queue_limits *limits)
333{
334 struct stripe_c *sc = ti->private;
335 unsigned chunk_size = (sc->chunk_mask + 1) << 9;
336
337 blk_limits_io_min(limits, chunk_size);
Martin K. Petersen3c5820c2009-09-11 21:54:52 +0200338 blk_limits_io_opt(limits, chunk_size * sc->stripes);
Mike Snitzer40bea432009-09-04 20:40:25 +0100339}
340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341static struct target_type stripe_target = {
342 .name = "striped",
Mike Snitzer40bea432009-09-04 20:40:25 +0100343 .version = {1, 3, 0},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 .module = THIS_MODULE,
345 .ctr = stripe_ctr,
346 .dtr = stripe_dtr,
347 .map = stripe_map,
Brian Wooda25eb942008-02-08 02:11:22 +0000348 .end_io = stripe_end_io,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 .status = stripe_status,
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100350 .iterate_devices = stripe_iterate_devices,
Mike Snitzer40bea432009-09-04 20:40:25 +0100351 .io_hints = stripe_io_hints,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352};
353
354int __init dm_stripe_init(void)
355{
356 int r;
357
358 r = dm_register_target(&stripe_target);
Heinz Mauelshagen6edebde2008-11-13 23:38:56 +0000359 if (r < 0) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700360 DMWARN("target registration failed");
Heinz Mauelshagen6edebde2008-11-13 23:38:56 +0000361 return r;
362 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
Brian Wooda25eb942008-02-08 02:11:22 +0000364 kstriped = create_singlethread_workqueue("kstriped");
365 if (!kstriped) {
366 DMERR("failed to create workqueue kstriped");
367 dm_unregister_target(&stripe_target);
368 return -ENOMEM;
369 }
370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 return r;
372}
373
374void dm_stripe_exit(void)
375{
Mikulas Patocka10d3bd02009-01-06 03:04:58 +0000376 dm_unregister_target(&stripe_target);
Brian Wooda25eb942008-02-08 02:11:22 +0000377 destroy_workqueue(kstriped);
378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 return;
380}