1/* 2 linear.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 7 Linear mode management functions. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2, or (at your option) 12 any later version. 13 14 You should have received a copy of the GNU General Public License 15 (for example /usr/src/linux/COPYING); if not, write to the Free 16 Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 17*/ 18 19#include <linux/blkdev.h> 20#include <linux/raid/md_u.h> 21#include <linux/seq_file.h> 22#include <linux/slab.h> 23#include "md.h" 24#include "linear.h" 25 26/* 27 * find which device holds a particular offset 28 */ 29static inline dev_info_t *which_dev(mddev_t *mddev, sector_t sector) 30{ 31 int lo, mid, hi; 32 linear_conf_t *conf; 33 34 lo = 0; 35 hi = mddev->raid_disks - 1; 36 conf = rcu_dereference(mddev->private); 37 38 /* 39 * Binary Search 40 */ 41 42 while (hi > lo) { 43 44 mid = (hi + lo) / 2; 45 if (sector < conf->disks[mid].end_sector) 46 hi = mid; 47 else 48 lo = mid + 1; 49 } 50 51 return conf->disks + lo; 52} 53 54/** 55 * linear_mergeable_bvec -- tell bio layer if two requests can be merged 56 * @q: request queue 57 * @bvm: properties of new bio 58 * @biovec: the request that could be merged to it. 59 * 60 * Return amount of bytes we can take at this offset 61 */ 62static int linear_mergeable_bvec(struct request_queue *q, 63 struct bvec_merge_data *bvm, 64 struct bio_vec *biovec) 65{ 66 mddev_t *mddev = q->queuedata; 67 dev_info_t *dev0; 68 unsigned long maxsectors, bio_sectors = bvm->bi_size >> 9; 69 sector_t sector = bvm->bi_sector + get_start_sect(bvm->bi_bdev); 70 71 rcu_read_lock(); 72 dev0 = which_dev(mddev, sector); 73 maxsectors = dev0->end_sector - sector; 74 rcu_read_unlock(); 75 76 if (maxsectors < bio_sectors) 77 maxsectors = 0; 78 else 79 maxsectors -= bio_sectors; 80 81 if (maxsectors <= (PAGE_SIZE >> 9 ) && bio_sectors == 0) 82 return biovec->bv_len; 83 /* The bytes available at this offset could be really big, 84 * so we cap at 2^31 to avoid overflow */ 85 if (maxsectors > (1 << (31-9))) 86 return 1<<31; 87 return maxsectors << 9; 88} 89 90static void linear_unplug(struct request_queue *q) 91{ 92 mddev_t *mddev = q->queuedata; 93 linear_conf_t *conf; 94 int i; 95 96 rcu_read_lock(); 97 conf = rcu_dereference(mddev->private); 98 99 for (i=0; i < mddev->raid_disks; i++) { 100 struct request_queue *r_queue = bdev_get_queue(conf->disks[i].rdev->bdev); 101 blk_unplug(r_queue); 102 } 103 rcu_read_unlock(); 104} 105 106static int linear_congested(void *data, int bits) 107{ 108 mddev_t *mddev = data; 109 linear_conf_t *conf; 110 int i, ret = 0; 111 112 if (mddev_congested(mddev, bits)) 113 return 1; 114 115 rcu_read_lock(); 116 conf = rcu_dereference(mddev->private); 117 118 for (i = 0; i < mddev->raid_disks && !ret ; i++) { 119 struct request_queue *q = bdev_get_queue(conf->disks[i].rdev->bdev); 120 ret |= bdi_congested(&q->backing_dev_info, bits); 121 } 122 123 rcu_read_unlock(); 124 return ret; 125} 126 127static sector_t linear_size(mddev_t *mddev, sector_t sectors, int raid_disks) 128{ 129 linear_conf_t *conf; 130 sector_t array_sectors; 131 132 rcu_read_lock(); 133 conf = rcu_dereference(mddev->private); 134 WARN_ONCE(sectors || raid_disks, 135 "%s does not support generic reshape\n", __func__); 136 array_sectors = conf->array_sectors; 137 rcu_read_unlock(); 138 139 return array_sectors; 140} 141 142static linear_conf_t *linear_conf(mddev_t *mddev, int raid_disks) 143{ 144 linear_conf_t *conf; 145 mdk_rdev_t *rdev; 146 int i, cnt; 147 148 conf = kzalloc (sizeof (*conf) + raid_disks*sizeof(dev_info_t), 149 GFP_KERNEL); 150 if (!conf) 151 return NULL; 152 153 cnt = 0; 154 conf->array_sectors = 0; 155 156 list_for_each_entry(rdev, &mddev->disks, same_set) { 157 int j = rdev->raid_disk; 158 dev_info_t *disk = conf->disks + j; 159 sector_t sectors; 160 161 if (j < 0 || j >= raid_disks || disk->rdev) { 162 printk(KERN_ERR "md/linear:%s: disk numbering problem. Aborting!\n", 163 mdname(mddev)); 164 goto out; 165 } 166 167 disk->rdev = rdev; 168 if (mddev->chunk_sectors) { 169 sectors = rdev->sectors; 170 sector_div(sectors, mddev->chunk_sectors); 171 rdev->sectors = sectors * mddev->chunk_sectors; 172 } 173 174 disk_stack_limits(mddev->gendisk, rdev->bdev, 175 rdev->data_offset << 9); 176 /* as we don't honour merge_bvec_fn, we must never risk 177 * violating it, so limit max_segments to 1 lying within 178 * a single page. 179 */ 180 if (rdev->bdev->bd_disk->queue->merge_bvec_fn) { 181 blk_queue_max_segments(mddev->queue, 1); 182 blk_queue_segment_boundary(mddev->queue, 183 PAGE_CACHE_SIZE - 1); 184 } 185 186 conf->array_sectors += rdev->sectors; 187 cnt++; 188 189 } 190 if (cnt != raid_disks) { 191 printk(KERN_ERR "md/linear:%s: not enough drives present. Aborting!\n", 192 mdname(mddev)); 193 goto out; 194 } 195 196 /* 197 * Here we calculate the device offsets. 198 */ 199 conf->disks[0].end_sector = conf->disks[0].rdev->sectors; 200 201 for (i = 1; i < raid_disks; i++) 202 conf->disks[i].end_sector = 203 conf->disks[i-1].end_sector + 204 conf->disks[i].rdev->sectors; 205 206 return conf; 207 208out: 209 kfree(conf); 210 return NULL; 211} 212 213static int linear_run (mddev_t *mddev) 214{ 215 linear_conf_t *conf; 216 217 if (md_check_no_bitmap(mddev)) 218 return -EINVAL; 219 mddev->queue->queue_lock = &mddev->queue->__queue_lock; 220 conf = linear_conf(mddev, mddev->raid_disks); 221 222 if (!conf) 223 return 1; 224 mddev->private = conf; 225 md_set_array_sectors(mddev, linear_size(mddev, 0, 0)); 226 227 blk_queue_merge_bvec(mddev->queue, linear_mergeable_bvec); 228 mddev->queue->unplug_fn = linear_unplug; 229 mddev->queue->backing_dev_info.congested_fn = linear_congested; 230 mddev->queue->backing_dev_info.congested_data = mddev; 231 md_integrity_register(mddev); 232 return 0; 233} 234 235static void free_conf(struct rcu_head *head) 236{ 237 linear_conf_t *conf = container_of(head, linear_conf_t, rcu); 238 kfree(conf); 239} 240 241static int linear_add(mddev_t *mddev, mdk_rdev_t *rdev) 242{ 243 /* Adding a drive to a linear array allows the array to grow. 244 * It is permitted if the new drive has a matching superblock 245 * already on it, with raid_disk equal to raid_disks. 246 * It is achieved by creating a new linear_private_data structure 247 * and swapping it in in-place of the current one. 248 * The current one is never freed until the array is stopped. 249 * This avoids races. 250 */ 251 linear_conf_t *newconf, *oldconf; 252 253 if (rdev->saved_raid_disk != mddev->raid_disks) 254 return -EINVAL; 255 256 rdev->raid_disk = rdev->saved_raid_disk; 257 258 newconf = linear_conf(mddev,mddev->raid_disks+1); 259 260 if (!newconf) 261 return -ENOMEM; 262 263 oldconf = rcu_dereference(mddev->private); 264 mddev->raid_disks++; 265 rcu_assign_pointer(mddev->private, newconf); 266 md_set_array_sectors(mddev, linear_size(mddev, 0, 0)); 267 set_capacity(mddev->gendisk, mddev->array_sectors); 268 revalidate_disk(mddev->gendisk); 269 call_rcu(&oldconf->rcu, free_conf); 270 return 0; 271} 272 273static int linear_stop (mddev_t *mddev) 274{ 275 linear_conf_t *conf = mddev->private; 276 277 /* 278 * We do not require rcu protection here since 279 * we hold reconfig_mutex for both linear_add and 280 * linear_stop, so they cannot race. 281 * We should make sure any old 'conf's are properly 282 * freed though. 283 */ 284 rcu_barrier(); 285 blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/ 286 kfree(conf); 287 mddev->private = NULL; 288 289 return 0; 290} 291 292static int linear_make_request (mddev_t *mddev, struct bio *bio) 293{ 294 dev_info_t *tmp_dev; 295 sector_t start_sector; 296 297 if (unlikely(bio->bi_rw & REQ_HARDBARRIER)) { 298 md_barrier_request(mddev, bio); 299 return 0; 300 } 301 302 rcu_read_lock(); 303 tmp_dev = which_dev(mddev, bio->bi_sector); 304 start_sector = tmp_dev->end_sector - tmp_dev->rdev->sectors; 305 306 307 if (unlikely(bio->bi_sector >= (tmp_dev->end_sector) 308 || (bio->bi_sector < start_sector))) { 309 char b[BDEVNAME_SIZE]; 310 311 printk(KERN_ERR 312 "md/linear:%s: make_request: Sector %llu out of bounds on " 313 "dev %s: %llu sectors, offset %llu\n", 314 mdname(mddev), 315 (unsigned long long)bio->bi_sector, 316 bdevname(tmp_dev->rdev->bdev, b), 317 (unsigned long long)tmp_dev->rdev->sectors, 318 (unsigned long long)start_sector); 319 rcu_read_unlock(); 320 bio_io_error(bio); 321 return 0; 322 } 323 if (unlikely(bio->bi_sector + (bio->bi_size >> 9) > 324 tmp_dev->end_sector)) { 325 /* This bio crosses a device boundary, so we have to 326 * split it. 327 */ 328 struct bio_pair *bp; 329 sector_t end_sector = tmp_dev->end_sector; 330 331 rcu_read_unlock(); 332 333 bp = bio_split(bio, end_sector - bio->bi_sector); 334 335 if (linear_make_request(mddev, &bp->bio1)) 336 generic_make_request(&bp->bio1); 337 if (linear_make_request(mddev, &bp->bio2)) 338 generic_make_request(&bp->bio2); 339 bio_pair_release(bp); 340 return 0; 341 } 342 343 bio->bi_bdev = tmp_dev->rdev->bdev; 344 bio->bi_sector = bio->bi_sector - start_sector 345 + tmp_dev->rdev->data_offset; 346 rcu_read_unlock(); 347 348 return 1; 349} 350 351static void linear_status (struct seq_file *seq, mddev_t *mddev) 352{ 353 354 seq_printf(seq, " %dk rounding", mddev->chunk_sectors / 2); 355} 356 357 358static struct mdk_personality linear_personality = 359{ 360 .name = "linear", 361 .level = LEVEL_LINEAR, 362 .owner = THIS_MODULE, 363 .make_request = linear_make_request, 364 .run = linear_run, 365 .stop = linear_stop, 366 .status = linear_status, 367 .hot_add_disk = linear_add, 368 .size = linear_size, 369}; 370 371static int __init linear_init (void) 372{ 373 return register_md_personality (&linear_personality); 374} 375 376static void linear_exit (void) 377{ 378 unregister_md_personality (&linear_personality); 379} 380 381 382module_init(linear_init); 383module_exit(linear_exit); 384MODULE_LICENSE("GPL"); 385MODULE_DESCRIPTION("Linear device concatenation personality for MD"); 386MODULE_ALIAS("md-personality-1"); /* LINEAR - deprecated*/ 387MODULE_ALIAS("md-linear"); 388MODULE_ALIAS("md-level--1"); 389