1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20#include <linux/blkdev.h>
21#include <linux/seq_file.h>
22#include <linux/module.h>
23#include <linux/slab.h>
24#include "md.h"
25#include "raid0.h"
26#include "raid5.h"
27
28static int raid0_congested(struct mddev *mddev, int bits)
29{
30 struct r0conf *conf = mddev->private;
31 struct md_rdev **devlist = conf->devlist;
32 int raid_disks = conf->strip_zone[0].nb_dev;
33 int i, ret = 0;
34
35 for (i = 0; i < raid_disks && !ret ; i++) {
36 struct request_queue *q = bdev_get_queue(devlist[i]->bdev);
37
38 ret |= bdi_congested(&q->backing_dev_info, bits);
39 }
40 return ret;
41}
42
43
44
45
46static void dump_zones(struct mddev *mddev)
47{
48 int j, k;
49 sector_t zone_size = 0;
50 sector_t zone_start = 0;
51 char b[BDEVNAME_SIZE];
52 struct r0conf *conf = mddev->private;
53 int raid_disks = conf->strip_zone[0].nb_dev;
54 printk(KERN_INFO "md: RAID0 configuration for %s - %d zone%s\n",
55 mdname(mddev),
56 conf->nr_strip_zones, conf->nr_strip_zones==1?"":"s");
57 for (j = 0; j < conf->nr_strip_zones; j++) {
58 printk(KERN_INFO "md: zone%d=[", j);
59 for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
60 printk(KERN_CONT "%s%s", k?"/":"",
61 bdevname(conf->devlist[j*raid_disks
62 + k]->bdev, b));
63 printk(KERN_CONT "]\n");
64
65 zone_size = conf->strip_zone[j].zone_end - zone_start;
66 printk(KERN_INFO " zone-offset=%10lluKB, "
67 "device-offset=%10lluKB, size=%10lluKB\n",
68 (unsigned long long)zone_start>>1,
69 (unsigned long long)conf->strip_zone[j].dev_start>>1,
70 (unsigned long long)zone_size>>1);
71 zone_start = conf->strip_zone[j].zone_end;
72 }
73 printk(KERN_INFO "\n");
74}
75
76static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
77{
78 int i, c, err;
79 sector_t curr_zone_end, sectors;
80 struct md_rdev *smallest, *rdev1, *rdev2, *rdev, **dev;
81 struct strip_zone *zone;
82 int cnt;
83 char b[BDEVNAME_SIZE];
84 char b2[BDEVNAME_SIZE];
85 struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
86 bool discard_supported = false;
87
88 if (!conf)
89 return -ENOMEM;
90 rdev_for_each(rdev1, mddev) {
91 pr_debug("md/raid0:%s: looking at %s\n",
92 mdname(mddev),
93 bdevname(rdev1->bdev, b));
94 c = 0;
95
96
97 sectors = rdev1->sectors;
98 sector_div(sectors, mddev->chunk_sectors);
99 rdev1->sectors = sectors * mddev->chunk_sectors;
100
101 rdev_for_each(rdev2, mddev) {
102 pr_debug("md/raid0:%s: comparing %s(%llu)"
103 " with %s(%llu)\n",
104 mdname(mddev),
105 bdevname(rdev1->bdev,b),
106 (unsigned long long)rdev1->sectors,
107 bdevname(rdev2->bdev,b2),
108 (unsigned long long)rdev2->sectors);
109 if (rdev2 == rdev1) {
110 pr_debug("md/raid0:%s: END\n",
111 mdname(mddev));
112 break;
113 }
114 if (rdev2->sectors == rdev1->sectors) {
115
116
117
118
119 pr_debug("md/raid0:%s: EQUAL\n",
120 mdname(mddev));
121 c = 1;
122 break;
123 }
124 pr_debug("md/raid0:%s: NOT EQUAL\n",
125 mdname(mddev));
126 }
127 if (!c) {
128 pr_debug("md/raid0:%s: ==> UNIQUE\n",
129 mdname(mddev));
130 conf->nr_strip_zones++;
131 pr_debug("md/raid0:%s: %d zones\n",
132 mdname(mddev), conf->nr_strip_zones);
133 }
134 }
135 pr_debug("md/raid0:%s: FINAL %d zones\n",
136 mdname(mddev), conf->nr_strip_zones);
137 err = -ENOMEM;
138 conf->strip_zone = kzalloc(sizeof(struct strip_zone)*
139 conf->nr_strip_zones, GFP_KERNEL);
140 if (!conf->strip_zone)
141 goto abort;
142 conf->devlist = kzalloc(sizeof(struct md_rdev*)*
143 conf->nr_strip_zones*mddev->raid_disks,
144 GFP_KERNEL);
145 if (!conf->devlist)
146 goto abort;
147
148
149
150
151 zone = &conf->strip_zone[0];
152 cnt = 0;
153 smallest = NULL;
154 dev = conf->devlist;
155 err = -EINVAL;
156 rdev_for_each(rdev1, mddev) {
157 int j = rdev1->raid_disk;
158
159 if (mddev->level == 10) {
160
161 j /= 2;
162 rdev1->new_raid_disk = j;
163 }
164
165 if (mddev->level == 1) {
166
167
168
169 j = 0;
170 rdev1->new_raid_disk = j;
171 }
172
173 if (j < 0) {
174 printk(KERN_ERR
175 "md/raid0:%s: remove inactive devices before converting to RAID0\n",
176 mdname(mddev));
177 goto abort;
178 }
179 if (j >= mddev->raid_disks) {
180 printk(KERN_ERR "md/raid0:%s: bad disk number %d - "
181 "aborting!\n", mdname(mddev), j);
182 goto abort;
183 }
184 if (dev[j]) {
185 printk(KERN_ERR "md/raid0:%s: multiple devices for %d - "
186 "aborting!\n", mdname(mddev), j);
187 goto abort;
188 }
189 dev[j] = rdev1;
190
191 if (mddev->queue)
192 disk_stack_limits(mddev->gendisk, rdev1->bdev,
193 rdev1->data_offset << 9);
194
195 if (rdev1->bdev->bd_disk->queue->merge_bvec_fn)
196 conf->has_merge_bvec = 1;
197
198 if (!smallest || (rdev1->sectors < smallest->sectors))
199 smallest = rdev1;
200 cnt++;
201
202 if (blk_queue_discard(bdev_get_queue(rdev1->bdev)))
203 discard_supported = true;
204 }
205 if (cnt != mddev->raid_disks) {
206 printk(KERN_ERR "md/raid0:%s: too few disks (%d of %d) - "
207 "aborting!\n", mdname(mddev), cnt, mddev->raid_disks);
208 goto abort;
209 }
210 zone->nb_dev = cnt;
211 zone->zone_end = smallest->sectors * cnt;
212
213 curr_zone_end = zone->zone_end;
214
215
216 for (i = 1; i < conf->nr_strip_zones; i++)
217 {
218 int j;
219
220 zone = conf->strip_zone + i;
221 dev = conf->devlist + i * mddev->raid_disks;
222
223 pr_debug("md/raid0:%s: zone %d\n", mdname(mddev), i);
224 zone->dev_start = smallest->sectors;
225 smallest = NULL;
226 c = 0;
227
228 for (j=0; j<cnt; j++) {
229 rdev = conf->devlist[j];
230 if (rdev->sectors <= zone->dev_start) {
231 pr_debug("md/raid0:%s: checking %s ... nope\n",
232 mdname(mddev),
233 bdevname(rdev->bdev, b));
234 continue;
235 }
236 pr_debug("md/raid0:%s: checking %s ..."
237 " contained as device %d\n",
238 mdname(mddev),
239 bdevname(rdev->bdev, b), c);
240 dev[c] = rdev;
241 c++;
242 if (!smallest || rdev->sectors < smallest->sectors) {
243 smallest = rdev;
244 pr_debug("md/raid0:%s: (%llu) is smallest!.\n",
245 mdname(mddev),
246 (unsigned long long)rdev->sectors);
247 }
248 }
249
250 zone->nb_dev = c;
251 sectors = (smallest->sectors - zone->dev_start) * c;
252 pr_debug("md/raid0:%s: zone->nb_dev: %d, sectors: %llu\n",
253 mdname(mddev),
254 zone->nb_dev, (unsigned long long)sectors);
255
256 curr_zone_end += sectors;
257 zone->zone_end = curr_zone_end;
258
259 pr_debug("md/raid0:%s: current zone start: %llu\n",
260 mdname(mddev),
261 (unsigned long long)smallest->sectors);
262 }
263
264
265
266
267
268 if ((mddev->chunk_sectors << 9) % queue_logical_block_size(mddev->queue)) {
269 printk(KERN_ERR "md/raid0:%s: chunk_size of %d not valid\n",
270 mdname(mddev),
271 mddev->chunk_sectors << 9);
272 goto abort;
273 }
274
275 if (mddev->queue) {
276 blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
277 blk_queue_io_opt(mddev->queue,
278 (mddev->chunk_sectors << 9) * mddev->raid_disks);
279
280 if (!discard_supported)
281 queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
282 else
283 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
284 }
285
286 pr_debug("md/raid0:%s: done.\n", mdname(mddev));
287 *private_conf = conf;
288
289 return 0;
290abort:
291 kfree(conf->strip_zone);
292 kfree(conf->devlist);
293 kfree(conf);
294 *private_conf = ERR_PTR(err);
295 return err;
296}
297
298
299
300
301static struct strip_zone *find_zone(struct r0conf *conf,
302 sector_t *sectorp)
303{
304 int i;
305 struct strip_zone *z = conf->strip_zone;
306 sector_t sector = *sectorp;
307
308 for (i = 0; i < conf->nr_strip_zones; i++)
309 if (sector < z[i].zone_end) {
310 if (i)
311 *sectorp = sector - z[i-1].zone_end;
312 return z + i;
313 }
314 BUG();
315}
316
317
318
319
320
321static struct md_rdev *map_sector(struct mddev *mddev, struct strip_zone *zone,
322 sector_t sector, sector_t *sector_offset)
323{
324 unsigned int sect_in_chunk;
325 sector_t chunk;
326 struct r0conf *conf = mddev->private;
327 int raid_disks = conf->strip_zone[0].nb_dev;
328 unsigned int chunk_sects = mddev->chunk_sectors;
329
330 if (is_power_of_2(chunk_sects)) {
331 int chunksect_bits = ffz(~chunk_sects);
332
333 sect_in_chunk = sector & (chunk_sects - 1);
334 sector >>= chunksect_bits;
335
336 chunk = *sector_offset;
337
338 sector_div(chunk, zone->nb_dev << chunksect_bits);
339 } else{
340 sect_in_chunk = sector_div(sector, chunk_sects);
341 chunk = *sector_offset;
342 sector_div(chunk, chunk_sects * zone->nb_dev);
343 }
344
345
346
347
348
349 *sector_offset = (chunk * chunk_sects) + sect_in_chunk;
350 return conf->devlist[(zone - conf->strip_zone)*raid_disks
351 + sector_div(sector, zone->nb_dev)];
352}
353
354
355
356
357
358
359
360
361
362static int raid0_mergeable_bvec(struct mddev *mddev,
363 struct bvec_merge_data *bvm,
364 struct bio_vec *biovec)
365{
366 struct r0conf *conf = mddev->private;
367 sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
368 sector_t sector_offset = sector;
369 int max;
370 unsigned int chunk_sectors = mddev->chunk_sectors;
371 unsigned int bio_sectors = bvm->bi_size >> 9;
372 struct strip_zone *zone;
373 struct md_rdev *rdev;
374 struct request_queue *subq;
375
376 if (is_power_of_2(chunk_sectors))
377 max = (chunk_sectors - ((sector & (chunk_sectors-1))
378 + bio_sectors)) << 9;
379 else
380 max = (chunk_sectors - (sector_div(sector, chunk_sectors)
381 + bio_sectors)) << 9;
382 if (max < 0)
383 max = 0;
384 if (max <= biovec->bv_len && bio_sectors == 0)
385 return biovec->bv_len;
386 if (max < biovec->bv_len)
387
388 return max;
389 if (!conf->has_merge_bvec)
390 return max;
391
392
393 sector = sector_offset;
394 zone = find_zone(mddev->private, §or_offset);
395 rdev = map_sector(mddev, zone, sector, §or_offset);
396 subq = bdev_get_queue(rdev->bdev);
397 if (subq->merge_bvec_fn) {
398 bvm->bi_bdev = rdev->bdev;
399 bvm->bi_sector = sector_offset + zone->dev_start +
400 rdev->data_offset;
401 return min(max, subq->merge_bvec_fn(subq, bvm, biovec));
402 } else
403 return max;
404}
405
406static sector_t raid0_size(struct mddev *mddev, sector_t sectors, int raid_disks)
407{
408 sector_t array_sectors = 0;
409 struct md_rdev *rdev;
410
411 WARN_ONCE(sectors || raid_disks,
412 "%s does not support generic reshape\n", __func__);
413
414 rdev_for_each(rdev, mddev)
415 array_sectors += (rdev->sectors &
416 ~(sector_t)(mddev->chunk_sectors-1));
417
418 return array_sectors;
419}
420
421static void raid0_free(struct mddev *mddev, void *priv);
422
423static int raid0_run(struct mddev *mddev)
424{
425 struct r0conf *conf;
426 int ret;
427
428 if (mddev->chunk_sectors == 0) {
429 printk(KERN_ERR "md/raid0:%s: chunk size must be set.\n",
430 mdname(mddev));
431 return -EINVAL;
432 }
433 if (md_check_no_bitmap(mddev))
434 return -EINVAL;
435
436 if (mddev->queue) {
437 blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
438 blk_queue_max_write_same_sectors(mddev->queue, mddev->chunk_sectors);
439 blk_queue_max_discard_sectors(mddev->queue, mddev->chunk_sectors);
440 }
441
442
443 if (mddev->private == NULL) {
444 ret = create_strip_zones(mddev, &conf);
445 if (ret < 0)
446 return ret;
447 mddev->private = conf;
448 }
449 conf = mddev->private;
450
451
452 md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));
453
454 printk(KERN_INFO "md/raid0:%s: md_size is %llu sectors.\n",
455 mdname(mddev),
456 (unsigned long long)mddev->array_sectors);
457
458 if (mddev->queue) {
459
460
461
462
463
464
465
466
467
468 int stripe = mddev->raid_disks *
469 (mddev->chunk_sectors << 9) / PAGE_SIZE;
470 if (mddev->queue->backing_dev_info.ra_pages < 2* stripe)
471 mddev->queue->backing_dev_info.ra_pages = 2* stripe;
472 }
473
474 dump_zones(mddev);
475
476 ret = md_integrity_register(mddev);
477
478 return ret;
479}
480
481static void raid0_free(struct mddev *mddev, void *priv)
482{
483 struct r0conf *conf = priv;
484
485 kfree(conf->strip_zone);
486 kfree(conf->devlist);
487 kfree(conf);
488}
489
490
491
492
493static inline int is_io_in_chunk_boundary(struct mddev *mddev,
494 unsigned int chunk_sects, struct bio *bio)
495{
496 if (likely(is_power_of_2(chunk_sects))) {
497 return chunk_sects >=
498 ((bio->bi_iter.bi_sector & (chunk_sects-1))
499 + bio_sectors(bio));
500 } else{
501 sector_t sector = bio->bi_iter.bi_sector;
502 return chunk_sects >= (sector_div(sector, chunk_sects)
503 + bio_sectors(bio));
504 }
505}
506
507static void raid0_make_request(struct mddev *mddev, struct bio *bio)
508{
509 struct strip_zone *zone;
510 struct md_rdev *tmp_dev;
511 struct bio *split;
512
513 if (unlikely(bio->bi_rw & REQ_FLUSH)) {
514 md_flush_request(mddev, bio);
515 return;
516 }
517
518 do {
519 sector_t sector = bio->bi_iter.bi_sector;
520 unsigned chunk_sects = mddev->chunk_sectors;
521
522 unsigned sectors = chunk_sects -
523 (likely(is_power_of_2(chunk_sects))
524 ? (sector & (chunk_sects-1))
525 : sector_div(sector, chunk_sects));
526
527
528 sector = bio->bi_iter.bi_sector;
529
530 if (sectors < bio_sectors(bio)) {
531 split = bio_split(bio, sectors, GFP_NOIO, fs_bio_set);
532 bio_chain(split, bio);
533 } else {
534 split = bio;
535 }
536
537 zone = find_zone(mddev->private, §or);
538 tmp_dev = map_sector(mddev, zone, sector, §or);
539 split->bi_bdev = tmp_dev->bdev;
540 split->bi_iter.bi_sector = sector + zone->dev_start +
541 tmp_dev->data_offset;
542
543 if (unlikely((split->bi_rw & REQ_DISCARD) &&
544 !blk_queue_discard(bdev_get_queue(split->bi_bdev)))) {
545
546 bio_endio(split, 0);
547 } else
548 generic_make_request(split);
549 } while (split != bio);
550}
551
552static void raid0_status(struct seq_file *seq, struct mddev *mddev)
553{
554 seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);
555 return;
556}
557
558static void *raid0_takeover_raid45(struct mddev *mddev)
559{
560 struct md_rdev *rdev;
561 struct r0conf *priv_conf;
562
563 if (mddev->degraded != 1) {
564 printk(KERN_ERR "md/raid0:%s: raid5 must be degraded! Degraded disks: %d\n",
565 mdname(mddev),
566 mddev->degraded);
567 return ERR_PTR(-EINVAL);
568 }
569
570 rdev_for_each(rdev, mddev) {
571
572 if (rdev->raid_disk == mddev->raid_disks-1) {
573 printk(KERN_ERR "md/raid0:%s: raid5 must have missing parity disk!\n",
574 mdname(mddev));
575 return ERR_PTR(-EINVAL);
576 }
577 rdev->sectors = mddev->dev_sectors;
578 }
579
580
581 mddev->new_level = 0;
582 mddev->new_layout = 0;
583 mddev->new_chunk_sectors = mddev->chunk_sectors;
584 mddev->raid_disks--;
585 mddev->delta_disks = -1;
586
587 mddev->recovery_cp = MaxSector;
588
589 create_strip_zones(mddev, &priv_conf);
590 return priv_conf;
591}
592
593static void *raid0_takeover_raid10(struct mddev *mddev)
594{
595 struct r0conf *priv_conf;
596
597
598
599
600
601
602
603 if (mddev->layout != ((1 << 8) + 2)) {
604 printk(KERN_ERR "md/raid0:%s:: Raid0 cannot takover layout: 0x%x\n",
605 mdname(mddev),
606 mddev->layout);
607 return ERR_PTR(-EINVAL);
608 }
609 if (mddev->raid_disks & 1) {
610 printk(KERN_ERR "md/raid0:%s: Raid0 cannot takover Raid10 with odd disk number.\n",
611 mdname(mddev));
612 return ERR_PTR(-EINVAL);
613 }
614 if (mddev->degraded != (mddev->raid_disks>>1)) {
615 printk(KERN_ERR "md/raid0:%s: All mirrors must be already degraded!\n",
616 mdname(mddev));
617 return ERR_PTR(-EINVAL);
618 }
619
620
621 mddev->new_level = 0;
622 mddev->new_layout = 0;
623 mddev->new_chunk_sectors = mddev->chunk_sectors;
624 mddev->delta_disks = - mddev->raid_disks / 2;
625 mddev->raid_disks += mddev->delta_disks;
626 mddev->degraded = 0;
627
628 mddev->recovery_cp = MaxSector;
629
630 create_strip_zones(mddev, &priv_conf);
631 return priv_conf;
632}
633
634static void *raid0_takeover_raid1(struct mddev *mddev)
635{
636 struct r0conf *priv_conf;
637 int chunksect;
638
639
640
641
642 if ((mddev->raid_disks - 1) != mddev->degraded) {
643 printk(KERN_ERR "md/raid0:%s: (N - 1) mirrors drives must be already faulty!\n",
644 mdname(mddev));
645 return ERR_PTR(-EINVAL);
646 }
647
648
649
650
651
652 chunksect = 64 * 2;
653
654
655 while (chunksect && (mddev->array_sectors & (chunksect - 1)))
656 chunksect >>= 1;
657
658 if ((chunksect << 9) < PAGE_SIZE)
659
660 return ERR_PTR(-EINVAL);
661
662
663 mddev->new_level = 0;
664 mddev->new_layout = 0;
665 mddev->new_chunk_sectors = chunksect;
666 mddev->chunk_sectors = chunksect;
667 mddev->delta_disks = 1 - mddev->raid_disks;
668 mddev->raid_disks = 1;
669
670 mddev->recovery_cp = MaxSector;
671
672 create_strip_zones(mddev, &priv_conf);
673 return priv_conf;
674}
675
676static void *raid0_takeover(struct mddev *mddev)
677{
678
679
680
681
682
683
684
685 if (mddev->bitmap) {
686 printk(KERN_ERR "md/raid0: %s: cannot takeover array with bitmap\n",
687 mdname(mddev));
688 return ERR_PTR(-EBUSY);
689 }
690 if (mddev->level == 4)
691 return raid0_takeover_raid45(mddev);
692
693 if (mddev->level == 5) {
694 if (mddev->layout == ALGORITHM_PARITY_N)
695 return raid0_takeover_raid45(mddev);
696
697 printk(KERN_ERR "md/raid0:%s: Raid can only takeover Raid5 with layout: %d\n",
698 mdname(mddev), ALGORITHM_PARITY_N);
699 }
700
701 if (mddev->level == 10)
702 return raid0_takeover_raid10(mddev);
703
704 if (mddev->level == 1)
705 return raid0_takeover_raid1(mddev);
706
707 printk(KERN_ERR "Takeover from raid%i to raid0 not supported\n",
708 mddev->level);
709
710 return ERR_PTR(-EINVAL);
711}
712
713static void raid0_quiesce(struct mddev *mddev, int state)
714{
715}
716
717static struct md_personality raid0_personality=
718{
719 .name = "raid0",
720 .level = 0,
721 .owner = THIS_MODULE,
722 .make_request = raid0_make_request,
723 .run = raid0_run,
724 .free = raid0_free,
725 .status = raid0_status,
726 .size = raid0_size,
727 .takeover = raid0_takeover,
728 .quiesce = raid0_quiesce,
729 .congested = raid0_congested,
730 .mergeable_bvec = raid0_mergeable_bvec,
731};
732
733static int __init raid0_init (void)
734{
735 return register_md_personality (&raid0_personality);
736}
737
738static void raid0_exit (void)
739{
740 unregister_md_personality (&raid0_personality);
741}
742
743module_init(raid0_init);
744module_exit(raid0_exit);
745MODULE_LICENSE("GPL");
746MODULE_DESCRIPTION("RAID0 (striping) personality for MD");
747MODULE_ALIAS("md-personality-2");
748MODULE_ALIAS("md-raid0");
749MODULE_ALIAS("md-level-0");
750