raid0.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. raid0.c : Multiple Devices driver for Linux
  4. Copyright (C) 1994-96 Marc ZYNGIER
  5. <[email protected]> or
  6. <[email protected]>
  7. Copyright (C) 1999, 2000 Ingo Molnar, Red Hat
  8. RAID-0 management functions.
  9. */
  10. #include <linux/blkdev.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 "raid0.h"
  17. #include "raid5.h"
  18. static int default_layout = 0;
  19. module_param(default_layout, int, 0644);
  20. #define UNSUPPORTED_MDDEV_FLAGS \
  21. ((1L << MD_HAS_JOURNAL) | \
  22. (1L << MD_JOURNAL_CLEAN) | \
  23. (1L << MD_FAILFAST_SUPPORTED) |\
  24. (1L << MD_HAS_PPL) | \
  25. (1L << MD_HAS_MULTIPLE_PPLS))
  26. /*
  27. * inform the user of the raid configuration
  28. */
  29. static void dump_zones(struct mddev *mddev)
  30. {
  31. int j, k;
  32. sector_t zone_size = 0;
  33. sector_t zone_start = 0;
  34. struct r0conf *conf = mddev->private;
  35. int raid_disks = conf->strip_zone[0].nb_dev;
  36. pr_debug("md: RAID0 configuration for %s - %d zone%s\n",
  37. mdname(mddev),
  38. conf->nr_strip_zones, conf->nr_strip_zones==1?"":"s");
  39. for (j = 0; j < conf->nr_strip_zones; j++) {
  40. char line[200];
  41. int len = 0;
  42. for (k = 0; k < conf->strip_zone[j].nb_dev; k++)
  43. len += scnprintf(line+len, 200-len, "%s%pg", k?"/":"",
  44. conf->devlist[j * raid_disks + k]->bdev);
  45. pr_debug("md: zone%d=[%s]\n", j, line);
  46. zone_size = conf->strip_zone[j].zone_end - zone_start;
  47. pr_debug(" zone-offset=%10lluKB, device-offset=%10lluKB, size=%10lluKB\n",
  48. (unsigned long long)zone_start>>1,
  49. (unsigned long long)conf->strip_zone[j].dev_start>>1,
  50. (unsigned long long)zone_size>>1);
  51. zone_start = conf->strip_zone[j].zone_end;
  52. }
  53. }
  54. static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
  55. {
  56. int i, c, err;
  57. sector_t curr_zone_end, sectors;
  58. struct md_rdev *smallest, *rdev1, *rdev2, *rdev, **dev;
  59. struct strip_zone *zone;
  60. int cnt;
  61. struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
  62. unsigned blksize = 512;
  63. *private_conf = ERR_PTR(-ENOMEM);
  64. if (!conf)
  65. return -ENOMEM;
  66. rdev_for_each(rdev1, mddev) {
  67. pr_debug("md/raid0:%s: looking at %pg\n",
  68. mdname(mddev),
  69. rdev1->bdev);
  70. c = 0;
  71. /* round size to chunk_size */
  72. sectors = rdev1->sectors;
  73. sector_div(sectors, mddev->chunk_sectors);
  74. rdev1->sectors = sectors * mddev->chunk_sectors;
  75. blksize = max(blksize, queue_logical_block_size(
  76. rdev1->bdev->bd_disk->queue));
  77. rdev_for_each(rdev2, mddev) {
  78. pr_debug("md/raid0:%s: comparing %pg(%llu)"
  79. " with %pg(%llu)\n",
  80. mdname(mddev),
  81. rdev1->bdev,
  82. (unsigned long long)rdev1->sectors,
  83. rdev2->bdev,
  84. (unsigned long long)rdev2->sectors);
  85. if (rdev2 == rdev1) {
  86. pr_debug("md/raid0:%s: END\n",
  87. mdname(mddev));
  88. break;
  89. }
  90. if (rdev2->sectors == rdev1->sectors) {
  91. /*
  92. * Not unique, don't count it as a new
  93. * group
  94. */
  95. pr_debug("md/raid0:%s: EQUAL\n",
  96. mdname(mddev));
  97. c = 1;
  98. break;
  99. }
  100. pr_debug("md/raid0:%s: NOT EQUAL\n",
  101. mdname(mddev));
  102. }
  103. if (!c) {
  104. pr_debug("md/raid0:%s: ==> UNIQUE\n",
  105. mdname(mddev));
  106. conf->nr_strip_zones++;
  107. pr_debug("md/raid0:%s: %d zones\n",
  108. mdname(mddev), conf->nr_strip_zones);
  109. }
  110. }
  111. pr_debug("md/raid0:%s: FINAL %d zones\n",
  112. mdname(mddev), conf->nr_strip_zones);
  113. /*
  114. * now since we have the hard sector sizes, we can make sure
  115. * chunk size is a multiple of that sector size
  116. */
  117. if ((mddev->chunk_sectors << 9) % blksize) {
  118. pr_warn("md/raid0:%s: chunk_size of %d not multiple of block size %d\n",
  119. mdname(mddev),
  120. mddev->chunk_sectors << 9, blksize);
  121. err = -EINVAL;
  122. goto abort;
  123. }
  124. err = -ENOMEM;
  125. conf->strip_zone = kcalloc(conf->nr_strip_zones,
  126. sizeof(struct strip_zone),
  127. GFP_KERNEL);
  128. if (!conf->strip_zone)
  129. goto abort;
  130. conf->devlist = kzalloc(array3_size(sizeof(struct md_rdev *),
  131. conf->nr_strip_zones,
  132. mddev->raid_disks),
  133. GFP_KERNEL);
  134. if (!conf->devlist)
  135. goto abort;
  136. /* The first zone must contain all devices, so here we check that
  137. * there is a proper alignment of slots to devices and find them all
  138. */
  139. zone = &conf->strip_zone[0];
  140. cnt = 0;
  141. smallest = NULL;
  142. dev = conf->devlist;
  143. err = -EINVAL;
  144. rdev_for_each(rdev1, mddev) {
  145. int j = rdev1->raid_disk;
  146. if (mddev->level == 10) {
  147. /* taking over a raid10-n2 array */
  148. j /= 2;
  149. rdev1->new_raid_disk = j;
  150. }
  151. if (mddev->level == 1) {
  152. /* taiking over a raid1 array-
  153. * we have only one active disk
  154. */
  155. j = 0;
  156. rdev1->new_raid_disk = j;
  157. }
  158. if (j < 0) {
  159. pr_warn("md/raid0:%s: remove inactive devices before converting to RAID0\n",
  160. mdname(mddev));
  161. goto abort;
  162. }
  163. if (j >= mddev->raid_disks) {
  164. pr_warn("md/raid0:%s: bad disk number %d - aborting!\n",
  165. mdname(mddev), j);
  166. goto abort;
  167. }
  168. if (dev[j]) {
  169. pr_warn("md/raid0:%s: multiple devices for %d - aborting!\n",
  170. mdname(mddev), j);
  171. goto abort;
  172. }
  173. dev[j] = rdev1;
  174. if (!smallest || (rdev1->sectors < smallest->sectors))
  175. smallest = rdev1;
  176. cnt++;
  177. }
  178. if (cnt != mddev->raid_disks) {
  179. pr_warn("md/raid0:%s: too few disks (%d of %d) - aborting!\n",
  180. mdname(mddev), cnt, mddev->raid_disks);
  181. goto abort;
  182. }
  183. zone->nb_dev = cnt;
  184. zone->zone_end = smallest->sectors * cnt;
  185. curr_zone_end = zone->zone_end;
  186. /* now do the other zones */
  187. for (i = 1; i < conf->nr_strip_zones; i++)
  188. {
  189. int j;
  190. zone = conf->strip_zone + i;
  191. dev = conf->devlist + i * mddev->raid_disks;
  192. pr_debug("md/raid0:%s: zone %d\n", mdname(mddev), i);
  193. zone->dev_start = smallest->sectors;
  194. smallest = NULL;
  195. c = 0;
  196. for (j=0; j<cnt; j++) {
  197. rdev = conf->devlist[j];
  198. if (rdev->sectors <= zone->dev_start) {
  199. pr_debug("md/raid0:%s: checking %pg ... nope\n",
  200. mdname(mddev),
  201. rdev->bdev);
  202. continue;
  203. }
  204. pr_debug("md/raid0:%s: checking %pg ..."
  205. " contained as device %d\n",
  206. mdname(mddev),
  207. rdev->bdev, c);
  208. dev[c] = rdev;
  209. c++;
  210. if (!smallest || rdev->sectors < smallest->sectors) {
  211. smallest = rdev;
  212. pr_debug("md/raid0:%s: (%llu) is smallest!.\n",
  213. mdname(mddev),
  214. (unsigned long long)rdev->sectors);
  215. }
  216. }
  217. zone->nb_dev = c;
  218. sectors = (smallest->sectors - zone->dev_start) * c;
  219. pr_debug("md/raid0:%s: zone->nb_dev: %d, sectors: %llu\n",
  220. mdname(mddev),
  221. zone->nb_dev, (unsigned long long)sectors);
  222. curr_zone_end += sectors;
  223. zone->zone_end = curr_zone_end;
  224. pr_debug("md/raid0:%s: current zone start: %llu\n",
  225. mdname(mddev),
  226. (unsigned long long)smallest->sectors);
  227. }
  228. if (conf->nr_strip_zones == 1 || conf->strip_zone[1].nb_dev == 1) {
  229. conf->layout = RAID0_ORIG_LAYOUT;
  230. } else if (mddev->layout == RAID0_ORIG_LAYOUT ||
  231. mddev->layout == RAID0_ALT_MULTIZONE_LAYOUT) {
  232. conf->layout = mddev->layout;
  233. } else if (default_layout == RAID0_ORIG_LAYOUT ||
  234. default_layout == RAID0_ALT_MULTIZONE_LAYOUT) {
  235. conf->layout = default_layout;
  236. } else {
  237. pr_err("md/raid0:%s: cannot assemble multi-zone RAID0 with default_layout setting\n",
  238. mdname(mddev));
  239. pr_err("md/raid0: please set raid0.default_layout to 1 or 2\n");
  240. err = -EOPNOTSUPP;
  241. goto abort;
  242. }
  243. if (conf->layout == RAID0_ORIG_LAYOUT) {
  244. for (i = 1; i < conf->nr_strip_zones; i++) {
  245. sector_t first_sector = conf->strip_zone[i-1].zone_end;
  246. sector_div(first_sector, mddev->chunk_sectors);
  247. zone = conf->strip_zone + i;
  248. /* disk_shift is first disk index used in the zone */
  249. zone->disk_shift = sector_div(first_sector,
  250. zone->nb_dev);
  251. }
  252. }
  253. pr_debug("md/raid0:%s: done.\n", mdname(mddev));
  254. *private_conf = conf;
  255. return 0;
  256. abort:
  257. kfree(conf->strip_zone);
  258. kfree(conf->devlist);
  259. kfree(conf);
  260. *private_conf = ERR_PTR(err);
  261. return err;
  262. }
  263. /* Find the zone which holds a particular offset
  264. * Update *sectorp to be an offset in that zone
  265. */
  266. static struct strip_zone *find_zone(struct r0conf *conf,
  267. sector_t *sectorp)
  268. {
  269. int i;
  270. struct strip_zone *z = conf->strip_zone;
  271. sector_t sector = *sectorp;
  272. for (i = 0; i < conf->nr_strip_zones; i++)
  273. if (sector < z[i].zone_end) {
  274. if (i)
  275. *sectorp = sector - z[i-1].zone_end;
  276. return z + i;
  277. }
  278. BUG();
  279. }
  280. /*
  281. * remaps the bio to the target device. we separate two flows.
  282. * power 2 flow and a general flow for the sake of performance
  283. */
  284. static struct md_rdev *map_sector(struct mddev *mddev, struct strip_zone *zone,
  285. sector_t sector, sector_t *sector_offset)
  286. {
  287. unsigned int sect_in_chunk;
  288. sector_t chunk;
  289. struct r0conf *conf = mddev->private;
  290. int raid_disks = conf->strip_zone[0].nb_dev;
  291. unsigned int chunk_sects = mddev->chunk_sectors;
  292. if (is_power_of_2(chunk_sects)) {
  293. int chunksect_bits = ffz(~chunk_sects);
  294. /* find the sector offset inside the chunk */
  295. sect_in_chunk = sector & (chunk_sects - 1);
  296. sector >>= chunksect_bits;
  297. /* chunk in zone */
  298. chunk = *sector_offset;
  299. /* quotient is the chunk in real device*/
  300. sector_div(chunk, zone->nb_dev << chunksect_bits);
  301. } else{
  302. sect_in_chunk = sector_div(sector, chunk_sects);
  303. chunk = *sector_offset;
  304. sector_div(chunk, chunk_sects * zone->nb_dev);
  305. }
  306. /*
  307. * position the bio over the real device
  308. * real sector = chunk in device + starting of zone
  309. * + the position in the chunk
  310. */
  311. *sector_offset = (chunk * chunk_sects) + sect_in_chunk;
  312. return conf->devlist[(zone - conf->strip_zone)*raid_disks
  313. + sector_div(sector, zone->nb_dev)];
  314. }
  315. static sector_t raid0_size(struct mddev *mddev, sector_t sectors, int raid_disks)
  316. {
  317. sector_t array_sectors = 0;
  318. struct md_rdev *rdev;
  319. WARN_ONCE(sectors || raid_disks,
  320. "%s does not support generic reshape\n", __func__);
  321. rdev_for_each(rdev, mddev)
  322. array_sectors += (rdev->sectors &
  323. ~(sector_t)(mddev->chunk_sectors-1));
  324. return array_sectors;
  325. }
  326. static void free_conf(struct mddev *mddev, struct r0conf *conf)
  327. {
  328. kfree(conf->strip_zone);
  329. kfree(conf->devlist);
  330. kfree(conf);
  331. }
  332. static void raid0_free(struct mddev *mddev, void *priv)
  333. {
  334. struct r0conf *conf = priv;
  335. free_conf(mddev, conf);
  336. acct_bioset_exit(mddev);
  337. }
  338. static int raid0_run(struct mddev *mddev)
  339. {
  340. struct r0conf *conf;
  341. int ret;
  342. if (mddev->chunk_sectors == 0) {
  343. pr_warn("md/raid0:%s: chunk size must be set.\n", mdname(mddev));
  344. return -EINVAL;
  345. }
  346. if (md_check_no_bitmap(mddev))
  347. return -EINVAL;
  348. if (acct_bioset_init(mddev)) {
  349. pr_err("md/raid0:%s: alloc acct bioset failed.\n", mdname(mddev));
  350. return -ENOMEM;
  351. }
  352. /* if private is not null, we are here after takeover */
  353. if (mddev->private == NULL) {
  354. ret = create_strip_zones(mddev, &conf);
  355. if (ret < 0)
  356. goto exit_acct_set;
  357. mddev->private = conf;
  358. }
  359. conf = mddev->private;
  360. if (mddev->queue) {
  361. struct md_rdev *rdev;
  362. blk_queue_max_hw_sectors(mddev->queue, mddev->chunk_sectors);
  363. blk_queue_max_write_zeroes_sectors(mddev->queue, mddev->chunk_sectors);
  364. blk_queue_io_min(mddev->queue, mddev->chunk_sectors << 9);
  365. blk_queue_io_opt(mddev->queue,
  366. (mddev->chunk_sectors << 9) * mddev->raid_disks);
  367. rdev_for_each(rdev, mddev) {
  368. disk_stack_limits(mddev->gendisk, rdev->bdev,
  369. rdev->data_offset << 9);
  370. }
  371. }
  372. /* calculate array device size */
  373. md_set_array_sectors(mddev, raid0_size(mddev, 0, 0));
  374. pr_debug("md/raid0:%s: md_size is %llu sectors.\n",
  375. mdname(mddev),
  376. (unsigned long long)mddev->array_sectors);
  377. dump_zones(mddev);
  378. ret = md_integrity_register(mddev);
  379. if (ret)
  380. goto free;
  381. return ret;
  382. free:
  383. free_conf(mddev, conf);
  384. exit_acct_set:
  385. acct_bioset_exit(mddev);
  386. return ret;
  387. }
  388. /*
  389. * Convert disk_index to the disk order in which it is read/written.
  390. * For example, if we have 4 disks, they are numbered 0,1,2,3. If we
  391. * write the disks starting at disk 3, then the read/write order would
  392. * be disk 3, then 0, then 1, and then disk 2 and we want map_disk_shift()
  393. * to map the disks as follows 0,1,2,3 => 1,2,3,0. So disk 0 would map
  394. * to 1, 1 to 2, 2 to 3, and 3 to 0. That way we can compare disks in
  395. * that 'output' space to understand the read/write disk ordering.
  396. */
  397. static int map_disk_shift(int disk_index, int num_disks, int disk_shift)
  398. {
  399. return ((disk_index + num_disks - disk_shift) % num_disks);
  400. }
  401. static void raid0_handle_discard(struct mddev *mddev, struct bio *bio)
  402. {
  403. struct r0conf *conf = mddev->private;
  404. struct strip_zone *zone;
  405. sector_t start = bio->bi_iter.bi_sector;
  406. sector_t end;
  407. unsigned int stripe_size;
  408. sector_t first_stripe_index, last_stripe_index;
  409. sector_t start_disk_offset;
  410. unsigned int start_disk_index;
  411. sector_t end_disk_offset;
  412. unsigned int end_disk_index;
  413. unsigned int disk;
  414. sector_t orig_start, orig_end;
  415. orig_start = start;
  416. zone = find_zone(conf, &start);
  417. if (bio_end_sector(bio) > zone->zone_end) {
  418. struct bio *split = bio_split(bio,
  419. zone->zone_end - bio->bi_iter.bi_sector, GFP_NOIO,
  420. &mddev->bio_set);
  421. bio_chain(split, bio);
  422. submit_bio_noacct(bio);
  423. bio = split;
  424. end = zone->zone_end;
  425. } else
  426. end = bio_end_sector(bio);
  427. orig_end = end;
  428. if (zone != conf->strip_zone)
  429. end = end - zone[-1].zone_end;
  430. /* Now start and end is the offset in zone */
  431. stripe_size = zone->nb_dev * mddev->chunk_sectors;
  432. first_stripe_index = start;
  433. sector_div(first_stripe_index, stripe_size);
  434. last_stripe_index = end;
  435. sector_div(last_stripe_index, stripe_size);
  436. /* In the first zone the original and alternate layouts are the same */
  437. if ((conf->layout == RAID0_ORIG_LAYOUT) && (zone != conf->strip_zone)) {
  438. sector_div(orig_start, mddev->chunk_sectors);
  439. start_disk_index = sector_div(orig_start, zone->nb_dev);
  440. start_disk_index = map_disk_shift(start_disk_index,
  441. zone->nb_dev,
  442. zone->disk_shift);
  443. sector_div(orig_end, mddev->chunk_sectors);
  444. end_disk_index = sector_div(orig_end, zone->nb_dev);
  445. end_disk_index = map_disk_shift(end_disk_index,
  446. zone->nb_dev, zone->disk_shift);
  447. } else {
  448. start_disk_index = (int)(start - first_stripe_index * stripe_size) /
  449. mddev->chunk_sectors;
  450. end_disk_index = (int)(end - last_stripe_index * stripe_size) /
  451. mddev->chunk_sectors;
  452. }
  453. start_disk_offset = ((int)(start - first_stripe_index * stripe_size) %
  454. mddev->chunk_sectors) +
  455. first_stripe_index * mddev->chunk_sectors;
  456. end_disk_offset = ((int)(end - last_stripe_index * stripe_size) %
  457. mddev->chunk_sectors) +
  458. last_stripe_index * mddev->chunk_sectors;
  459. for (disk = 0; disk < zone->nb_dev; disk++) {
  460. sector_t dev_start, dev_end;
  461. struct md_rdev *rdev;
  462. int compare_disk;
  463. compare_disk = map_disk_shift(disk, zone->nb_dev,
  464. zone->disk_shift);
  465. if (compare_disk < start_disk_index)
  466. dev_start = (first_stripe_index + 1) *
  467. mddev->chunk_sectors;
  468. else if (compare_disk > start_disk_index)
  469. dev_start = first_stripe_index * mddev->chunk_sectors;
  470. else
  471. dev_start = start_disk_offset;
  472. if (compare_disk < end_disk_index)
  473. dev_end = (last_stripe_index + 1) * mddev->chunk_sectors;
  474. else if (compare_disk > end_disk_index)
  475. dev_end = last_stripe_index * mddev->chunk_sectors;
  476. else
  477. dev_end = end_disk_offset;
  478. if (dev_end <= dev_start)
  479. continue;
  480. rdev = conf->devlist[(zone - conf->strip_zone) *
  481. conf->strip_zone[0].nb_dev + disk];
  482. md_submit_discard_bio(mddev, rdev, bio,
  483. dev_start + zone->dev_start + rdev->data_offset,
  484. dev_end - dev_start);
  485. }
  486. bio_endio(bio);
  487. }
  488. static void raid0_map_submit_bio(struct mddev *mddev, struct bio *bio)
  489. {
  490. struct r0conf *conf = mddev->private;
  491. struct strip_zone *zone;
  492. struct md_rdev *tmp_dev;
  493. sector_t bio_sector = bio->bi_iter.bi_sector;
  494. sector_t sector = bio_sector;
  495. md_account_bio(mddev, &bio);
  496. zone = find_zone(mddev->private, &sector);
  497. switch (conf->layout) {
  498. case RAID0_ORIG_LAYOUT:
  499. tmp_dev = map_sector(mddev, zone, bio_sector, &sector);
  500. break;
  501. case RAID0_ALT_MULTIZONE_LAYOUT:
  502. tmp_dev = map_sector(mddev, zone, sector, &sector);
  503. break;
  504. default:
  505. WARN(1, "md/raid0:%s: Invalid layout\n", mdname(mddev));
  506. bio_io_error(bio);
  507. return;
  508. }
  509. if (unlikely(is_rdev_broken(tmp_dev))) {
  510. bio_io_error(bio);
  511. md_error(mddev, tmp_dev);
  512. return;
  513. }
  514. bio_set_dev(bio, tmp_dev->bdev);
  515. bio->bi_iter.bi_sector = sector + zone->dev_start +
  516. tmp_dev->data_offset;
  517. if (mddev->gendisk)
  518. trace_block_bio_remap(bio, disk_devt(mddev->gendisk),
  519. bio_sector);
  520. mddev_check_write_zeroes(mddev, bio);
  521. submit_bio_noacct(bio);
  522. }
  523. static bool raid0_make_request(struct mddev *mddev, struct bio *bio)
  524. {
  525. sector_t sector;
  526. unsigned chunk_sects;
  527. unsigned sectors;
  528. if (unlikely(bio->bi_opf & REQ_PREFLUSH)
  529. && md_flush_request(mddev, bio))
  530. return true;
  531. if (unlikely((bio_op(bio) == REQ_OP_DISCARD))) {
  532. raid0_handle_discard(mddev, bio);
  533. return true;
  534. }
  535. sector = bio->bi_iter.bi_sector;
  536. chunk_sects = mddev->chunk_sectors;
  537. sectors = chunk_sects -
  538. (likely(is_power_of_2(chunk_sects))
  539. ? (sector & (chunk_sects-1))
  540. : sector_div(sector, chunk_sects));
  541. if (sectors < bio_sectors(bio)) {
  542. struct bio *split = bio_split(bio, sectors, GFP_NOIO,
  543. &mddev->bio_set);
  544. bio_chain(split, bio);
  545. raid0_map_submit_bio(mddev, bio);
  546. bio = split;
  547. }
  548. raid0_map_submit_bio(mddev, bio);
  549. return true;
  550. }
  551. static void raid0_status(struct seq_file *seq, struct mddev *mddev)
  552. {
  553. seq_printf(seq, " %dk chunks", mddev->chunk_sectors / 2);
  554. return;
  555. }
  556. static void raid0_error(struct mddev *mddev, struct md_rdev *rdev)
  557. {
  558. if (!test_and_set_bit(MD_BROKEN, &mddev->flags)) {
  559. char *md_name = mdname(mddev);
  560. pr_crit("md/raid0%s: Disk failure on %pg detected, failing array.\n",
  561. md_name, rdev->bdev);
  562. }
  563. }
  564. static void *raid0_takeover_raid45(struct mddev *mddev)
  565. {
  566. struct md_rdev *rdev;
  567. struct r0conf *priv_conf;
  568. if (mddev->degraded != 1) {
  569. pr_warn("md/raid0:%s: raid5 must be degraded! Degraded disks: %d\n",
  570. mdname(mddev),
  571. mddev->degraded);
  572. return ERR_PTR(-EINVAL);
  573. }
  574. rdev_for_each(rdev, mddev) {
  575. /* check slot number for a disk */
  576. if (rdev->raid_disk == mddev->raid_disks-1) {
  577. pr_warn("md/raid0:%s: raid5 must have missing parity disk!\n",
  578. mdname(mddev));
  579. return ERR_PTR(-EINVAL);
  580. }
  581. rdev->sectors = mddev->dev_sectors;
  582. }
  583. /* Set new parameters */
  584. mddev->new_level = 0;
  585. mddev->new_layout = 0;
  586. mddev->new_chunk_sectors = mddev->chunk_sectors;
  587. mddev->raid_disks--;
  588. mddev->delta_disks = -1;
  589. /* make sure it will be not marked as dirty */
  590. mddev->recovery_cp = MaxSector;
  591. mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
  592. create_strip_zones(mddev, &priv_conf);
  593. return priv_conf;
  594. }
  595. static void *raid0_takeover_raid10(struct mddev *mddev)
  596. {
  597. struct r0conf *priv_conf;
  598. /* Check layout:
  599. * - far_copies must be 1
  600. * - near_copies must be 2
  601. * - disks number must be even
  602. * - all mirrors must be already degraded
  603. */
  604. if (mddev->layout != ((1 << 8) + 2)) {
  605. pr_warn("md/raid0:%s:: Raid0 cannot takeover layout: 0x%x\n",
  606. mdname(mddev),
  607. mddev->layout);
  608. return ERR_PTR(-EINVAL);
  609. }
  610. if (mddev->raid_disks & 1) {
  611. pr_warn("md/raid0:%s: Raid0 cannot takeover Raid10 with odd disk number.\n",
  612. mdname(mddev));
  613. return ERR_PTR(-EINVAL);
  614. }
  615. if (mddev->degraded != (mddev->raid_disks>>1)) {
  616. pr_warn("md/raid0:%s: All mirrors must be already degraded!\n",
  617. mdname(mddev));
  618. return ERR_PTR(-EINVAL);
  619. }
  620. /* Set new parameters */
  621. mddev->new_level = 0;
  622. mddev->new_layout = 0;
  623. mddev->new_chunk_sectors = mddev->chunk_sectors;
  624. mddev->delta_disks = - mddev->raid_disks / 2;
  625. mddev->raid_disks += mddev->delta_disks;
  626. mddev->degraded = 0;
  627. /* make sure it will be not marked as dirty */
  628. mddev->recovery_cp = MaxSector;
  629. mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
  630. create_strip_zones(mddev, &priv_conf);
  631. return priv_conf;
  632. }
  633. static void *raid0_takeover_raid1(struct mddev *mddev)
  634. {
  635. struct r0conf *priv_conf;
  636. int chunksect;
  637. /* Check layout:
  638. * - (N - 1) mirror drives must be already faulty
  639. */
  640. if ((mddev->raid_disks - 1) != mddev->degraded) {
  641. pr_err("md/raid0:%s: (N - 1) mirrors drives must be already faulty!\n",
  642. mdname(mddev));
  643. return ERR_PTR(-EINVAL);
  644. }
  645. /*
  646. * a raid1 doesn't have the notion of chunk size, so
  647. * figure out the largest suitable size we can use.
  648. */
  649. chunksect = 64 * 2; /* 64K by default */
  650. /* The array must be an exact multiple of chunksize */
  651. while (chunksect && (mddev->array_sectors & (chunksect - 1)))
  652. chunksect >>= 1;
  653. if ((chunksect << 9) < PAGE_SIZE)
  654. /* array size does not allow a suitable chunk size */
  655. return ERR_PTR(-EINVAL);
  656. /* Set new parameters */
  657. mddev->new_level = 0;
  658. mddev->new_layout = 0;
  659. mddev->new_chunk_sectors = chunksect;
  660. mddev->chunk_sectors = chunksect;
  661. mddev->delta_disks = 1 - mddev->raid_disks;
  662. mddev->raid_disks = 1;
  663. /* make sure it will be not marked as dirty */
  664. mddev->recovery_cp = MaxSector;
  665. mddev_clear_unsupported_flags(mddev, UNSUPPORTED_MDDEV_FLAGS);
  666. create_strip_zones(mddev, &priv_conf);
  667. return priv_conf;
  668. }
  669. static void *raid0_takeover(struct mddev *mddev)
  670. {
  671. /* raid0 can take over:
  672. * raid4 - if all data disks are active.
  673. * raid5 - providing it is Raid4 layout and one disk is faulty
  674. * raid10 - assuming we have all necessary active disks
  675. * raid1 - with (N -1) mirror drives faulty
  676. */
  677. if (mddev->bitmap) {
  678. pr_warn("md/raid0: %s: cannot takeover array with bitmap\n",
  679. mdname(mddev));
  680. return ERR_PTR(-EBUSY);
  681. }
  682. if (mddev->level == 4)
  683. return raid0_takeover_raid45(mddev);
  684. if (mddev->level == 5) {
  685. if (mddev->layout == ALGORITHM_PARITY_N)
  686. return raid0_takeover_raid45(mddev);
  687. pr_warn("md/raid0:%s: Raid can only takeover Raid5 with layout: %d\n",
  688. mdname(mddev), ALGORITHM_PARITY_N);
  689. }
  690. if (mddev->level == 10)
  691. return raid0_takeover_raid10(mddev);
  692. if (mddev->level == 1)
  693. return raid0_takeover_raid1(mddev);
  694. pr_warn("Takeover from raid%i to raid0 not supported\n",
  695. mddev->level);
  696. return ERR_PTR(-EINVAL);
  697. }
  698. static void raid0_quiesce(struct mddev *mddev, int quiesce)
  699. {
  700. }
  701. static struct md_personality raid0_personality=
  702. {
  703. .name = "raid0",
  704. .level = 0,
  705. .owner = THIS_MODULE,
  706. .make_request = raid0_make_request,
  707. .run = raid0_run,
  708. .free = raid0_free,
  709. .status = raid0_status,
  710. .size = raid0_size,
  711. .takeover = raid0_takeover,
  712. .quiesce = raid0_quiesce,
  713. .error_handler = raid0_error,
  714. };
  715. static int __init raid0_init (void)
  716. {
  717. return register_md_personality (&raid0_personality);
  718. }
  719. static void raid0_exit (void)
  720. {
  721. unregister_md_personality (&raid0_personality);
  722. }
  723. module_init(raid0_init);
  724. module_exit(raid0_exit);
  725. MODULE_LICENSE("GPL");
  726. MODULE_DESCRIPTION("RAID0 (striping) personality for MD");
  727. MODULE_ALIAS("md-personality-2"); /* RAID0 */
  728. MODULE_ALIAS("md-raid0");
  729. MODULE_ALIAS("md-level-0");