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