1 // SPDX-License-Identifier: GPL-2.0-or-later
3 raid0.c : Multiple Devices driver for Linux
4 Copyright (C) 1994-96 Marc ZYNGIER
5 <zyngier@ufr-info-p7.ibp.fr> or
7 Copyright (C) 1999, 2000 Ingo Molnar, Red Hat
9 RAID-0 management functions.
13 #include <linux/blkdev.h>
14 #include <linux/seq_file.h>
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <trace/events/block.h>
22 static int default_layout = 0;
23 module_param(default_layout, int, 0644);
25 #define UNSUPPORTED_MDDEV_FLAGS \
26 ((1L << MD_HAS_JOURNAL) | \
27 (1L << MD_JOURNAL_CLEAN) | \
28 (1L << MD_FAILFAST_SUPPORTED) |\
29 (1L << MD_HAS_PPL) | \
30 (1L << MD_HAS_MULTIPLE_PPLS))
32 static int raid0_congested(struct mddev *mddev, int bits)
34 struct r0conf *conf = mddev->private;
35 struct md_rdev **devlist = conf->devlist;
36 int raid_disks = conf->strip_zone[0].nb_dev;
39 for (i = 0; i < raid_disks && !ret ; i++) {
40 struct request_queue *q = bdev_get_queue(devlist[i]->bdev);
42 ret |= bdi_congested(q->backing_dev_info, bits);
48 * inform the user of the raid configuration
50 static void dump_zones(struct mddev *mddev)
53 sector_t zone_size = 0;
54 sector_t zone_start = 0;
55 char b[BDEVNAME_SIZE];
56 struct r0conf *conf = mddev->private;
57 int raid_disks = conf->strip_zone[0].nb_dev;
58 pr_debug("md: RAID0 configuration for %s - %d zone%s\n",
60 conf->nr_strip_zones, conf->nr_strip_zones==1?"":"s");
61 for (j = 0; j < conf->nr_strip_zones; j++) {
65 for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
66 len += snprintf(line+len, 200-len, "%s%s", k?"/":"",
67 bdevname(conf->devlist[j*raid_disks
69 pr_debug("md: zone%d=[%s]\n", j, line);
71 zone_size = conf->strip_zone[j].zone_end - zone_start;
72 pr_debug(" zone-offset=%10lluKB, device-offset=%10lluKB, size=%10lluKB\n",
73 (unsigned long long)zone_start>>1,
74 (unsigned long long)conf->strip_zone[j].dev_start>>1,
75 (unsigned long long)zone_size>>1);
76 zone_start = conf->strip_zone[j].zone_end;
80 static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
83 sector_t curr_zone_end, sectors;
84 struct md_rdev *smallest, *rdev1, *rdev2, *rdev, **dev;
85 struct strip_zone *zone;
87 char b[BDEVNAME_SIZE];
88 char b2[BDEVNAME_SIZE];
89 struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
90 unsigned short blksize = 512;
92 *private_conf = ERR_PTR(-ENOMEM);
95 rdev_for_each(rdev1, mddev) {
96 pr_debug("md/raid0:%s: looking at %s\n",
98 bdevname(rdev1->bdev, b));
101 /* round size to chunk_size */
102 sectors = rdev1->sectors;
103 sector_div(sectors, mddev->chunk_sectors);
104 rdev1->sectors = sectors * mddev->chunk_sectors;
106 blksize = max(blksize, queue_logical_block_size(
107 rdev1->bdev->bd_disk->queue));
109 rdev_for_each(rdev2, mddev) {
110 pr_debug("md/raid0:%s: comparing %s(%llu)"
113 bdevname(rdev1->bdev,b),
114 (unsigned long long)rdev1->sectors,
115 bdevname(rdev2->bdev,b2),
116 (unsigned long long)rdev2->sectors);
117 if (rdev2 == rdev1) {
118 pr_debug("md/raid0:%s: END\n",
122 if (rdev2->sectors == rdev1->sectors) {
124 * Not unique, don't count it as a new
127 pr_debug("md/raid0:%s: EQUAL\n",
132 pr_debug("md/raid0:%s: NOT EQUAL\n",
136 pr_debug("md/raid0:%s: ==> UNIQUE\n",
138 conf->nr_strip_zones++;
139 pr_debug("md/raid0:%s: %d zones\n",
140 mdname(mddev), conf->nr_strip_zones);
143 pr_debug("md/raid0:%s: FINAL %d zones\n",
144 mdname(mddev), conf->nr_strip_zones);
146 if (conf->nr_strip_zones == 1) {
147 conf->layout = RAID0_ORIG_LAYOUT;
148 } else if (default_layout == RAID0_ORIG_LAYOUT ||
149 default_layout == RAID0_ALT_MULTIZONE_LAYOUT) {
150 conf->layout = default_layout;
152 pr_err("md/raid0:%s: cannot assemble multi-zone RAID0 with default_layout setting\n",
154 pr_err("md/raid0: please set raid0.default_layout to 1 or 2\n");
159 * now since we have the hard sector sizes, we can make sure
160 * chunk size is a multiple of that sector size
162 if ((mddev->chunk_sectors << 9) % blksize) {
163 pr_warn("md/raid0:%s: chunk_size of %d not multiple of block size %d\n",
165 mddev->chunk_sectors << 9, blksize);
171 conf->strip_zone = kcalloc(conf->nr_strip_zones,
172 sizeof(struct strip_zone),
174 if (!conf->strip_zone)
176 conf->devlist = kzalloc(array3_size(sizeof(struct md_rdev *),
177 conf->nr_strip_zones,
183 /* The first zone must contain all devices, so here we check that
184 * there is a proper alignment of slots to devices and find them all
186 zone = &conf->strip_zone[0];
191 rdev_for_each(rdev1, mddev) {
192 int j = rdev1->raid_disk;
194 if (mddev->level == 10) {
195 /* taking over a raid10-n2 array */
197 rdev1->new_raid_disk = j;
200 if (mddev->level == 1) {
201 /* taiking over a raid1 array-
202 * we have only one active disk
205 rdev1->new_raid_disk = j;
209 pr_warn("md/raid0:%s: remove inactive devices before converting to RAID0\n",
213 if (j >= mddev->raid_disks) {
214 pr_warn("md/raid0:%s: bad disk number %d - aborting!\n",
219 pr_warn("md/raid0:%s: multiple devices for %d - aborting!\n",
225 if (!smallest || (rdev1->sectors < smallest->sectors))
229 if (cnt != mddev->raid_disks) {
230 pr_warn("md/raid0:%s: too few disks (%d of %d) - aborting!\n",
231 mdname(mddev), cnt, mddev->raid_disks);
235 zone->zone_end = smallest->sectors * cnt;
237 curr_zone_end = zone->zone_end;
239 /* now do the other zones */
240 for (i = 1; i < conf->nr_strip_zones; i++)
244 zone = conf->strip_zone + i;
245 dev = conf->devlist + i * mddev->raid_disks;
247 pr_debug("md/raid0:%s: zone %d\n", mdname(mddev), i);
248 zone->dev_start = smallest->sectors;
252 for (j=0; j<cnt; j++) {
253 rdev = conf->devlist[j];
254 if (rdev->sectors <= zone->dev_start) {
255 pr_debug("md/raid0:%s: checking %s ... nope\n",
257 bdevname(rdev->bdev, b));
260 pr_debug("md/raid0:%s: checking %s ..."
261 " contained as device %d\n",
263 bdevname(rdev->bdev, b), c);
266 if (!smallest || rdev->sectors < smallest->sectors) {
268 pr_debug("md/raid0:%s: (%llu) is smallest!.\n",
270 (unsigned long long)rdev->sectors);
275 sectors = (smallest->sectors - zone->dev_start) * c;
276 pr_debug("md/raid0:%s: zone->nb_dev: %d, sectors: %llu\n",
278 zone->nb_dev, (unsigned long long)sectors);
280 curr_zone_end += sectors;
281 zone->zone_end = curr_zone_end;
283 pr_debug("md/raid0:%s: current zone start: %llu\n",
285 (unsigned long long)smallest->sectors);
288 pr_debug("md/raid0:%s: done.\n", mdname(mddev));
289 *private_conf = conf;
293 kfree(conf->strip_zone);
294 kfree(conf->devlist);
296 *private_conf = ERR_PTR(err);
300 /* Find the zone which holds a particular offset
301 * Update *sectorp to be an offset in that zone
303 static struct strip_zone *find_zone(struct r0conf *conf,
307 struct strip_zone *z = conf->strip_zone;
308 sector_t sector = *sectorp;
310 for (i = 0; i < conf->nr_strip_zones; i++)
311 if (sector < z[i].zone_end) {
313 *sectorp = sector - z[i-1].zone_end;
320 * remaps the bio to the target device. we separate two flows.
321 * power 2 flow and a general flow for the sake of performance
323 static struct md_rdev *map_sector(struct mddev *mddev, struct strip_zone *zone,
324 sector_t sector, sector_t *sector_offset)
326 unsigned int sect_in_chunk;
328 struct r0conf *conf = mddev->private;
329 int raid_disks = conf->strip_zone[0].nb_dev;
330 unsigned int chunk_sects = mddev->chunk_sectors;
332 if (is_power_of_2(chunk_sects)) {
333 int chunksect_bits = ffz(~chunk_sects);
334 /* find the sector offset inside the chunk */
335 sect_in_chunk = sector & (chunk_sects - 1);
336 sector >>= chunksect_bits;
338 chunk = *sector_offset;
339 /* quotient is the chunk in real device*/
340 sector_div(chunk, zone->nb_dev << chunksect_bits);
342 sect_in_chunk = sector_div(sector, chunk_sects);
343 chunk = *sector_offset;
344 sector_div(chunk, chunk_sects * zone->nb_dev);
347 * position the bio over the real device
348 * real sector = chunk in device + starting of zone
349 * + the position in the chunk
351 *sector_offset = (chunk * chunk_sects) + sect_in_chunk;
352 return conf->devlist[(zone - conf->strip_zone)*raid_disks
353 + sector_div(sector, zone->nb_dev)];
356 static sector_t raid0_size(struct mddev *mddev, sector_t sectors, int raid_disks)
358 sector_t array_sectors = 0;
359 struct md_rdev *rdev;
361 WARN_ONCE(sectors || raid_disks,
362 "%s does not support generic reshape\n", __func__);
364 rdev_for_each(rdev, mddev)
365 array_sectors += (rdev->sectors &
366 ~(sector_t)(mddev->chunk_sectors-1));
368 return array_sectors;
371 static void raid0_free(struct mddev *mddev, void *priv);
373 static int raid0_run(struct mddev *mddev)
378 if (mddev->chunk_sectors == 0) {
379 pr_warn("md/raid0:%s: chunk size must be set.\n", mdname(mddev));
382 if (md_check_no_bitmap(mddev))
385 /* if private is not null, we are here after takeover */
386 if (mddev->private == NULL) {
387 ret = create_strip_zones(mddev, &conf);
390 mddev->private = conf;
392 conf = mddev->private;
394 struct md_rdev *rdev;
395 bool discard_supported = false;
397 blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
398 blk_queue_max_write_same_sectors(mddev->queue, mddev->chunk_sectors);
399 blk_queue_max_write_zeroes_sectors(mddev->queue, mddev->chunk_sectors);
400 blk_queue_max_discard_sectors(mddev->queue, UINT_MAX);
402 blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
403 blk_queue_io_opt(mddev->queue,
404 (mddev->chunk_sectors << 9) * mddev->raid_disks);
406 rdev_for_each(rdev, mddev) {
407 disk_stack_limits(mddev->gendisk, rdev->bdev,
408 rdev->data_offset << 9);
409 if (blk_queue_discard(bdev_get_queue(rdev->bdev)))
410 discard_supported = true;
412 if (!discard_supported)
413 blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue);
415 blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue);
418 /* calculate array device size */
419 md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));
421 pr_debug("md/raid0:%s: md_size is %llu sectors.\n",
423 (unsigned long long)mddev->array_sectors);
426 /* calculate the max read-ahead size.
427 * For read-ahead of large files to be effective, we need to
428 * readahead at least twice a whole stripe. i.e. number of devices
429 * multiplied by chunk size times 2.
430 * If an individual device has an ra_pages greater than the
431 * chunk size, then we will not drive that device as hard as it
432 * wants. We consider this a configuration error: a larger
433 * chunksize should be used in that case.
435 int stripe = mddev->raid_disks *
436 (mddev->chunk_sectors << 9) / PAGE_SIZE;
437 if (mddev->queue->backing_dev_info->ra_pages < 2* stripe)
438 mddev->queue->backing_dev_info->ra_pages = 2* stripe;
443 ret = md_integrity_register(mddev);
448 static void raid0_free(struct mddev *mddev, void *priv)
450 struct r0conf *conf = priv;
452 kfree(conf->strip_zone);
453 kfree(conf->devlist);
458 * Is io distribute over 1 or more chunks ?
460 static inline int is_io_in_chunk_boundary(struct mddev *mddev,
461 unsigned int chunk_sects, struct bio *bio)
463 if (likely(is_power_of_2(chunk_sects))) {
464 return chunk_sects >=
465 ((bio->bi_iter.bi_sector & (chunk_sects-1))
468 sector_t sector = bio->bi_iter.bi_sector;
469 return chunk_sects >= (sector_div(sector, chunk_sects)
474 static void raid0_handle_discard(struct mddev *mddev, struct bio *bio)
476 struct r0conf *conf = mddev->private;
477 struct strip_zone *zone;
478 sector_t start = bio->bi_iter.bi_sector;
480 unsigned int stripe_size;
481 sector_t first_stripe_index, last_stripe_index;
482 sector_t start_disk_offset;
483 unsigned int start_disk_index;
484 sector_t end_disk_offset;
485 unsigned int end_disk_index;
488 zone = find_zone(conf, &start);
490 if (bio_end_sector(bio) > zone->zone_end) {
491 struct bio *split = bio_split(bio,
492 zone->zone_end - bio->bi_iter.bi_sector, GFP_NOIO,
494 bio_chain(split, bio);
495 generic_make_request(bio);
497 end = zone->zone_end;
499 end = bio_end_sector(bio);
501 if (zone != conf->strip_zone)
502 end = end - zone[-1].zone_end;
504 /* Now start and end is the offset in zone */
505 stripe_size = zone->nb_dev * mddev->chunk_sectors;
507 first_stripe_index = start;
508 sector_div(first_stripe_index, stripe_size);
509 last_stripe_index = end;
510 sector_div(last_stripe_index, stripe_size);
512 start_disk_index = (int)(start - first_stripe_index * stripe_size) /
513 mddev->chunk_sectors;
514 start_disk_offset = ((int)(start - first_stripe_index * stripe_size) %
515 mddev->chunk_sectors) +
516 first_stripe_index * mddev->chunk_sectors;
517 end_disk_index = (int)(end - last_stripe_index * stripe_size) /
518 mddev->chunk_sectors;
519 end_disk_offset = ((int)(end - last_stripe_index * stripe_size) %
520 mddev->chunk_sectors) +
521 last_stripe_index * mddev->chunk_sectors;
523 for (disk = 0; disk < zone->nb_dev; disk++) {
524 sector_t dev_start, dev_end;
525 struct bio *discard_bio = NULL;
526 struct md_rdev *rdev;
528 if (disk < start_disk_index)
529 dev_start = (first_stripe_index + 1) *
530 mddev->chunk_sectors;
531 else if (disk > start_disk_index)
532 dev_start = first_stripe_index * mddev->chunk_sectors;
534 dev_start = start_disk_offset;
536 if (disk < end_disk_index)
537 dev_end = (last_stripe_index + 1) * mddev->chunk_sectors;
538 else if (disk > end_disk_index)
539 dev_end = last_stripe_index * mddev->chunk_sectors;
541 dev_end = end_disk_offset;
543 if (dev_end <= dev_start)
546 rdev = conf->devlist[(zone - conf->strip_zone) *
547 conf->strip_zone[0].nb_dev + disk];
548 if (__blkdev_issue_discard(rdev->bdev,
549 dev_start + zone->dev_start + rdev->data_offset,
550 dev_end - dev_start, GFP_NOIO, 0, &discard_bio) ||
553 bio_chain(discard_bio, bio);
554 bio_clone_blkg_association(discard_bio, bio);
556 trace_block_bio_remap(bdev_get_queue(rdev->bdev),
557 discard_bio, disk_devt(mddev->gendisk),
558 bio->bi_iter.bi_sector);
559 generic_make_request(discard_bio);
564 static bool raid0_make_request(struct mddev *mddev, struct bio *bio)
566 struct r0conf *conf = mddev->private;
567 struct strip_zone *zone;
568 struct md_rdev *tmp_dev;
571 sector_t orig_sector;
572 unsigned chunk_sects;
575 if (unlikely(bio->bi_opf & REQ_PREFLUSH)) {
576 md_flush_request(mddev, bio);
580 if (unlikely((bio_op(bio) == REQ_OP_DISCARD))) {
581 raid0_handle_discard(mddev, bio);
585 bio_sector = bio->bi_iter.bi_sector;
587 chunk_sects = mddev->chunk_sectors;
589 sectors = chunk_sects -
590 (likely(is_power_of_2(chunk_sects))
591 ? (sector & (chunk_sects-1))
592 : sector_div(sector, chunk_sects));
594 /* Restore due to sector_div */
597 if (sectors < bio_sectors(bio)) {
598 struct bio *split = bio_split(bio, sectors, GFP_NOIO,
600 bio_chain(split, bio);
601 generic_make_request(bio);
605 orig_sector = sector;
606 zone = find_zone(mddev->private, §or);
607 switch (conf->layout) {
608 case RAID0_ORIG_LAYOUT:
609 tmp_dev = map_sector(mddev, zone, orig_sector, §or);
611 case RAID0_ALT_MULTIZONE_LAYOUT:
612 tmp_dev = map_sector(mddev, zone, sector, §or);
615 WARN("md/raid0:%s: Invalid layout\n", mdname(mddev));
620 bio_set_dev(bio, tmp_dev->bdev);
621 bio->bi_iter.bi_sector = sector + zone->dev_start +
622 tmp_dev->data_offset;
625 trace_block_bio_remap(bio->bi_disk->queue, bio,
626 disk_devt(mddev->gendisk), bio_sector);
627 mddev_check_writesame(mddev, bio);
628 mddev_check_write_zeroes(mddev, bio);
629 generic_make_request(bio);
633 static void raid0_status(struct seq_file *seq, struct mddev *mddev)
635 seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);
639 static void *raid0_takeover_raid45(struct mddev *mddev)
641 struct md_rdev *rdev;
642 struct r0conf *priv_conf;
644 if (mddev->degraded != 1) {
645 pr_warn("md/raid0:%s: raid5 must be degraded! Degraded disks: %d\n",
648 return ERR_PTR(-EINVAL);
651 rdev_for_each(rdev, mddev) {
652 /* check slot number for a disk */
653 if (rdev->raid_disk == mddev->raid_disks-1) {
654 pr_warn("md/raid0:%s: raid5 must have missing parity disk!\n",
656 return ERR_PTR(-EINVAL);
658 rdev->sectors = mddev->dev_sectors;
661 /* Set new parameters */
662 mddev->new_level = 0;
663 mddev->new_layout = 0;
664 mddev->new_chunk_sectors = mddev->chunk_sectors;
666 mddev->delta_disks = -1;
667 /* make sure it will be not marked as dirty */
668 mddev->recovery_cp = MaxSector;
669 mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
671 create_strip_zones(mddev, &priv_conf);
676 static void *raid0_takeover_raid10(struct mddev *mddev)
678 struct r0conf *priv_conf;
681 * - far_copies must be 1
682 * - near_copies must be 2
683 * - disks number must be even
684 * - all mirrors must be already degraded
686 if (mddev->layout != ((1 << 8) + 2)) {
687 pr_warn("md/raid0:%s:: Raid0 cannot takeover layout: 0x%x\n",
690 return ERR_PTR(-EINVAL);
692 if (mddev->raid_disks & 1) {
693 pr_warn("md/raid0:%s: Raid0 cannot takeover Raid10 with odd disk number.\n",
695 return ERR_PTR(-EINVAL);
697 if (mddev->degraded != (mddev->raid_disks>>1)) {
698 pr_warn("md/raid0:%s: All mirrors must be already degraded!\n",
700 return ERR_PTR(-EINVAL);
703 /* Set new parameters */
704 mddev->new_level = 0;
705 mddev->new_layout = 0;
706 mddev->new_chunk_sectors = mddev->chunk_sectors;
707 mddev->delta_disks = - mddev->raid_disks / 2;
708 mddev->raid_disks += mddev->delta_disks;
710 /* make sure it will be not marked as dirty */
711 mddev->recovery_cp = MaxSector;
712 mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
714 create_strip_zones(mddev, &priv_conf);
718 static void *raid0_takeover_raid1(struct mddev *mddev)
720 struct r0conf *priv_conf;
724 * - (N - 1) mirror drives must be already faulty
726 if ((mddev->raid_disks - 1) != mddev->degraded) {
727 pr_err("md/raid0:%s: (N - 1) mirrors drives must be already faulty!\n",
729 return ERR_PTR(-EINVAL);
733 * a raid1 doesn't have the notion of chunk size, so
734 * figure out the largest suitable size we can use.
736 chunksect = 64 * 2; /* 64K by default */
738 /* The array must be an exact multiple of chunksize */
739 while (chunksect && (mddev->array_sectors & (chunksect - 1)))
742 if ((chunksect << 9) < PAGE_SIZE)
743 /* array size does not allow a suitable chunk size */
744 return ERR_PTR(-EINVAL);
746 /* Set new parameters */
747 mddev->new_level = 0;
748 mddev->new_layout = 0;
749 mddev->new_chunk_sectors = chunksect;
750 mddev->chunk_sectors = chunksect;
751 mddev->delta_disks = 1 - mddev->raid_disks;
752 mddev->raid_disks = 1;
753 /* make sure it will be not marked as dirty */
754 mddev->recovery_cp = MaxSector;
755 mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
757 create_strip_zones(mddev, &priv_conf);
761 static void *raid0_takeover(struct mddev *mddev)
763 /* raid0 can take over:
764 * raid4 - if all data disks are active.
765 * raid5 - providing it is Raid4 layout and one disk is faulty
766 * raid10 - assuming we have all necessary active disks
767 * raid1 - with (N -1) mirror drives faulty
771 pr_warn("md/raid0: %s: cannot takeover array with bitmap\n",
773 return ERR_PTR(-EBUSY);
775 if (mddev->level == 4)
776 return raid0_takeover_raid45(mddev);
778 if (mddev->level == 5) {
779 if (mddev->layout == ALGORITHM_PARITY_N)
780 return raid0_takeover_raid45(mddev);
782 pr_warn("md/raid0:%s: Raid can only takeover Raid5 with layout: %d\n",
783 mdname(mddev), ALGORITHM_PARITY_N);
786 if (mddev->level == 10)
787 return raid0_takeover_raid10(mddev);
789 if (mddev->level == 1)
790 return raid0_takeover_raid1(mddev);
792 pr_warn("Takeover from raid%i to raid0 not supported\n",
795 return ERR_PTR(-EINVAL);
798 static void raid0_quiesce(struct mddev *mddev, int quiesce)
802 static struct md_personality raid0_personality=
806 .owner = THIS_MODULE,
807 .make_request = raid0_make_request,
810 .status = raid0_status,
812 .takeover = raid0_takeover,
813 .quiesce = raid0_quiesce,
814 .congested = raid0_congested,
817 static int __init raid0_init (void)
819 return register_md_personality (&raid0_personality);
822 static void raid0_exit (void)
824 unregister_md_personality (&raid0_personality);
827 module_init(raid0_init);
828 module_exit(raid0_exit);
829 MODULE_LICENSE("GPL");
830 MODULE_DESCRIPTION("RAID0 (striping) personality for MD");
831 MODULE_ALIAS("md-personality-2"); /* RAID0 */
832 MODULE_ALIAS("md-raid0");
833 MODULE_ALIAS("md-level-0");