blob: b5e892149c542ba76f0cad8d819cb30c442075e9 [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
Mike Snitzer7fff5e82013-09-06 11:36:01 -04007#include "dm.h"
Mikulas Patocka586e80e2008-10-21 17:44:59 +01008#include <linux/device-mapper.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009
10#include <linux/module.h>
11#include <linux/init.h>
12#include <linux/blkdev.h>
13#include <linux/bio.h>
Dan Williams817bf402017-04-12 13:37:44 -070014#include <linux/dax.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015#include <linux/slab.h>
vignesh babu6f3c3f02007-10-19 22:38:44 +010016#include <linux/log2.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017
Alasdair G Kergon72d94862006-06-26 00:27:35 -070018#define DM_MSG_PREFIX "striped"
Brian Wooda25eb942008-02-08 02:11:22 +000019#define DM_IO_ERROR_THRESHOLD 15
Alasdair G Kergon72d94862006-06-26 00:27:35 -070020
Linus Torvalds1da177e2005-04-16 15:20:36 -070021struct stripe {
22 struct dm_dev *dev;
23 sector_t physical_start;
Brian Wooda25eb942008-02-08 02:11:22 +000024
25 atomic_t error_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -070026};
27
28struct stripe_c {
29 uint32_t stripes;
Mikulas Patockac96053b2010-08-12 04:14:21 +010030 int stripes_shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
32 /* The size of this target / num. stripes */
33 sector_t stripe_width;
34
Mike Snitzereb850de2012-07-27 15:08:01 +010035 uint32_t chunk_size;
Mikulas Patocka33d07c02012-07-27 15:08:02 +010036 int chunk_size_shift;
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Brian Wooda25eb942008-02-08 02:11:22 +000038 /* Needed for handling events */
39 struct dm_target *ti;
40
41 /* Work struct used for triggering events*/
Tejun Heof521f072011-01-13 19:59:57 +000042 struct work_struct trigger_event;
Brian Wooda25eb942008-02-08 02:11:22 +000043
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 struct stripe stripe[0];
45};
46
Brian Wooda25eb942008-02-08 02:11:22 +000047/*
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{
Tejun Heof521f072011-01-13 19:59:57 +000053 struct stripe_c *sc = container_of(work, struct stripe_c,
54 trigger_event);
Brian Wooda25eb942008-02-08 02:11:22 +000055 dm_table_event(sc->ti->table);
Brian Wooda25eb942008-02-08 02:11:22 +000056}
57
Linus Torvalds1da177e2005-04-16 15:20:36 -070058static inline struct stripe_c *alloc_context(unsigned int stripes)
59{
60 size_t len;
61
Mikulas Patockad63a5ce2008-10-21 17:44:57 +010062 if (dm_array_too_big(sizeof(struct stripe_c), sizeof(struct stripe),
63 stripes))
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 return NULL;
65
66 len = sizeof(struct stripe_c) + (sizeof(struct stripe) * stripes);
67
68 return kmalloc(len, GFP_KERNEL);
69}
70
71/*
72 * Parse a single <dev> <sector> pair
73 */
74static int get_stripe(struct dm_target *ti, struct stripe_c *sc,
75 unsigned int stripe, char **argv)
76{
Andrew Morton4ee218c2006-03-27 01:17:48 -080077 unsigned long long start;
Mikulas Patocka31998ef2012-03-28 18:41:26 +010078 char dummy;
Vivek Goyale80d1c82015-07-31 09:20:36 -040079 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
Mikulas Patocka31998ef2012-03-28 18:41:26 +010081 if (sscanf(argv[1], "%llu%c", &start, &dummy) != 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 return -EINVAL;
83
Vivek Goyale80d1c82015-07-31 09:20:36 -040084 ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
85 &sc->stripe[stripe].dev);
86 if (ret)
87 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89 sc->stripe[stripe].physical_start = start;
Brian Wooda25eb942008-02-08 02:11:22 +000090
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 return 0;
92}
93
94/*
95 * Construct a striped mapping.
Mike Snitzereb850de2012-07-27 15:08:01 +010096 * <number of stripes> <chunk size> [<dev_path> <offset>]+
Linus Torvalds1da177e2005-04-16 15:20:36 -070097 */
98static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
99{
100 struct stripe_c *sc;
Mike Snitzerd793e6842013-05-10 14:37:14 +0100101 sector_t width, tmp_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 uint32_t stripes;
103 uint32_t chunk_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 int r;
105 unsigned int i;
106
107 if (argc < 2) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700108 ti->error = "Not enough arguments";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 return -EINVAL;
110 }
111
majianpeng1a66a082012-07-27 15:07:59 +0100112 if (kstrtouint(argv[0], 10, &stripes) || !stripes) {
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
Mikulas Patocka8f069b42012-07-27 15:08:01 +0100117 if (kstrtouint(argv[1], 10, &chunk_size) || !chunk_size) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700118 ti->error = "Invalid chunk_size";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 return -EINVAL;
120 }
121
Mike Snitzereb850de2012-07-27 15:08:01 +0100122 width = ti->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 if (sector_div(width, stripes)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700124 ti->error = "Target length not divisible by "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 "number of stripes";
126 return -EINVAL;
127 }
128
Mike Snitzerd793e6842013-05-10 14:37:14 +0100129 tmp_len = width;
130 if (sector_div(tmp_len, chunk_size)) {
131 ti->error = "Target length not divisible by "
132 "chunk size";
133 return -EINVAL;
134 }
135
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 /*
137 * Do we have enough arguments for that many stripes ?
138 */
139 if (argc != (2 + 2 * stripes)) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700140 ti->error = "Not enough destinations "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 "specified";
142 return -EINVAL;
143 }
144
145 sc = alloc_context(stripes);
146 if (!sc) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700147 ti->error = "Memory allocation for striped context "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 "failed";
149 return -ENOMEM;
150 }
151
Tejun Heof521f072011-01-13 19:59:57 +0000152 INIT_WORK(&sc->trigger_event, trigger_event);
Brian Wooda25eb942008-02-08 02:11:22 +0000153
154 /* Set pointer to dm target; used in trigger_event */
155 sc->ti = ti;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 sc->stripes = stripes;
157 sc->stripe_width = width;
Mikulas Patockac96053b2010-08-12 04:14:21 +0100158
159 if (stripes & (stripes - 1))
160 sc->stripes_shift = -1;
Mikulas Patocka1df05482012-07-27 15:08:00 +0100161 else
162 sc->stripes_shift = __ffs(stripes);
Mikulas Patockac96053b2010-08-12 04:14:21 +0100163
Mike Snitzer542f9032012-07-27 15:08:00 +0100164 r = dm_set_target_max_io_len(ti, chunk_size);
Pavitra Kumara3f2af22014-10-10 15:19:46 +0000165 if (r) {
166 kfree(sc);
Mike Snitzer542f9032012-07-27 15:08:00 +0100167 return r;
Pavitra Kumara3f2af22014-10-10 15:19:46 +0000168 }
Mike Snitzer542f9032012-07-27 15:08:00 +0100169
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000170 ti->num_flush_bios = stripes;
171 ti->num_discard_bios = stripes;
172 ti->num_write_same_bios = stripes;
Christoph Hellwigac62d622017-04-05 19:21:05 +0200173 ti->num_write_zeroes_bios = stripes;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174
Mike Snitzereb850de2012-07-27 15:08:01 +0100175 sc->chunk_size = chunk_size;
Mikulas Patocka33d07c02012-07-27 15:08:02 +0100176 if (chunk_size & (chunk_size - 1))
177 sc->chunk_size_shift = -1;
178 else
179 sc->chunk_size_shift = __ffs(chunk_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180
181 /*
182 * Get the stripe destinations.
183 */
184 for (i = 0; i < stripes; i++) {
185 argv += 2;
186
187 r = get_stripe(ti, sc, i, argv);
188 if (r < 0) {
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700189 ti->error = "Couldn't parse stripe destination";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 while (i--)
191 dm_put_device(ti, sc->stripe[i].dev);
192 kfree(sc);
193 return r;
194 }
Brian Wooda25eb942008-02-08 02:11:22 +0000195 atomic_set(&(sc->stripe[i].error_count), 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 }
197
198 ti->private = sc;
Brian Wooda25eb942008-02-08 02:11:22 +0000199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 return 0;
201}
202
203static void stripe_dtr(struct dm_target *ti)
204{
205 unsigned int i;
206 struct stripe_c *sc = (struct stripe_c *) ti->private;
207
208 for (i = 0; i < sc->stripes; i++)
209 dm_put_device(ti, sc->stripe[i].dev);
210
Tejun Heo43829732012-08-20 14:51:24 -0700211 flush_work(&sc->trigger_event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 kfree(sc);
213}
214
Mikulas Patocka65988522010-08-12 04:14:14 +0100215static void stripe_map_sector(struct stripe_c *sc, sector_t sector,
216 uint32_t *stripe, sector_t *result)
217{
Mike Snitzereb850de2012-07-27 15:08:01 +0100218 sector_t chunk = dm_target_offset(sc->ti, sector);
Mikulas Patocka33d07c02012-07-27 15:08:02 +0100219 sector_t chunk_offset;
220
221 if (sc->chunk_size_shift < 0)
222 chunk_offset = sector_div(chunk, sc->chunk_size);
223 else {
224 chunk_offset = chunk & (sc->chunk_size - 1);
225 chunk >>= sc->chunk_size_shift;
226 }
Mikulas Patocka65988522010-08-12 04:14:14 +0100227
Mikulas Patockac96053b2010-08-12 04:14:21 +0100228 if (sc->stripes_shift < 0)
229 *stripe = sector_div(chunk, sc->stripes);
230 else {
Mikulas Patocka1df05482012-07-27 15:08:00 +0100231 *stripe = chunk & (sc->stripes - 1);
Mikulas Patockac96053b2010-08-12 04:14:21 +0100232 chunk >>= sc->stripes_shift;
233 }
234
Mikulas Patocka33d07c02012-07-27 15:08:02 +0100235 if (sc->chunk_size_shift < 0)
236 chunk *= sc->chunk_size;
237 else
238 chunk <<= sc->chunk_size_shift;
239
240 *result = chunk + chunk_offset;
Mikulas Patocka65988522010-08-12 04:14:14 +0100241}
242
Mikulas Patocka7b76ec12010-08-12 04:14:26 +0100243static void stripe_map_range_sector(struct stripe_c *sc, sector_t sector,
244 uint32_t target_stripe, sector_t *result)
245{
246 uint32_t stripe;
247
248 stripe_map_sector(sc, sector, &stripe, result);
249 if (stripe == target_stripe)
250 return;
Mike Snitzereb850de2012-07-27 15:08:01 +0100251
252 /* round down */
253 sector = *result;
Mikulas Patocka33d07c02012-07-27 15:08:02 +0100254 if (sc->chunk_size_shift < 0)
255 *result -= sector_div(sector, sc->chunk_size);
256 else
257 *result = sector & ~(sector_t)(sc->chunk_size - 1);
Mike Snitzereb850de2012-07-27 15:08:01 +0100258
Mikulas Patocka7b76ec12010-08-12 04:14:26 +0100259 if (target_stripe < stripe)
Mike Snitzereb850de2012-07-27 15:08:01 +0100260 *result += sc->chunk_size; /* next chunk */
Mikulas Patocka7b76ec12010-08-12 04:14:26 +0100261}
262
Mike Snitzer45e621d2012-12-21 20:23:41 +0000263static int stripe_map_range(struct stripe_c *sc, struct bio *bio,
264 uint32_t target_stripe)
Mikulas Patocka7b76ec12010-08-12 04:14:26 +0100265{
266 sector_t begin, end;
267
Kent Overstreet4f024f32013-10-11 15:44:27 -0700268 stripe_map_range_sector(sc, bio->bi_iter.bi_sector,
269 target_stripe, &begin);
Kent Overstreetf73a1c72012-09-25 15:05:12 -0700270 stripe_map_range_sector(sc, bio_end_sector(bio),
Mikulas Patocka7b76ec12010-08-12 04:14:26 +0100271 target_stripe, &end);
272 if (begin < end) {
Christoph Hellwig74d46992017-08-23 19:10:32 +0200273 bio_set_dev(bio, sc->stripe[target_stripe].dev->bdev);
Kent Overstreet4f024f32013-10-11 15:44:27 -0700274 bio->bi_iter.bi_sector = begin +
275 sc->stripe[target_stripe].physical_start;
276 bio->bi_iter.bi_size = to_bytes(end - begin);
Mikulas Patocka7b76ec12010-08-12 04:14:26 +0100277 return DM_MAPIO_REMAPPED;
278 } else {
279 /* The range doesn't map to the target stripe */
Christoph Hellwig4246a0b2015-07-20 15:29:37 +0200280 bio_endio(bio);
Mikulas Patocka7b76ec12010-08-12 04:14:26 +0100281 return DM_MAPIO_SUBMITTED;
282 }
283}
284
Mikulas Patocka7de3ee52012-12-21 20:23:41 +0000285static int stripe_map(struct dm_target *ti, struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286{
Mikulas Patocka65988522010-08-12 04:14:14 +0100287 struct stripe_c *sc = ti->private;
Mikulas Patocka374bf7e2009-06-22 10:12:22 +0100288 uint32_t stripe;
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000289 unsigned target_bio_nr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290
Jens Axboe1eff9d32016-08-05 15:35:16 -0600291 if (bio->bi_opf & REQ_PREFLUSH) {
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000292 target_bio_nr = dm_bio_get_target_bio_nr(bio);
293 BUG_ON(target_bio_nr >= sc->stripes);
Christoph Hellwig74d46992017-08-23 19:10:32 +0200294 bio_set_dev(bio, sc->stripe[target_bio_nr].dev->bdev);
Mikulas Patocka374bf7e2009-06-22 10:12:22 +0100295 return DM_MAPIO_REMAPPED;
296 }
Mike Christiee6047142016-06-05 14:32:04 -0500297 if (unlikely(bio_op(bio) == REQ_OP_DISCARD) ||
Christoph Hellwigac62d622017-04-05 19:21:05 +0200298 unlikely(bio_op(bio) == REQ_OP_WRITE_ZEROES) ||
Mike Christiee6047142016-06-05 14:32:04 -0500299 unlikely(bio_op(bio) == REQ_OP_WRITE_SAME)) {
Alasdair G Kergon55a62ee2013-03-01 22:45:47 +0000300 target_bio_nr = dm_bio_get_target_bio_nr(bio);
301 BUG_ON(target_bio_nr >= sc->stripes);
302 return stripe_map_range(sc, bio, target_bio_nr);
Mikulas Patocka7b76ec12010-08-12 04:14:26 +0100303 }
Mikulas Patocka374bf7e2009-06-22 10:12:22 +0100304
Kent Overstreet4f024f32013-10-11 15:44:27 -0700305 stripe_map_sector(sc, bio->bi_iter.bi_sector,
306 &stripe, &bio->bi_iter.bi_sector);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
Kent Overstreet4f024f32013-10-11 15:44:27 -0700308 bio->bi_iter.bi_sector += sc->stripe[stripe].physical_start;
Christoph Hellwig74d46992017-08-23 19:10:32 +0200309 bio_set_dev(bio, sc->stripe[stripe].dev->bdev);
Mikulas Patocka65988522010-08-12 04:14:14 +0100310
Kiyoshi Uedad2a7ad22006-12-08 02:41:06 -0800311 return DM_MAPIO_REMAPPED;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312}
313
Dan Williams817bf402017-04-12 13:37:44 -0700314static long stripe_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,
315 long nr_pages, void **kaddr, pfn_t *pfn)
Toshi Kanibeec25b2016-06-24 12:23:30 -0600316{
Dan Williams817bf402017-04-12 13:37:44 -0700317 sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
Toshi Kanibeec25b2016-06-24 12:23:30 -0600318 struct stripe_c *sc = ti->private;
Dan Williams817bf402017-04-12 13:37:44 -0700319 struct dax_device *dax_dev;
Toshi Kanibeec25b2016-06-24 12:23:30 -0600320 struct block_device *bdev;
Dan Williams817bf402017-04-12 13:37:44 -0700321 uint32_t stripe;
Toshi Kanibeec25b2016-06-24 12:23:30 -0600322 long ret;
323
Dan Williams817bf402017-04-12 13:37:44 -0700324 stripe_map_sector(sc, sector, &stripe, &dev_sector);
325 dev_sector += sc->stripe[stripe].physical_start;
326 dax_dev = sc->stripe[stripe].dev->dax_dev;
Toshi Kanibeec25b2016-06-24 12:23:30 -0600327 bdev = sc->stripe[stripe].dev->bdev;
328
Dan Williams817bf402017-04-12 13:37:44 -0700329 ret = bdev_dax_pgoff(bdev, dev_sector, nr_pages * PAGE_SIZE, &pgoff);
330 if (ret)
331 return ret;
332 return dax_direct_access(dax_dev, pgoff, nr_pages, kaddr, pfn);
Toshi Kanibeec25b2016-06-24 12:23:30 -0600333}
334
Dan Williams7e026c82017-05-29 12:57:56 -0700335static size_t stripe_dax_copy_from_iter(struct dm_target *ti, pgoff_t pgoff,
336 void *addr, size_t bytes, struct iov_iter *i)
337{
338 sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
339 struct stripe_c *sc = ti->private;
340 struct dax_device *dax_dev;
341 struct block_device *bdev;
342 uint32_t stripe;
343
344 stripe_map_sector(sc, sector, &stripe, &dev_sector);
345 dev_sector += sc->stripe[stripe].physical_start;
346 dax_dev = sc->stripe[stripe].dev->dax_dev;
347 bdev = sc->stripe[stripe].dev->bdev;
348
349 if (bdev_dax_pgoff(bdev, dev_sector, ALIGN(bytes, PAGE_SIZE), &pgoff))
350 return 0;
351 return dax_copy_from_iter(dax_dev, pgoff, addr, bytes, i);
352}
353
Brian Wood4f7f5c62008-02-08 02:11:24 +0000354/*
355 * Stripe status:
356 *
357 * INFO
358 * #stripes [stripe_name <stripe_name>] [group word count]
359 * [error count 'A|D' <error count 'A|D'>]
360 *
361 * TABLE
362 * #stripes [stripe chunk size]
363 * [stripe_name physical_start <stripe_name physical_start>]
364 *
365 */
366
Mikulas Patockafd7c0922013-03-01 22:45:44 +0000367static void stripe_status(struct dm_target *ti, status_type_t type,
368 unsigned status_flags, char *result, unsigned maxlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
370 struct stripe_c *sc = (struct stripe_c *) ti->private;
Brian Wood4f7f5c62008-02-08 02:11:24 +0000371 char buffer[sc->stripes + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 unsigned int sz = 0;
373 unsigned int i;
374
375 switch (type) {
376 case STATUSTYPE_INFO:
Brian Wood4f7f5c62008-02-08 02:11:24 +0000377 DMEMIT("%d ", sc->stripes);
378 for (i = 0; i < sc->stripes; i++) {
379 DMEMIT("%s ", sc->stripe[i].dev->name);
380 buffer[i] = atomic_read(&(sc->stripe[i].error_count)) ?
381 'D' : 'A';
382 }
383 buffer[i] = '\0';
384 DMEMIT("1 %s", buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700385 break;
386
387 case STATUSTYPE_TABLE:
Andrew Morton4ee218c2006-03-27 01:17:48 -0800388 DMEMIT("%d %llu", sc->stripes,
Mike Snitzereb850de2012-07-27 15:08:01 +0100389 (unsigned long long)sc->chunk_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 for (i = 0; i < sc->stripes; i++)
Andrew Morton4ee218c2006-03-27 01:17:48 -0800391 DMEMIT(" %s %llu", sc->stripe[i].dev->name,
392 (unsigned long long)sc->stripe[i].physical_start);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 break;
394 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395}
396
Christoph Hellwig4e4cbee2017-06-03 09:38:06 +0200397static int stripe_end_io(struct dm_target *ti, struct bio *bio,
398 blk_status_t *error)
Brian Wooda25eb942008-02-08 02:11:22 +0000399{
400 unsigned i;
401 char major_minor[16];
402 struct stripe_c *sc = ti->private;
403
Christoph Hellwig1be56902017-06-03 09:38:03 +0200404 if (!*error)
405 return DM_ENDIO_DONE; /* I/O complete */
Brian Wooda25eb942008-02-08 02:11:22 +0000406
Christoph Hellwig9966afa2017-06-03 09:37:57 +0200407 if (bio->bi_opf & REQ_RAHEAD)
Christoph Hellwig1be56902017-06-03 09:38:03 +0200408 return DM_ENDIO_DONE;
Brian Wooda25eb942008-02-08 02:11:22 +0000409
Christoph Hellwig4e4cbee2017-06-03 09:38:06 +0200410 if (*error == BLK_STS_NOTSUPP)
Christoph Hellwig1be56902017-06-03 09:38:03 +0200411 return DM_ENDIO_DONE;
Brian Wooda25eb942008-02-08 02:11:22 +0000412
413 memset(major_minor, 0, sizeof(major_minor));
Christoph Hellwig74d46992017-08-23 19:10:32 +0200414 sprintf(major_minor, "%d:%d", MAJOR(bio_dev(bio)), MINOR(bio_dev(bio)));
Brian Wooda25eb942008-02-08 02:11:22 +0000415
416 /*
417 * Test to see which stripe drive triggered the event
418 * and increment error count for all stripes on that device.
419 * If the error count for a given device exceeds the threshold
420 * value we will no longer trigger any further events.
421 */
422 for (i = 0; i < sc->stripes; i++)
423 if (!strcmp(sc->stripe[i].dev->name, major_minor)) {
424 atomic_inc(&(sc->stripe[i].error_count));
425 if (atomic_read(&(sc->stripe[i].error_count)) <
426 DM_IO_ERROR_THRESHOLD)
Tejun Heof521f072011-01-13 19:59:57 +0000427 schedule_work(&sc->trigger_event);
Brian Wooda25eb942008-02-08 02:11:22 +0000428 }
429
Christoph Hellwig1be56902017-06-03 09:38:03 +0200430 return DM_ENDIO_DONE;
Brian Wooda25eb942008-02-08 02:11:22 +0000431}
432
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100433static int stripe_iterate_devices(struct dm_target *ti,
434 iterate_devices_callout_fn fn, void *data)
435{
436 struct stripe_c *sc = ti->private;
437 int ret = 0;
438 unsigned i = 0;
439
Mike Snitzer5dea2712009-07-23 20:30:42 +0100440 do {
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100441 ret = fn(ti, sc->stripe[i].dev,
Mike Snitzer5dea2712009-07-23 20:30:42 +0100442 sc->stripe[i].physical_start,
443 sc->stripe_width, data);
444 } while (!ret && ++i < sc->stripes);
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100445
446 return ret;
447}
448
Mike Snitzer40bea432009-09-04 20:40:25 +0100449static void stripe_io_hints(struct dm_target *ti,
450 struct queue_limits *limits)
451{
452 struct stripe_c *sc = ti->private;
Mike Snitzereb850de2012-07-27 15:08:01 +0100453 unsigned chunk_size = sc->chunk_size << SECTOR_SHIFT;
Mike Snitzer40bea432009-09-04 20:40:25 +0100454
455 blk_limits_io_min(limits, chunk_size);
Martin K. Petersen3c5820c2009-09-11 21:54:52 +0200456 blk_limits_io_opt(limits, chunk_size * sc->stripes);
Mike Snitzer40bea432009-09-04 20:40:25 +0100457}
458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459static struct target_type stripe_target = {
460 .name = "striped",
Toshi Kanibeec25b2016-06-24 12:23:30 -0600461 .version = {1, 6, 0},
Mikulas Patockae2460f22017-04-18 16:51:48 -0400462 .features = DM_TARGET_PASSES_INTEGRITY,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 .module = THIS_MODULE,
464 .ctr = stripe_ctr,
465 .dtr = stripe_dtr,
466 .map = stripe_map,
Brian Wooda25eb942008-02-08 02:11:22 +0000467 .end_io = stripe_end_io,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 .status = stripe_status,
Mike Snitzeraf4874e2009-06-22 10:12:33 +0100469 .iterate_devices = stripe_iterate_devices,
Mike Snitzer40bea432009-09-04 20:40:25 +0100470 .io_hints = stripe_io_hints,
Dan Williams817bf402017-04-12 13:37:44 -0700471 .direct_access = stripe_dax_direct_access,
Dan Williams7e026c82017-05-29 12:57:56 -0700472 .dax_copy_from_iter = stripe_dax_copy_from_iter,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473};
474
475int __init dm_stripe_init(void)
476{
477 int r;
478
479 r = dm_register_target(&stripe_target);
Luis Henriquese223e1d2015-04-27 21:29:36 +0100480 if (r < 0)
Alasdair G Kergon72d94862006-06-26 00:27:35 -0700481 DMWARN("target registration failed");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
483 return r;
484}
485
486void dm_stripe_exit(void)
487{
Mikulas Patocka10d3bd02009-01-06 03:04:58 +0000488 dm_unregister_target(&stripe_target);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489}