multipath.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583
  1. /*
  2. * multipath.c : Multiple Devices driver for Linux
  3. *
  4. * Copyright (C) 1999, 2000, 2001 Ingo Molnar, Red Hat
  5. *
  6. * Copyright (C) 1996, 1997, 1998 Ingo Molnar, Miguel de Icaza, Gadi Oxman
  7. *
  8. * MULTIPATH management functions.
  9. *
  10. * derived from raid1.c.
  11. *
  12. * This program is free software; you can redistribute it and/or modify
  13. * it under the terms of the GNU General Public License as published by
  14. * the Free Software Foundation; either version 2, or (at your option)
  15. * any later version.
  16. *
  17. * You should have received a copy of the GNU General Public License
  18. * (for example /usr/src/linux/COPYING); if not, write to the Free
  19. * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21. #include <linux/blkdev.h>
  22. #include <linux/raid/md_u.h>
  23. #include <linux/seq_file.h>
  24. #include "md.h"
  25. #include "multipath.h"
  26. #define MAX_WORK_PER_DISK 128
  27. #define NR_RESERVED_BUFS 32
  28. static int multipath_map (multipath_conf_t *conf)
  29. {
  30. int i, disks = conf->raid_disks;
  31. /*
  32. * Later we do read balancing on the read side
  33. * now we use the first available disk.
  34. */
  35. rcu_read_lock();
  36. for (i = 0; i < disks; i++) {
  37. mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
  38. if (rdev && test_bit(In_sync, &rdev->flags)) {
  39. atomic_inc(&rdev->nr_pending);
  40. rcu_read_unlock();
  41. return i;
  42. }
  43. }
  44. rcu_read_unlock();
  45. printk(KERN_ERR "multipath_map(): no more operational IO paths?\n");
  46. return (-1);
  47. }
  48. static void multipath_reschedule_retry (struct multipath_bh *mp_bh)
  49. {
  50. unsigned long flags;
  51. mddev_t *mddev = mp_bh->mddev;
  52. multipath_conf_t *conf = mddev->private;
  53. spin_lock_irqsave(&conf->device_lock, flags);
  54. list_add(&mp_bh->retry_list, &conf->retry_list);
  55. spin_unlock_irqrestore(&conf->device_lock, flags);
  56. md_wakeup_thread(mddev->thread);
  57. }
  58. /*
  59. * multipath_end_bh_io() is called when we have finished servicing a multipathed
  60. * operation and are ready to return a success/failure code to the buffer
  61. * cache layer.
  62. */
  63. static void multipath_end_bh_io (struct multipath_bh *mp_bh, int err)
  64. {
  65. struct bio *bio = mp_bh->master_bio;
  66. multipath_conf_t *conf = mp_bh->mddev->private;
  67. bio_endio(bio, err);
  68. mempool_free(mp_bh, conf->pool);
  69. }
  70. static void multipath_end_request(struct bio *bio, int error)
  71. {
  72. int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
  73. struct multipath_bh * mp_bh = (struct multipath_bh *)(bio->bi_private);
  74. multipath_conf_t *conf = mp_bh->mddev->private;
  75. mdk_rdev_t *rdev = conf->multipaths[mp_bh->path].rdev;
  76. if (uptodate)
  77. multipath_end_bh_io(mp_bh, 0);
  78. else if (!bio_rw_flagged(bio, BIO_RW_AHEAD)) {
  79. /*
  80. * oops, IO error:
  81. */
  82. char b[BDEVNAME_SIZE];
  83. md_error (mp_bh->mddev, rdev);
  84. printk(KERN_ERR "multipath: %s: rescheduling sector %llu\n",
  85. bdevname(rdev->bdev,b),
  86. (unsigned long long)bio->bi_sector);
  87. multipath_reschedule_retry(mp_bh);
  88. } else
  89. multipath_end_bh_io(mp_bh, error);
  90. rdev_dec_pending(rdev, conf->mddev);
  91. }
  92. static void unplug_slaves(mddev_t *mddev)
  93. {
  94. multipath_conf_t *conf = mddev->private;
  95. int i;
  96. rcu_read_lock();
  97. for (i=0; i<mddev->raid_disks; i++) {
  98. mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
  99. if (rdev && !test_bit(Faulty, &rdev->flags)
  100. && atomic_read(&rdev->nr_pending)) {
  101. struct request_queue *r_queue = bdev_get_queue(rdev->bdev);
  102. atomic_inc(&rdev->nr_pending);
  103. rcu_read_unlock();
  104. blk_unplug(r_queue);
  105. rdev_dec_pending(rdev, mddev);
  106. rcu_read_lock();
  107. }
  108. }
  109. rcu_read_unlock();
  110. }
  111. static void multipath_unplug(struct request_queue *q)
  112. {
  113. unplug_slaves(q->queuedata);
  114. }
  115. static int multipath_make_request (struct request_queue *q, struct bio * bio)
  116. {
  117. mddev_t *mddev = q->queuedata;
  118. multipath_conf_t *conf = mddev->private;
  119. struct multipath_bh * mp_bh;
  120. struct multipath_info *multipath;
  121. const int rw = bio_data_dir(bio);
  122. int cpu;
  123. if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER))) {
  124. bio_endio(bio, -EOPNOTSUPP);
  125. return 0;
  126. }
  127. mp_bh = mempool_alloc(conf->pool, GFP_NOIO);
  128. mp_bh->master_bio = bio;
  129. mp_bh->mddev = mddev;
  130. cpu = part_stat_lock();
  131. part_stat_inc(cpu, &mddev->gendisk->part0, ios[rw]);
  132. part_stat_add(cpu, &mddev->gendisk->part0, sectors[rw],
  133. bio_sectors(bio));
  134. part_stat_unlock();
  135. mp_bh->path = multipath_map(conf);
  136. if (mp_bh->path < 0) {
  137. bio_endio(bio, -EIO);
  138. mempool_free(mp_bh, conf->pool);
  139. return 0;
  140. }
  141. multipath = conf->multipaths + mp_bh->path;
  142. mp_bh->bio = *bio;
  143. mp_bh->bio.bi_sector += multipath->rdev->data_offset;
  144. mp_bh->bio.bi_bdev = multipath->rdev->bdev;
  145. mp_bh->bio.bi_rw |= (1 << BIO_RW_FAILFAST_TRANSPORT);
  146. mp_bh->bio.bi_end_io = multipath_end_request;
  147. mp_bh->bio.bi_private = mp_bh;
  148. generic_make_request(&mp_bh->bio);
  149. return 0;
  150. }
  151. static void multipath_status (struct seq_file *seq, mddev_t *mddev)
  152. {
  153. multipath_conf_t *conf = mddev->private;
  154. int i;
  155. seq_printf (seq, " [%d/%d] [", conf->raid_disks,
  156. conf->working_disks);
  157. for (i = 0; i < conf->raid_disks; i++)
  158. seq_printf (seq, "%s",
  159. conf->multipaths[i].rdev &&
  160. test_bit(In_sync, &conf->multipaths[i].rdev->flags) ? "U" : "_");
  161. seq_printf (seq, "]");
  162. }
  163. static int multipath_congested(void *data, int bits)
  164. {
  165. mddev_t *mddev = data;
  166. multipath_conf_t *conf = mddev->private;
  167. int i, ret = 0;
  168. rcu_read_lock();
  169. for (i = 0; i < mddev->raid_disks ; i++) {
  170. mdk_rdev_t *rdev = rcu_dereference(conf->multipaths[i].rdev);
  171. if (rdev && !test_bit(Faulty, &rdev->flags)) {
  172. struct request_queue *q = bdev_get_queue(rdev->bdev);
  173. ret |= bdi_congested(&q->backing_dev_info, bits);
  174. /* Just like multipath_map, we just check the
  175. * first available device
  176. */
  177. break;
  178. }
  179. }
  180. rcu_read_unlock();
  181. return ret;
  182. }
  183. /*
  184. * Careful, this can execute in IRQ contexts as well!
  185. */
  186. static void multipath_error (mddev_t *mddev, mdk_rdev_t *rdev)
  187. {
  188. multipath_conf_t *conf = mddev->private;
  189. if (conf->working_disks <= 1) {
  190. /*
  191. * Uh oh, we can do nothing if this is our last path, but
  192. * first check if this is a queued request for a device
  193. * which has just failed.
  194. */
  195. printk(KERN_ALERT
  196. "multipath: only one IO path left and IO error.\n");
  197. /* leave it active... it's all we have */
  198. } else {
  199. /*
  200. * Mark disk as unusable
  201. */
  202. if (!test_bit(Faulty, &rdev->flags)) {
  203. char b[BDEVNAME_SIZE];
  204. clear_bit(In_sync, &rdev->flags);
  205. set_bit(Faulty, &rdev->flags);
  206. set_bit(MD_CHANGE_DEVS, &mddev->flags);
  207. conf->working_disks--;
  208. mddev->degraded++;
  209. printk(KERN_ALERT "multipath: IO failure on %s,"
  210. " disabling IO path.\n"
  211. "multipath: Operation continuing"
  212. " on %d IO paths.\n",
  213. bdevname (rdev->bdev,b),
  214. conf->working_disks);
  215. }
  216. }
  217. }
  218. static void print_multipath_conf (multipath_conf_t *conf)
  219. {
  220. int i;
  221. struct multipath_info *tmp;
  222. printk("MULTIPATH conf printout:\n");
  223. if (!conf) {
  224. printk("(conf==NULL)\n");
  225. return;
  226. }
  227. printk(" --- wd:%d rd:%d\n", conf->working_disks,
  228. conf->raid_disks);
  229. for (i = 0; i < conf->raid_disks; i++) {
  230. char b[BDEVNAME_SIZE];
  231. tmp = conf->multipaths + i;
  232. if (tmp->rdev)
  233. printk(" disk%d, o:%d, dev:%s\n",
  234. i,!test_bit(Faulty, &tmp->rdev->flags),
  235. bdevname(tmp->rdev->bdev,b));
  236. }
  237. }
  238. static int multipath_add_disk(mddev_t *mddev, mdk_rdev_t *rdev)
  239. {
  240. multipath_conf_t *conf = mddev->private;
  241. struct request_queue *q;
  242. int err = -EEXIST;
  243. int path;
  244. struct multipath_info *p;
  245. int first = 0;
  246. int last = mddev->raid_disks - 1;
  247. if (rdev->raid_disk >= 0)
  248. first = last = rdev->raid_disk;
  249. print_multipath_conf(conf);
  250. for (path = first; path <= last; path++)
  251. if ((p=conf->multipaths+path)->rdev == NULL) {
  252. q = rdev->bdev->bd_disk->queue;
  253. disk_stack_limits(mddev->gendisk, rdev->bdev,
  254. rdev->data_offset << 9);
  255. /* as we don't honour merge_bvec_fn, we must never risk
  256. * violating it, so limit ->max_sector to one PAGE, as
  257. * a one page request is never in violation.
  258. * (Note: it is very unlikely that a device with
  259. * merge_bvec_fn will be involved in multipath.)
  260. */
  261. if (q->merge_bvec_fn &&
  262. queue_max_sectors(q) > (PAGE_SIZE>>9))
  263. blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
  264. conf->working_disks++;
  265. mddev->degraded--;
  266. rdev->raid_disk = path;
  267. set_bit(In_sync, &rdev->flags);
  268. rcu_assign_pointer(p->rdev, rdev);
  269. err = 0;
  270. md_integrity_add_rdev(rdev, mddev);
  271. break;
  272. }
  273. print_multipath_conf(conf);
  274. return err;
  275. }
  276. static int multipath_remove_disk(mddev_t *mddev, int number)
  277. {
  278. multipath_conf_t *conf = mddev->private;
  279. int err = 0;
  280. mdk_rdev_t *rdev;
  281. struct multipath_info *p = conf->multipaths + number;
  282. print_multipath_conf(conf);
  283. rdev = p->rdev;
  284. if (rdev) {
  285. if (test_bit(In_sync, &rdev->flags) ||
  286. atomic_read(&rdev->nr_pending)) {
  287. printk(KERN_ERR "hot-remove-disk, slot %d is identified"
  288. " but is still operational!\n", number);
  289. err = -EBUSY;
  290. goto abort;
  291. }
  292. p->rdev = NULL;
  293. synchronize_rcu();
  294. if (atomic_read(&rdev->nr_pending)) {
  295. /* lost the race, try later */
  296. err = -EBUSY;
  297. p->rdev = rdev;
  298. goto abort;
  299. }
  300. md_integrity_register(mddev);
  301. }
  302. abort:
  303. print_multipath_conf(conf);
  304. return err;
  305. }
  306. /*
  307. * This is a kernel thread which:
  308. *
  309. * 1. Retries failed read operations on working multipaths.
  310. * 2. Updates the raid superblock when problems encounter.
  311. * 3. Performs writes following reads for array syncronising.
  312. */
  313. static void multipathd (mddev_t *mddev)
  314. {
  315. struct multipath_bh *mp_bh;
  316. struct bio *bio;
  317. unsigned long flags;
  318. multipath_conf_t *conf = mddev->private;
  319. struct list_head *head = &conf->retry_list;
  320. md_check_recovery(mddev);
  321. for (;;) {
  322. char b[BDEVNAME_SIZE];
  323. spin_lock_irqsave(&conf->device_lock, flags);
  324. if (list_empty(head))
  325. break;
  326. mp_bh = list_entry(head->prev, struct multipath_bh, retry_list);
  327. list_del(head->prev);
  328. spin_unlock_irqrestore(&conf->device_lock, flags);
  329. bio = &mp_bh->bio;
  330. bio->bi_sector = mp_bh->master_bio->bi_sector;
  331. if ((mp_bh->path = multipath_map (conf))<0) {
  332. printk(KERN_ALERT "multipath: %s: unrecoverable IO read"
  333. " error for block %llu\n",
  334. bdevname(bio->bi_bdev,b),
  335. (unsigned long long)bio->bi_sector);
  336. multipath_end_bh_io(mp_bh, -EIO);
  337. } else {
  338. printk(KERN_ERR "multipath: %s: redirecting sector %llu"
  339. " to another IO path\n",
  340. bdevname(bio->bi_bdev,b),
  341. (unsigned long long)bio->bi_sector);
  342. *bio = *(mp_bh->master_bio);
  343. bio->bi_sector += conf->multipaths[mp_bh->path].rdev->data_offset;
  344. bio->bi_bdev = conf->multipaths[mp_bh->path].rdev->bdev;
  345. bio->bi_rw |= (1 << BIO_RW_FAILFAST_TRANSPORT);
  346. bio->bi_end_io = multipath_end_request;
  347. bio->bi_private = mp_bh;
  348. generic_make_request(bio);
  349. }
  350. }
  351. spin_unlock_irqrestore(&conf->device_lock, flags);
  352. }
  353. static sector_t multipath_size(mddev_t *mddev, sector_t sectors, int raid_disks)
  354. {
  355. WARN_ONCE(sectors || raid_disks,
  356. "%s does not support generic reshape\n", __func__);
  357. return mddev->dev_sectors;
  358. }
  359. static int multipath_run (mddev_t *mddev)
  360. {
  361. multipath_conf_t *conf;
  362. int disk_idx;
  363. struct multipath_info *disk;
  364. mdk_rdev_t *rdev;
  365. if (md_check_no_bitmap(mddev))
  366. return -EINVAL;
  367. if (mddev->level != LEVEL_MULTIPATH) {
  368. printk("multipath: %s: raid level not set to multipath IO (%d)\n",
  369. mdname(mddev), mddev->level);
  370. goto out;
  371. }
  372. /*
  373. * copy the already verified devices into our private MULTIPATH
  374. * bookkeeping area. [whatever we allocate in multipath_run(),
  375. * should be freed in multipath_stop()]
  376. */
  377. mddev->queue->queue_lock = &mddev->queue->__queue_lock;
  378. conf = kzalloc(sizeof(multipath_conf_t), GFP_KERNEL);
  379. mddev->private = conf;
  380. if (!conf) {
  381. printk(KERN_ERR
  382. "multipath: couldn't allocate memory for %s\n",
  383. mdname(mddev));
  384. goto out;
  385. }
  386. conf->multipaths = kzalloc(sizeof(struct multipath_info)*mddev->raid_disks,
  387. GFP_KERNEL);
  388. if (!conf->multipaths) {
  389. printk(KERN_ERR
  390. "multipath: couldn't allocate memory for %s\n",
  391. mdname(mddev));
  392. goto out_free_conf;
  393. }
  394. conf->working_disks = 0;
  395. list_for_each_entry(rdev, &mddev->disks, same_set) {
  396. disk_idx = rdev->raid_disk;
  397. if (disk_idx < 0 ||
  398. disk_idx >= mddev->raid_disks)
  399. continue;
  400. disk = conf->multipaths + disk_idx;
  401. disk->rdev = rdev;
  402. disk_stack_limits(mddev->gendisk, rdev->bdev,
  403. rdev->data_offset << 9);
  404. /* as we don't honour merge_bvec_fn, we must never risk
  405. * violating it, not that we ever expect a device with
  406. * a merge_bvec_fn to be involved in multipath */
  407. if (rdev->bdev->bd_disk->queue->merge_bvec_fn &&
  408. queue_max_sectors(mddev->queue) > (PAGE_SIZE>>9))
  409. blk_queue_max_sectors(mddev->queue, PAGE_SIZE>>9);
  410. if (!test_bit(Faulty, &rdev->flags))
  411. conf->working_disks++;
  412. }
  413. conf->raid_disks = mddev->raid_disks;
  414. conf->mddev = mddev;
  415. spin_lock_init(&conf->device_lock);
  416. INIT_LIST_HEAD(&conf->retry_list);
  417. if (!conf->working_disks) {
  418. printk(KERN_ERR "multipath: no operational IO paths for %s\n",
  419. mdname(mddev));
  420. goto out_free_conf;
  421. }
  422. mddev->degraded = conf->raid_disks - conf->working_disks;
  423. conf->pool = mempool_create_kzalloc_pool(NR_RESERVED_BUFS,
  424. sizeof(struct multipath_bh));
  425. if (conf->pool == NULL) {
  426. printk(KERN_ERR
  427. "multipath: couldn't allocate memory for %s\n",
  428. mdname(mddev));
  429. goto out_free_conf;
  430. }
  431. {
  432. mddev->thread = md_register_thread(multipathd, mddev, "%s_multipath");
  433. if (!mddev->thread) {
  434. printk(KERN_ERR "multipath: couldn't allocate thread"
  435. " for %s\n", mdname(mddev));
  436. goto out_free_conf;
  437. }
  438. }
  439. printk(KERN_INFO
  440. "multipath: array %s active with %d out of %d IO paths\n",
  441. mdname(mddev), conf->working_disks, mddev->raid_disks);
  442. /*
  443. * Ok, everything is just fine now
  444. */
  445. md_set_array_sectors(mddev, multipath_size(mddev, 0, 0));
  446. mddev->queue->unplug_fn = multipath_unplug;
  447. mddev->queue->backing_dev_info.congested_fn = multipath_congested;
  448. mddev->queue->backing_dev_info.congested_data = mddev;
  449. md_integrity_register(mddev);
  450. return 0;
  451. out_free_conf:
  452. if (conf->pool)
  453. mempool_destroy(conf->pool);
  454. kfree(conf->multipaths);
  455. kfree(conf);
  456. mddev->private = NULL;
  457. out:
  458. return -EIO;
  459. }
  460. static int multipath_stop (mddev_t *mddev)
  461. {
  462. multipath_conf_t *conf = mddev->private;
  463. md_unregister_thread(mddev->thread);
  464. mddev->thread = NULL;
  465. blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
  466. mempool_destroy(conf->pool);
  467. kfree(conf->multipaths);
  468. kfree(conf);
  469. mddev->private = NULL;
  470. return 0;
  471. }
  472. static struct mdk_personality multipath_personality =
  473. {
  474. .name = "multipath",
  475. .level = LEVEL_MULTIPATH,
  476. .owner = THIS_MODULE,
  477. .make_request = multipath_make_request,
  478. .run = multipath_run,
  479. .stop = multipath_stop,
  480. .status = multipath_status,
  481. .error_handler = multipath_error,
  482. .hot_add_disk = multipath_add_disk,
  483. .hot_remove_disk= multipath_remove_disk,
  484. .size = multipath_size,
  485. };
  486. static int __init multipath_init (void)
  487. {
  488. return register_md_personality (&multipath_personality);
  489. }
  490. static void __exit multipath_exit (void)
  491. {
  492. unregister_md_personality (&multipath_personality);
  493. }
  494. module_init(multipath_init);
  495. module_exit(multipath_exit);
  496. MODULE_LICENSE("GPL");
  497. MODULE_ALIAS("md-personality-7"); /* MULTIPATH */
  498. MODULE_ALIAS("md-multipath");
  499. MODULE_ALIAS("md-level--4");