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/module.h> 23 #include <linux/slab.h> 24 #include <trace/events/block.h> 25 #include "md.h" 26 #include "md-linear.h" 27 28 /* 29 * find which device holds a particular offset 30 */ 31 static inline struct dev_info *which_dev(struct mddev *mddev, sector_t sector) 32 { 33 int lo, mid, hi; 34 struct linear_conf *conf; 35 36 lo = 0; 37 hi = mddev->raid_disks - 1; 38 conf = mddev->private; 39 40 /* 41 * Binary Search 42 */ 43 44 while (hi > lo) { 45 46 mid = (hi + lo) / 2; 47 if (sector < conf->disks[mid].end_sector) 48 hi = mid; 49 else 50 lo = mid + 1; 51 } 52 53 return conf->disks + lo; 54 } 55 56 /* 57 * In linear_congested() conf->raid_disks is used as a copy of 58 * mddev->raid_disks to iterate conf->disks[], because conf->raid_disks 59 * and conf->disks[] are created in linear_conf(), they are always 60 * consitent with each other, but mddev->raid_disks does not. 61 */ 62 static int linear_congested(struct mddev *mddev, int bits) 63 { 64 struct linear_conf *conf; 65 int i, ret = 0; 66 67 rcu_read_lock(); 68 conf = rcu_dereference(mddev->private); 69 70 for (i = 0; i < conf->raid_disks && !ret ; i++) { 71 struct request_queue *q = bdev_get_queue(conf->disks[i].rdev->bdev); 72 ret |= bdi_congested(q->backing_dev_info, bits); 73 } 74 75 rcu_read_unlock(); 76 return ret; 77 } 78 79 static sector_t linear_size(struct mddev *mddev, sector_t sectors, int raid_disks) 80 { 81 struct linear_conf *conf; 82 sector_t array_sectors; 83 84 conf = mddev->private; 85 WARN_ONCE(sectors || raid_disks, 86 "%s does not support generic reshape\n", __func__); 87 array_sectors = conf->array_sectors; 88 89 return array_sectors; 90 } 91 92 static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks) 93 { 94 struct linear_conf *conf; 95 struct md_rdev *rdev; 96 int i, cnt; 97 bool discard_supported = false; 98 99 conf = kzalloc(struct_size(conf, disks, raid_disks), GFP_KERNEL); 100 if (!conf) 101 return NULL; 102 103 cnt = 0; 104 conf->array_sectors = 0; 105 106 rdev_for_each(rdev, mddev) { 107 int j = rdev->raid_disk; 108 struct dev_info *disk = conf->disks + j; 109 sector_t sectors; 110 111 if (j < 0 || j >= raid_disks || disk->rdev) { 112 pr_warn("md/linear:%s: disk numbering problem. Aborting!\n", 113 mdname(mddev)); 114 goto out; 115 } 116 117 disk->rdev = rdev; 118 if (mddev->chunk_sectors) { 119 sectors = rdev->sectors; 120 sector_div(sectors, mddev->chunk_sectors); 121 rdev->sectors = sectors * mddev->chunk_sectors; 122 } 123 124 disk_stack_limits(mddev->gendisk, rdev->bdev, 125 rdev->data_offset << 9); 126 127 conf->array_sectors += rdev->sectors; 128 cnt++; 129 130 if (blk_queue_discard(bdev_get_queue(rdev->bdev))) 131 discard_supported = true; 132 } 133 if (cnt != raid_disks) { 134 pr_warn("md/linear:%s: not enough drives present. Aborting!\n", 135 mdname(mddev)); 136 goto out; 137 } 138 139 if (!discard_supported) 140 blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue); 141 else 142 blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue); 143 144 /* 145 * Here we calculate the device offsets. 146 */ 147 conf->disks[0].end_sector = conf->disks[0].rdev->sectors; 148 149 for (i = 1; i < raid_disks; i++) 150 conf->disks[i].end_sector = 151 conf->disks[i-1].end_sector + 152 conf->disks[i].rdev->sectors; 153 154 /* 155 * conf->raid_disks is copy of mddev->raid_disks. The reason to 156 * keep a copy of mddev->raid_disks in struct linear_conf is, 157 * mddev->raid_disks may not be consistent with pointers number of 158 * conf->disks[] when it is updated in linear_add() and used to 159 * iterate old conf->disks[] earray in linear_congested(). 160 * Here conf->raid_disks is always consitent with number of 161 * pointers in conf->disks[] array, and mddev->private is updated 162 * with rcu_assign_pointer() in linear_addr(), such race can be 163 * avoided. 164 */ 165 conf->raid_disks = raid_disks; 166 167 return conf; 168 169 out: 170 kfree(conf); 171 return NULL; 172 } 173 174 static int linear_run (struct mddev *mddev) 175 { 176 struct linear_conf *conf; 177 int ret; 178 179 if (md_check_no_bitmap(mddev)) 180 return -EINVAL; 181 conf = linear_conf(mddev, mddev->raid_disks); 182 183 if (!conf) 184 return 1; 185 mddev->private = conf; 186 md_set_array_sectors(mddev, linear_size(mddev, 0, 0)); 187 188 ret = md_integrity_register(mddev); 189 if (ret) { 190 kfree(conf); 191 mddev->private = NULL; 192 } 193 return ret; 194 } 195 196 static int linear_add(struct mddev *mddev, struct md_rdev *rdev) 197 { 198 /* Adding a drive to a linear array allows the array to grow. 199 * It is permitted if the new drive has a matching superblock 200 * already on it, with raid_disk equal to raid_disks. 201 * It is achieved by creating a new linear_private_data structure 202 * and swapping it in in-place of the current one. 203 * The current one is never freed until the array is stopped. 204 * This avoids races. 205 */ 206 struct linear_conf *newconf, *oldconf; 207 208 if (rdev->saved_raid_disk != mddev->raid_disks) 209 return -EINVAL; 210 211 rdev->raid_disk = rdev->saved_raid_disk; 212 rdev->saved_raid_disk = -1; 213 214 newconf = linear_conf(mddev,mddev->raid_disks+1); 215 216 if (!newconf) 217 return -ENOMEM; 218 219 /* newconf->raid_disks already keeps a copy of * the increased 220 * value of mddev->raid_disks, WARN_ONCE() is just used to make 221 * sure of this. It is possible that oldconf is still referenced 222 * in linear_congested(), therefore kfree_rcu() is used to free 223 * oldconf until no one uses it anymore. 224 */ 225 mddev_suspend(mddev); 226 oldconf = rcu_dereference_protected(mddev->private, 227 lockdep_is_held(&mddev->reconfig_mutex)); 228 mddev->raid_disks++; 229 WARN_ONCE(mddev->raid_disks != newconf->raid_disks, 230 "copied raid_disks doesn't match mddev->raid_disks"); 231 rcu_assign_pointer(mddev->private, newconf); 232 md_set_array_sectors(mddev, linear_size(mddev, 0, 0)); 233 set_capacity(mddev->gendisk, mddev->array_sectors); 234 mddev_resume(mddev); 235 revalidate_disk(mddev->gendisk); 236 kfree_rcu(oldconf, rcu); 237 return 0; 238 } 239 240 static void linear_free(struct mddev *mddev, void *priv) 241 { 242 struct linear_conf *conf = priv; 243 244 kfree(conf); 245 } 246 247 static bool linear_make_request(struct mddev *mddev, struct bio *bio) 248 { 249 char b[BDEVNAME_SIZE]; 250 struct dev_info *tmp_dev; 251 sector_t start_sector, end_sector, data_offset; 252 sector_t bio_sector = bio->bi_iter.bi_sector; 253 254 if (unlikely(bio->bi_opf & REQ_PREFLUSH)) { 255 md_flush_request(mddev, bio); 256 return true; 257 } 258 259 tmp_dev = which_dev(mddev, bio_sector); 260 start_sector = tmp_dev->end_sector - tmp_dev->rdev->sectors; 261 end_sector = tmp_dev->end_sector; 262 data_offset = tmp_dev->rdev->data_offset; 263 264 if (unlikely(bio_sector >= end_sector || 265 bio_sector < start_sector)) 266 goto out_of_bounds; 267 268 if (unlikely(bio_end_sector(bio) > end_sector)) { 269 /* This bio crosses a device boundary, so we have to split it */ 270 struct bio *split = bio_split(bio, end_sector - bio_sector, 271 GFP_NOIO, &mddev->bio_set); 272 bio_chain(split, bio); 273 generic_make_request(bio); 274 bio = split; 275 } 276 277 bio_set_dev(bio, tmp_dev->rdev->bdev); 278 bio->bi_iter.bi_sector = bio->bi_iter.bi_sector - 279 start_sector + data_offset; 280 281 if (unlikely((bio_op(bio) == REQ_OP_DISCARD) && 282 !blk_queue_discard(bio->bi_disk->queue))) { 283 /* Just ignore it */ 284 bio_endio(bio); 285 } else { 286 if (mddev->gendisk) 287 trace_block_bio_remap(bio->bi_disk->queue, 288 bio, disk_devt(mddev->gendisk), 289 bio_sector); 290 mddev_check_writesame(mddev, bio); 291 mddev_check_write_zeroes(mddev, bio); 292 generic_make_request(bio); 293 } 294 return true; 295 296 out_of_bounds: 297 pr_err("md/linear:%s: make_request: Sector %llu out of bounds on dev %s: %llu sectors, offset %llu\n", 298 mdname(mddev), 299 (unsigned long long)bio->bi_iter.bi_sector, 300 bdevname(tmp_dev->rdev->bdev, b), 301 (unsigned long long)tmp_dev->rdev->sectors, 302 (unsigned long long)start_sector); 303 bio_io_error(bio); 304 return true; 305 } 306 307 static void linear_status (struct seq_file *seq, struct mddev *mddev) 308 { 309 seq_printf(seq, " %dk rounding", mddev->chunk_sectors / 2); 310 } 311 312 static void linear_quiesce(struct mddev *mddev, int state) 313 { 314 } 315 316 static struct md_personality linear_personality = 317 { 318 .name = "linear", 319 .level = LEVEL_LINEAR, 320 .owner = THIS_MODULE, 321 .make_request = linear_make_request, 322 .run = linear_run, 323 .free = linear_free, 324 .status = linear_status, 325 .hot_add_disk = linear_add, 326 .size = linear_size, 327 .quiesce = linear_quiesce, 328 .congested = linear_congested, 329 }; 330 331 static int __init linear_init (void) 332 { 333 return register_md_personality (&linear_personality); 334 } 335 336 static void linear_exit (void) 337 { 338 unregister_md_personality (&linear_personality); 339 } 340 341 module_init(linear_init); 342 module_exit(linear_exit); 343 MODULE_LICENSE("GPL"); 344 MODULE_DESCRIPTION("Linear device concatenation personality for MD"); 345 MODULE_ALIAS("md-personality-1"); /* LINEAR - deprecated*/ 346 MODULE_ALIAS("md-linear"); 347 MODULE_ALIAS("md-level--1"); 348