blob: 7ef5cbf31bb1a5dfc7b7f11593988aaef38d7cf3 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 raid0.c : Multiple Devices driver for Linux
3 Copyright (C) 1994-96 Marc ZYNGIER
4 <zyngier@ufr-info-p7.ibp.fr> or
5 <maz@gloups.fdn.fr>
6 Copyright (C) 1999, 2000 Ingo Molnar, Red Hat
7
8
9 RAID-0 management functions.
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 2, or (at your option)
14 any later version.
15
16 You should have received a copy of the GNU General Public License
17 (for example /usr/src/linux/COPYING); if not, write to the Free
18 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19*/
20
NeilBrownbff61972009-03-31 14:33:13 +110021#include <linux/blkdev.h>
NeilBrownbff61972009-03-31 14:33:13 +110022#include <linux/seq_file.h>
Paul Gortmaker056075c2011-07-03 13:58:33 -040023#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090024#include <linux/slab.h>
NeilBrown43b2e5d2009-03-31 14:33:13 +110025#include "md.h"
Christoph Hellwigef740c32009-03-31 14:27:03 +110026#include "raid0.h"
Trela, Maciej9af204c2010-03-08 16:02:44 +110027#include "raid5.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
NeilBrown26be34d2006-10-03 01:15:53 -070029static int raid0_congested(void *data, int bits)
30{
NeilBrownfd01b882011-10-11 16:47:53 +110031 struct mddev *mddev = data;
NeilBrowne373ab12011-10-11 16:48:59 +110032 struct r0conf *conf = mddev->private;
NeilBrown3cb03002011-10-11 16:45:26 +110033 struct md_rdev **devlist = conf->devlist;
NeilBrown84707f32010-03-16 17:23:35 +110034 int raid_disks = conf->strip_zone[0].nb_dev;
NeilBrown26be34d2006-10-03 01:15:53 -070035 int i, ret = 0;
36
NeilBrown3fa841d2009-09-23 18:10:29 +100037 if (mddev_congested(mddev, bits))
38 return 1;
39
NeilBrown84707f32010-03-16 17:23:35 +110040 for (i = 0; i < raid_disks && !ret ; i++) {
Jens Axboe165125e2007-07-24 09:28:11 +020041 struct request_queue *q = bdev_get_queue(devlist[i]->bdev);
NeilBrown26be34d2006-10-03 01:15:53 -070042
43 ret |= bdi_congested(&q->backing_dev_info, bits);
44 }
45 return ret;
46}
47
raz ben yehuda46994192009-06-16 17:00:54 +100048/*
49 * inform the user of the raid configuration
50*/
NeilBrownfd01b882011-10-11 16:47:53 +110051static void dump_zones(struct mddev *mddev)
raz ben yehuda46994192009-06-16 17:00:54 +100052{
NeilBrown50de8df2011-10-07 14:23:22 +110053 int j, k;
raz ben yehuda46994192009-06-16 17:00:54 +100054 sector_t zone_size = 0;
55 sector_t zone_start = 0;
56 char b[BDEVNAME_SIZE];
NeilBrowne373ab12011-10-11 16:48:59 +110057 struct r0conf *conf = mddev->private;
NeilBrown84707f32010-03-16 17:23:35 +110058 int raid_disks = conf->strip_zone[0].nb_dev;
NeilBrown50de8df2011-10-07 14:23:22 +110059 printk(KERN_INFO "md: RAID0 configuration for %s - %d zone%s\n",
60 mdname(mddev),
61 conf->nr_strip_zones, conf->nr_strip_zones==1?"":"s");
raz ben yehuda46994192009-06-16 17:00:54 +100062 for (j = 0; j < conf->nr_strip_zones; j++) {
NeilBrown50de8df2011-10-07 14:23:22 +110063 printk(KERN_INFO "md: zone%d=[", j);
raz ben yehuda46994192009-06-16 17:00:54 +100064 for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
NeilBrown50de8df2011-10-07 14:23:22 +110065 printk(KERN_CONT "%s%s", k?"/":"",
NeilBrown84707f32010-03-16 17:23:35 +110066 bdevname(conf->devlist[j*raid_disks
raz ben yehuda46994192009-06-16 17:00:54 +100067 + k]->bdev, b));
NeilBrownb5a20962010-05-03 15:06:27 +100068 printk(KERN_CONT "]\n");
raz ben yehuda46994192009-06-16 17:00:54 +100069
70 zone_size = conf->strip_zone[j].zone_end - zone_start;
NeilBrown50de8df2011-10-07 14:23:22 +110071 printk(KERN_INFO " zone-offset=%10lluKB, "
72 "device-offset=%10lluKB, size=%10lluKB\n",
raz ben yehuda46994192009-06-16 17:00:54 +100073 (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;
77 }
NeilBrown50de8df2011-10-07 14:23:22 +110078 printk(KERN_INFO "\n");
raz ben yehuda46994192009-06-16 17:00:54 +100079}
80
NeilBrowne373ab12011-10-11 16:48:59 +110081static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
Linus Torvalds1da177e2005-04-16 15:20:36 -070082{
NeilBrowna9f326e2009-09-23 18:06:41 +100083 int i, c, err;
NeilBrown49f357a22009-06-16 16:50:35 +100084 sector_t curr_zone_end, sectors;
NeilBrown3cb03002011-10-11 16:45:26 +110085 struct md_rdev *smallest, *rdev1, *rdev2, *rdev, **dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 struct strip_zone *zone;
87 int cnt;
88 char b[BDEVNAME_SIZE];
NeilBrown50de8df2011-10-07 14:23:22 +110089 char b2[BDEVNAME_SIZE];
NeilBrowne373ab12011-10-11 16:48:59 +110090 struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
Andre Nolled7b0032009-06-16 16:47:36 +100091
92 if (!conf)
93 return -ENOMEM;
NeilBrowndafb20f2012-03-19 12:46:39 +110094 rdev_for_each(rdev1, mddev) {
NeilBrown50de8df2011-10-07 14:23:22 +110095 pr_debug("md/raid0:%s: looking at %s\n",
96 mdname(mddev),
97 bdevname(rdev1->bdev, b));
Linus Torvalds1da177e2005-04-16 15:20:36 -070098 c = 0;
NeilBrown13f26822009-06-18 08:48:55 +100099
100 /* round size to chunk_size */
101 sectors = rdev1->sectors;
102 sector_div(sectors, mddev->chunk_sectors);
103 rdev1->sectors = sectors * mddev->chunk_sectors;
104
NeilBrowndafb20f2012-03-19 12:46:39 +1100105 rdev_for_each(rdev2, mddev) {
NeilBrown50de8df2011-10-07 14:23:22 +1100106 pr_debug("md/raid0:%s: comparing %s(%llu)"
107 " with %s(%llu)\n",
108 mdname(mddev),
109 bdevname(rdev1->bdev,b),
110 (unsigned long long)rdev1->sectors,
111 bdevname(rdev2->bdev,b2),
112 (unsigned long long)rdev2->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 if (rdev2 == rdev1) {
NeilBrown50de8df2011-10-07 14:23:22 +1100114 pr_debug("md/raid0:%s: END\n",
115 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 break;
117 }
Andre Nolldd8ac332009-03-31 14:33:13 +1100118 if (rdev2->sectors == rdev1->sectors) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 /*
120 * Not unique, don't count it as a new
121 * group
122 */
NeilBrown50de8df2011-10-07 14:23:22 +1100123 pr_debug("md/raid0:%s: EQUAL\n",
124 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 c = 1;
126 break;
127 }
NeilBrown50de8df2011-10-07 14:23:22 +1100128 pr_debug("md/raid0:%s: NOT EQUAL\n",
129 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 }
131 if (!c) {
NeilBrown50de8df2011-10-07 14:23:22 +1100132 pr_debug("md/raid0:%s: ==> UNIQUE\n",
133 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 conf->nr_strip_zones++;
NeilBrown50de8df2011-10-07 14:23:22 +1100135 pr_debug("md/raid0:%s: %d zones\n",
136 mdname(mddev), conf->nr_strip_zones);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 }
138 }
NeilBrown50de8df2011-10-07 14:23:22 +1100139 pr_debug("md/raid0:%s: FINAL %d zones\n",
140 mdname(mddev), conf->nr_strip_zones);
Andre Nolled7b0032009-06-16 16:47:36 +1000141 err = -ENOMEM;
NeilBrown9ffae0c2006-01-06 00:20:32 -0800142 conf->strip_zone = kzalloc(sizeof(struct strip_zone)*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 conf->nr_strip_zones, GFP_KERNEL);
144 if (!conf->strip_zone)
Andre Nolled7b0032009-06-16 16:47:36 +1000145 goto abort;
NeilBrown3cb03002011-10-11 16:45:26 +1100146 conf->devlist = kzalloc(sizeof(struct md_rdev*)*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 conf->nr_strip_zones*mddev->raid_disks,
148 GFP_KERNEL);
149 if (!conf->devlist)
Andre Nolled7b0032009-06-16 16:47:36 +1000150 goto abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 /* The first zone must contain all devices, so here we check that
153 * there is a proper alignment of slots to devices and find them all
154 */
155 zone = &conf->strip_zone[0];
156 cnt = 0;
157 smallest = NULL;
NeilBrownb4145792009-06-16 16:50:52 +1000158 dev = conf->devlist;
Andre Nolled7b0032009-06-16 16:47:36 +1000159 err = -EINVAL;
NeilBrowndafb20f2012-03-19 12:46:39 +1100160 rdev_for_each(rdev1, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 int j = rdev1->raid_disk;
162
NeilBrowne93f68a2010-06-15 09:36:03 +0100163 if (mddev->level == 10) {
Trela, Maciej9af204c2010-03-08 16:02:44 +1100164 /* taking over a raid10-n2 array */
165 j /= 2;
NeilBrowne93f68a2010-06-15 09:36:03 +0100166 rdev1->new_raid_disk = j;
167 }
Trela, Maciej9af204c2010-03-08 16:02:44 +1100168
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100169 if (mddev->level == 1) {
170 /* taiking over a raid1 array-
171 * we have only one active disk
172 */
173 j = 0;
174 rdev1->new_raid_disk = j;
175 }
176
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177 if (j < 0 || j >= mddev->raid_disks) {
NeilBrownb5a20962010-05-03 15:06:27 +1000178 printk(KERN_ERR "md/raid0:%s: bad disk number %d - "
179 "aborting!\n", mdname(mddev), j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180 goto abort;
181 }
NeilBrownb4145792009-06-16 16:50:52 +1000182 if (dev[j]) {
NeilBrownb5a20962010-05-03 15:06:27 +1000183 printk(KERN_ERR "md/raid0:%s: multiple devices for %d - "
184 "aborting!\n", mdname(mddev), j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 goto abort;
186 }
NeilBrownb4145792009-06-16 16:50:52 +1000187 dev[j] = rdev1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188
Martin K. Petersen8f6c2e42009-07-01 11:13:45 +1000189 disk_stack_limits(mddev->gendisk, rdev1->bdev,
190 rdev1->data_offset << 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 /* as we don't honour merge_bvec_fn, we must never risk
NeilBrown627a2d32010-03-08 16:44:38 +1100192 * violating it, so limit ->max_segments to 1, lying within
193 * a single page.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 */
195
NeilBrown627a2d32010-03-08 16:44:38 +1100196 if (rdev1->bdev->bd_disk->queue->merge_bvec_fn) {
197 blk_queue_max_segments(mddev->queue, 1);
198 blk_queue_segment_boundary(mddev->queue,
199 PAGE_CACHE_SIZE - 1);
200 }
Andre Nolldd8ac332009-03-31 14:33:13 +1100201 if (!smallest || (rdev1->sectors < smallest->sectors))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 smallest = rdev1;
203 cnt++;
204 }
205 if (cnt != mddev->raid_disks) {
NeilBrownb5a20962010-05-03 15:06:27 +1000206 printk(KERN_ERR "md/raid0:%s: too few disks (%d of %d) - "
207 "aborting!\n", mdname(mddev), cnt, mddev->raid_disks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 goto abort;
209 }
210 zone->nb_dev = cnt;
NeilBrown49f357a22009-06-16 16:50:35 +1000211 zone->zone_end = smallest->sectors * cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212
NeilBrown49f357a22009-06-16 16:50:35 +1000213 curr_zone_end = zone->zone_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215 /* now do the other zones */
216 for (i = 1; i < conf->nr_strip_zones; i++)
217 {
NeilBrowna9f326e2009-09-23 18:06:41 +1000218 int j;
219
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 zone = conf->strip_zone + i;
NeilBrownb4145792009-06-16 16:50:52 +1000221 dev = conf->devlist + i * mddev->raid_disks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
NeilBrown50de8df2011-10-07 14:23:22 +1100223 pr_debug("md/raid0:%s: zone %d\n", mdname(mddev), i);
NeilBrownd27a43a2009-06-16 16:46:46 +1000224 zone->dev_start = smallest->sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 smallest = NULL;
226 c = 0;
227
228 for (j=0; j<cnt; j++) {
NeilBrownb4145792009-06-16 16:50:52 +1000229 rdev = conf->devlist[j];
NeilBrownd27a43a2009-06-16 16:46:46 +1000230 if (rdev->sectors <= zone->dev_start) {
NeilBrown50de8df2011-10-07 14:23:22 +1100231 pr_debug("md/raid0:%s: checking %s ... nope\n",
232 mdname(mddev),
233 bdevname(rdev->bdev, b));
Andre Nolldd8ac332009-03-31 14:33:13 +1100234 continue;
235 }
NeilBrown50de8df2011-10-07 14:23:22 +1100236 pr_debug("md/raid0:%s: checking %s ..."
237 " contained as device %d\n",
238 mdname(mddev),
239 bdevname(rdev->bdev, b), c);
NeilBrownb4145792009-06-16 16:50:52 +1000240 dev[c] = rdev;
Andre Nolldd8ac332009-03-31 14:33:13 +1100241 c++;
242 if (!smallest || rdev->sectors < smallest->sectors) {
243 smallest = rdev;
NeilBrown50de8df2011-10-07 14:23:22 +1100244 pr_debug("md/raid0:%s: (%llu) is smallest!.\n",
245 mdname(mddev),
246 (unsigned long long)rdev->sectors);
Andre Nolldd8ac332009-03-31 14:33:13 +1100247 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248 }
249
250 zone->nb_dev = c;
NeilBrown49f357a22009-06-16 16:50:35 +1000251 sectors = (smallest->sectors - zone->dev_start) * c;
NeilBrown50de8df2011-10-07 14:23:22 +1100252 pr_debug("md/raid0:%s: zone->nb_dev: %d, sectors: %llu\n",
253 mdname(mddev),
254 zone->nb_dev, (unsigned long long)sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
NeilBrown49f357a22009-06-16 16:50:35 +1000256 curr_zone_end += sectors;
NeilBrownd27a43a2009-06-16 16:46:46 +1000257 zone->zone_end = curr_zone_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
NeilBrown50de8df2011-10-07 14:23:22 +1100259 pr_debug("md/raid0:%s: current zone start: %llu\n",
260 mdname(mddev),
261 (unsigned long long)smallest->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 }
NeilBrown26be34d2006-10-03 01:15:53 -0700263 mddev->queue->backing_dev_info.congested_fn = raid0_congested;
264 mddev->queue->backing_dev_info.congested_data = mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265
raz ben yehuda92e59b62009-06-16 17:00:57 +1000266 /*
267 * now since we have the hard sector sizes, we can make sure
268 * chunk size is a multiple of that sector size
269 */
Andre Noll9d8f0362009-06-18 08:45:01 +1000270 if ((mddev->chunk_sectors << 9) % queue_logical_block_size(mddev->queue)) {
NeilBrownb5a20962010-05-03 15:06:27 +1000271 printk(KERN_ERR "md/raid0:%s: chunk_size of %d not valid\n",
raz ben yehuda92e59b62009-06-16 17:00:57 +1000272 mdname(mddev),
Andre Noll9d8f0362009-06-18 08:45:01 +1000273 mddev->chunk_sectors << 9);
raz ben yehuda92e59b62009-06-16 17:00:57 +1000274 goto abort;
275 }
Martin K. Petersen8f6c2e42009-07-01 11:13:45 +1000276
277 blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
278 blk_queue_io_opt(mddev->queue,
279 (mddev->chunk_sectors << 9) * mddev->raid_disks);
280
NeilBrown50de8df2011-10-07 14:23:22 +1100281 pr_debug("md/raid0:%s: done.\n", mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100282 *private_conf = conf;
283
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 return 0;
Andre Noll5568a602009-06-16 16:47:21 +1000285abort:
Andre Nolled7b0032009-06-16 16:47:36 +1000286 kfree(conf->strip_zone);
287 kfree(conf->devlist);
288 kfree(conf);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100289 *private_conf = NULL;
Andre Nolled7b0032009-06-16 16:47:36 +1000290 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700291}
292
293/**
294 * raid0_mergeable_bvec -- tell bio layer if a two requests can be merged
295 * @q: request queue
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200296 * @bvm: properties of new bio
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 * @biovec: the request that could be merged to it.
298 *
299 * Return amount of bytes we can accept at this offset
300 */
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200301static int raid0_mergeable_bvec(struct request_queue *q,
302 struct bvec_merge_data *bvm,
303 struct bio_vec *biovec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304{
NeilBrownfd01b882011-10-11 16:47:53 +1100305 struct mddev *mddev = q->queuedata;
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200306 sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 int max;
Andre Noll9d8f0362009-06-18 08:45:01 +1000308 unsigned int chunk_sectors = mddev->chunk_sectors;
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200309 unsigned int bio_sectors = bvm->bi_size >> 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
NeilBrownd6e412e2009-06-18 08:47:00 +1000311 if (is_power_of_2(chunk_sectors))
raz ben yehudafbb704e2009-06-16 17:02:05 +1000312 max = (chunk_sectors - ((sector & (chunk_sectors-1))
313 + bio_sectors)) << 9;
314 else
315 max = (chunk_sectors - (sector_div(sector, chunk_sectors)
316 + bio_sectors)) << 9;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317 if (max < 0) max = 0; /* bio_add cannot handle a negative return */
318 if (max <= biovec->bv_len && bio_sectors == 0)
319 return biovec->bv_len;
320 else
321 return max;
322}
323
NeilBrownfd01b882011-10-11 16:47:53 +1100324static sector_t raid0_size(struct mddev *mddev, sector_t sectors, int raid_disks)
Dan Williams80c3a6c2009-03-17 18:10:40 -0700325{
326 sector_t array_sectors = 0;
NeilBrown3cb03002011-10-11 16:45:26 +1100327 struct md_rdev *rdev;
Dan Williams80c3a6c2009-03-17 18:10:40 -0700328
329 WARN_ONCE(sectors || raid_disks,
330 "%s does not support generic reshape\n", __func__);
331
NeilBrowndafb20f2012-03-19 12:46:39 +1100332 rdev_for_each(rdev, mddev)
Dan Williams80c3a6c2009-03-17 18:10:40 -0700333 array_sectors += rdev->sectors;
334
335 return array_sectors;
336}
337
NeilBrownfd01b882011-10-11 16:47:53 +1100338static int raid0_run(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
NeilBrowne373ab12011-10-11 16:48:59 +1100340 struct r0conf *conf;
Andre Noll5568a602009-06-16 16:47:21 +1000341 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
Andre Noll9d8f0362009-06-18 08:45:01 +1000343 if (mddev->chunk_sectors == 0) {
NeilBrownb5a20962010-05-03 15:06:27 +1000344 printk(KERN_ERR "md/raid0:%s: chunk size must be set.\n",
345 mdname(mddev));
NeilBrown2604b702006-01-06 00:20:36 -0800346 return -EINVAL;
347 }
Andre Noll0894cc32009-06-18 08:49:23 +1000348 if (md_check_no_bitmap(mddev))
349 return -EINVAL;
Martin K. Petersen086fa5f2010-02-26 00:20:38 -0500350 blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351
Trela, Maciej9af204c2010-03-08 16:02:44 +1100352 /* if private is not null, we are here after takeover */
353 if (mddev->private == NULL) {
354 ret = create_strip_zones(mddev, &conf);
355 if (ret < 0)
356 return ret;
357 mddev->private = conf;
358 }
359 conf = mddev->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
361 /* calculate array device size */
Dan Williams1f403622009-03-31 14:59:03 +1100362 md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
NeilBrownb5a20962010-05-03 15:06:27 +1000364 printk(KERN_INFO "md/raid0:%s: md_size is %llu sectors.\n",
365 mdname(mddev),
366 (unsigned long long)mddev->array_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 /* calculate the max read-ahead size.
368 * For read-ahead of large files to be effective, we need to
369 * readahead at least twice a whole stripe. i.e. number of devices
370 * multiplied by chunk size times 2.
371 * If an individual device has an ra_pages greater than the
372 * chunk size, then we will not drive that device as hard as it
373 * wants. We consider this a configuration error: a larger
374 * chunksize should be used in that case.
375 */
376 {
Andre Noll9d8f0362009-06-18 08:45:01 +1000377 int stripe = mddev->raid_disks *
378 (mddev->chunk_sectors << 9) / PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 if (mddev->queue->backing_dev_info.ra_pages < 2* stripe)
380 mddev->queue->backing_dev_info.ra_pages = 2* stripe;
381 }
382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 blk_queue_merge_bvec(mddev->queue, raid0_mergeable_bvec);
raz ben yehuda46994192009-06-16 17:00:54 +1000384 dump_zones(mddev);
Martin K. Petersena91a2782011-03-17 11:11:05 +0100385 return md_integrity_register(mddev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386}
387
NeilBrownfd01b882011-10-11 16:47:53 +1100388static int raid0_stop(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389{
NeilBrowne373ab12011-10-11 16:48:59 +1100390 struct r0conf *conf = mddev->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391
392 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700393 kfree(conf->strip_zone);
Andre Nollfb5ab4b2009-06-16 16:48:19 +1000394 kfree(conf->devlist);
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700395 kfree(conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 mddev->private = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 return 0;
398}
399
NeilBrown49f357a22009-06-16 16:50:35 +1000400/* Find the zone which holds a particular offset
401 * Update *sectorp to be an offset in that zone
402 */
NeilBrowne373ab12011-10-11 16:48:59 +1100403static struct strip_zone *find_zone(struct r0conf *conf,
NeilBrown49f357a22009-06-16 16:50:35 +1000404 sector_t *sectorp)
Andre Nolldc582662009-06-16 16:18:43 +1000405{
406 int i;
407 struct strip_zone *z = conf->strip_zone;
NeilBrown49f357a22009-06-16 16:50:35 +1000408 sector_t sector = *sectorp;
Andre Nolldc582662009-06-16 16:18:43 +1000409
410 for (i = 0; i < conf->nr_strip_zones; i++)
NeilBrown49f357a22009-06-16 16:50:35 +1000411 if (sector < z[i].zone_end) {
412 if (i)
413 *sectorp = sector - z[i-1].zone_end;
Andre Nolldc582662009-06-16 16:18:43 +1000414 return z + i;
NeilBrown49f357a22009-06-16 16:50:35 +1000415 }
Andre Nolldc582662009-06-16 16:18:43 +1000416 BUG();
417}
418
raz ben yehudafbb704e2009-06-16 17:02:05 +1000419/*
420 * remaps the bio to the target device. we separate two flows.
421 * power 2 flow and a general flow for the sake of perfromance
422*/
NeilBrownfd01b882011-10-11 16:47:53 +1100423static struct md_rdev *map_sector(struct mddev *mddev, struct strip_zone *zone,
raz ben yehudafbb704e2009-06-16 17:02:05 +1000424 sector_t sector, sector_t *sector_offset)
425{
426 unsigned int sect_in_chunk;
427 sector_t chunk;
NeilBrowne373ab12011-10-11 16:48:59 +1100428 struct r0conf *conf = mddev->private;
NeilBrown84707f32010-03-16 17:23:35 +1100429 int raid_disks = conf->strip_zone[0].nb_dev;
Andre Noll9d8f0362009-06-18 08:45:01 +1000430 unsigned int chunk_sects = mddev->chunk_sectors;
raz ben yehudafbb704e2009-06-16 17:02:05 +1000431
NeilBrownd6e412e2009-06-18 08:47:00 +1000432 if (is_power_of_2(chunk_sects)) {
raz ben yehudafbb704e2009-06-16 17:02:05 +1000433 int chunksect_bits = ffz(~chunk_sects);
434 /* find the sector offset inside the chunk */
435 sect_in_chunk = sector & (chunk_sects - 1);
436 sector >>= chunksect_bits;
437 /* chunk in zone */
438 chunk = *sector_offset;
439 /* quotient is the chunk in real device*/
440 sector_div(chunk, zone->nb_dev << chunksect_bits);
441 } else{
442 sect_in_chunk = sector_div(sector, chunk_sects);
443 chunk = *sector_offset;
444 sector_div(chunk, chunk_sects * zone->nb_dev);
445 }
446 /*
447 * position the bio over the real device
448 * real sector = chunk in device + starting of zone
449 * + the position in the chunk
450 */
451 *sector_offset = (chunk * chunk_sects) + sect_in_chunk;
NeilBrown84707f32010-03-16 17:23:35 +1100452 return conf->devlist[(zone - conf->strip_zone)*raid_disks
raz ben yehudafbb704e2009-06-16 17:02:05 +1000453 + sector_div(sector, zone->nb_dev)];
454}
455
456/*
457 * Is io distribute over 1 or more chunks ?
458*/
NeilBrownfd01b882011-10-11 16:47:53 +1100459static inline int is_io_in_chunk_boundary(struct mddev *mddev,
raz ben yehudafbb704e2009-06-16 17:02:05 +1000460 unsigned int chunk_sects, struct bio *bio)
461{
NeilBrownd6e412e2009-06-18 08:47:00 +1000462 if (likely(is_power_of_2(chunk_sects))) {
raz ben yehudafbb704e2009-06-16 17:02:05 +1000463 return chunk_sects >= ((bio->bi_sector & (chunk_sects-1))
464 + (bio->bi_size >> 9));
465 } else{
466 sector_t sector = bio->bi_sector;
467 return chunk_sects >= (sector_div(sector, chunk_sects)
468 + (bio->bi_size >> 9));
469 }
470}
471
Linus Torvaldsb4fdcb02011-11-04 17:06:58 -0700472static void raid0_make_request(struct mddev *mddev, struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473{
raz ben yehudafbb704e2009-06-16 17:02:05 +1000474 unsigned int chunk_sects;
475 sector_t sector_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 struct strip_zone *zone;
NeilBrown3cb03002011-10-11 16:45:26 +1100477 struct md_rdev *tmp_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
Tejun Heoe9c74692010-09-03 11:56:18 +0200479 if (unlikely(bio->bi_rw & REQ_FLUSH)) {
480 md_flush_request(mddev, bio);
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200481 return;
NeilBrowne5dcdd82005-09-09 16:23:41 -0700482 }
483
Andre Noll9d8f0362009-06-18 08:45:01 +1000484 chunk_sects = mddev->chunk_sectors;
raz ben yehudafbb704e2009-06-16 17:02:05 +1000485 if (unlikely(!is_io_in_chunk_boundary(mddev, chunk_sects, bio))) {
486 sector_t sector = bio->bi_sector;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 struct bio_pair *bp;
488 /* Sanity check -- queue functions should prevent this happening */
489 if (bio->bi_vcnt != 1 ||
490 bio->bi_idx != 0)
491 goto bad_map;
492 /* This is a one page bio that upper layers
493 * refuse to split for us, so we need to split it.
494 */
NeilBrownd6e412e2009-06-18 08:47:00 +1000495 if (likely(is_power_of_2(chunk_sects)))
raz ben yehudafbb704e2009-06-16 17:02:05 +1000496 bp = bio_split(bio, chunk_sects - (sector &
497 (chunk_sects-1)));
498 else
499 bp = bio_split(bio, chunk_sects -
500 sector_div(sector, chunk_sects));
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200501 raid0_make_request(mddev, &bp->bio1);
502 raid0_make_request(mddev, &bp->bio2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 bio_pair_release(bp);
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200504 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
raz ben yehudafbb704e2009-06-16 17:02:05 +1000507 sector_offset = bio->bi_sector;
508 zone = find_zone(mddev->private, &sector_offset);
509 tmp_dev = map_sector(mddev, zone, bio->bi_sector,
510 &sector_offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511 bio->bi_bdev = tmp_dev->bdev;
raz ben yehudafbb704e2009-06-16 17:02:05 +1000512 bio->bi_sector = sector_offset + zone->dev_start +
513 tmp_dev->data_offset;
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200514
515 generic_make_request(bio);
516 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
518bad_map:
NeilBrownb5a20962010-05-03 15:06:27 +1000519 printk("md/raid0:%s: make_request bug: can't convert block across chunks"
520 " or bigger than %dk %llu %d\n",
521 mdname(mddev), chunk_sects / 2,
522 (unsigned long long)bio->bi_sector, bio->bi_size >> 10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523
NeilBrown6712ecf2007-09-27 12:47:43 +0200524 bio_io_error(bio);
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200525 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526}
NeilBrown8299d7f2007-10-16 23:30:53 -0700527
NeilBrownfd01b882011-10-11 16:47:53 +1100528static void raid0_status(struct seq_file *seq, struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
Andre Noll9d8f0362009-06-18 08:45:01 +1000530 seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 return;
532}
533
NeilBrownfd01b882011-10-11 16:47:53 +1100534static void *raid0_takeover_raid45(struct mddev *mddev)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100535{
NeilBrown3cb03002011-10-11 16:45:26 +1100536 struct md_rdev *rdev;
NeilBrowne373ab12011-10-11 16:48:59 +1100537 struct r0conf *priv_conf;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100538
539 if (mddev->degraded != 1) {
NeilBrownb5a20962010-05-03 15:06:27 +1000540 printk(KERN_ERR "md/raid0:%s: raid5 must be degraded! Degraded disks: %d\n",
541 mdname(mddev),
Trela, Maciej9af204c2010-03-08 16:02:44 +1100542 mddev->degraded);
543 return ERR_PTR(-EINVAL);
544 }
545
NeilBrowndafb20f2012-03-19 12:46:39 +1100546 rdev_for_each(rdev, mddev) {
Trela, Maciej9af204c2010-03-08 16:02:44 +1100547 /* check slot number for a disk */
548 if (rdev->raid_disk == mddev->raid_disks-1) {
NeilBrownb5a20962010-05-03 15:06:27 +1000549 printk(KERN_ERR "md/raid0:%s: raid5 must have missing parity disk!\n",
550 mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100551 return ERR_PTR(-EINVAL);
552 }
553 }
554
555 /* Set new parameters */
556 mddev->new_level = 0;
Maciej Trela001048a2010-06-16 11:55:14 +0100557 mddev->new_layout = 0;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100558 mddev->new_chunk_sectors = mddev->chunk_sectors;
559 mddev->raid_disks--;
560 mddev->delta_disks = -1;
561 /* make sure it will be not marked as dirty */
562 mddev->recovery_cp = MaxSector;
563
564 create_strip_zones(mddev, &priv_conf);
565 return priv_conf;
566}
567
NeilBrownfd01b882011-10-11 16:47:53 +1100568static void *raid0_takeover_raid10(struct mddev *mddev)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100569{
NeilBrowne373ab12011-10-11 16:48:59 +1100570 struct r0conf *priv_conf;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100571
572 /* Check layout:
573 * - far_copies must be 1
574 * - near_copies must be 2
575 * - disks number must be even
576 * - all mirrors must be already degraded
577 */
578 if (mddev->layout != ((1 << 8) + 2)) {
NeilBrownb5a20962010-05-03 15:06:27 +1000579 printk(KERN_ERR "md/raid0:%s:: Raid0 cannot takover layout: 0x%x\n",
580 mdname(mddev),
Trela, Maciej9af204c2010-03-08 16:02:44 +1100581 mddev->layout);
582 return ERR_PTR(-EINVAL);
583 }
584 if (mddev->raid_disks & 1) {
NeilBrownb5a20962010-05-03 15:06:27 +1000585 printk(KERN_ERR "md/raid0:%s: Raid0 cannot takover Raid10 with odd disk number.\n",
586 mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100587 return ERR_PTR(-EINVAL);
588 }
589 if (mddev->degraded != (mddev->raid_disks>>1)) {
NeilBrownb5a20962010-05-03 15:06:27 +1000590 printk(KERN_ERR "md/raid0:%s: All mirrors must be already degraded!\n",
591 mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100592 return ERR_PTR(-EINVAL);
593 }
594
595 /* Set new parameters */
596 mddev->new_level = 0;
Maciej Trela001048a2010-06-16 11:55:14 +0100597 mddev->new_layout = 0;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100598 mddev->new_chunk_sectors = mddev->chunk_sectors;
599 mddev->delta_disks = - mddev->raid_disks / 2;
600 mddev->raid_disks += mddev->delta_disks;
601 mddev->degraded = 0;
602 /* make sure it will be not marked as dirty */
603 mddev->recovery_cp = MaxSector;
604
605 create_strip_zones(mddev, &priv_conf);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100606 return priv_conf;
607}
608
NeilBrownfd01b882011-10-11 16:47:53 +1100609static void *raid0_takeover_raid1(struct mddev *mddev)
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100610{
NeilBrowne373ab12011-10-11 16:48:59 +1100611 struct r0conf *priv_conf;
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100612
613 /* Check layout:
614 * - (N - 1) mirror drives must be already faulty
615 */
616 if ((mddev->raid_disks - 1) != mddev->degraded) {
617 printk(KERN_ERR "md/raid0:%s: (N - 1) mirrors drives must be already faulty!\n",
618 mdname(mddev));
619 return ERR_PTR(-EINVAL);
620 }
621
622 /* Set new parameters */
623 mddev->new_level = 0;
624 mddev->new_layout = 0;
625 mddev->new_chunk_sectors = 128; /* by default set chunk size to 64k */
626 mddev->delta_disks = 1 - mddev->raid_disks;
Krzysztof Wojcikf7bee802011-02-14 10:01:41 +1100627 mddev->raid_disks = 1;
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100628 /* make sure it will be not marked as dirty */
629 mddev->recovery_cp = MaxSector;
630
631 create_strip_zones(mddev, &priv_conf);
632 return priv_conf;
633}
634
NeilBrownfd01b882011-10-11 16:47:53 +1100635static void *raid0_takeover(struct mddev *mddev)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100636{
637 /* raid0 can take over:
Maciej Trela049d6c12010-06-16 11:56:12 +0100638 * raid4 - if all data disks are active.
Trela, Maciej9af204c2010-03-08 16:02:44 +1100639 * raid5 - providing it is Raid4 layout and one disk is faulty
640 * raid10 - assuming we have all necessary active disks
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100641 * raid1 - with (N -1) mirror drives faulty
Trela, Maciej9af204c2010-03-08 16:02:44 +1100642 */
Maciej Trela049d6c12010-06-16 11:56:12 +0100643 if (mddev->level == 4)
644 return raid0_takeover_raid45(mddev);
645
Trela, Maciej9af204c2010-03-08 16:02:44 +1100646 if (mddev->level == 5) {
647 if (mddev->layout == ALGORITHM_PARITY_N)
Maciej Trela049d6c12010-06-16 11:56:12 +0100648 return raid0_takeover_raid45(mddev);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100649
NeilBrownb5a20962010-05-03 15:06:27 +1000650 printk(KERN_ERR "md/raid0:%s: Raid can only takeover Raid5 with layout: %d\n",
651 mdname(mddev), ALGORITHM_PARITY_N);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100652 }
653
654 if (mddev->level == 10)
655 return raid0_takeover_raid10(mddev);
656
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100657 if (mddev->level == 1)
658 return raid0_takeover_raid1(mddev);
659
660 printk(KERN_ERR "Takeover from raid%i to raid0 not supported\n",
661 mddev->level);
662
Trela, Maciej9af204c2010-03-08 16:02:44 +1100663 return ERR_PTR(-EINVAL);
664}
665
NeilBrownfd01b882011-10-11 16:47:53 +1100666static void raid0_quiesce(struct mddev *mddev, int state)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100667{
668}
669
NeilBrown84fc4b52011-10-11 16:49:58 +1100670static struct md_personality raid0_personality=
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671{
672 .name = "raid0",
NeilBrown2604b702006-01-06 00:20:36 -0800673 .level = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 .owner = THIS_MODULE,
675 .make_request = raid0_make_request,
676 .run = raid0_run,
677 .stop = raid0_stop,
678 .status = raid0_status,
Dan Williams80c3a6c2009-03-17 18:10:40 -0700679 .size = raid0_size,
Trela, Maciej9af204c2010-03-08 16:02:44 +1100680 .takeover = raid0_takeover,
681 .quiesce = raid0_quiesce,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682};
683
684static int __init raid0_init (void)
685{
NeilBrown2604b702006-01-06 00:20:36 -0800686 return register_md_personality (&raid0_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687}
688
689static void raid0_exit (void)
690{
NeilBrown2604b702006-01-06 00:20:36 -0800691 unregister_md_personality (&raid0_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692}
693
694module_init(raid0_init);
695module_exit(raid0_exit);
696MODULE_LICENSE("GPL");
NeilBrown0efb9e62009-12-14 12:49:58 +1100697MODULE_DESCRIPTION("RAID0 (striping) personality for MD");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698MODULE_ALIAS("md-personality-2"); /* RAID0 */
NeilBrownd9d166c2006-01-06 00:20:51 -0800699MODULE_ALIAS("md-raid0");
NeilBrown2604b702006-01-06 00:20:36 -0800700MODULE_ALIAS("md-level-0");