dm-stripe.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528
  1. /*
  2. * Copyright (C) 2001-2003 Sistina Software (UK) Limited.
  3. *
  4. * This file is released under the GPL.
  5. */
  6. #include "dm.h"
  7. #include <linux/device-mapper.h>
  8. #include <linux/module.h>
  9. #include <linux/init.h>
  10. #include <linux/blkdev.h>
  11. #include <linux/bio.h>
  12. #include <linux/dax.h>
  13. #include <linux/slab.h>
  14. #include <linux/log2.h>
  15. #define DM_MSG_PREFIX "striped"
  16. #define DM_IO_ERROR_THRESHOLD 15
  17. struct stripe {
  18. struct dm_dev *dev;
  19. sector_t physical_start;
  20. atomic_t error_count;
  21. };
  22. struct stripe_c {
  23. uint32_t stripes;
  24. int stripes_shift;
  25. /* The size of this target / num. stripes */
  26. sector_t stripe_width;
  27. uint32_t chunk_size;
  28. int chunk_size_shift;
  29. /* Needed for handling events */
  30. struct dm_target *ti;
  31. /* Work struct used for triggering events*/
  32. struct work_struct trigger_event;
  33. struct stripe stripe[];
  34. };
  35. /*
  36. * An event is triggered whenever a drive
  37. * drops out of a stripe volume.
  38. */
  39. static void trigger_event(struct work_struct *work)
  40. {
  41. struct stripe_c *sc = container_of(work, struct stripe_c,
  42. trigger_event);
  43. dm_table_event(sc->ti->table);
  44. }
  45. /*
  46. * Parse a single <dev> <sector> pair
  47. */
  48. static int get_stripe(struct dm_target *ti, struct stripe_c *sc,
  49. unsigned int stripe, char **argv)
  50. {
  51. unsigned long long start;
  52. char dummy;
  53. int ret;
  54. if (sscanf(argv[1], "%llu%c", &start, &dummy) != 1)
  55. return -EINVAL;
  56. ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
  57. &sc->stripe[stripe].dev);
  58. if (ret)
  59. return ret;
  60. sc->stripe[stripe].physical_start = start;
  61. return 0;
  62. }
  63. /*
  64. * Construct a striped mapping.
  65. * <number of stripes> <chunk size> [<dev_path> <offset>]+
  66. */
  67. static int stripe_ctr(struct dm_target *ti, unsigned int argc, char **argv)
  68. {
  69. struct stripe_c *sc;
  70. sector_t width, tmp_len;
  71. uint32_t stripes;
  72. uint32_t chunk_size;
  73. int r;
  74. unsigned int i;
  75. if (argc < 2) {
  76. ti->error = "Not enough arguments";
  77. return -EINVAL;
  78. }
  79. if (kstrtouint(argv[0], 10, &stripes) || !stripes) {
  80. ti->error = "Invalid stripe count";
  81. return -EINVAL;
  82. }
  83. if (kstrtouint(argv[1], 10, &chunk_size) || !chunk_size) {
  84. ti->error = "Invalid chunk_size";
  85. return -EINVAL;
  86. }
  87. width = ti->len;
  88. if (sector_div(width, stripes)) {
  89. ti->error = "Target length not divisible by "
  90. "number of stripes";
  91. return -EINVAL;
  92. }
  93. tmp_len = width;
  94. if (sector_div(tmp_len, chunk_size)) {
  95. ti->error = "Target length not divisible by "
  96. "chunk size";
  97. return -EINVAL;
  98. }
  99. /*
  100. * Do we have enough arguments for that many stripes ?
  101. */
  102. if (argc != (2 + 2 * stripes)) {
  103. ti->error = "Not enough destinations "
  104. "specified";
  105. return -EINVAL;
  106. }
  107. sc = kmalloc(struct_size(sc, stripe, stripes), GFP_KERNEL);
  108. if (!sc) {
  109. ti->error = "Memory allocation for striped context "
  110. "failed";
  111. return -ENOMEM;
  112. }
  113. INIT_WORK(&sc->trigger_event, trigger_event);
  114. /* Set pointer to dm target; used in trigger_event */
  115. sc->ti = ti;
  116. sc->stripes = stripes;
  117. sc->stripe_width = width;
  118. if (stripes & (stripes - 1))
  119. sc->stripes_shift = -1;
  120. else
  121. sc->stripes_shift = __ffs(stripes);
  122. r = dm_set_target_max_io_len(ti, chunk_size);
  123. if (r) {
  124. kfree(sc);
  125. return r;
  126. }
  127. ti->num_flush_bios = stripes;
  128. ti->num_discard_bios = stripes;
  129. ti->num_secure_erase_bios = stripes;
  130. ti->num_write_same_bios = stripes;
  131. ti->num_write_zeroes_bios = stripes;
  132. sc->chunk_size = chunk_size;
  133. if (chunk_size & (chunk_size - 1))
  134. sc->chunk_size_shift = -1;
  135. else
  136. sc->chunk_size_shift = __ffs(chunk_size);
  137. /*
  138. * Get the stripe destinations.
  139. */
  140. for (i = 0; i < stripes; i++) {
  141. argv += 2;
  142. r = get_stripe(ti, sc, i, argv);
  143. if (r < 0) {
  144. ti->error = "Couldn't parse stripe destination";
  145. while (i--)
  146. dm_put_device(ti, sc->stripe[i].dev);
  147. kfree(sc);
  148. return r;
  149. }
  150. atomic_set(&(sc->stripe[i].error_count), 0);
  151. }
  152. ti->private = sc;
  153. return 0;
  154. }
  155. static void stripe_dtr(struct dm_target *ti)
  156. {
  157. unsigned int i;
  158. struct stripe_c *sc = (struct stripe_c *) ti->private;
  159. for (i = 0; i < sc->stripes; i++)
  160. dm_put_device(ti, sc->stripe[i].dev);
  161. flush_work(&sc->trigger_event);
  162. kfree(sc);
  163. }
  164. static void stripe_map_sector(struct stripe_c *sc, sector_t sector,
  165. uint32_t *stripe, sector_t *result)
  166. {
  167. sector_t chunk = dm_target_offset(sc->ti, sector);
  168. sector_t chunk_offset;
  169. if (sc->chunk_size_shift < 0)
  170. chunk_offset = sector_div(chunk, sc->chunk_size);
  171. else {
  172. chunk_offset = chunk & (sc->chunk_size - 1);
  173. chunk >>= sc->chunk_size_shift;
  174. }
  175. if (sc->stripes_shift < 0)
  176. *stripe = sector_div(chunk, sc->stripes);
  177. else {
  178. *stripe = chunk & (sc->stripes - 1);
  179. chunk >>= sc->stripes_shift;
  180. }
  181. if (sc->chunk_size_shift < 0)
  182. chunk *= sc->chunk_size;
  183. else
  184. chunk <<= sc->chunk_size_shift;
  185. *result = chunk + chunk_offset;
  186. }
  187. static void stripe_map_range_sector(struct stripe_c *sc, sector_t sector,
  188. uint32_t target_stripe, sector_t *result)
  189. {
  190. uint32_t stripe;
  191. stripe_map_sector(sc, sector, &stripe, result);
  192. if (stripe == target_stripe)
  193. return;
  194. /* round down */
  195. sector = *result;
  196. if (sc->chunk_size_shift < 0)
  197. *result -= sector_div(sector, sc->chunk_size);
  198. else
  199. *result = sector & ~(sector_t)(sc->chunk_size - 1);
  200. if (target_stripe < stripe)
  201. *result += sc->chunk_size; /* next chunk */
  202. }
  203. static int stripe_map_range(struct stripe_c *sc, struct bio *bio,
  204. uint32_t target_stripe)
  205. {
  206. sector_t begin, end;
  207. stripe_map_range_sector(sc, bio->bi_iter.bi_sector,
  208. target_stripe, &begin);
  209. stripe_map_range_sector(sc, bio_end_sector(bio),
  210. target_stripe, &end);
  211. if (begin < end) {
  212. bio_set_dev(bio, sc->stripe[target_stripe].dev->bdev);
  213. bio->bi_iter.bi_sector = begin +
  214. sc->stripe[target_stripe].physical_start;
  215. bio->bi_iter.bi_size = to_bytes(end - begin);
  216. return DM_MAPIO_REMAPPED;
  217. } else {
  218. /* The range doesn't map to the target stripe */
  219. bio_endio(bio);
  220. return DM_MAPIO_SUBMITTED;
  221. }
  222. }
  223. static int stripe_map(struct dm_target *ti, struct bio *bio)
  224. {
  225. struct stripe_c *sc = ti->private;
  226. uint32_t stripe;
  227. unsigned target_bio_nr;
  228. if (bio->bi_opf & REQ_PREFLUSH) {
  229. target_bio_nr = dm_bio_get_target_bio_nr(bio);
  230. BUG_ON(target_bio_nr >= sc->stripes);
  231. bio_set_dev(bio, sc->stripe[target_bio_nr].dev->bdev);
  232. return DM_MAPIO_REMAPPED;
  233. }
  234. if (unlikely(bio_op(bio) == REQ_OP_DISCARD) ||
  235. unlikely(bio_op(bio) == REQ_OP_SECURE_ERASE) ||
  236. unlikely(bio_op(bio) == REQ_OP_WRITE_ZEROES) ||
  237. unlikely(bio_op(bio) == REQ_OP_WRITE_SAME)) {
  238. target_bio_nr = dm_bio_get_target_bio_nr(bio);
  239. BUG_ON(target_bio_nr >= sc->stripes);
  240. return stripe_map_range(sc, bio, target_bio_nr);
  241. }
  242. stripe_map_sector(sc, bio->bi_iter.bi_sector,
  243. &stripe, &bio->bi_iter.bi_sector);
  244. bio->bi_iter.bi_sector += sc->stripe[stripe].physical_start;
  245. bio_set_dev(bio, sc->stripe[stripe].dev->bdev);
  246. return DM_MAPIO_REMAPPED;
  247. }
  248. #if IS_ENABLED(CONFIG_DAX_DRIVER)
  249. static long stripe_dax_direct_access(struct dm_target *ti, pgoff_t pgoff,
  250. long nr_pages, void **kaddr, pfn_t *pfn)
  251. {
  252. sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
  253. struct stripe_c *sc = ti->private;
  254. struct dax_device *dax_dev;
  255. struct block_device *bdev;
  256. uint32_t stripe;
  257. long ret;
  258. stripe_map_sector(sc, sector, &stripe, &dev_sector);
  259. dev_sector += sc->stripe[stripe].physical_start;
  260. dax_dev = sc->stripe[stripe].dev->dax_dev;
  261. bdev = sc->stripe[stripe].dev->bdev;
  262. ret = bdev_dax_pgoff(bdev, dev_sector, nr_pages * PAGE_SIZE, &pgoff);
  263. if (ret)
  264. return ret;
  265. return dax_direct_access(dax_dev, pgoff, nr_pages, kaddr, pfn);
  266. }
  267. static size_t stripe_dax_copy_from_iter(struct dm_target *ti, pgoff_t pgoff,
  268. void *addr, size_t bytes, struct iov_iter *i)
  269. {
  270. sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
  271. struct stripe_c *sc = ti->private;
  272. struct dax_device *dax_dev;
  273. struct block_device *bdev;
  274. uint32_t stripe;
  275. stripe_map_sector(sc, sector, &stripe, &dev_sector);
  276. dev_sector += sc->stripe[stripe].physical_start;
  277. dax_dev = sc->stripe[stripe].dev->dax_dev;
  278. bdev = sc->stripe[stripe].dev->bdev;
  279. if (bdev_dax_pgoff(bdev, dev_sector, ALIGN(bytes, PAGE_SIZE), &pgoff))
  280. return 0;
  281. return dax_copy_from_iter(dax_dev, pgoff, addr, bytes, i);
  282. }
  283. static size_t stripe_dax_copy_to_iter(struct dm_target *ti, pgoff_t pgoff,
  284. void *addr, size_t bytes, struct iov_iter *i)
  285. {
  286. sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
  287. struct stripe_c *sc = ti->private;
  288. struct dax_device *dax_dev;
  289. struct block_device *bdev;
  290. uint32_t stripe;
  291. stripe_map_sector(sc, sector, &stripe, &dev_sector);
  292. dev_sector += sc->stripe[stripe].physical_start;
  293. dax_dev = sc->stripe[stripe].dev->dax_dev;
  294. bdev = sc->stripe[stripe].dev->bdev;
  295. if (bdev_dax_pgoff(bdev, dev_sector, ALIGN(bytes, PAGE_SIZE), &pgoff))
  296. return 0;
  297. return dax_copy_to_iter(dax_dev, pgoff, addr, bytes, i);
  298. }
  299. static int stripe_dax_zero_page_range(struct dm_target *ti, pgoff_t pgoff,
  300. size_t nr_pages)
  301. {
  302. int ret;
  303. sector_t dev_sector, sector = pgoff * PAGE_SECTORS;
  304. struct stripe_c *sc = ti->private;
  305. struct dax_device *dax_dev;
  306. struct block_device *bdev;
  307. uint32_t stripe;
  308. stripe_map_sector(sc, sector, &stripe, &dev_sector);
  309. dev_sector += sc->stripe[stripe].physical_start;
  310. dax_dev = sc->stripe[stripe].dev->dax_dev;
  311. bdev = sc->stripe[stripe].dev->bdev;
  312. ret = bdev_dax_pgoff(bdev, dev_sector, nr_pages << PAGE_SHIFT, &pgoff);
  313. if (ret)
  314. return ret;
  315. return dax_zero_page_range(dax_dev, pgoff, nr_pages);
  316. }
  317. #else
  318. #define stripe_dax_direct_access NULL
  319. #define stripe_dax_copy_from_iter NULL
  320. #define stripe_dax_copy_to_iter NULL
  321. #define stripe_dax_zero_page_range NULL
  322. #endif
  323. /*
  324. * Stripe status:
  325. *
  326. * INFO
  327. * #stripes [stripe_name <stripe_name>] [group word count]
  328. * [error count 'A|D' <error count 'A|D'>]
  329. *
  330. * TABLE
  331. * #stripes [stripe chunk size]
  332. * [stripe_name physical_start <stripe_name physical_start>]
  333. *
  334. */
  335. static void stripe_status(struct dm_target *ti, status_type_t type,
  336. unsigned status_flags, char *result, unsigned maxlen)
  337. {
  338. struct stripe_c *sc = (struct stripe_c *) ti->private;
  339. unsigned int sz = 0;
  340. unsigned int i;
  341. switch (type) {
  342. case STATUSTYPE_INFO:
  343. DMEMIT("%d ", sc->stripes);
  344. for (i = 0; i < sc->stripes; i++) {
  345. DMEMIT("%s ", sc->stripe[i].dev->name);
  346. }
  347. DMEMIT("1 ");
  348. for (i = 0; i < sc->stripes; i++) {
  349. DMEMIT("%c", atomic_read(&(sc->stripe[i].error_count)) ?
  350. 'D' : 'A');
  351. }
  352. break;
  353. case STATUSTYPE_TABLE:
  354. DMEMIT("%d %llu", sc->stripes,
  355. (unsigned long long)sc->chunk_size);
  356. for (i = 0; i < sc->stripes; i++)
  357. DMEMIT(" %s %llu", sc->stripe[i].dev->name,
  358. (unsigned long long)sc->stripe[i].physical_start);
  359. break;
  360. }
  361. }
  362. static int stripe_end_io(struct dm_target *ti, struct bio *bio,
  363. blk_status_t *error)
  364. {
  365. unsigned i;
  366. char major_minor[16];
  367. struct stripe_c *sc = ti->private;
  368. if (!*error)
  369. return DM_ENDIO_DONE; /* I/O complete */
  370. if (bio->bi_opf & REQ_RAHEAD)
  371. return DM_ENDIO_DONE;
  372. if (*error == BLK_STS_NOTSUPP)
  373. return DM_ENDIO_DONE;
  374. memset(major_minor, 0, sizeof(major_minor));
  375. sprintf(major_minor, "%d:%d", MAJOR(bio_dev(bio)), MINOR(bio_dev(bio)));
  376. /*
  377. * Test to see which stripe drive triggered the event
  378. * and increment error count for all stripes on that device.
  379. * If the error count for a given device exceeds the threshold
  380. * value we will no longer trigger any further events.
  381. */
  382. for (i = 0; i < sc->stripes; i++)
  383. if (!strcmp(sc->stripe[i].dev->name, major_minor)) {
  384. atomic_inc(&(sc->stripe[i].error_count));
  385. if (atomic_read(&(sc->stripe[i].error_count)) <
  386. DM_IO_ERROR_THRESHOLD)
  387. schedule_work(&sc->trigger_event);
  388. }
  389. return DM_ENDIO_DONE;
  390. }
  391. static int stripe_iterate_devices(struct dm_target *ti,
  392. iterate_devices_callout_fn fn, void *data)
  393. {
  394. struct stripe_c *sc = ti->private;
  395. int ret = 0;
  396. unsigned i = 0;
  397. do {
  398. ret = fn(ti, sc->stripe[i].dev,
  399. sc->stripe[i].physical_start,
  400. sc->stripe_width, data);
  401. } while (!ret && ++i < sc->stripes);
  402. return ret;
  403. }
  404. static void stripe_io_hints(struct dm_target *ti,
  405. struct queue_limits *limits)
  406. {
  407. struct stripe_c *sc = ti->private;
  408. unsigned chunk_size = sc->chunk_size << SECTOR_SHIFT;
  409. blk_limits_io_min(limits, chunk_size);
  410. blk_limits_io_opt(limits, chunk_size * sc->stripes);
  411. }
  412. static struct target_type stripe_target = {
  413. .name = "striped",
  414. .version = {1, 6, 0},
  415. .features = DM_TARGET_PASSES_INTEGRITY,
  416. .module = THIS_MODULE,
  417. .ctr = stripe_ctr,
  418. .dtr = stripe_dtr,
  419. .map = stripe_map,
  420. .end_io = stripe_end_io,
  421. .status = stripe_status,
  422. .iterate_devices = stripe_iterate_devices,
  423. .io_hints = stripe_io_hints,
  424. .direct_access = stripe_dax_direct_access,
  425. .dax_copy_from_iter = stripe_dax_copy_from_iter,
  426. .dax_copy_to_iter = stripe_dax_copy_to_iter,
  427. .dax_zero_page_range = stripe_dax_zero_page_range,
  428. };
  429. int __init dm_stripe_init(void)
  430. {
  431. int r;
  432. r = dm_register_target(&stripe_target);
  433. if (r < 0)
  434. DMWARN("target registration failed");
  435. return r;
  436. }
  437. void dm_stripe_exit(void)
  438. {
  439. dm_unregister_target(&stripe_target);
  440. }