raid0.c 20 KB

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