blob: 6f44177593a552dd5ba4c1979b58494845a1cee0 [file] [log] [blame]
Thomas Gleixneraf1a8892019-05-20 19:08:12 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 raid0.c : Multiple Devices driver for Linux
NeilBrownf72ffdd2014-09-30 14:23:59 +10004 Copyright (C) 1994-96 Marc ZYNGIER
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 <zyngier@ufr-info-p7.ibp.fr> or
6 <maz@gloups.fdn.fr>
NeilBrownf72ffdd2014-09-30 14:23:59 +10007 Copyright (C) 1999, 2000 Ingo Molnar, Red Hat
Linus Torvalds1da177e2005-04-16 15:20:36 -07008
9 RAID-0 management functions.
10
Linus Torvalds1da177e2005-04-16 15:20:36 -070011*/
12
NeilBrownbff61972009-03-31 14:33:13 +110013#include <linux/blkdev.h>
NeilBrownbff61972009-03-31 14:33:13 +110014#include <linux/seq_file.h>
Paul Gortmaker056075c2011-07-03 13:58:33 -040015#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090016#include <linux/slab.h>
NeilBrown109e3762016-11-18 13:22:04 +110017#include <trace/events/block.h>
NeilBrown43b2e5d2009-03-31 14:33:13 +110018#include "md.h"
Christoph Hellwigef740c32009-03-31 14:27:03 +110019#include "raid0.h"
Trela, Maciej9af204c2010-03-08 16:02:44 +110020#include "raid5.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
NeilBrownc84a1372019-09-09 16:30:02 +100022static int default_layout = 0;
23module_param(default_layout, int, 0644);
24
Shaohua Li394ed8e2017-01-04 16:10:19 -080025#define UNSUPPORTED_MDDEV_FLAGS \
26 ((1L << MD_HAS_JOURNAL) | \
27 (1L << MD_JOURNAL_CLEAN) | \
Artur Paszkiewiczea0213e2017-03-09 09:59:57 +010028 (1L << MD_FAILFAST_SUPPORTED) |\
Pawel Baldysiakddc08822017-08-16 17:13:45 +020029 (1L << MD_HAS_PPL) | \
30 (1L << MD_HAS_MULTIPLE_PPLS))
Shaohua Li394ed8e2017-01-04 16:10:19 -080031
raz ben yehuda46994192009-06-16 17:00:54 +100032/*
33 * inform the user of the raid configuration
34*/
NeilBrownfd01b882011-10-11 16:47:53 +110035static void dump_zones(struct mddev *mddev)
raz ben yehuda46994192009-06-16 17:00:54 +100036{
NeilBrown50de8df2011-10-07 14:23:22 +110037 int j, k;
raz ben yehuda46994192009-06-16 17:00:54 +100038 sector_t zone_size = 0;
39 sector_t zone_start = 0;
40 char b[BDEVNAME_SIZE];
NeilBrowne373ab12011-10-11 16:48:59 +110041 struct r0conf *conf = mddev->private;
NeilBrown84707f32010-03-16 17:23:35 +110042 int raid_disks = conf->strip_zone[0].nb_dev;
NeilBrown76603882016-11-02 14:16:50 +110043 pr_debug("md: RAID0 configuration for %s - %d zone%s\n",
44 mdname(mddev),
45 conf->nr_strip_zones, conf->nr_strip_zones==1?"":"s");
raz ben yehuda46994192009-06-16 17:00:54 +100046 for (j = 0; j < conf->nr_strip_zones; j++) {
NeilBrown76603882016-11-02 14:16:50 +110047 char line[200];
48 int len = 0;
49
raz ben yehuda46994192009-06-16 17:00:54 +100050 for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
NeilBrown76603882016-11-02 14:16:50 +110051 len += snprintf(line+len, 200-len, "%s%s", k?"/":"",
52 bdevname(conf->devlist[j*raid_disks
53 + k]->bdev, b));
54 pr_debug("md: zone%d=[%s]\n", j, line);
raz ben yehuda46994192009-06-16 17:00:54 +100055
56 zone_size = conf->strip_zone[j].zone_end - zone_start;
NeilBrown76603882016-11-02 14:16:50 +110057 pr_debug(" zone-offset=%10lluKB, device-offset=%10lluKB, size=%10lluKB\n",
raz ben yehuda46994192009-06-16 17:00:54 +100058 (unsigned long long)zone_start>>1,
59 (unsigned long long)conf->strip_zone[j].dev_start>>1,
60 (unsigned long long)zone_size>>1);
61 zone_start = conf->strip_zone[j].zone_end;
62 }
raz ben yehuda46994192009-06-16 17:00:54 +100063}
64
NeilBrowne373ab12011-10-11 16:48:59 +110065static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{
NeilBrowna9f326e2009-09-23 18:06:41 +100067 int i, c, err;
NeilBrown49f357a22009-06-16 16:50:35 +100068 sector_t curr_zone_end, sectors;
NeilBrown3cb03002011-10-11 16:45:26 +110069 struct md_rdev *smallest, *rdev1, *rdev2, *rdev, **dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 struct strip_zone *zone;
71 int cnt;
72 char b[BDEVNAME_SIZE];
NeilBrown50de8df2011-10-07 14:23:22 +110073 char b2[BDEVNAME_SIZE];
NeilBrowne373ab12011-10-11 16:48:59 +110074 struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
Mikulas Patockaad6bf882020-01-15 08:35:25 -050075 unsigned blksize = 512;
Andre Nolled7b0032009-06-16 16:47:36 +100076
Dan Carpenter7dedd152016-04-14 12:31:49 +030077 *private_conf = ERR_PTR(-ENOMEM);
Andre Nolled7b0032009-06-16 16:47:36 +100078 if (!conf)
79 return -ENOMEM;
NeilBrowndafb20f2012-03-19 12:46:39 +110080 rdev_for_each(rdev1, mddev) {
NeilBrown50de8df2011-10-07 14:23:22 +110081 pr_debug("md/raid0:%s: looking at %s\n",
82 mdname(mddev),
83 bdevname(rdev1->bdev, b));
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 c = 0;
NeilBrown13f26822009-06-18 08:48:55 +100085
86 /* round size to chunk_size */
87 sectors = rdev1->sectors;
88 sector_div(sectors, mddev->chunk_sectors);
89 rdev1->sectors = sectors * mddev->chunk_sectors;
90
NeilBrown199dc6e2015-08-03 13:11:47 +100091 blksize = max(blksize, queue_logical_block_size(
92 rdev1->bdev->bd_disk->queue));
93
NeilBrowndafb20f2012-03-19 12:46:39 +110094 rdev_for_each(rdev2, mddev) {
NeilBrown50de8df2011-10-07 14:23:22 +110095 pr_debug("md/raid0:%s: comparing %s(%llu)"
96 " with %s(%llu)\n",
97 mdname(mddev),
98 bdevname(rdev1->bdev,b),
99 (unsigned long long)rdev1->sectors,
100 bdevname(rdev2->bdev,b2),
101 (unsigned long long)rdev2->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 if (rdev2 == rdev1) {
NeilBrown50de8df2011-10-07 14:23:22 +1100103 pr_debug("md/raid0:%s: END\n",
104 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 break;
106 }
Andre Nolldd8ac332009-03-31 14:33:13 +1100107 if (rdev2->sectors == rdev1->sectors) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 /*
109 * Not unique, don't count it as a new
110 * group
111 */
NeilBrown50de8df2011-10-07 14:23:22 +1100112 pr_debug("md/raid0:%s: EQUAL\n",
113 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 c = 1;
115 break;
116 }
NeilBrown50de8df2011-10-07 14:23:22 +1100117 pr_debug("md/raid0:%s: NOT EQUAL\n",
118 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 }
120 if (!c) {
NeilBrown50de8df2011-10-07 14:23:22 +1100121 pr_debug("md/raid0:%s: ==> UNIQUE\n",
122 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 conf->nr_strip_zones++;
NeilBrown50de8df2011-10-07 14:23:22 +1100124 pr_debug("md/raid0:%s: %d zones\n",
125 mdname(mddev), conf->nr_strip_zones);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 }
127 }
NeilBrown50de8df2011-10-07 14:23:22 +1100128 pr_debug("md/raid0:%s: FINAL %d zones\n",
129 mdname(mddev), conf->nr_strip_zones);
NeilBrownc84a1372019-09-09 16:30:02 +1000130
131 if (conf->nr_strip_zones == 1) {
132 conf->layout = RAID0_ORIG_LAYOUT;
NeilBrown33f2c352019-09-09 16:52:29 +1000133 } else if (mddev->layout == RAID0_ORIG_LAYOUT ||
134 mddev->layout == RAID0_ALT_MULTIZONE_LAYOUT) {
135 conf->layout = mddev->layout;
NeilBrownc84a1372019-09-09 16:30:02 +1000136 } else if (default_layout == RAID0_ORIG_LAYOUT ||
137 default_layout == RAID0_ALT_MULTIZONE_LAYOUT) {
138 conf->layout = default_layout;
139 } else {
140 pr_err("md/raid0:%s: cannot assemble multi-zone RAID0 with default_layout setting\n",
141 mdname(mddev));
Song Liu3874d732019-10-14 16:58:35 -0700142 pr_err("md/raid0: please set raid0.default_layout to 1 or 2\n");
NeilBrownc84a1372019-09-09 16:30:02 +1000143 err = -ENOTSUPP;
144 goto abort;
145 }
NeilBrown199dc6e2015-08-03 13:11:47 +1000146 /*
147 * now since we have the hard sector sizes, we can make sure
148 * chunk size is a multiple of that sector size
149 */
150 if ((mddev->chunk_sectors << 9) % blksize) {
NeilBrown76603882016-11-02 14:16:50 +1100151 pr_warn("md/raid0:%s: chunk_size of %d not multiple of block size %d\n",
152 mdname(mddev),
153 mddev->chunk_sectors << 9, blksize);
NeilBrown199dc6e2015-08-03 13:11:47 +1000154 err = -EINVAL;
155 goto abort;
156 }
157
Andre Nolled7b0032009-06-16 16:47:36 +1000158 err = -ENOMEM;
Kees Cook6396bb22018-06-12 14:03:40 -0700159 conf->strip_zone = kcalloc(conf->nr_strip_zones,
160 sizeof(struct strip_zone),
161 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 if (!conf->strip_zone)
Andre Nolled7b0032009-06-16 16:47:36 +1000163 goto abort;
Kees Cook6396bb22018-06-12 14:03:40 -0700164 conf->devlist = kzalloc(array3_size(sizeof(struct md_rdev *),
165 conf->nr_strip_zones,
166 mddev->raid_disks),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 GFP_KERNEL);
168 if (!conf->devlist)
Andre Nolled7b0032009-06-16 16:47:36 +1000169 goto abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 /* The first zone must contain all devices, so here we check that
172 * there is a proper alignment of slots to devices and find them all
173 */
174 zone = &conf->strip_zone[0];
175 cnt = 0;
176 smallest = NULL;
NeilBrownb4145792009-06-16 16:50:52 +1000177 dev = conf->devlist;
Andre Nolled7b0032009-06-16 16:47:36 +1000178 err = -EINVAL;
NeilBrowndafb20f2012-03-19 12:46:39 +1100179 rdev_for_each(rdev1, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 int j = rdev1->raid_disk;
181
NeilBrowne93f68a2010-06-15 09:36:03 +0100182 if (mddev->level == 10) {
Trela, Maciej9af204c2010-03-08 16:02:44 +1100183 /* taking over a raid10-n2 array */
184 j /= 2;
NeilBrowne93f68a2010-06-15 09:36:03 +0100185 rdev1->new_raid_disk = j;
186 }
Trela, Maciej9af204c2010-03-08 16:02:44 +1100187
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100188 if (mddev->level == 1) {
189 /* taiking over a raid1 array-
190 * we have only one active disk
191 */
192 j = 0;
193 rdev1->new_raid_disk = j;
194 }
195
NeilBrownf96c9f32013-02-21 15:50:07 +1100196 if (j < 0) {
NeilBrown76603882016-11-02 14:16:50 +1100197 pr_warn("md/raid0:%s: remove inactive devices before converting to RAID0\n",
198 mdname(mddev));
NeilBrownf96c9f32013-02-21 15:50:07 +1100199 goto abort;
200 }
201 if (j >= mddev->raid_disks) {
NeilBrown76603882016-11-02 14:16:50 +1100202 pr_warn("md/raid0:%s: bad disk number %d - aborting!\n",
203 mdname(mddev), j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 goto abort;
205 }
NeilBrownb4145792009-06-16 16:50:52 +1000206 if (dev[j]) {
NeilBrown76603882016-11-02 14:16:50 +1100207 pr_warn("md/raid0:%s: multiple devices for %d - aborting!\n",
208 mdname(mddev), j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209 goto abort;
210 }
NeilBrownb4145792009-06-16 16:50:52 +1000211 dev[j] = rdev1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212
Andre Nolldd8ac332009-03-31 14:33:13 +1100213 if (!smallest || (rdev1->sectors < smallest->sectors))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 smallest = rdev1;
215 cnt++;
216 }
217 if (cnt != mddev->raid_disks) {
NeilBrown76603882016-11-02 14:16:50 +1100218 pr_warn("md/raid0:%s: too few disks (%d of %d) - aborting!\n",
219 mdname(mddev), cnt, mddev->raid_disks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 goto abort;
221 }
222 zone->nb_dev = cnt;
NeilBrown49f357a22009-06-16 16:50:35 +1000223 zone->zone_end = smallest->sectors * cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
NeilBrown49f357a22009-06-16 16:50:35 +1000225 curr_zone_end = zone->zone_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
227 /* now do the other zones */
228 for (i = 1; i < conf->nr_strip_zones; i++)
229 {
NeilBrowna9f326e2009-09-23 18:06:41 +1000230 int j;
231
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 zone = conf->strip_zone + i;
NeilBrownb4145792009-06-16 16:50:52 +1000233 dev = conf->devlist + i * mddev->raid_disks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234
NeilBrown50de8df2011-10-07 14:23:22 +1100235 pr_debug("md/raid0:%s: zone %d\n", mdname(mddev), i);
NeilBrownd27a43ab2009-06-16 16:46:46 +1000236 zone->dev_start = smallest->sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 smallest = NULL;
238 c = 0;
239
240 for (j=0; j<cnt; j++) {
NeilBrownb4145792009-06-16 16:50:52 +1000241 rdev = conf->devlist[j];
NeilBrownd27a43ab2009-06-16 16:46:46 +1000242 if (rdev->sectors <= zone->dev_start) {
NeilBrown50de8df2011-10-07 14:23:22 +1100243 pr_debug("md/raid0:%s: checking %s ... nope\n",
244 mdname(mddev),
245 bdevname(rdev->bdev, b));
Andre Nolldd8ac332009-03-31 14:33:13 +1100246 continue;
247 }
NeilBrown50de8df2011-10-07 14:23:22 +1100248 pr_debug("md/raid0:%s: checking %s ..."
249 " contained as device %d\n",
250 mdname(mddev),
251 bdevname(rdev->bdev, b), c);
NeilBrownb4145792009-06-16 16:50:52 +1000252 dev[c] = rdev;
Andre Nolldd8ac332009-03-31 14:33:13 +1100253 c++;
254 if (!smallest || rdev->sectors < smallest->sectors) {
255 smallest = rdev;
NeilBrown50de8df2011-10-07 14:23:22 +1100256 pr_debug("md/raid0:%s: (%llu) is smallest!.\n",
257 mdname(mddev),
258 (unsigned long long)rdev->sectors);
Andre Nolldd8ac332009-03-31 14:33:13 +1100259 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 }
261
262 zone->nb_dev = c;
NeilBrown49f357a22009-06-16 16:50:35 +1000263 sectors = (smallest->sectors - zone->dev_start) * c;
NeilBrown50de8df2011-10-07 14:23:22 +1100264 pr_debug("md/raid0:%s: zone->nb_dev: %d, sectors: %llu\n",
265 mdname(mddev),
266 zone->nb_dev, (unsigned long long)sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
NeilBrown49f357a22009-06-16 16:50:35 +1000268 curr_zone_end += sectors;
NeilBrownd27a43ab2009-06-16 16:46:46 +1000269 zone->zone_end = curr_zone_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
NeilBrown50de8df2011-10-07 14:23:22 +1100271 pr_debug("md/raid0:%s: current zone start: %llu\n",
272 mdname(mddev),
273 (unsigned long long)smallest->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275
NeilBrown50de8df2011-10-07 14:23:22 +1100276 pr_debug("md/raid0:%s: done.\n", mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100277 *private_conf = conf;
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return 0;
Andre Noll5568a602009-06-16 16:47:21 +1000280abort:
Andre Nolled7b0032009-06-16 16:47:36 +1000281 kfree(conf->strip_zone);
282 kfree(conf->devlist);
283 kfree(conf);
NeilBrown58ebb342013-02-21 15:36:38 +1100284 *private_conf = ERR_PTR(err);
Andre Nolled7b0032009-06-16 16:47:36 +1000285 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286}
287
NeilBrownba13da42012-03-19 12:46:39 +1100288/* Find the zone which holds a particular offset
289 * Update *sectorp to be an offset in that zone
290 */
291static struct strip_zone *find_zone(struct r0conf *conf,
292 sector_t *sectorp)
293{
294 int i;
295 struct strip_zone *z = conf->strip_zone;
296 sector_t sector = *sectorp;
297
298 for (i = 0; i < conf->nr_strip_zones; i++)
299 if (sector < z[i].zone_end) {
300 if (i)
301 *sectorp = sector - z[i-1].zone_end;
302 return z + i;
303 }
304 BUG();
305}
306
307/*
308 * remaps the bio to the target device. we separate two flows.
NeilBrown47d68972015-04-10 13:19:04 +1000309 * power 2 flow and a general flow for the sake of performance
NeilBrownba13da42012-03-19 12:46:39 +1100310*/
311static struct md_rdev *map_sector(struct mddev *mddev, struct strip_zone *zone,
312 sector_t sector, sector_t *sector_offset)
313{
314 unsigned int sect_in_chunk;
315 sector_t chunk;
316 struct r0conf *conf = mddev->private;
317 int raid_disks = conf->strip_zone[0].nb_dev;
318 unsigned int chunk_sects = mddev->chunk_sectors;
319
320 if (is_power_of_2(chunk_sects)) {
321 int chunksect_bits = ffz(~chunk_sects);
322 /* find the sector offset inside the chunk */
323 sect_in_chunk = sector & (chunk_sects - 1);
324 sector >>= chunksect_bits;
325 /* chunk in zone */
326 chunk = *sector_offset;
327 /* quotient is the chunk in real device*/
328 sector_div(chunk, zone->nb_dev << chunksect_bits);
329 } else{
330 sect_in_chunk = sector_div(sector, chunk_sects);
331 chunk = *sector_offset;
332 sector_div(chunk, chunk_sects * zone->nb_dev);
333 }
334 /*
335 * position the bio over the real device
336 * real sector = chunk in device + starting of zone
337 * + the position in the chunk
338 */
339 *sector_offset = (chunk * chunk_sects) + sect_in_chunk;
340 return conf->devlist[(zone - conf->strip_zone)*raid_disks
341 + sector_div(sector, zone->nb_dev)];
342}
343
NeilBrownfd01b882011-10-11 16:47:53 +1100344static sector_t raid0_size(struct mddev *mddev, sector_t sectors, int raid_disks)
Dan Williams80c3a6c2009-03-17 18:10:40 -0700345{
346 sector_t array_sectors = 0;
NeilBrown3cb03002011-10-11 16:45:26 +1100347 struct md_rdev *rdev;
Dan Williams80c3a6c2009-03-17 18:10:40 -0700348
349 WARN_ONCE(sectors || raid_disks,
350 "%s does not support generic reshape\n", __func__);
351
NeilBrowndafb20f2012-03-19 12:46:39 +1100352 rdev_for_each(rdev, mddev)
NeilBrowna6468532013-02-21 14:33:17 +1100353 array_sectors += (rdev->sectors &
354 ~(sector_t)(mddev->chunk_sectors-1));
Dan Williams80c3a6c2009-03-17 18:10:40 -0700355
356 return array_sectors;
357}
358
NeilBrownafa0f552014-12-15 12:56:58 +1100359static void raid0_free(struct mddev *mddev, void *priv);
majianpeng0366ef82012-04-02 09:48:37 +1000360
NeilBrownfd01b882011-10-11 16:47:53 +1100361static int raid0_run(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362{
NeilBrowne373ab12011-10-11 16:48:59 +1100363 struct r0conf *conf;
Andre Noll5568a602009-06-16 16:47:21 +1000364 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365
Andre Noll9d8f0362009-06-18 08:45:01 +1000366 if (mddev->chunk_sectors == 0) {
NeilBrown76603882016-11-02 14:16:50 +1100367 pr_warn("md/raid0:%s: chunk size must be set.\n", mdname(mddev));
NeilBrown2604b702006-01-06 00:20:36 -0800368 return -EINVAL;
369 }
Andre Noll0894cc32009-06-18 08:49:23 +1000370 if (md_check_no_bitmap(mddev))
371 return -EINVAL;
Heinz Mauelshagen753f2852015-02-13 19:48:01 +0100372
Trela, Maciej9af204c2010-03-08 16:02:44 +1100373 /* if private is not null, we are here after takeover */
374 if (mddev->private == NULL) {
375 ret = create_strip_zones(mddev, &conf);
376 if (ret < 0)
377 return ret;
378 mddev->private = conf;
379 }
380 conf = mddev->private;
NeilBrown199dc6e2015-08-03 13:11:47 +1000381 if (mddev->queue) {
382 struct md_rdev *rdev;
383 bool discard_supported = false;
384
NeilBrown199dc6e2015-08-03 13:11:47 +1000385 blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
386 blk_queue_max_write_same_sectors(mddev->queue, mddev->chunk_sectors);
Christoph Hellwig3deff1a2017-04-05 19:21:03 +0200387 blk_queue_max_write_zeroes_sectors(mddev->queue, mddev->chunk_sectors);
Shaohua Li29efc392017-05-07 17:36:24 -0700388 blk_queue_max_discard_sectors(mddev->queue, UINT_MAX);
NeilBrown199dc6e2015-08-03 13:11:47 +1000389
390 blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
391 blk_queue_io_opt(mddev->queue,
392 (mddev->chunk_sectors << 9) * mddev->raid_disks);
393
NeilBrown66eefe52015-09-24 15:47:47 +1000394 rdev_for_each(rdev, mddev) {
395 disk_stack_limits(mddev->gendisk, rdev->bdev,
396 rdev->data_offset << 9);
397 if (blk_queue_discard(bdev_get_queue(rdev->bdev)))
398 discard_supported = true;
399 }
NeilBrown199dc6e2015-08-03 13:11:47 +1000400 if (!discard_supported)
Bart Van Assche8b904b52018-03-07 17:10:10 -0800401 blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue);
NeilBrown199dc6e2015-08-03 13:11:47 +1000402 else
Bart Van Assche8b904b52018-03-07 17:10:10 -0800403 blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue);
NeilBrown199dc6e2015-08-03 13:11:47 +1000404 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406 /* calculate array device size */
Dan Williams1f403622009-03-31 14:59:03 +1100407 md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
NeilBrown76603882016-11-02 14:16:50 +1100409 pr_debug("md/raid0:%s: md_size is %llu sectors.\n",
410 mdname(mddev),
411 (unsigned long long)mddev->array_sectors);
Heinz Mauelshagen753f2852015-02-13 19:48:01 +0100412
raz ben yehuda46994192009-06-16 17:00:54 +1000413 dump_zones(mddev);
majianpeng0366ef82012-04-02 09:48:37 +1000414
415 ret = md_integrity_register(mddev);
majianpeng0366ef82012-04-02 09:48:37 +1000416
417 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418}
419
NeilBrownafa0f552014-12-15 12:56:58 +1100420static void raid0_free(struct mddev *mddev, void *priv)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421{
NeilBrownafa0f552014-12-15 12:56:58 +1100422 struct r0conf *conf = priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700424 kfree(conf->strip_zone);
Andre Nollfb5ab4b2009-06-16 16:48:19 +1000425 kfree(conf->devlist);
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700426 kfree(conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427}
428
Shaohua Li29efc392017-05-07 17:36:24 -0700429static void raid0_handle_discard(struct mddev *mddev, struct bio *bio)
430{
431 struct r0conf *conf = mddev->private;
432 struct strip_zone *zone;
433 sector_t start = bio->bi_iter.bi_sector;
434 sector_t end;
435 unsigned int stripe_size;
436 sector_t first_stripe_index, last_stripe_index;
437 sector_t start_disk_offset;
438 unsigned int start_disk_index;
439 sector_t end_disk_offset;
440 unsigned int end_disk_index;
441 unsigned int disk;
442
443 zone = find_zone(conf, &start);
444
445 if (bio_end_sector(bio) > zone->zone_end) {
446 struct bio *split = bio_split(bio,
447 zone->zone_end - bio->bi_iter.bi_sector, GFP_NOIO,
Kent Overstreetafeee512018-05-20 18:25:52 -0400448 &mddev->bio_set);
Shaohua Li29efc392017-05-07 17:36:24 -0700449 bio_chain(split, bio);
Christoph Hellwiged00aab2020-07-01 10:59:44 +0200450 submit_bio_noacct(bio);
Shaohua Li29efc392017-05-07 17:36:24 -0700451 bio = split;
452 end = zone->zone_end;
453 } else
454 end = bio_end_sector(bio);
455
456 if (zone != conf->strip_zone)
457 end = end - zone[-1].zone_end;
458
459 /* Now start and end is the offset in zone */
460 stripe_size = zone->nb_dev * mddev->chunk_sectors;
461
462 first_stripe_index = start;
463 sector_div(first_stripe_index, stripe_size);
464 last_stripe_index = end;
465 sector_div(last_stripe_index, stripe_size);
466
467 start_disk_index = (int)(start - first_stripe_index * stripe_size) /
468 mddev->chunk_sectors;
469 start_disk_offset = ((int)(start - first_stripe_index * stripe_size) %
470 mddev->chunk_sectors) +
471 first_stripe_index * mddev->chunk_sectors;
472 end_disk_index = (int)(end - last_stripe_index * stripe_size) /
473 mddev->chunk_sectors;
474 end_disk_offset = ((int)(end - last_stripe_index * stripe_size) %
475 mddev->chunk_sectors) +
476 last_stripe_index * mddev->chunk_sectors;
477
478 for (disk = 0; disk < zone->nb_dev; disk++) {
479 sector_t dev_start, dev_end;
Shaohua Li29efc392017-05-07 17:36:24 -0700480 struct md_rdev *rdev;
481
482 if (disk < start_disk_index)
483 dev_start = (first_stripe_index + 1) *
484 mddev->chunk_sectors;
485 else if (disk > start_disk_index)
486 dev_start = first_stripe_index * mddev->chunk_sectors;
487 else
488 dev_start = start_disk_offset;
489
490 if (disk < end_disk_index)
491 dev_end = (last_stripe_index + 1) * mddev->chunk_sectors;
492 else if (disk > end_disk_index)
493 dev_end = last_stripe_index * mddev->chunk_sectors;
494 else
495 dev_end = end_disk_offset;
496
497 if (dev_end <= dev_start)
498 continue;
499
500 rdev = conf->devlist[(zone - conf->strip_zone) *
501 conf->strip_zone[0].nb_dev + disk];
Xiao Ni26280892020-08-25 13:42:59 +0800502 md_submit_discard_bio(mddev, rdev, bio,
Shaohua Li29efc392017-05-07 17:36:24 -0700503 dev_start + zone->dev_start + rdev->data_offset,
Xiao Ni26280892020-08-25 13:42:59 +0800504 dev_end - dev_start);
Shaohua Li29efc392017-05-07 17:36:24 -0700505 }
506 bio_endio(bio);
507}
508
NeilBrowncc27b0c2017-06-05 16:49:39 +1000509static bool raid0_make_request(struct mddev *mddev, struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510{
NeilBrownc84a1372019-09-09 16:30:02 +1000511 struct r0conf *conf = mddev->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 struct strip_zone *zone;
NeilBrown3cb03002011-10-11 16:45:26 +1100513 struct md_rdev *tmp_dev;
NeilBrownf00d7c82017-04-05 14:05:51 +1000514 sector_t bio_sector;
515 sector_t sector;
NeilBrownc84a1372019-09-09 16:30:02 +1000516 sector_t orig_sector;
NeilBrownf00d7c82017-04-05 14:05:51 +1000517 unsigned chunk_sects;
518 unsigned sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
David Jeffery775d7832019-09-16 13:15:14 -0400520 if (unlikely(bio->bi_opf & REQ_PREFLUSH)
521 && md_flush_request(mddev, bio))
NeilBrowncc27b0c2017-06-05 16:49:39 +1000522 return true;
NeilBrowne5dcdd82005-09-09 16:23:41 -0700523
Shaohua Li29efc392017-05-07 17:36:24 -0700524 if (unlikely((bio_op(bio) == REQ_OP_DISCARD))) {
525 raid0_handle_discard(mddev, bio);
NeilBrowncc27b0c2017-06-05 16:49:39 +1000526 return true;
Shaohua Li29efc392017-05-07 17:36:24 -0700527 }
528
NeilBrownf00d7c82017-04-05 14:05:51 +1000529 bio_sector = bio->bi_iter.bi_sector;
530 sector = bio_sector;
531 chunk_sects = mddev->chunk_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
NeilBrownf00d7c82017-04-05 14:05:51 +1000533 sectors = chunk_sects -
534 (likely(is_power_of_2(chunk_sects))
535 ? (sector & (chunk_sects-1))
536 : sector_div(sector, chunk_sects));
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200537
NeilBrownf00d7c82017-04-05 14:05:51 +1000538 /* Restore due to sector_div */
539 sector = bio_sector;
Eric Worka8115772015-05-18 23:26:23 -0700540
NeilBrownf00d7c82017-04-05 14:05:51 +1000541 if (sectors < bio_sectors(bio)) {
Kent Overstreetafeee512018-05-20 18:25:52 -0400542 struct bio *split = bio_split(bio, sectors, GFP_NOIO,
543 &mddev->bio_set);
NeilBrownf00d7c82017-04-05 14:05:51 +1000544 bio_chain(split, bio);
Christoph Hellwiged00aab2020-07-01 10:59:44 +0200545 submit_bio_noacct(bio);
NeilBrownf00d7c82017-04-05 14:05:51 +1000546 bio = split;
547 }
Shaohua Lic83057a2012-10-11 13:25:44 +1100548
NeilBrownc84a1372019-09-09 16:30:02 +1000549 orig_sector = sector;
NeilBrownf00d7c82017-04-05 14:05:51 +1000550 zone = find_zone(mddev->private, &sector);
NeilBrownc84a1372019-09-09 16:30:02 +1000551 switch (conf->layout) {
552 case RAID0_ORIG_LAYOUT:
553 tmp_dev = map_sector(mddev, zone, orig_sector, &sector);
554 break;
555 case RAID0_ALT_MULTIZONE_LAYOUT:
556 tmp_dev = map_sector(mddev, zone, sector, &sector);
557 break;
558 default:
Dan Carpentere3fc3f32019-09-21 09:00:31 +0300559 WARN(1, "md/raid0:%s: Invalid layout\n", mdname(mddev));
NeilBrownc84a1372019-09-09 16:30:02 +1000560 bio_io_error(bio);
561 return true;
562 }
Guilherme G. Piccoli62f7b192019-09-03 16:49:00 -0300563
564 if (unlikely(is_mddev_broken(tmp_dev, "raid0"))) {
565 bio_io_error(bio);
566 return true;
567 }
568
Christoph Hellwig74d46992017-08-23 19:10:32 +0200569 bio_set_dev(bio, tmp_dev->bdev);
NeilBrownf00d7c82017-04-05 14:05:51 +1000570 bio->bi_iter.bi_sector = sector + zone->dev_start +
571 tmp_dev->data_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572
Shaohua Li29efc392017-05-07 17:36:24 -0700573 if (mddev->gendisk)
Christoph Hellwig74d46992017-08-23 19:10:32 +0200574 trace_block_bio_remap(bio->bi_disk->queue, bio,
575 disk_devt(mddev->gendisk), bio_sector);
Shaohua Li29efc392017-05-07 17:36:24 -0700576 mddev_check_writesame(mddev, bio);
577 mddev_check_write_zeroes(mddev, bio);
Christoph Hellwiged00aab2020-07-01 10:59:44 +0200578 submit_bio_noacct(bio);
NeilBrowncc27b0c2017-06-05 16:49:39 +1000579 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580}
NeilBrown8299d7f2007-10-16 23:30:53 -0700581
NeilBrownfd01b882011-10-11 16:47:53 +1100582static void raid0_status(struct seq_file *seq, struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583{
Andre Noll9d8f0362009-06-18 08:45:01 +1000584 seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 return;
586}
587
NeilBrownfd01b882011-10-11 16:47:53 +1100588static void *raid0_takeover_raid45(struct mddev *mddev)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100589{
NeilBrown3cb03002011-10-11 16:45:26 +1100590 struct md_rdev *rdev;
NeilBrowne373ab12011-10-11 16:48:59 +1100591 struct r0conf *priv_conf;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100592
593 if (mddev->degraded != 1) {
NeilBrown76603882016-11-02 14:16:50 +1100594 pr_warn("md/raid0:%s: raid5 must be degraded! Degraded disks: %d\n",
595 mdname(mddev),
596 mddev->degraded);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100597 return ERR_PTR(-EINVAL);
598 }
599
NeilBrowndafb20f2012-03-19 12:46:39 +1100600 rdev_for_each(rdev, mddev) {
Trela, Maciej9af204c2010-03-08 16:02:44 +1100601 /* check slot number for a disk */
602 if (rdev->raid_disk == mddev->raid_disks-1) {
NeilBrown76603882016-11-02 14:16:50 +1100603 pr_warn("md/raid0:%s: raid5 must have missing parity disk!\n",
604 mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100605 return ERR_PTR(-EINVAL);
606 }
NeilBrowneea136d2013-06-26 11:55:20 +1000607 rdev->sectors = mddev->dev_sectors;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100608 }
609
610 /* Set new parameters */
611 mddev->new_level = 0;
Maciej Trela001048a2010-06-16 11:55:14 +0100612 mddev->new_layout = 0;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100613 mddev->new_chunk_sectors = mddev->chunk_sectors;
614 mddev->raid_disks--;
615 mddev->delta_disks = -1;
616 /* make sure it will be not marked as dirty */
617 mddev->recovery_cp = MaxSector;
Shaohua Li394ed8e2017-01-04 16:10:19 -0800618 mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100619
620 create_strip_zones(mddev, &priv_conf);
Shaohua Li6995f0b2016-12-08 15:48:17 -0800621
Trela, Maciej9af204c2010-03-08 16:02:44 +1100622 return priv_conf;
623}
624
NeilBrownfd01b882011-10-11 16:47:53 +1100625static void *raid0_takeover_raid10(struct mddev *mddev)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100626{
NeilBrowne373ab12011-10-11 16:48:59 +1100627 struct r0conf *priv_conf;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100628
629 /* Check layout:
630 * - far_copies must be 1
631 * - near_copies must be 2
632 * - disks number must be even
633 * - all mirrors must be already degraded
634 */
635 if (mddev->layout != ((1 << 8) + 2)) {
NeilBrown76603882016-11-02 14:16:50 +1100636 pr_warn("md/raid0:%s:: Raid0 cannot takeover layout: 0x%x\n",
637 mdname(mddev),
638 mddev->layout);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100639 return ERR_PTR(-EINVAL);
640 }
641 if (mddev->raid_disks & 1) {
NeilBrown76603882016-11-02 14:16:50 +1100642 pr_warn("md/raid0:%s: Raid0 cannot takeover Raid10 with odd disk number.\n",
643 mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100644 return ERR_PTR(-EINVAL);
645 }
646 if (mddev->degraded != (mddev->raid_disks>>1)) {
NeilBrown76603882016-11-02 14:16:50 +1100647 pr_warn("md/raid0:%s: All mirrors must be already degraded!\n",
648 mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100649 return ERR_PTR(-EINVAL);
650 }
651
652 /* Set new parameters */
653 mddev->new_level = 0;
Maciej Trela001048a2010-06-16 11:55:14 +0100654 mddev->new_layout = 0;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100655 mddev->new_chunk_sectors = mddev->chunk_sectors;
656 mddev->delta_disks = - mddev->raid_disks / 2;
657 mddev->raid_disks += mddev->delta_disks;
658 mddev->degraded = 0;
659 /* make sure it will be not marked as dirty */
660 mddev->recovery_cp = MaxSector;
Shaohua Li394ed8e2017-01-04 16:10:19 -0800661 mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100662
663 create_strip_zones(mddev, &priv_conf);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100664 return priv_conf;
665}
666
NeilBrownfd01b882011-10-11 16:47:53 +1100667static void *raid0_takeover_raid1(struct mddev *mddev)
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100668{
NeilBrowne373ab12011-10-11 16:48:59 +1100669 struct r0conf *priv_conf;
Jes Sorensen24b961f2012-04-01 23:48:38 +1000670 int chunksect;
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100671
672 /* Check layout:
673 * - (N - 1) mirror drives must be already faulty
674 */
675 if ((mddev->raid_disks - 1) != mddev->degraded) {
NeilBrown76603882016-11-02 14:16:50 +1100676 pr_err("md/raid0:%s: (N - 1) mirrors drives must be already faulty!\n",
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100677 mdname(mddev));
678 return ERR_PTR(-EINVAL);
679 }
680
Jes Sorensen24b961f2012-04-01 23:48:38 +1000681 /*
682 * a raid1 doesn't have the notion of chunk size, so
683 * figure out the largest suitable size we can use.
684 */
685 chunksect = 64 * 2; /* 64K by default */
686
687 /* The array must be an exact multiple of chunksize */
688 while (chunksect && (mddev->array_sectors & (chunksect - 1)))
689 chunksect >>= 1;
690
691 if ((chunksect << 9) < PAGE_SIZE)
692 /* array size does not allow a suitable chunk size */
693 return ERR_PTR(-EINVAL);
694
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100695 /* Set new parameters */
696 mddev->new_level = 0;
697 mddev->new_layout = 0;
Jes Sorensen24b961f2012-04-01 23:48:38 +1000698 mddev->new_chunk_sectors = chunksect;
699 mddev->chunk_sectors = chunksect;
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100700 mddev->delta_disks = 1 - mddev->raid_disks;
Krzysztof Wojcikf7bee802011-02-14 10:01:41 +1100701 mddev->raid_disks = 1;
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100702 /* make sure it will be not marked as dirty */
703 mddev->recovery_cp = MaxSector;
Shaohua Li394ed8e2017-01-04 16:10:19 -0800704 mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100705
706 create_strip_zones(mddev, &priv_conf);
707 return priv_conf;
708}
709
NeilBrownfd01b882011-10-11 16:47:53 +1100710static void *raid0_takeover(struct mddev *mddev)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100711{
712 /* raid0 can take over:
Maciej Trela049d6c12010-06-16 11:56:12 +0100713 * raid4 - if all data disks are active.
Trela, Maciej9af204c2010-03-08 16:02:44 +1100714 * raid5 - providing it is Raid4 layout and one disk is faulty
715 * raid10 - assuming we have all necessary active disks
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100716 * raid1 - with (N -1) mirror drives faulty
Trela, Maciej9af204c2010-03-08 16:02:44 +1100717 */
NeilBrowna8461a62014-08-06 16:34:27 +1000718
719 if (mddev->bitmap) {
NeilBrown76603882016-11-02 14:16:50 +1100720 pr_warn("md/raid0: %s: cannot takeover array with bitmap\n",
721 mdname(mddev));
NeilBrowna8461a62014-08-06 16:34:27 +1000722 return ERR_PTR(-EBUSY);
723 }
Maciej Trela049d6c12010-06-16 11:56:12 +0100724 if (mddev->level == 4)
725 return raid0_takeover_raid45(mddev);
726
Trela, Maciej9af204c2010-03-08 16:02:44 +1100727 if (mddev->level == 5) {
728 if (mddev->layout == ALGORITHM_PARITY_N)
Maciej Trela049d6c12010-06-16 11:56:12 +0100729 return raid0_takeover_raid45(mddev);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100730
NeilBrown76603882016-11-02 14:16:50 +1100731 pr_warn("md/raid0:%s: Raid can only takeover Raid5 with layout: %d\n",
732 mdname(mddev), ALGORITHM_PARITY_N);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100733 }
734
735 if (mddev->level == 10)
736 return raid0_takeover_raid10(mddev);
737
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100738 if (mddev->level == 1)
739 return raid0_takeover_raid1(mddev);
740
NeilBrown76603882016-11-02 14:16:50 +1100741 pr_warn("Takeover from raid%i to raid0 not supported\n",
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100742 mddev->level);
743
Trela, Maciej9af204c2010-03-08 16:02:44 +1100744 return ERR_PTR(-EINVAL);
745}
746
NeilBrownb03e0cc2017-10-19 12:49:15 +1100747static void raid0_quiesce(struct mddev *mddev, int quiesce)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100748{
749}
750
NeilBrown84fc4b52011-10-11 16:49:58 +1100751static struct md_personality raid0_personality=
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752{
753 .name = "raid0",
NeilBrown2604b702006-01-06 00:20:36 -0800754 .level = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 .owner = THIS_MODULE,
756 .make_request = raid0_make_request,
757 .run = raid0_run,
NeilBrownafa0f552014-12-15 12:56:58 +1100758 .free = raid0_free,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 .status = raid0_status,
Dan Williams80c3a6c2009-03-17 18:10:40 -0700760 .size = raid0_size,
Trela, Maciej9af204c2010-03-08 16:02:44 +1100761 .takeover = raid0_takeover,
762 .quiesce = raid0_quiesce,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763};
764
765static int __init raid0_init (void)
766{
NeilBrown2604b702006-01-06 00:20:36 -0800767 return register_md_personality (&raid0_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768}
769
770static void raid0_exit (void)
771{
NeilBrown2604b702006-01-06 00:20:36 -0800772 unregister_md_personality (&raid0_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773}
774
775module_init(raid0_init);
776module_exit(raid0_exit);
777MODULE_LICENSE("GPL");
NeilBrown0efb9e62009-12-14 12:49:58 +1100778MODULE_DESCRIPTION("RAID0 (striping) personality for MD");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779MODULE_ALIAS("md-personality-2"); /* RAID0 */
NeilBrownd9d166c2006-01-06 00:20:51 -0800780MODULE_ALIAS("md-raid0");
NeilBrown2604b702006-01-06 00:20:36 -0800781MODULE_ALIAS("md-level-0");