?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: mos7840: Cleanup useless header
[linux-2.6.git] / drivers / md / raid0.c
blobc3bec024612e63682a9367cc58579c89c1303f5f
1 /*
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
21 #include <linux/blkdev.h>
22 #include <linux/seq_file.h>
23 #include <linux/slab.h>
24 #include "md.h"
25 #include "raid0.h"
26
27 static void raid0_unplug(struct request_queue *q)
28 {
29 mddev_t *mddev = q->queuedata;
30 raid0_conf_t *conf = mddev->private;
31 mdk_rdev_t **devlist = conf->devlist;
32 int i;
33
34 for (i=0; i<mddev->raid_disks; i++) {
35 struct request_queue *r_queue = bdev_get_queue(devlist[i]->bdev);
36
37 blk_unplug(r_queue);
38 }
39 }
40
41 static int raid0_congested(void *data, int bits)
42 {
43 mddev_t *mddev = data;
44 raid0_conf_t *conf = mddev->private;
45 mdk_rdev_t **devlist = conf->devlist;
46 int i, ret = 0;
47
48 if (mddev_congested(mddev, bits))
49 return 1;
50
51 for (i = 0; i < mddev->raid_disks && !ret ; i++) {
52 struct request_queue *q = bdev_get_queue(devlist[i]->bdev);
53
54 ret |= bdi_congested(&q->backing_dev_info, bits);
55 }
56 return ret;
57 }
58
59 /*
60 * inform the user of the raid configuration
61 */
62 static void dump_zones(mddev_t *mddev)
63 {
64 int j, k, h;
65 sector_t zone_size = 0;
66 sector_t zone_start = 0;
67 char b[BDEVNAME_SIZE];
68 raid0_conf_t *conf = mddev->private;
69 printk(KERN_INFO "******* %s configuration *********\n",
70 mdname(mddev));
71 h = 0;
72 for (j = 0; j < conf->nr_strip_zones; j++) {
73 printk(KERN_INFO "zone%d=[", j);
74 for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
75 printk("%s/",
76 bdevname(conf->devlist[j*mddev->raid_disks
77 + k]->bdev, b));
78 printk("]\n");
79
80 zone_size = conf->strip_zone[j].zone_end - zone_start;
81 printk(KERN_INFO " zone offset=%llukb "
82 "device offset=%llukb size=%llukb\n",
83 (unsigned long long)zone_start>>1,
84 (unsigned long long)conf->strip_zone[j].dev_start>>1,
85 (unsigned long long)zone_size>>1);
86 zone_start = conf->strip_zone[j].zone_end;
87 }
88 printk(KERN_INFO "**********************************\n\n");
89 }
90
91 static int create_strip_zones(mddev_t *mddev)
92 {
93 int i, c, err;
94 sector_t curr_zone_end, sectors;
95 mdk_rdev_t *smallest, *rdev1, *rdev2, *rdev, **dev;
96 struct strip_zone *zone;
97 int cnt;
98 char b[BDEVNAME_SIZE];
99 raid0_conf_t *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
100
101 if (!conf)
102 return -ENOMEM;
103 list_for_each_entry(rdev1, &mddev->disks, same_set) {
104 printk(KERN_INFO "raid0: looking at %s\n",
105 bdevname(rdev1->bdev,b));
106 c = 0;
107
108 /* round size to chunk_size */
109 sectors = rdev1->sectors;
110 sector_div(sectors, mddev->chunk_sectors);
111 rdev1->sectors = sectors * mddev->chunk_sectors;
112
113 list_for_each_entry(rdev2, &mddev->disks, same_set) {
114 printk(KERN_INFO "raid0: comparing %s(%llu)",
115 bdevname(rdev1->bdev,b),
116 (unsigned long long)rdev1->sectors);
117 printk(KERN_INFO " with %s(%llu)\n",
118 bdevname(rdev2->bdev,b),
119 (unsigned long long)rdev2->sectors);
120 if (rdev2 == rdev1) {
121 printk(KERN_INFO "raid0: END\n");
122 break;
123 }
124 if (rdev2->sectors == rdev1->sectors) {
125 /*
126 * Not unique, don't count it as a new
127 * group
128 */
129 printk(KERN_INFO "raid0: EQUAL\n");
130 c = 1;
131 break;
132 }
133 printk(KERN_INFO "raid0: NOT EQUAL\n");
134 }
135 if (!c) {
136 printk(KERN_INFO "raid0: ==> UNIQUE\n");
137 conf->nr_strip_zones++;
138 printk(KERN_INFO "raid0: %d zones\n",
139 conf->nr_strip_zones);
140 }
141 }
142 printk(KERN_INFO "raid0: FINAL %d zones\n", conf->nr_strip_zones);
143 err = -ENOMEM;
144 conf->strip_zone = kzalloc(sizeof(struct strip_zone)*
145 conf->nr_strip_zones, GFP_KERNEL);
146 if (!conf->strip_zone)
147 goto abort;
148 conf->devlist = kzalloc(sizeof(mdk_rdev_t*)*
149 conf->nr_strip_zones*mddev->raid_disks,
150 GFP_KERNEL);
151 if (!conf->devlist)
152 goto abort;
153
154 /* The first zone must contain all devices, so here we check that
155 * there is a proper alignment of slots to devices and find them all
156 */
157 zone = &conf->strip_zone[0];
158 cnt = 0;
159 smallest = NULL;
160 dev = conf->devlist;
161 err = -EINVAL;
162 list_for_each_entry(rdev1, &mddev->disks, same_set) {
163 int j = rdev1->raid_disk;
164
165 if (j < 0 || j >= mddev->raid_disks) {
166 printk(KERN_ERR "raid0: bad disk number %d - "
167 "aborting!\n", j);
168 goto abort;
169 }
170 if (dev[j]) {
171 printk(KERN_ERR "raid0: multiple devices for %d - "
172 "aborting!\n", j);
173 goto abort;
174 }
175 dev[j] = rdev1;
176
177 disk_stack_limits(mddev->gendisk, rdev1->bdev,
178 rdev1->data_offset << 9);
179 /* as we don't honour merge_bvec_fn, we must never risk
180 * violating it, so limit ->max_segments to 1, lying within
181 * a single page.
182 */
183
184 if (rdev1->bdev->bd_disk->queue->merge_bvec_fn) {
185 blk_queue_max_segments(mddev->queue, 1);
186 blk_queue_segment_boundary(mddev->queue,
187 PAGE_CACHE_SIZE - 1);
188 }
189 if (!smallest || (rdev1->sectors < smallest->sectors))
190 smallest = rdev1;
191 cnt++;
192 }
193 if (cnt != mddev->raid_disks) {
194 printk(KERN_ERR "raid0: too few disks (%d of %d) - "
195 "aborting!\n", cnt, mddev->raid_disks);
196 goto abort;
197 }
198 zone->nb_dev = cnt;
199 zone->zone_end = smallest->sectors * cnt;
200
201 curr_zone_end = zone->zone_end;
202
203 /* now do the other zones */
204 for (i = 1; i < conf->nr_strip_zones; i++)
205 {
206 int j;
207
208 zone = conf->strip_zone + i;
209 dev = conf->devlist + i * mddev->raid_disks;
210
211 printk(KERN_INFO "raid0: zone %d\n", i);
212 zone->dev_start = smallest->sectors;
213 smallest = NULL;
214 c = 0;
215
216 for (j=0; j<cnt; j++) {
217 rdev = conf->devlist[j];
218 printk(KERN_INFO "raid0: checking %s ...",
219 bdevname(rdev->bdev, b));
220 if (rdev->sectors <= zone->dev_start) {
221 printk(KERN_INFO " nope.\n");
222 continue;
223 }
224 printk(KERN_INFO " contained as device %d\n", c);
225 dev[c] = rdev;
226 c++;
227 if (!smallest || rdev->sectors < smallest->sectors) {
228 smallest = rdev;
229 printk(KERN_INFO " (%llu) is smallest!.\n",
230 (unsigned long long)rdev->sectors);
231 }
232 }
233
234 zone->nb_dev = c;
235 sectors = (smallest->sectors - zone->dev_start) * c;
236 printk(KERN_INFO "raid0: zone->nb_dev: %d, sectors: %llu\n",
237 zone->nb_dev, (unsigned long long)sectors);
238
239 curr_zone_end += sectors;
240 zone->zone_end = curr_zone_end;
241
242 printk(KERN_INFO "raid0: current zone start: %llu\n",
243 (unsigned long long)smallest->sectors);
244 }
245 mddev->queue->unplug_fn = raid0_unplug;
246 mddev->queue->backing_dev_info.congested_fn = raid0_congested;
247 mddev->queue->backing_dev_info.congested_data = mddev;
248
249 /*
250 * now since we have the hard sector sizes, we can make sure
251 * chunk size is a multiple of that sector size
252 */
253 if ((mddev->chunk_sectors << 9) % queue_logical_block_size(mddev->queue)) {
254 printk(KERN_ERR "%s chunk_size of %d not valid\n",
255 mdname(mddev),
256 mddev->chunk_sectors << 9);
257 goto abort;
258 }
259
260 blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
261 blk_queue_io_opt(mddev->queue,
262 (mddev->chunk_sectors << 9) * mddev->raid_disks);
263
264 printk(KERN_INFO "raid0: done.\n");
265 mddev->private = conf;
266 return 0;
267 abort:
268 kfree(conf->strip_zone);
269 kfree(conf->devlist);
270 kfree(conf);
271 mddev->private = NULL;
272 return err;
273 }
274
275 /**
276 * raid0_mergeable_bvec -- tell bio layer if a two requests can be merged
277 * @q: request queue
278 * @bvm: properties of new bio
279 * @biovec: the request that could be merged to it.
280 *
281 * Return amount of bytes we can accept at this offset
282 */
283 static int raid0_mergeable_bvec(struct request_queue *q,
284 struct bvec_merge_data *bvm,
285 struct bio_vec *biovec)
286 {
287 mddev_t *mddev = q->queuedata;
288 sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev);
289 int max;
290 unsigned int chunk_sectors = mddev->chunk_sectors;
291 unsigned int bio_sectors = bvm->bi_size >> 9;
292
293 if (is_power_of_2(chunk_sectors))
294 max = (chunk_sectors - ((sector & (chunk_sectors-1))
295 + bio_sectors)) << 9;
296 else
297 max = (chunk_sectors - (sector_div(sector, chunk_sectors)
298 + bio_sectors)) << 9;
299 if (max < 0) max = 0; /* bio_add cannot handle a negative return */
300 if (max <= biovec->bv_len && bio_sectors == 0)
301 return biovec->bv_len;
302 else
303 return max;
304 }
305
306 static sector_t raid0_size(mddev_t *mddev, sector_t sectors, int raid_disks)
307 {
308 sector_t array_sectors = 0;
309 mdk_rdev_t *rdev;
310
311 WARN_ONCE(sectors || raid_disks,
312 "%s does not support generic reshape\n", __func__);
313
314 list_for_each_entry(rdev, &mddev->disks, same_set)
315 array_sectors += rdev->sectors;
316
317 return array_sectors;
318 }
319
320 static int raid0_run(mddev_t *mddev)
321 {
322 int ret;
323
324 if (mddev->chunk_sectors == 0) {
325 printk(KERN_ERR "md/raid0: chunk size must be set.\n");
326 return -EINVAL;
327 }
328 if (md_check_no_bitmap(mddev))
329 return -EINVAL;
330 blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
331 mddev->queue->queue_lock = &mddev->queue->__queue_lock;
332
333 ret = create_strip_zones(mddev);
334 if (ret < 0)
335 return ret;
336
337 /* calculate array device size */
338 md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));
339
340 printk(KERN_INFO "raid0 : md_size is %llu sectors.\n",
341 (unsigned long long)mddev->array_sectors);
342 /* calculate the max read-ahead size.
343 * For read-ahead of large files to be effective, we need to
344 * readahead at least twice a whole stripe. i.e. number of devices
345 * multiplied by chunk size times 2.
346 * If an individual device has an ra_pages greater than the
347 * chunk size, then we will not drive that device as hard as it
348 * wants. We consider this a configuration error: a larger
349 * chunksize should be used in that case.
350 */
351 {
352 int stripe = mddev->raid_disks *
353 (mddev->chunk_sectors << 9) / PAGE_SIZE;
354 if (mddev->queue->backing_dev_info.ra_pages < 2* stripe)
355 mddev->queue->backing_dev_info.ra_pages = 2* stripe;
356 }
357
358 blk_queue_merge_bvec(mddev->queue, raid0_mergeable_bvec);
359 dump_zones(mddev);
360 md_integrity_register(mddev);
361 return 0;
362 }
363
364 static int raid0_stop(mddev_t *mddev)
365 {
366 raid0_conf_t *conf = mddev->private;
367
368 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
369 kfree(conf->strip_zone);
370 kfree(conf->devlist);
371 kfree(conf);
372 mddev->private = NULL;
373 return 0;
374 }
375
376 /* Find the zone which holds a particular offset
377 * Update *sectorp to be an offset in that zone
378 */
379 static struct strip_zone *find_zone(struct raid0_private_data *conf,
380 sector_t *sectorp)
381 {
382 int i;
383 struct strip_zone *z = conf->strip_zone;
384 sector_t sector = *sectorp;
385
386 for (i = 0; i < conf->nr_strip_zones; i++)
387 if (sector < z[i].zone_end) {
388 if (i)
389 *sectorp = sector - z[i-1].zone_end;
390 return z + i;
391 }
392 BUG();
393 }
394
395 /*
396 * remaps the bio to the target device. we separate two flows.
397 * power 2 flow and a general flow for the sake of perfromance
398 */
399 static mdk_rdev_t *map_sector(mddev_t *mddev, struct strip_zone *zone,
400 sector_t sector, sector_t *sector_offset)
401 {
402 unsigned int sect_in_chunk;
403 sector_t chunk;
404 raid0_conf_t *conf = mddev->private;
405 unsigned int chunk_sects = mddev->chunk_sectors;
406
407 if (is_power_of_2(chunk_sects)) {
408 int chunksect_bits = ffz(~chunk_sects);
409 /* find the sector offset inside the chunk */
410 sect_in_chunk = sector & (chunk_sects - 1);
411 sector >>= chunksect_bits;
412 /* chunk in zone */
413 chunk = *sector_offset;
414 /* quotient is the chunk in real device*/
415 sector_div(chunk, zone->nb_dev << chunksect_bits);
416 } else{
417 sect_in_chunk = sector_div(sector, chunk_sects);
418 chunk = *sector_offset;
419 sector_div(chunk, chunk_sects * zone->nb_dev);
420 }
421 /*
422 * position the bio over the real device
423 * real sector = chunk in device + starting of zone
424 * + the position in the chunk
425 */
426 *sector_offset = (chunk * chunk_sects) + sect_in_chunk;
427 return conf->devlist[(zone - conf->strip_zone)*mddev->raid_disks
428 + sector_div(sector, zone->nb_dev)];
429 }
430
431 /*
432 * Is io distribute over 1 or more chunks ?
433 */
434 static inline int is_io_in_chunk_boundary(mddev_t *mddev,
435 unsigned int chunk_sects, struct bio *bio)
436 {
437 if (likely(is_power_of_2(chunk_sects))) {
438 return chunk_sects >= ((bio->bi_sector & (chunk_sects-1))
439 + (bio->bi_size >> 9));
440 } else{
441 sector_t sector = bio->bi_sector;
442 return chunk_sects >= (sector_div(sector, chunk_sects)
443 + (bio->bi_size >> 9));
444 }
445 }
446
447 static int raid0_make_request(struct request_queue *q, struct bio *bio)
448 {
449 mddev_t *mddev = q->queuedata;
450 unsigned int chunk_sects;
451 sector_t sector_offset;
452 struct strip_zone *zone;
453 mdk_rdev_t *tmp_dev;
454 const int rw = bio_data_dir(bio);
455 int cpu;
456
457 if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER))) {
458 md_barrier_request(mddev, bio);
459 return 0;
460 }
461
462 cpu = part_stat_lock();
463 part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
464 part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
465 bio_sectors(bio));
466 part_stat_unlock();
467
468 chunk_sects = mddev->chunk_sectors;
469 if (unlikely(!is_io_in_chunk_boundary(mddev, chunk_sects, bio))) {
470 sector_t sector = bio->bi_sector;
471 struct bio_pair *bp;
472 /* Sanity check -- queue functions should prevent this happening */
473 if (bio->bi_vcnt != 1 ||
474 bio->bi_idx != 0)
475 goto bad_map;
476 /* This is a one page bio that upper layers
477 * refuse to split for us, so we need to split it.
478 */
479 if (likely(is_power_of_2(chunk_sects)))
480 bp = bio_split(bio, chunk_sects - (sector &
481 (chunk_sects-1)));
482 else
483 bp = bio_split(bio, chunk_sects -
484 sector_div(sector, chunk_sects));
485 if (raid0_make_request(q, &bp->bio1))
486 generic_make_request(&bp->bio1);
487 if (raid0_make_request(q, &bp->bio2))
488 generic_make_request(&bp->bio2);
489
490 bio_pair_release(bp);
491 return 0;
492 }
493
494 sector_offset = bio->bi_sector;
495 zone = find_zone(mddev->private, &sector_offset);
496 tmp_dev = map_sector(mddev, zone, bio->bi_sector,
497 &sector_offset);
498 bio->bi_bdev = tmp_dev->bdev;
499 bio->bi_sector = sector_offset + zone->dev_start +
500 tmp_dev->data_offset;
501 /*
502 * Let the main block layer submit the IO and resolve recursion:
503 */
504 return 1;
505
506 bad_map:
507 printk("raid0_make_request bug: can't convert block across chunks"
508 " or bigger than %dk %llu %d\n", chunk_sects / 2,
509 (unsigned long long)bio->bi_sector, bio->bi_size >> 10);
510
511 bio_io_error(bio);
512 return 0;
513 }
514
515 static void raid0_status(struct seq_file *seq, mddev_t *mddev)
516 {
517 #undef MD_DEBUG
518 #ifdef MD_DEBUG
519 int j, k, h;
520 char b[BDEVNAME_SIZE];
521 raid0_conf_t *conf = mddev->private;
522
523 sector_t zone_size;
524 sector_t zone_start = 0;
525 h = 0;
526
527 for (j = 0; j < conf->nr_strip_zones; j++) {
528 seq_printf(seq, " z%d", j);
529 seq_printf(seq, "=[");
530 for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
531 seq_printf(seq, "%s/", bdevname(
532 conf->devlist[j*mddev->raid_disks + k]
533 ->bdev, b));
534
535 zone_size = conf->strip_zone[j].zone_end - zone_start;
536 seq_printf(seq, "] ze=%lld ds=%lld s=%lld\n",
537 (unsigned long long)zone_start>>1,
538 (unsigned long long)conf->strip_zone[j].dev_start>>1,
539 (unsigned long long)zone_size>>1);
540 zone_start = conf->strip_zone[j].zone_end;
541 }
542 #endif
543 seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);
544 return;
545 }
546
547 static struct mdk_personality raid0_personality=
548 {
549 .name = "raid0",
550 .level = 0,
551 .owner = THIS_MODULE,
552 .make_request = raid0_make_request,
553 .run = raid0_run,
554 .stop = raid0_stop,
555 .status = raid0_status,
556 .size = raid0_size,
557 };
558
559 static int __init raid0_init (void)
560 {
561 return register_md_personality (&raid0_personality);
562 }
563
564 static void raid0_exit (void)
565 {
566 unregister_md_personality (&raid0_personality);
567 }
568
569 module_init(raid0_init);
570 module_exit(raid0_exit);
571 MODULE_LICENSE("GPL");
572 MODULE_DESCRIPTION("RAID0 (striping) personality for MD");
573 MODULE_ALIAS("md-personality-2"); /* RAID0 */
574 MODULE_ALIAS("md-raid0");
575 MODULE_ALIAS("md-level-0");
Linus' kernel tree