2 raid0.c : Multiple Devices driver for Linux
3 Copyright (C) 1994-96 Marc ZYNGIER
4 <zyngier@ufr-info-p7.ibp.fr> or
6 Copyright (C) 1999, 2000 Ingo Molnar, Red Hat
8 RAID-0 management functions.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
15 You should have received a copy of the GNU General Public License
16 (for example /usr/src/linux/COPYING); if not, write to the Free
17 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 #include <linux/blkdev.h>
21 #include <linux/seq_file.h>
22 #include <linux/module.h>
23 #include <linux/slab.h>
24 #include <trace/events/block.h>
29 static int default_layout
= 0;
30 module_param(default_layout
, int, 0644);
32 #define UNSUPPORTED_MDDEV_FLAGS \
33 ((1L << MD_HAS_JOURNAL) | \
34 (1L << MD_JOURNAL_CLEAN) | \
35 (1L << MD_FAILFAST_SUPPORTED) |\
36 (1L << MD_HAS_PPL) | \
37 (1L << MD_HAS_MULTIPLE_PPLS))
39 static int raid0_congested(struct mddev
*mddev
, int bits
)
41 struct r0conf
*conf
= mddev
->private;
42 struct md_rdev
**devlist
= conf
->devlist
;
43 int raid_disks
= conf
->strip_zone
[0].nb_dev
;
46 for (i
= 0; i
< raid_disks
&& !ret
; i
++) {
47 struct request_queue
*q
= bdev_get_queue(devlist
[i
]->bdev
);
49 ret
|= bdi_congested(q
->backing_dev_info
, bits
);
55 * inform the user of the raid configuration
57 static void dump_zones(struct mddev
*mddev
)
60 sector_t zone_size
= 0;
61 sector_t zone_start
= 0;
62 char b
[BDEVNAME_SIZE
];
63 struct r0conf
*conf
= mddev
->private;
64 int raid_disks
= conf
->strip_zone
[0].nb_dev
;
65 pr_debug("md: RAID0 configuration for %s - %d zone%s\n",
67 conf
->nr_strip_zones
, conf
->nr_strip_zones
==1?"":"s");
68 for (j
= 0; j
< conf
->nr_strip_zones
; j
++) {
72 for (k
= 0; k
< conf
->strip_zone
[j
].nb_dev
; k
++)
73 len
+= snprintf(line
+len
, 200-len
, "%s%s", k
?"/":"",
74 bdevname(conf
->devlist
[j
*raid_disks
76 pr_debug("md: zone%d=[%s]\n", j
, line
);
78 zone_size
= conf
->strip_zone
[j
].zone_end
- zone_start
;
79 pr_debug(" zone-offset=%10lluKB, device-offset=%10lluKB, size=%10lluKB\n",
80 (unsigned long long)zone_start
>>1,
81 (unsigned long long)conf
->strip_zone
[j
].dev_start
>>1,
82 (unsigned long long)zone_size
>>1);
83 zone_start
= conf
->strip_zone
[j
].zone_end
;
87 static int create_strip_zones(struct mddev
*mddev
, struct r0conf
**private_conf
)
90 sector_t curr_zone_end
, sectors
;
91 struct md_rdev
*smallest
, *rdev1
, *rdev2
, *rdev
, **dev
;
92 struct strip_zone
*zone
;
94 char b
[BDEVNAME_SIZE
];
95 char b2
[BDEVNAME_SIZE
];
96 struct r0conf
*conf
= kzalloc(sizeof(*conf
), GFP_KERNEL
);
97 unsigned blksize
= 512;
99 *private_conf
= ERR_PTR(-ENOMEM
);
102 rdev_for_each(rdev1
, mddev
) {
103 pr_debug("md/raid0:%s: looking at %s\n",
105 bdevname(rdev1
->bdev
, b
));
108 /* round size to chunk_size */
109 sectors
= rdev1
->sectors
;
110 sector_div(sectors
, mddev
->chunk_sectors
);
111 rdev1
->sectors
= sectors
* mddev
->chunk_sectors
;
113 blksize
= max(blksize
, queue_logical_block_size(
114 rdev1
->bdev
->bd_disk
->queue
));
116 rdev_for_each(rdev2
, mddev
) {
117 pr_debug("md/raid0:%s: comparing %s(%llu)"
120 bdevname(rdev1
->bdev
,b
),
121 (unsigned long long)rdev1
->sectors
,
122 bdevname(rdev2
->bdev
,b2
),
123 (unsigned long long)rdev2
->sectors
);
124 if (rdev2
== rdev1
) {
125 pr_debug("md/raid0:%s: END\n",
129 if (rdev2
->sectors
== rdev1
->sectors
) {
131 * Not unique, don't count it as a new
134 pr_debug("md/raid0:%s: EQUAL\n",
139 pr_debug("md/raid0:%s: NOT EQUAL\n",
143 pr_debug("md/raid0:%s: ==> UNIQUE\n",
145 conf
->nr_strip_zones
++;
146 pr_debug("md/raid0:%s: %d zones\n",
147 mdname(mddev
), conf
->nr_strip_zones
);
150 pr_debug("md/raid0:%s: FINAL %d zones\n",
151 mdname(mddev
), conf
->nr_strip_zones
);
153 if (conf
->nr_strip_zones
== 1) {
154 conf
->layout
= RAID0_ORIG_LAYOUT
;
155 } else if (mddev
->layout
== RAID0_ORIG_LAYOUT
||
156 mddev
->layout
== RAID0_ALT_MULTIZONE_LAYOUT
) {
157 conf
->layout
= mddev
->layout
;
158 } else if (default_layout
== RAID0_ORIG_LAYOUT
||
159 default_layout
== RAID0_ALT_MULTIZONE_LAYOUT
) {
160 conf
->layout
= default_layout
;
162 conf
->layout
= RAID0_ALT_MULTIZONE_LAYOUT
;
163 pr_warn("md/raid0:%s: !!! DEFAULTING TO ALTERNATE LAYOUT !!!\n",
165 pr_warn("md/raid0: Please set raid0.default_layout to 1 or 2\n");
166 pr_warn("md/raid0: Read the following page for more information:\n");
167 pr_warn("md/raid0: https://wiki.ubuntu.com/Kernel/Raid0LayoutMigration\n");
170 * now since we have the hard sector sizes, we can make sure
171 * chunk size is a multiple of that sector size
173 if ((mddev
->chunk_sectors
<< 9) % blksize
) {
174 pr_warn("md/raid0:%s: chunk_size of %d not multiple of block size %d\n",
176 mddev
->chunk_sectors
<< 9, blksize
);
182 conf
->strip_zone
= kzalloc(sizeof(struct strip_zone
)*
183 conf
->nr_strip_zones
, GFP_KERNEL
);
184 if (!conf
->strip_zone
)
186 conf
->devlist
= kzalloc(sizeof(struct md_rdev
*)*
187 conf
->nr_strip_zones
*mddev
->raid_disks
,
192 /* The first zone must contain all devices, so here we check that
193 * there is a proper alignment of slots to devices and find them all
195 zone
= &conf
->strip_zone
[0];
200 rdev_for_each(rdev1
, mddev
) {
201 int j
= rdev1
->raid_disk
;
203 if (mddev
->level
== 10) {
204 /* taking over a raid10-n2 array */
206 rdev1
->new_raid_disk
= j
;
209 if (mddev
->level
== 1) {
210 /* taiking over a raid1 array-
211 * we have only one active disk
214 rdev1
->new_raid_disk
= j
;
218 pr_warn("md/raid0:%s: remove inactive devices before converting to RAID0\n",
222 if (j
>= mddev
->raid_disks
) {
223 pr_warn("md/raid0:%s: bad disk number %d - aborting!\n",
228 pr_warn("md/raid0:%s: multiple devices for %d - aborting!\n",
234 if (!smallest
|| (rdev1
->sectors
< smallest
->sectors
))
238 if (cnt
!= mddev
->raid_disks
) {
239 pr_warn("md/raid0:%s: too few disks (%d of %d) - aborting!\n",
240 mdname(mddev
), cnt
, mddev
->raid_disks
);
244 zone
->zone_end
= smallest
->sectors
* cnt
;
246 curr_zone_end
= zone
->zone_end
;
248 /* now do the other zones */
249 for (i
= 1; i
< conf
->nr_strip_zones
; i
++)
253 zone
= conf
->strip_zone
+ i
;
254 dev
= conf
->devlist
+ i
* mddev
->raid_disks
;
256 pr_debug("md/raid0:%s: zone %d\n", mdname(mddev
), i
);
257 zone
->dev_start
= smallest
->sectors
;
261 for (j
=0; j
<cnt
; j
++) {
262 rdev
= conf
->devlist
[j
];
263 if (rdev
->sectors
<= zone
->dev_start
) {
264 pr_debug("md/raid0:%s: checking %s ... nope\n",
266 bdevname(rdev
->bdev
, b
));
269 pr_debug("md/raid0:%s: checking %s ..."
270 " contained as device %d\n",
272 bdevname(rdev
->bdev
, b
), c
);
275 if (!smallest
|| rdev
->sectors
< smallest
->sectors
) {
277 pr_debug("md/raid0:%s: (%llu) is smallest!.\n",
279 (unsigned long long)rdev
->sectors
);
284 sectors
= (smallest
->sectors
- zone
->dev_start
) * c
;
285 pr_debug("md/raid0:%s: zone->nb_dev: %d, sectors: %llu\n",
287 zone
->nb_dev
, (unsigned long long)sectors
);
289 curr_zone_end
+= sectors
;
290 zone
->zone_end
= curr_zone_end
;
292 pr_debug("md/raid0:%s: current zone start: %llu\n",
294 (unsigned long long)smallest
->sectors
);
297 pr_debug("md/raid0:%s: done.\n", mdname(mddev
));
298 *private_conf
= conf
;
302 kfree(conf
->strip_zone
);
303 kfree(conf
->devlist
);
305 *private_conf
= ERR_PTR(err
);
309 /* Find the zone which holds a particular offset
310 * Update *sectorp to be an offset in that zone
312 static struct strip_zone
*find_zone(struct r0conf
*conf
,
316 struct strip_zone
*z
= conf
->strip_zone
;
317 sector_t sector
= *sectorp
;
319 for (i
= 0; i
< conf
->nr_strip_zones
; i
++)
320 if (sector
< z
[i
].zone_end
) {
322 *sectorp
= sector
- z
[i
-1].zone_end
;
329 * remaps the bio to the target device. we separate two flows.
330 * power 2 flow and a general flow for the sake of performance
332 static struct md_rdev
*map_sector(struct mddev
*mddev
, struct strip_zone
*zone
,
333 sector_t sector
, sector_t
*sector_offset
)
335 unsigned int sect_in_chunk
;
337 struct r0conf
*conf
= mddev
->private;
338 int raid_disks
= conf
->strip_zone
[0].nb_dev
;
339 unsigned int chunk_sects
= mddev
->chunk_sectors
;
341 if (is_power_of_2(chunk_sects
)) {
342 int chunksect_bits
= ffz(~chunk_sects
);
343 /* find the sector offset inside the chunk */
344 sect_in_chunk
= sector
& (chunk_sects
- 1);
345 sector
>>= chunksect_bits
;
347 chunk
= *sector_offset
;
348 /* quotient is the chunk in real device*/
349 sector_div(chunk
, zone
->nb_dev
<< chunksect_bits
);
351 sect_in_chunk
= sector_div(sector
, chunk_sects
);
352 chunk
= *sector_offset
;
353 sector_div(chunk
, chunk_sects
* zone
->nb_dev
);
356 * position the bio over the real device
357 * real sector = chunk in device + starting of zone
358 * + the position in the chunk
360 *sector_offset
= (chunk
* chunk_sects
) + sect_in_chunk
;
361 return conf
->devlist
[(zone
- conf
->strip_zone
)*raid_disks
362 + sector_div(sector
, zone
->nb_dev
)];
365 static sector_t
raid0_size(struct mddev
*mddev
, sector_t sectors
, int raid_disks
)
367 sector_t array_sectors
= 0;
368 struct md_rdev
*rdev
;
370 WARN_ONCE(sectors
|| raid_disks
,
371 "%s does not support generic reshape\n", __func__
);
373 rdev_for_each(rdev
, mddev
)
374 array_sectors
+= (rdev
->sectors
&
375 ~(sector_t
)(mddev
->chunk_sectors
-1));
377 return array_sectors
;
380 static void raid0_free(struct mddev
*mddev
, void *priv
);
382 static int raid0_run(struct mddev
*mddev
)
387 if (mddev
->chunk_sectors
== 0) {
388 pr_warn("md/raid0:%s: chunk size must be set.\n", mdname(mddev
));
391 if (md_check_no_bitmap(mddev
))
394 /* if private is not null, we are here after takeover */
395 if (mddev
->private == NULL
) {
396 ret
= create_strip_zones(mddev
, &conf
);
399 mddev
->private = conf
;
401 conf
= mddev
->private;
403 struct md_rdev
*rdev
;
404 bool discard_supported
= false;
406 blk_queue_max_hw_sectors(mddev
->queue
, mddev
->chunk_sectors
);
407 blk_queue_max_write_same_sectors(mddev
->queue
, mddev
->chunk_sectors
);
408 blk_queue_max_write_zeroes_sectors(mddev
->queue
, mddev
->chunk_sectors
);
409 blk_queue_max_discard_sectors(mddev
->queue
, UINT_MAX
);
411 blk_queue_io_min(mddev
->queue
, mddev
->chunk_sectors
<< 9);
412 blk_queue_io_opt(mddev
->queue
,
413 (mddev
->chunk_sectors
<< 9) * mddev
->raid_disks
);
415 rdev_for_each(rdev
, mddev
) {
416 disk_stack_limits(mddev
->gendisk
, rdev
->bdev
,
417 rdev
->data_offset
<< 9);
418 if (blk_queue_discard(bdev_get_queue(rdev
->bdev
)))
419 discard_supported
= true;
421 if (!discard_supported
)
422 queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD
, mddev
->queue
);
424 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD
, mddev
->queue
);
427 /* calculate array device size */
428 md_set_array_sectors(mddev
, raid0_size(mddev
, 0, 0));
430 pr_debug("md/raid0:%s: md_size is %llu sectors.\n",
432 (unsigned long long)mddev
->array_sectors
);
435 /* calculate the max read-ahead size.
436 * For read-ahead of large files to be effective, we need to
437 * readahead at least twice a whole stripe. i.e. number of devices
438 * multiplied by chunk size times 2.
439 * If an individual device has an ra_pages greater than the
440 * chunk size, then we will not drive that device as hard as it
441 * wants. We consider this a configuration error: a larger
442 * chunksize should be used in that case.
444 int stripe
= mddev
->raid_disks
*
445 (mddev
->chunk_sectors
<< 9) / PAGE_SIZE
;
446 if (mddev
->queue
->backing_dev_info
->ra_pages
< 2* stripe
)
447 mddev
->queue
->backing_dev_info
->ra_pages
= 2* stripe
;
452 ret
= md_integrity_register(mddev
);
457 static void raid0_free(struct mddev
*mddev
, void *priv
)
459 struct r0conf
*conf
= priv
;
461 kfree(conf
->strip_zone
);
462 kfree(conf
->devlist
);
467 * Is io distribute over 1 or more chunks ?
469 static inline int is_io_in_chunk_boundary(struct mddev
*mddev
,
470 unsigned int chunk_sects
, struct bio
*bio
)
472 if (likely(is_power_of_2(chunk_sects
))) {
473 return chunk_sects
>=
474 ((bio
->bi_iter
.bi_sector
& (chunk_sects
-1))
477 sector_t sector
= bio
->bi_iter
.bi_sector
;
478 return chunk_sects
>= (sector_div(sector
, chunk_sects
)
483 static void raid0_handle_discard(struct mddev
*mddev
, struct bio
*bio
)
485 struct r0conf
*conf
= mddev
->private;
486 struct strip_zone
*zone
;
487 sector_t start
= bio
->bi_iter
.bi_sector
;
489 unsigned int stripe_size
;
490 sector_t first_stripe_index
, last_stripe_index
;
491 sector_t start_disk_offset
;
492 unsigned int start_disk_index
;
493 sector_t end_disk_offset
;
494 unsigned int end_disk_index
;
497 zone
= find_zone(conf
, &start
);
499 if (bio_end_sector(bio
) > zone
->zone_end
) {
500 struct bio
*split
= bio_split(bio
,
501 zone
->zone_end
- bio
->bi_iter
.bi_sector
, GFP_NOIO
,
503 bio_chain(split
, bio
);
504 generic_make_request(bio
);
506 end
= zone
->zone_end
;
508 end
= bio_end_sector(bio
);
510 if (zone
!= conf
->strip_zone
)
511 end
= end
- zone
[-1].zone_end
;
513 /* Now start and end is the offset in zone */
514 stripe_size
= zone
->nb_dev
* mddev
->chunk_sectors
;
516 first_stripe_index
= start
;
517 sector_div(first_stripe_index
, stripe_size
);
518 last_stripe_index
= end
;
519 sector_div(last_stripe_index
, stripe_size
);
521 start_disk_index
= (int)(start
- first_stripe_index
* stripe_size
) /
522 mddev
->chunk_sectors
;
523 start_disk_offset
= ((int)(start
- first_stripe_index
* stripe_size
) %
524 mddev
->chunk_sectors
) +
525 first_stripe_index
* mddev
->chunk_sectors
;
526 end_disk_index
= (int)(end
- last_stripe_index
* stripe_size
) /
527 mddev
->chunk_sectors
;
528 end_disk_offset
= ((int)(end
- last_stripe_index
* stripe_size
) %
529 mddev
->chunk_sectors
) +
530 last_stripe_index
* mddev
->chunk_sectors
;
532 for (disk
= 0; disk
< zone
->nb_dev
; disk
++) {
533 sector_t dev_start
, dev_end
;
534 struct bio
*discard_bio
= NULL
;
535 struct md_rdev
*rdev
;
537 if (disk
< start_disk_index
)
538 dev_start
= (first_stripe_index
+ 1) *
539 mddev
->chunk_sectors
;
540 else if (disk
> start_disk_index
)
541 dev_start
= first_stripe_index
* mddev
->chunk_sectors
;
543 dev_start
= start_disk_offset
;
545 if (disk
< end_disk_index
)
546 dev_end
= (last_stripe_index
+ 1) * mddev
->chunk_sectors
;
547 else if (disk
> end_disk_index
)
548 dev_end
= last_stripe_index
* mddev
->chunk_sectors
;
550 dev_end
= end_disk_offset
;
552 if (dev_end
<= dev_start
)
555 rdev
= conf
->devlist
[(zone
- conf
->strip_zone
) *
556 conf
->strip_zone
[0].nb_dev
+ disk
];
557 if (__blkdev_issue_discard(rdev
->bdev
,
558 dev_start
+ zone
->dev_start
+ rdev
->data_offset
,
559 dev_end
- dev_start
, GFP_NOIO
, 0, &discard_bio
) ||
562 bio_chain(discard_bio
, bio
);
563 bio_clone_blkcg_association(discard_bio
, bio
);
565 trace_block_bio_remap(bdev_get_queue(rdev
->bdev
),
566 discard_bio
, disk_devt(mddev
->gendisk
),
567 bio
->bi_iter
.bi_sector
);
568 generic_make_request(discard_bio
);
573 static bool raid0_make_request(struct mddev
*mddev
, struct bio
*bio
)
575 struct r0conf
*conf
= mddev
->private;
576 struct strip_zone
*zone
;
577 struct md_rdev
*tmp_dev
;
580 sector_t orig_sector
;
581 unsigned chunk_sects
;
584 if (unlikely(bio
->bi_opf
& REQ_PREFLUSH
)
585 && md_flush_request(mddev
, bio
))
588 if (unlikely((bio_op(bio
) == REQ_OP_DISCARD
))) {
589 raid0_handle_discard(mddev
, bio
);
593 bio_sector
= bio
->bi_iter
.bi_sector
;
595 chunk_sects
= mddev
->chunk_sectors
;
597 sectors
= chunk_sects
-
598 (likely(is_power_of_2(chunk_sects
))
599 ? (sector
& (chunk_sects
-1))
600 : sector_div(sector
, chunk_sects
));
602 /* Restore due to sector_div */
605 if (sectors
< bio_sectors(bio
)) {
606 struct bio
*split
= bio_split(bio
, sectors
, GFP_NOIO
, mddev
->bio_set
);
607 bio_chain(split
, bio
);
608 generic_make_request(bio
);
612 orig_sector
= sector
;
613 zone
= find_zone(mddev
->private, §or
);
614 switch (conf
->layout
) {
615 case RAID0_ORIG_LAYOUT
:
616 tmp_dev
= map_sector(mddev
, zone
, orig_sector
, §or
);
618 case RAID0_ALT_MULTIZONE_LAYOUT
:
619 tmp_dev
= map_sector(mddev
, zone
, sector
, §or
);
622 WARN(1, "md/raid0:%s: Invalid layout\n", mdname(mddev
));
627 if (unlikely(is_mddev_broken(tmp_dev
, "raid0"))) {
632 bio_set_dev(bio
, tmp_dev
->bdev
);
633 bio
->bi_iter
.bi_sector
= sector
+ zone
->dev_start
+
634 tmp_dev
->data_offset
;
637 trace_block_bio_remap(bio
->bi_disk
->queue
, bio
,
638 disk_devt(mddev
->gendisk
), bio_sector
);
639 mddev_check_writesame(mddev
, bio
);
640 mddev_check_write_zeroes(mddev
, bio
);
641 generic_make_request(bio
);
645 static void raid0_status(struct seq_file
*seq
, struct mddev
*mddev
)
647 seq_printf(seq
, " %dk chunks", mddev
->chunk_sectors
/ 2);
651 static void *raid0_takeover_raid45(struct mddev
*mddev
)
653 struct md_rdev
*rdev
;
654 struct r0conf
*priv_conf
;
656 if (mddev
->degraded
!= 1) {
657 pr_warn("md/raid0:%s: raid5 must be degraded! Degraded disks: %d\n",
660 return ERR_PTR(-EINVAL
);
663 rdev_for_each(rdev
, mddev
) {
664 /* check slot number for a disk */
665 if (rdev
->raid_disk
== mddev
->raid_disks
-1) {
666 pr_warn("md/raid0:%s: raid5 must have missing parity disk!\n",
668 return ERR_PTR(-EINVAL
);
670 rdev
->sectors
= mddev
->dev_sectors
;
673 /* Set new parameters */
674 mddev
->new_level
= 0;
675 mddev
->new_layout
= 0;
676 mddev
->new_chunk_sectors
= mddev
->chunk_sectors
;
678 mddev
->delta_disks
= -1;
679 /* make sure it will be not marked as dirty */
680 mddev
->recovery_cp
= MaxSector
;
681 mddev_clear_unsupported_flags(mddev
, UNSUPPORTED_MDDEV_FLAGS
);
683 create_strip_zones(mddev
, &priv_conf
);
688 static void *raid0_takeover_raid10(struct mddev
*mddev
)
690 struct r0conf
*priv_conf
;
693 * - far_copies must be 1
694 * - near_copies must be 2
695 * - disks number must be even
696 * - all mirrors must be already degraded
698 if (mddev
->layout
!= ((1 << 8) + 2)) {
699 pr_warn("md/raid0:%s:: Raid0 cannot takeover layout: 0x%x\n",
702 return ERR_PTR(-EINVAL
);
704 if (mddev
->raid_disks
& 1) {
705 pr_warn("md/raid0:%s: Raid0 cannot takeover Raid10 with odd disk number.\n",
707 return ERR_PTR(-EINVAL
);
709 if (mddev
->degraded
!= (mddev
->raid_disks
>>1)) {
710 pr_warn("md/raid0:%s: All mirrors must be already degraded!\n",
712 return ERR_PTR(-EINVAL
);
715 /* Set new parameters */
716 mddev
->new_level
= 0;
717 mddev
->new_layout
= 0;
718 mddev
->new_chunk_sectors
= mddev
->chunk_sectors
;
719 mddev
->delta_disks
= - mddev
->raid_disks
/ 2;
720 mddev
->raid_disks
+= mddev
->delta_disks
;
722 /* make sure it will be not marked as dirty */
723 mddev
->recovery_cp
= MaxSector
;
724 mddev_clear_unsupported_flags(mddev
, UNSUPPORTED_MDDEV_FLAGS
);
726 create_strip_zones(mddev
, &priv_conf
);
730 static void *raid0_takeover_raid1(struct mddev
*mddev
)
732 struct r0conf
*priv_conf
;
736 * - (N - 1) mirror drives must be already faulty
738 if ((mddev
->raid_disks
- 1) != mddev
->degraded
) {
739 pr_err("md/raid0:%s: (N - 1) mirrors drives must be already faulty!\n",
741 return ERR_PTR(-EINVAL
);
745 * a raid1 doesn't have the notion of chunk size, so
746 * figure out the largest suitable size we can use.
748 chunksect
= 64 * 2; /* 64K by default */
750 /* The array must be an exact multiple of chunksize */
751 while (chunksect
&& (mddev
->array_sectors
& (chunksect
- 1)))
754 if ((chunksect
<< 9) < PAGE_SIZE
)
755 /* array size does not allow a suitable chunk size */
756 return ERR_PTR(-EINVAL
);
758 /* Set new parameters */
759 mddev
->new_level
= 0;
760 mddev
->new_layout
= 0;
761 mddev
->new_chunk_sectors
= chunksect
;
762 mddev
->chunk_sectors
= chunksect
;
763 mddev
->delta_disks
= 1 - mddev
->raid_disks
;
764 mddev
->raid_disks
= 1;
765 /* make sure it will be not marked as dirty */
766 mddev
->recovery_cp
= MaxSector
;
767 mddev_clear_unsupported_flags(mddev
, UNSUPPORTED_MDDEV_FLAGS
);
769 create_strip_zones(mddev
, &priv_conf
);
773 static void *raid0_takeover(struct mddev
*mddev
)
775 /* raid0 can take over:
776 * raid4 - if all data disks are active.
777 * raid5 - providing it is Raid4 layout and one disk is faulty
778 * raid10 - assuming we have all necessary active disks
779 * raid1 - with (N -1) mirror drives faulty
783 pr_warn("md/raid0: %s: cannot takeover array with bitmap\n",
785 return ERR_PTR(-EBUSY
);
787 if (mddev
->level
== 4)
788 return raid0_takeover_raid45(mddev
);
790 if (mddev
->level
== 5) {
791 if (mddev
->layout
== ALGORITHM_PARITY_N
)
792 return raid0_takeover_raid45(mddev
);
794 pr_warn("md/raid0:%s: Raid can only takeover Raid5 with layout: %d\n",
795 mdname(mddev
), ALGORITHM_PARITY_N
);
798 if (mddev
->level
== 10)
799 return raid0_takeover_raid10(mddev
);
801 if (mddev
->level
== 1)
802 return raid0_takeover_raid1(mddev
);
804 pr_warn("Takeover from raid%i to raid0 not supported\n",
807 return ERR_PTR(-EINVAL
);
810 static void raid0_quiesce(struct mddev
*mddev
, int quiesce
)
814 static struct md_personality raid0_personality
=
818 .owner
= THIS_MODULE
,
819 .make_request
= raid0_make_request
,
822 .status
= raid0_status
,
824 .takeover
= raid0_takeover
,
825 .quiesce
= raid0_quiesce
,
826 .congested
= raid0_congested
,
829 static int __init
raid0_init (void)
831 return register_md_personality (&raid0_personality
);
834 static void raid0_exit (void)
836 unregister_md_personality (&raid0_personality
);
839 module_init(raid0_init
);
840 module_exit(raid0_exit
);
841 MODULE_LICENSE("GPL");
842 MODULE_DESCRIPTION("RAID0 (striping) personality for MD");
843 MODULE_ALIAS("md-personality-2"); /* RAID0 */
844 MODULE_ALIAS("md-raid0");
845 MODULE_ALIAS("md-level-0");