blob: cf91f5910c7c8e9422ef1beb73001c0f76cbdaf1 [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);
Shaohua Lic83057a2012-10-11 13:25:44 +110091 bool discard_supported = false;
Andre Nolled7b0032009-06-16 16:47:36 +100092
93 if (!conf)
94 return -ENOMEM;
NeilBrowndafb20f2012-03-19 12:46:39 +110095 rdev_for_each(rdev1, mddev) {
NeilBrown50de8df2011-10-07 14:23:22 +110096 pr_debug("md/raid0:%s: looking at %s\n",
97 mdname(mddev),
98 bdevname(rdev1->bdev, b));
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 c = 0;
NeilBrown13f26822009-06-18 08:48:55 +1000100
101 /* round size to chunk_size */
102 sectors = rdev1->sectors;
103 sector_div(sectors, mddev->chunk_sectors);
104 rdev1->sectors = sectors * mddev->chunk_sectors;
105
NeilBrowndafb20f2012-03-19 12:46:39 +1100106 rdev_for_each(rdev2, mddev) {
NeilBrown50de8df2011-10-07 14:23:22 +1100107 pr_debug("md/raid0:%s: comparing %s(%llu)"
108 " with %s(%llu)\n",
109 mdname(mddev),
110 bdevname(rdev1->bdev,b),
111 (unsigned long long)rdev1->sectors,
112 bdevname(rdev2->bdev,b2),
113 (unsigned long long)rdev2->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 if (rdev2 == rdev1) {
NeilBrown50de8df2011-10-07 14:23:22 +1100115 pr_debug("md/raid0:%s: END\n",
116 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 break;
118 }
Andre Nolldd8ac332009-03-31 14:33:13 +1100119 if (rdev2->sectors == rdev1->sectors) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 /*
121 * Not unique, don't count it as a new
122 * group
123 */
NeilBrown50de8df2011-10-07 14:23:22 +1100124 pr_debug("md/raid0:%s: EQUAL\n",
125 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 c = 1;
127 break;
128 }
NeilBrown50de8df2011-10-07 14:23:22 +1100129 pr_debug("md/raid0:%s: NOT EQUAL\n",
130 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 }
132 if (!c) {
NeilBrown50de8df2011-10-07 14:23:22 +1100133 pr_debug("md/raid0:%s: ==> UNIQUE\n",
134 mdname(mddev));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 conf->nr_strip_zones++;
NeilBrown50de8df2011-10-07 14:23:22 +1100136 pr_debug("md/raid0:%s: %d zones\n",
137 mdname(mddev), conf->nr_strip_zones);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 }
139 }
NeilBrown50de8df2011-10-07 14:23:22 +1100140 pr_debug("md/raid0:%s: FINAL %d zones\n",
141 mdname(mddev), conf->nr_strip_zones);
Andre Nolled7b0032009-06-16 16:47:36 +1000142 err = -ENOMEM;
NeilBrown9ffae0c2006-01-06 00:20:32 -0800143 conf->strip_zone = kzalloc(sizeof(struct strip_zone)*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 conf->nr_strip_zones, GFP_KERNEL);
145 if (!conf->strip_zone)
Andre Nolled7b0032009-06-16 16:47:36 +1000146 goto abort;
NeilBrown3cb03002011-10-11 16:45:26 +1100147 conf->devlist = kzalloc(sizeof(struct md_rdev*)*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 conf->nr_strip_zones*mddev->raid_disks,
149 GFP_KERNEL);
150 if (!conf->devlist)
Andre Nolled7b0032009-06-16 16:47:36 +1000151 goto abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 /* The first zone must contain all devices, so here we check that
154 * there is a proper alignment of slots to devices and find them all
155 */
156 zone = &conf->strip_zone[0];
157 cnt = 0;
158 smallest = NULL;
NeilBrownb4145792009-06-16 16:50:52 +1000159 dev = conf->devlist;
Andre Nolled7b0032009-06-16 16:47:36 +1000160 err = -EINVAL;
NeilBrowndafb20f2012-03-19 12:46:39 +1100161 rdev_for_each(rdev1, mddev) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 int j = rdev1->raid_disk;
163
NeilBrowne93f68a2010-06-15 09:36:03 +0100164 if (mddev->level == 10) {
Trela, Maciej9af204c2010-03-08 16:02:44 +1100165 /* taking over a raid10-n2 array */
166 j /= 2;
NeilBrowne93f68a2010-06-15 09:36:03 +0100167 rdev1->new_raid_disk = j;
168 }
Trela, Maciej9af204c2010-03-08 16:02:44 +1100169
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100170 if (mddev->level == 1) {
171 /* taiking over a raid1 array-
172 * we have only one active disk
173 */
174 j = 0;
175 rdev1->new_raid_disk = j;
176 }
177
NeilBrownf96c9f32013-02-21 15:50:07 +1100178 if (j < 0) {
179 printk(KERN_ERR
180 "md/raid0:%s: remove inactive devices before converting to RAID0\n",
181 mdname(mddev));
182 goto abort;
183 }
184 if (j >= mddev->raid_disks) {
NeilBrownb5a20962010-05-03 15:06:27 +1000185 printk(KERN_ERR "md/raid0:%s: bad disk number %d - "
186 "aborting!\n", mdname(mddev), j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 goto abort;
188 }
NeilBrownb4145792009-06-16 16:50:52 +1000189 if (dev[j]) {
NeilBrownb5a20962010-05-03 15:06:27 +1000190 printk(KERN_ERR "md/raid0:%s: multiple devices for %d - "
191 "aborting!\n", mdname(mddev), j);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 goto abort;
193 }
NeilBrownb4145792009-06-16 16:50:52 +1000194 dev[j] = rdev1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
Martin K. Petersen8f6c2e42009-07-01 11:13:45 +1000196 disk_stack_limits(mddev->gendisk, rdev1->bdev,
197 rdev1->data_offset << 9);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198
NeilBrownba13da42012-03-19 12:46:39 +1100199 if (rdev1->bdev->bd_disk->queue->merge_bvec_fn)
200 conf->has_merge_bvec = 1;
201
Andre Nolldd8ac332009-03-31 14:33:13 +1100202 if (!smallest || (rdev1->sectors < smallest->sectors))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 smallest = rdev1;
204 cnt++;
Shaohua Lic83057a2012-10-11 13:25:44 +1100205
206 if (blk_queue_discard(bdev_get_queue(rdev1->bdev)))
207 discard_supported = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 }
209 if (cnt != mddev->raid_disks) {
NeilBrownb5a20962010-05-03 15:06:27 +1000210 printk(KERN_ERR "md/raid0:%s: too few disks (%d of %d) - "
211 "aborting!\n", mdname(mddev), cnt, mddev->raid_disks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 goto abort;
213 }
214 zone->nb_dev = cnt;
NeilBrown49f357a22009-06-16 16:50:35 +1000215 zone->zone_end = smallest->sectors * cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216
NeilBrown49f357a22009-06-16 16:50:35 +1000217 curr_zone_end = zone->zone_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218
219 /* now do the other zones */
220 for (i = 1; i < conf->nr_strip_zones; i++)
221 {
NeilBrowna9f326e2009-09-23 18:06:41 +1000222 int j;
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 zone = conf->strip_zone + i;
NeilBrownb4145792009-06-16 16:50:52 +1000225 dev = conf->devlist + i * mddev->raid_disks;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226
NeilBrown50de8df2011-10-07 14:23:22 +1100227 pr_debug("md/raid0:%s: zone %d\n", mdname(mddev), i);
NeilBrownd27a43ab2009-06-16 16:46:46 +1000228 zone->dev_start = smallest->sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 smallest = NULL;
230 c = 0;
231
232 for (j=0; j<cnt; j++) {
NeilBrownb4145792009-06-16 16:50:52 +1000233 rdev = conf->devlist[j];
NeilBrownd27a43ab2009-06-16 16:46:46 +1000234 if (rdev->sectors <= zone->dev_start) {
NeilBrown50de8df2011-10-07 14:23:22 +1100235 pr_debug("md/raid0:%s: checking %s ... nope\n",
236 mdname(mddev),
237 bdevname(rdev->bdev, b));
Andre Nolldd8ac332009-03-31 14:33:13 +1100238 continue;
239 }
NeilBrown50de8df2011-10-07 14:23:22 +1100240 pr_debug("md/raid0:%s: checking %s ..."
241 " contained as device %d\n",
242 mdname(mddev),
243 bdevname(rdev->bdev, b), c);
NeilBrownb4145792009-06-16 16:50:52 +1000244 dev[c] = rdev;
Andre Nolldd8ac332009-03-31 14:33:13 +1100245 c++;
246 if (!smallest || rdev->sectors < smallest->sectors) {
247 smallest = rdev;
NeilBrown50de8df2011-10-07 14:23:22 +1100248 pr_debug("md/raid0:%s: (%llu) is smallest!.\n",
249 mdname(mddev),
250 (unsigned long long)rdev->sectors);
Andre Nolldd8ac332009-03-31 14:33:13 +1100251 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 }
253
254 zone->nb_dev = c;
NeilBrown49f357a22009-06-16 16:50:35 +1000255 sectors = (smallest->sectors - zone->dev_start) * c;
NeilBrown50de8df2011-10-07 14:23:22 +1100256 pr_debug("md/raid0:%s: zone->nb_dev: %d, sectors: %llu\n",
257 mdname(mddev),
258 zone->nb_dev, (unsigned long long)sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259
NeilBrown49f357a22009-06-16 16:50:35 +1000260 curr_zone_end += sectors;
NeilBrownd27a43ab2009-06-16 16:46:46 +1000261 zone->zone_end = curr_zone_end;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262
NeilBrown50de8df2011-10-07 14:23:22 +1100263 pr_debug("md/raid0:%s: current zone start: %llu\n",
264 mdname(mddev),
265 (unsigned long long)smallest->sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 }
NeilBrown26be34d2006-10-03 01:15:53 -0700267 mddev->queue->backing_dev_info.congested_fn = raid0_congested;
268 mddev->queue->backing_dev_info.congested_data = mddev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
raz ben yehuda92e59b62009-06-16 17:00:57 +1000270 /*
271 * now since we have the hard sector sizes, we can make sure
272 * chunk size is a multiple of that sector size
273 */
Andre Noll9d8f0362009-06-18 08:45:01 +1000274 if ((mddev->chunk_sectors << 9) % queue_logical_block_size(mddev->queue)) {
NeilBrownb5a20962010-05-03 15:06:27 +1000275 printk(KERN_ERR "md/raid0:%s: chunk_size of %d not valid\n",
raz ben yehuda92e59b62009-06-16 17:00:57 +1000276 mdname(mddev),
Andre Noll9d8f0362009-06-18 08:45:01 +1000277 mddev->chunk_sectors << 9);
raz ben yehuda92e59b62009-06-16 17:00:57 +1000278 goto abort;
279 }
Martin K. Petersen8f6c2e42009-07-01 11:13:45 +1000280
281 blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
282 blk_queue_io_opt(mddev->queue,
283 (mddev->chunk_sectors << 9) * mddev->raid_disks);
284
Shaohua Lic83057a2012-10-11 13:25:44 +1100285 if (!discard_supported)
286 queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
287 else
288 queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, mddev->queue);
289
NeilBrown50de8df2011-10-07 14:23:22 +1100290 pr_debug("md/raid0:%s: done.\n", mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100291 *private_conf = conf;
292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 return 0;
Andre Noll5568a602009-06-16 16:47:21 +1000294abort:
Andre Nolled7b0032009-06-16 16:47:36 +1000295 kfree(conf->strip_zone);
296 kfree(conf->devlist);
297 kfree(conf);
NeilBrown58ebb342013-02-21 15:36:38 +1100298 *private_conf = ERR_PTR(err);
Andre Nolled7b0032009-06-16 16:47:36 +1000299 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300}
301
NeilBrownba13da42012-03-19 12:46:39 +1100302/* Find the zone which holds a particular offset
303 * Update *sectorp to be an offset in that zone
304 */
305static struct strip_zone *find_zone(struct r0conf *conf,
306 sector_t *sectorp)
307{
308 int i;
309 struct strip_zone *z = conf->strip_zone;
310 sector_t sector = *sectorp;
311
312 for (i = 0; i < conf->nr_strip_zones; i++)
313 if (sector < z[i].zone_end) {
314 if (i)
315 *sectorp = sector - z[i-1].zone_end;
316 return z + i;
317 }
318 BUG();
319}
320
321/*
322 * remaps the bio to the target device. we separate two flows.
323 * power 2 flow and a general flow for the sake of perfromance
324*/
325static struct md_rdev *map_sector(struct mddev *mddev, struct strip_zone *zone,
326 sector_t sector, sector_t *sector_offset)
327{
328 unsigned int sect_in_chunk;
329 sector_t chunk;
330 struct r0conf *conf = mddev->private;
331 int raid_disks = conf->strip_zone[0].nb_dev;
332 unsigned int chunk_sects = mddev->chunk_sectors;
333
334 if (is_power_of_2(chunk_sects)) {
335 int chunksect_bits = ffz(~chunk_sects);
336 /* find the sector offset inside the chunk */
337 sect_in_chunk = sector & (chunk_sects - 1);
338 sector >>= chunksect_bits;
339 /* chunk in zone */
340 chunk = *sector_offset;
341 /* quotient is the chunk in real device*/
342 sector_div(chunk, zone->nb_dev << chunksect_bits);
343 } else{
344 sect_in_chunk = sector_div(sector, chunk_sects);
345 chunk = *sector_offset;
346 sector_div(chunk, chunk_sects * zone->nb_dev);
347 }
348 /*
349 * position the bio over the real device
350 * real sector = chunk in device + starting of zone
351 * + the position in the chunk
352 */
353 *sector_offset = (chunk * chunk_sects) + sect_in_chunk;
354 return conf->devlist[(zone - conf->strip_zone)*raid_disks
355 + sector_div(sector, zone->nb_dev)];
356}
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358/**
NeilBrownba13da42012-03-19 12:46:39 +1100359 * raid0_mergeable_bvec -- tell bio layer if two requests can be merged
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 * @q: request queue
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200361 * @bvm: properties of new bio
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 * @biovec: the request that could be merged to it.
363 *
364 * Return amount of bytes we can accept at this offset
365 */
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200366static int raid0_mergeable_bvec(struct request_queue *q,
367 struct bvec_merge_data *bvm,
368 struct bio_vec *biovec)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369{
NeilBrownfd01b882011-10-11 16:47:53 +1100370 struct mddev *mddev = q->queuedata;
NeilBrownba13da42012-03-19 12:46:39 +1100371 struct r0conf *conf = mddev->private;
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200372 sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
NeilBrownba13da42012-03-19 12:46:39 +1100373 sector_t sector_offset = sector;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 int max;
Andre Noll9d8f0362009-06-18 08:45:01 +1000375 unsigned int chunk_sectors = mddev->chunk_sectors;
Alasdair G Kergoncc371e62008-07-03 09:53:43 +0200376 unsigned int bio_sectors = bvm->bi_size >> 9;
NeilBrownba13da42012-03-19 12:46:39 +1100377 struct strip_zone *zone;
378 struct md_rdev *rdev;
379 struct request_queue *subq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380
NeilBrownd6e412e2009-06-18 08:47:00 +1000381 if (is_power_of_2(chunk_sectors))
raz ben yehudafbb704e2009-06-16 17:02:05 +1000382 max = (chunk_sectors - ((sector & (chunk_sectors-1))
383 + bio_sectors)) << 9;
384 else
385 max = (chunk_sectors - (sector_div(sector, chunk_sectors)
386 + bio_sectors)) << 9;
NeilBrownba13da42012-03-19 12:46:39 +1100387 if (max < 0)
388 max = 0; /* bio_add cannot handle a negative return */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 if (max <= biovec->bv_len && bio_sectors == 0)
390 return biovec->bv_len;
NeilBrownba13da42012-03-19 12:46:39 +1100391 if (max < biovec->bv_len)
392 /* too small already, no need to check further */
393 return max;
394 if (!conf->has_merge_bvec)
395 return max;
396
397 /* May need to check subordinate device */
398 sector = sector_offset;
399 zone = find_zone(mddev->private, &sector_offset);
400 rdev = map_sector(mddev, zone, sector, &sector_offset);
401 subq = bdev_get_queue(rdev->bdev);
402 if (subq->merge_bvec_fn) {
403 bvm->bi_bdev = rdev->bdev;
404 bvm->bi_sector = sector_offset + zone->dev_start +
405 rdev->data_offset;
406 return min(max, subq->merge_bvec_fn(subq, bvm, biovec));
407 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 return max;
409}
410
NeilBrownfd01b882011-10-11 16:47:53 +1100411static sector_t raid0_size(struct mddev *mddev, sector_t sectors, int raid_disks)
Dan Williams80c3a6c2009-03-17 18:10:40 -0700412{
413 sector_t array_sectors = 0;
NeilBrown3cb03002011-10-11 16:45:26 +1100414 struct md_rdev *rdev;
Dan Williams80c3a6c2009-03-17 18:10:40 -0700415
416 WARN_ONCE(sectors || raid_disks,
417 "%s does not support generic reshape\n", __func__);
418
NeilBrowndafb20f2012-03-19 12:46:39 +1100419 rdev_for_each(rdev, mddev)
NeilBrowna6468532013-02-21 14:33:17 +1100420 array_sectors += (rdev->sectors &
421 ~(sector_t)(mddev->chunk_sectors-1));
Dan Williams80c3a6c2009-03-17 18:10:40 -0700422
423 return array_sectors;
424}
425
majianpeng0366ef82012-04-02 09:48:37 +1000426static int raid0_stop(struct mddev *mddev);
427
NeilBrownfd01b882011-10-11 16:47:53 +1100428static int raid0_run(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429{
NeilBrowne373ab12011-10-11 16:48:59 +1100430 struct r0conf *conf;
Andre Noll5568a602009-06-16 16:47:21 +1000431 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
Andre Noll9d8f0362009-06-18 08:45:01 +1000433 if (mddev->chunk_sectors == 0) {
NeilBrownb5a20962010-05-03 15:06:27 +1000434 printk(KERN_ERR "md/raid0:%s: chunk size must be set.\n",
435 mdname(mddev));
NeilBrown2604b702006-01-06 00:20:36 -0800436 return -EINVAL;
437 }
Andre Noll0894cc32009-06-18 08:49:23 +1000438 if (md_check_no_bitmap(mddev))
439 return -EINVAL;
Martin K. Petersen086fa5f2010-02-26 00:20:38 -0500440 blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
Martin K. Petersen4363ac72012-09-18 12:19:27 -0400441 blk_queue_max_write_same_sectors(mddev->queue, mddev->chunk_sectors);
Shaohua Lic83057a2012-10-11 13:25:44 +1100442 blk_queue_max_discard_sectors(mddev->queue, mddev->chunk_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
Trela, Maciej9af204c2010-03-08 16:02:44 +1100444 /* if private is not null, we are here after takeover */
445 if (mddev->private == NULL) {
446 ret = create_strip_zones(mddev, &conf);
447 if (ret < 0)
448 return ret;
449 mddev->private = conf;
450 }
451 conf = mddev->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
453 /* calculate array device size */
Dan Williams1f403622009-03-31 14:59:03 +1100454 md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
NeilBrownb5a20962010-05-03 15:06:27 +1000456 printk(KERN_INFO "md/raid0:%s: md_size is %llu sectors.\n",
457 mdname(mddev),
458 (unsigned long long)mddev->array_sectors);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 /* calculate the max read-ahead size.
460 * For read-ahead of large files to be effective, we need to
461 * readahead at least twice a whole stripe. i.e. number of devices
462 * multiplied by chunk size times 2.
463 * If an individual device has an ra_pages greater than the
464 * chunk size, then we will not drive that device as hard as it
465 * wants. We consider this a configuration error: a larger
466 * chunksize should be used in that case.
467 */
468 {
Andre Noll9d8f0362009-06-18 08:45:01 +1000469 int stripe = mddev->raid_disks *
470 (mddev->chunk_sectors << 9) / PAGE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 if (mddev->queue->backing_dev_info.ra_pages < 2* stripe)
472 mddev->queue->backing_dev_info.ra_pages = 2* stripe;
473 }
474
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 blk_queue_merge_bvec(mddev->queue, raid0_mergeable_bvec);
raz ben yehuda46994192009-06-16 17:00:54 +1000476 dump_zones(mddev);
majianpeng0366ef82012-04-02 09:48:37 +1000477
478 ret = md_integrity_register(mddev);
479 if (ret)
480 raid0_stop(mddev);
481
482 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483}
484
NeilBrownfd01b882011-10-11 16:47:53 +1100485static int raid0_stop(struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486{
NeilBrowne373ab12011-10-11 16:48:59 +1100487 struct r0conf *conf = mddev->private;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488
489 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700490 kfree(conf->strip_zone);
Andre Nollfb5ab4b2009-06-16 16:48:19 +1000491 kfree(conf->devlist);
Jesper Juhl990a8ba2005-06-21 17:17:30 -0700492 kfree(conf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 mddev->private = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 return 0;
495}
496
raz ben yehudafbb704e2009-06-16 17:02:05 +1000497/*
498 * Is io distribute over 1 or more chunks ?
499*/
NeilBrownfd01b882011-10-11 16:47:53 +1100500static inline int is_io_in_chunk_boundary(struct mddev *mddev,
raz ben yehudafbb704e2009-06-16 17:02:05 +1000501 unsigned int chunk_sects, struct bio *bio)
502{
NeilBrownd6e412e2009-06-18 08:47:00 +1000503 if (likely(is_power_of_2(chunk_sects))) {
Kent Overstreet4f024f32013-10-11 15:44:27 -0700504 return chunk_sects >=
505 ((bio->bi_iter.bi_sector & (chunk_sects-1))
Kent Overstreetaa8b57a2013-02-05 15:19:29 -0800506 + bio_sectors(bio));
raz ben yehudafbb704e2009-06-16 17:02:05 +1000507 } else{
Kent Overstreet4f024f32013-10-11 15:44:27 -0700508 sector_t sector = bio->bi_iter.bi_sector;
raz ben yehudafbb704e2009-06-16 17:02:05 +1000509 return chunk_sects >= (sector_div(sector, chunk_sects)
Kent Overstreetaa8b57a2013-02-05 15:19:29 -0800510 + bio_sectors(bio));
raz ben yehudafbb704e2009-06-16 17:02:05 +1000511 }
512}
513
Linus Torvaldsb4fdcb02011-11-04 17:06:58 -0700514static void raid0_make_request(struct mddev *mddev, struct bio *bio)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 struct strip_zone *zone;
NeilBrown3cb03002011-10-11 16:45:26 +1100517 struct md_rdev *tmp_dev;
Kent Overstreet20d01892013-11-23 18:21:01 -0800518 struct bio *split;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
Tejun Heoe9c74692010-09-03 11:56:18 +0200520 if (unlikely(bio->bi_rw & REQ_FLUSH)) {
521 md_flush_request(mddev, bio);
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200522 return;
NeilBrowne5dcdd82005-09-09 16:23:41 -0700523 }
524
Kent Overstreet20d01892013-11-23 18:21:01 -0800525 do {
Kent Overstreet4f024f32013-10-11 15:44:27 -0700526 sector_t sector = bio->bi_iter.bi_sector;
Kent Overstreet20d01892013-11-23 18:21:01 -0800527 unsigned chunk_sects = mddev->chunk_sectors;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Kent Overstreet20d01892013-11-23 18:21:01 -0800529 unsigned sectors = chunk_sects -
530 (likely(is_power_of_2(chunk_sects))
531 ? (sector & (chunk_sects-1))
532 : sector_div(sector, chunk_sects));
Christoph Hellwig5a7bbad2011-09-12 12:12:01 +0200533
Kent Overstreet20d01892013-11-23 18:21:01 -0800534 if (sectors < bio_sectors(bio)) {
535 split = bio_split(bio, sectors, GFP_NOIO, fs_bio_set);
536 bio_chain(split, bio);
537 } else {
538 split = bio;
539 }
Shaohua Lic83057a2012-10-11 13:25:44 +1100540
Kent Overstreet20d01892013-11-23 18:21:01 -0800541 zone = find_zone(mddev->private, &sector);
542 tmp_dev = map_sector(mddev, zone, sector, &sector);
543 split->bi_bdev = tmp_dev->bdev;
544 split->bi_iter.bi_sector = sector + zone->dev_start +
545 tmp_dev->data_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546
Kent Overstreet20d01892013-11-23 18:21:01 -0800547 if (unlikely((split->bi_rw & REQ_DISCARD) &&
548 !blk_queue_discard(bdev_get_queue(split->bi_bdev)))) {
549 /* Just ignore it */
550 bio_endio(split, 0);
551 } else
552 generic_make_request(split);
553 } while (split != bio);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554}
NeilBrown8299d7f2007-10-16 23:30:53 -0700555
NeilBrownfd01b882011-10-11 16:47:53 +1100556static void raid0_status(struct seq_file *seq, struct mddev *mddev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
Andre Noll9d8f0362009-06-18 08:45:01 +1000558 seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 return;
560}
561
NeilBrownfd01b882011-10-11 16:47:53 +1100562static void *raid0_takeover_raid45(struct mddev *mddev)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100563{
NeilBrown3cb03002011-10-11 16:45:26 +1100564 struct md_rdev *rdev;
NeilBrowne373ab12011-10-11 16:48:59 +1100565 struct r0conf *priv_conf;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100566
567 if (mddev->degraded != 1) {
NeilBrownb5a20962010-05-03 15:06:27 +1000568 printk(KERN_ERR "md/raid0:%s: raid5 must be degraded! Degraded disks: %d\n",
569 mdname(mddev),
Trela, Maciej9af204c2010-03-08 16:02:44 +1100570 mddev->degraded);
571 return ERR_PTR(-EINVAL);
572 }
573
NeilBrowndafb20f2012-03-19 12:46:39 +1100574 rdev_for_each(rdev, mddev) {
Trela, Maciej9af204c2010-03-08 16:02:44 +1100575 /* check slot number for a disk */
576 if (rdev->raid_disk == mddev->raid_disks-1) {
NeilBrownb5a20962010-05-03 15:06:27 +1000577 printk(KERN_ERR "md/raid0:%s: raid5 must have missing parity disk!\n",
578 mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100579 return ERR_PTR(-EINVAL);
580 }
NeilBrowneea136d2013-06-26 11:55:20 +1000581 rdev->sectors = mddev->dev_sectors;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100582 }
583
584 /* Set new parameters */
585 mddev->new_level = 0;
Maciej Trela001048a2010-06-16 11:55:14 +0100586 mddev->new_layout = 0;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100587 mddev->new_chunk_sectors = mddev->chunk_sectors;
588 mddev->raid_disks--;
589 mddev->delta_disks = -1;
590 /* make sure it will be not marked as dirty */
591 mddev->recovery_cp = MaxSector;
592
593 create_strip_zones(mddev, &priv_conf);
594 return priv_conf;
595}
596
NeilBrownfd01b882011-10-11 16:47:53 +1100597static void *raid0_takeover_raid10(struct mddev *mddev)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100598{
NeilBrowne373ab12011-10-11 16:48:59 +1100599 struct r0conf *priv_conf;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100600
601 /* Check layout:
602 * - far_copies must be 1
603 * - near_copies must be 2
604 * - disks number must be even
605 * - all mirrors must be already degraded
606 */
607 if (mddev->layout != ((1 << 8) + 2)) {
NeilBrownb5a20962010-05-03 15:06:27 +1000608 printk(KERN_ERR "md/raid0:%s:: Raid0 cannot takover layout: 0x%x\n",
609 mdname(mddev),
Trela, Maciej9af204c2010-03-08 16:02:44 +1100610 mddev->layout);
611 return ERR_PTR(-EINVAL);
612 }
613 if (mddev->raid_disks & 1) {
NeilBrownb5a20962010-05-03 15:06:27 +1000614 printk(KERN_ERR "md/raid0:%s: Raid0 cannot takover Raid10 with odd disk number.\n",
615 mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100616 return ERR_PTR(-EINVAL);
617 }
618 if (mddev->degraded != (mddev->raid_disks>>1)) {
NeilBrownb5a20962010-05-03 15:06:27 +1000619 printk(KERN_ERR "md/raid0:%s: All mirrors must be already degraded!\n",
620 mdname(mddev));
Trela, Maciej9af204c2010-03-08 16:02:44 +1100621 return ERR_PTR(-EINVAL);
622 }
623
624 /* Set new parameters */
625 mddev->new_level = 0;
Maciej Trela001048a2010-06-16 11:55:14 +0100626 mddev->new_layout = 0;
Trela, Maciej9af204c2010-03-08 16:02:44 +1100627 mddev->new_chunk_sectors = mddev->chunk_sectors;
628 mddev->delta_disks = - mddev->raid_disks / 2;
629 mddev->raid_disks += mddev->delta_disks;
630 mddev->degraded = 0;
631 /* make sure it will be not marked as dirty */
632 mddev->recovery_cp = MaxSector;
633
634 create_strip_zones(mddev, &priv_conf);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100635 return priv_conf;
636}
637
NeilBrownfd01b882011-10-11 16:47:53 +1100638static void *raid0_takeover_raid1(struct mddev *mddev)
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100639{
NeilBrowne373ab12011-10-11 16:48:59 +1100640 struct r0conf *priv_conf;
Jes Sorensen24b961f2012-04-01 23:48:38 +1000641 int chunksect;
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100642
643 /* Check layout:
644 * - (N - 1) mirror drives must be already faulty
645 */
646 if ((mddev->raid_disks - 1) != mddev->degraded) {
647 printk(KERN_ERR "md/raid0:%s: (N - 1) mirrors drives must be already faulty!\n",
648 mdname(mddev));
649 return ERR_PTR(-EINVAL);
650 }
651
Jes Sorensen24b961f2012-04-01 23:48:38 +1000652 /*
653 * a raid1 doesn't have the notion of chunk size, so
654 * figure out the largest suitable size we can use.
655 */
656 chunksect = 64 * 2; /* 64K by default */
657
658 /* The array must be an exact multiple of chunksize */
659 while (chunksect && (mddev->array_sectors & (chunksect - 1)))
660 chunksect >>= 1;
661
662 if ((chunksect << 9) < PAGE_SIZE)
663 /* array size does not allow a suitable chunk size */
664 return ERR_PTR(-EINVAL);
665
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100666 /* Set new parameters */
667 mddev->new_level = 0;
668 mddev->new_layout = 0;
Jes Sorensen24b961f2012-04-01 23:48:38 +1000669 mddev->new_chunk_sectors = chunksect;
670 mddev->chunk_sectors = chunksect;
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100671 mddev->delta_disks = 1 - mddev->raid_disks;
Krzysztof Wojcikf7bee802011-02-14 10:01:41 +1100672 mddev->raid_disks = 1;
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100673 /* make sure it will be not marked as dirty */
674 mddev->recovery_cp = MaxSector;
675
676 create_strip_zones(mddev, &priv_conf);
677 return priv_conf;
678}
679
NeilBrownfd01b882011-10-11 16:47:53 +1100680static void *raid0_takeover(struct mddev *mddev)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100681{
682 /* raid0 can take over:
Maciej Trela049d6c12010-06-16 11:56:12 +0100683 * raid4 - if all data disks are active.
Trela, Maciej9af204c2010-03-08 16:02:44 +1100684 * raid5 - providing it is Raid4 layout and one disk is faulty
685 * raid10 - assuming we have all necessary active disks
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100686 * raid1 - with (N -1) mirror drives faulty
Trela, Maciej9af204c2010-03-08 16:02:44 +1100687 */
NeilBrowna8461a62014-08-06 16:34:27 +1000688
689 if (mddev->bitmap) {
690 printk(KERN_ERR "md/raid0: %s: cannot takeover array with bitmap\n",
691 mdname(mddev));
692 return ERR_PTR(-EBUSY);
693 }
Maciej Trela049d6c12010-06-16 11:56:12 +0100694 if (mddev->level == 4)
695 return raid0_takeover_raid45(mddev);
696
Trela, Maciej9af204c2010-03-08 16:02:44 +1100697 if (mddev->level == 5) {
698 if (mddev->layout == ALGORITHM_PARITY_N)
Maciej Trela049d6c12010-06-16 11:56:12 +0100699 return raid0_takeover_raid45(mddev);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100700
NeilBrownb5a20962010-05-03 15:06:27 +1000701 printk(KERN_ERR "md/raid0:%s: Raid can only takeover Raid5 with layout: %d\n",
702 mdname(mddev), ALGORITHM_PARITY_N);
Trela, Maciej9af204c2010-03-08 16:02:44 +1100703 }
704
705 if (mddev->level == 10)
706 return raid0_takeover_raid10(mddev);
707
Krzysztof Wojcikfc3a08b2011-01-31 13:47:13 +1100708 if (mddev->level == 1)
709 return raid0_takeover_raid1(mddev);
710
711 printk(KERN_ERR "Takeover from raid%i to raid0 not supported\n",
712 mddev->level);
713
Trela, Maciej9af204c2010-03-08 16:02:44 +1100714 return ERR_PTR(-EINVAL);
715}
716
NeilBrownfd01b882011-10-11 16:47:53 +1100717static void raid0_quiesce(struct mddev *mddev, int state)
Trela, Maciej9af204c2010-03-08 16:02:44 +1100718{
719}
720
NeilBrown84fc4b52011-10-11 16:49:58 +1100721static struct md_personality raid0_personality=
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722{
723 .name = "raid0",
NeilBrown2604b702006-01-06 00:20:36 -0800724 .level = 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 .owner = THIS_MODULE,
726 .make_request = raid0_make_request,
727 .run = raid0_run,
728 .stop = raid0_stop,
729 .status = raid0_status,
Dan Williams80c3a6c2009-03-17 18:10:40 -0700730 .size = raid0_size,
Trela, Maciej9af204c2010-03-08 16:02:44 +1100731 .takeover = raid0_takeover,
732 .quiesce = raid0_quiesce,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733};
734
735static int __init raid0_init (void)
736{
NeilBrown2604b702006-01-06 00:20:36 -0800737 return register_md_personality (&raid0_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738}
739
740static void raid0_exit (void)
741{
NeilBrown2604b702006-01-06 00:20:36 -0800742 unregister_md_personality (&raid0_personality);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743}
744
745module_init(raid0_init);
746module_exit(raid0_exit);
747MODULE_LICENSE("GPL");
NeilBrown0efb9e62009-12-14 12:49:58 +1100748MODULE_DESCRIPTION("RAID0 (striping) personality for MD");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749MODULE_ALIAS("md-personality-2"); /* RAID0 */
NeilBrownd9d166c2006-01-06 00:20:51 -0800750MODULE_ALIAS("md-raid0");
NeilBrown2604b702006-01-06 00:20:36 -0800751MODULE_ALIAS("md-level-0");