md-linear.c 8.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. linear.c : Multiple Devices driver for Linux
  4. Copyright (C) 1994-96 Marc ZYNGIER
  5. <zyngier@ufr-info-p7.ibp.fr> or
  6. <maz@gloups.fdn.fr>
  7. Linear mode management functions.
  8. */
  9. #include <linux/blkdev.h>
  10. #include <linux/raid/md_u.h>
  11. #include <linux/seq_file.h>
  12. #include <linux/module.h>
  13. #include <linux/slab.h>
  14. #include <trace/events/block.h>
  15. #include "md.h"
  16. #include "md-linear.h"
  17. /*
  18. * find which device holds a particular offset
  19. */
  20. static inline struct dev_info *which_dev(struct mddev *mddev, sector_t sector)
  21. {
  22. int lo, mid, hi;
  23. struct linear_conf *conf;
  24. lo = 0;
  25. hi = mddev->raid_disks - 1;
  26. conf = mddev->private;
  27. /*
  28. * Binary Search
  29. */
  30. while (hi > lo) {
  31. mid = (hi + lo) / 2;
  32. if (sector < conf->disks[mid].end_sector)
  33. hi = mid;
  34. else
  35. lo = mid + 1;
  36. }
  37. return conf->disks + lo;
  38. }
  39. static sector_t linear_size(struct mddev *mddev, sector_t sectors, int raid_disks)
  40. {
  41. struct linear_conf *conf;
  42. sector_t array_sectors;
  43. conf = mddev->private;
  44. WARN_ONCE(sectors || raid_disks,
  45. "%s does not support generic reshape\n", __func__);
  46. array_sectors = conf->array_sectors;
  47. return array_sectors;
  48. }
  49. static struct linear_conf *linear_conf(struct mddev *mddev, int raid_disks)
  50. {
  51. struct linear_conf *conf;
  52. struct md_rdev *rdev;
  53. int i, cnt;
  54. bool discard_supported = false;
  55. conf = kzalloc(struct_size(conf, disks, raid_disks), GFP_KERNEL);
  56. if (!conf)
  57. return NULL;
  58. cnt = 0;
  59. conf->array_sectors = 0;
  60. rdev_for_each(rdev, mddev) {
  61. int j = rdev->raid_disk;
  62. struct dev_info *disk = conf->disks + j;
  63. sector_t sectors;
  64. if (j < 0 || j >= raid_disks || disk->rdev) {
  65. pr_warn("md/linear:%s: disk numbering problem. Aborting!\n",
  66. mdname(mddev));
  67. goto out;
  68. }
  69. disk->rdev = rdev;
  70. if (mddev->chunk_sectors) {
  71. sectors = rdev->sectors;
  72. sector_div(sectors, mddev->chunk_sectors);
  73. rdev->sectors = sectors * mddev->chunk_sectors;
  74. }
  75. disk_stack_limits(mddev->gendisk, rdev->bdev,
  76. rdev->data_offset << 9);
  77. conf->array_sectors += rdev->sectors;
  78. cnt++;
  79. if (blk_queue_discard(bdev_get_queue(rdev->bdev)))
  80. discard_supported = true;
  81. }
  82. if (cnt != raid_disks) {
  83. pr_warn("md/linear:%s: not enough drives present. Aborting!\n",
  84. mdname(mddev));
  85. goto out;
  86. }
  87. if (!discard_supported)
  88. blk_queue_flag_clear(QUEUE_FLAG_DISCARD, mddev->queue);
  89. else
  90. blk_queue_flag_set(QUEUE_FLAG_DISCARD, mddev->queue);
  91. /*
  92. * Here we calculate the device offsets.
  93. */
  94. conf->disks[0].end_sector = conf->disks[0].rdev->sectors;
  95. for (i = 1; i < raid_disks; i++)
  96. conf->disks[i].end_sector =
  97. conf->disks[i-1].end_sector +
  98. conf->disks[i].rdev->sectors;
  99. /*
  100. * conf->raid_disks is copy of mddev->raid_disks. The reason to
  101. * keep a copy of mddev->raid_disks in struct linear_conf is,
  102. * mddev->raid_disks may not be consistent with pointers number of
  103. * conf->disks[] when it is updated in linear_add() and used to
  104. * iterate old conf->disks[] earray in linear_congested().
  105. * Here conf->raid_disks is always consitent with number of
  106. * pointers in conf->disks[] array, and mddev->private is updated
  107. * with rcu_assign_pointer() in linear_addr(), such race can be
  108. * avoided.
  109. */
  110. conf->raid_disks = raid_disks;
  111. return conf;
  112. out:
  113. kfree(conf);
  114. return NULL;
  115. }
  116. static int linear_run (struct mddev *mddev)
  117. {
  118. struct linear_conf *conf;
  119. int ret;
  120. if (md_check_no_bitmap(mddev))
  121. return -EINVAL;
  122. conf = linear_conf(mddev, mddev->raid_disks);
  123. if (!conf)
  124. return 1;
  125. mddev->private = conf;
  126. md_set_array_sectors(mddev, linear_size(mddev, 0, 0));
  127. ret = md_integrity_register(mddev);
  128. if (ret) {
  129. kfree(conf);
  130. mddev->private = NULL;
  131. }
  132. return ret;
  133. }
  134. static int linear_add(struct mddev *mddev, struct md_rdev *rdev)
  135. {
  136. /* Adding a drive to a linear array allows the array to grow.
  137. * It is permitted if the new drive has a matching superblock
  138. * already on it, with raid_disk equal to raid_disks.
  139. * It is achieved by creating a new linear_private_data structure
  140. * and swapping it in in-place of the current one.
  141. * The current one is never freed until the array is stopped.
  142. * This avoids races.
  143. */
  144. struct linear_conf *newconf, *oldconf;
  145. if (rdev->saved_raid_disk != mddev->raid_disks)
  146. return -EINVAL;
  147. rdev->raid_disk = rdev->saved_raid_disk;
  148. rdev->saved_raid_disk = -1;
  149. newconf = linear_conf(mddev,mddev->raid_disks+1);
  150. if (!newconf)
  151. return -ENOMEM;
  152. /* newconf->raid_disks already keeps a copy of * the increased
  153. * value of mddev->raid_disks, WARN_ONCE() is just used to make
  154. * sure of this. It is possible that oldconf is still referenced
  155. * in linear_congested(), therefore kfree_rcu() is used to free
  156. * oldconf until no one uses it anymore.
  157. */
  158. mddev_suspend(mddev);
  159. oldconf = rcu_dereference_protected(mddev->private,
  160. lockdep_is_held(&mddev->reconfig_mutex));
  161. mddev->raid_disks++;
  162. WARN_ONCE(mddev->raid_disks != newconf->raid_disks,
  163. "copied raid_disks doesn't match mddev->raid_disks");
  164. rcu_assign_pointer(mddev->private, newconf);
  165. md_set_array_sectors(mddev, linear_size(mddev, 0, 0));
  166. set_capacity(mddev->gendisk, mddev->array_sectors);
  167. mddev_resume(mddev);
  168. revalidate_disk_size(mddev->gendisk, true);
  169. kfree_rcu(oldconf, rcu);
  170. return 0;
  171. }
  172. static void linear_free(struct mddev *mddev, void *priv)
  173. {
  174. struct linear_conf *conf = priv;
  175. kfree(conf);
  176. }
  177. static bool linear_make_request(struct mddev *mddev, struct bio *bio)
  178. {
  179. char b[BDEVNAME_SIZE];
  180. struct dev_info *tmp_dev;
  181. sector_t start_sector, end_sector, data_offset;
  182. sector_t bio_sector = bio->bi_iter.bi_sector;
  183. if (unlikely(bio->bi_opf & REQ_PREFLUSH)
  184. && md_flush_request(mddev, bio))
  185. return true;
  186. tmp_dev = which_dev(mddev, bio_sector);
  187. start_sector = tmp_dev->end_sector - tmp_dev->rdev->sectors;
  188. end_sector = tmp_dev->end_sector;
  189. data_offset = tmp_dev->rdev->data_offset;
  190. if (unlikely(bio_sector >= end_sector ||
  191. bio_sector < start_sector))
  192. goto out_of_bounds;
  193. if (unlikely(is_mddev_broken(tmp_dev->rdev, "linear"))) {
  194. bio_io_error(bio);
  195. return true;
  196. }
  197. if (unlikely(bio_end_sector(bio) > end_sector)) {
  198. /* This bio crosses a device boundary, so we have to split it */
  199. struct bio *split = bio_split(bio, end_sector - bio_sector,
  200. GFP_NOIO, &mddev->bio_set);
  201. bio_chain(split, bio);
  202. submit_bio_noacct(bio);
  203. bio = split;
  204. }
  205. bio_set_dev(bio, tmp_dev->rdev->bdev);
  206. bio->bi_iter.bi_sector = bio->bi_iter.bi_sector -
  207. start_sector + data_offset;
  208. if (unlikely((bio_op(bio) == REQ_OP_DISCARD) &&
  209. !blk_queue_discard(bio->bi_disk->queue))) {
  210. /* Just ignore it */
  211. bio_endio(bio);
  212. } else {
  213. if (mddev->gendisk)
  214. trace_block_bio_remap(bio->bi_disk->queue,
  215. bio, disk_devt(mddev->gendisk),
  216. bio_sector);
  217. mddev_check_writesame(mddev, bio);
  218. mddev_check_write_zeroes(mddev, bio);
  219. submit_bio_noacct(bio);
  220. }
  221. return true;
  222. out_of_bounds:
  223. pr_err("md/linear:%s: make_request: Sector %llu out of bounds on dev %s: %llu sectors, offset %llu\n",
  224. mdname(mddev),
  225. (unsigned long long)bio->bi_iter.bi_sector,
  226. bdevname(tmp_dev->rdev->bdev, b),
  227. (unsigned long long)tmp_dev->rdev->sectors,
  228. (unsigned long long)start_sector);
  229. bio_io_error(bio);
  230. return true;
  231. }
  232. static void linear_status (struct seq_file *seq, struct mddev *mddev)
  233. {
  234. seq_printf(seq, " %dk rounding", mddev->chunk_sectors / 2);
  235. }
  236. static void linear_quiesce(struct mddev *mddev, int state)
  237. {
  238. }
  239. static struct md_personality linear_personality =
  240. {
  241. .name = "linear",
  242. .level = LEVEL_LINEAR,
  243. .owner = THIS_MODULE,
  244. .make_request = linear_make_request,
  245. .run = linear_run,
  246. .free = linear_free,
  247. .status = linear_status,
  248. .hot_add_disk = linear_add,
  249. .size = linear_size,
  250. .quiesce = linear_quiesce,
  251. };
  252. static int __init linear_init (void)
  253. {
  254. return register_md_personality (&linear_personality);
  255. }
  256. static void linear_exit (void)
  257. {
  258. unregister_md_personality (&linear_personality);
  259. }
  260. module_init(linear_init);
  261. module_exit(linear_exit);
  262. MODULE_LICENSE("GPL");
  263. MODULE_DESCRIPTION("Linear device concatenation personality for MD");
  264. MODULE_ALIAS("md-personality-1"); /* LINEAR - deprecated*/
  265. MODULE_ALIAS("md-linear");
  266. MODULE_ALIAS("md-level--1");