2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* multipath.c : Multiple Devices driver for Linux
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999, 2000, 2001 Ingo Molnar, Red Hat
|
|
|
|
*
|
|
|
|
* Copyright (C) 1996, 1997, 1998 Ingo Molnar, Miguel de Icaza, Gadi Oxman
|
|
|
|
*
|
|
|
|
* MULTIPATH management functions.
|
|
|
|
*
|
|
|
|
* derived from raid1.c.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2, or (at your option)
|
|
|
|
* any later version.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* (for example /usr/src/linux/COPYING); if not, write to the Free
|
|
|
|
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
*/
|
|
|
|
|
2009-03-30 21:33:13 -06:00
|
|
|
#include <linux/blkdev.h>
|
2011-07-03 11:58:33 -06:00
|
|
|
#include <linux/module.h>
|
2009-03-30 21:33:13 -06:00
|
|
|
#include <linux/raid/md_u.h>
|
|
|
|
#include <linux/seq_file.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2009-03-30 21:33:13 -06:00
|
|
|
#include "md.h"
|
2017-10-10 15:02:41 -06:00
|
|
|
#include "md-multipath.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#define MAX_WORK_PER_DISK 128
|
|
|
|
|
|
|
|
#define NR_RESERVED_BUFS 32
|
|
|
|
|
2011-10-10 23:48:57 -06:00
|
|
|
static int multipath_map (struct mpconf *conf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i, disks = conf->raid_disks;
|
|
|
|
|
|
|
|
/*
|
2014-09-29 22:23:59 -06:00
|
|
|
* Later we do read balancing on the read side
|
2005-04-16 16:20:36 -06:00
|
|
|
* now we use the first available disk.
|
|
|
|
*/
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
for (i = 0; i < disks; i++) {
|
2011-10-10 23:45:26 -06:00
|
|
|
struct md_rdev *rdev = rcu_dereference(conf->multipaths[i].rdev);
|
2016-06-02 00:19:53 -06:00
|
|
|
if (rdev && test_bit(In_sync, &rdev->flags) &&
|
|
|
|
!test_bit(Faulty, &rdev->flags)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
atomic_inc(&rdev->nr_pending);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_crit_ratelimited("multipath_map(): no more operational IO paths?\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return (-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void multipath_reschedule_retry (struct multipath_bh *mp_bh)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
2011-10-10 23:47:53 -06:00
|
|
|
struct mddev *mddev = mp_bh->mddev;
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mddev->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
spin_lock_irqsave(&conf->device_lock, flags);
|
|
|
|
list_add(&mp_bh->retry_list, &conf->retry_list);
|
|
|
|
spin_unlock_irqrestore(&conf->device_lock, flags);
|
|
|
|
md_wakeup_thread(mddev->thread);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* multipath_end_bh_io() is called when we have finished servicing a multipathed
|
|
|
|
* operation and are ready to return a success/failure code to the buffer
|
|
|
|
* cache layer.
|
|
|
|
*/
|
2017-06-03 01:38:06 -06:00
|
|
|
static void multipath_end_bh_io(struct multipath_bh *mp_bh, blk_status_t status)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct bio *bio = mp_bh->master_bio;
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mp_bh->mddev->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-06-03 01:38:06 -06:00
|
|
|
bio->bi_status = status;
|
2015-07-20 07:29:37 -06:00
|
|
|
bio_endio(bio);
|
2005-04-16 16:20:36 -06:00
|
|
|
mempool_free(mp_bh, conf->pool);
|
|
|
|
}
|
|
|
|
|
2015-07-20 07:29:37 -06:00
|
|
|
static void multipath_end_request(struct bio *bio)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-03-07 22:02:40 -07:00
|
|
|
struct multipath_bh *mp_bh = bio->bi_private;
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mp_bh->mddev->private;
|
2011-10-10 23:45:26 -06:00
|
|
|
struct md_rdev *rdev = conf->multipaths[mp_bh->path].rdev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-06-03 01:38:06 -06:00
|
|
|
if (!bio->bi_status)
|
2005-04-16 16:20:36 -06:00
|
|
|
multipath_end_bh_io(mp_bh, 0);
|
2016-08-05 15:35:16 -06:00
|
|
|
else if (!(bio->bi_opf & REQ_RAHEAD)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* oops, IO error:
|
|
|
|
*/
|
|
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
md_error (mp_bh->mddev, rdev);
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_info("multipath: %s: rescheduling sector %llu\n",
|
|
|
|
bdevname(rdev->bdev,b),
|
|
|
|
(unsigned long long)bio->bi_iter.bi_sector);
|
2005-04-16 16:20:36 -06:00
|
|
|
multipath_reschedule_retry(mp_bh);
|
|
|
|
} else
|
2017-06-03 01:38:06 -06:00
|
|
|
multipath_end_bh_io(mp_bh, bio->bi_status);
|
2005-04-16 16:20:36 -06:00
|
|
|
rdev_dec_pending(rdev, conf->mddev);
|
|
|
|
}
|
|
|
|
|
2017-06-05 00:49:39 -06:00
|
|
|
static bool multipath_make_request(struct mddev *mddev, struct bio * bio)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mddev->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct multipath_bh * mp_bh;
|
|
|
|
struct multipath_info *multipath;
|
|
|
|
|
2016-08-05 15:35:16 -06:00
|
|
|
if (unlikely(bio->bi_opf & REQ_PREFLUSH)) {
|
2010-09-03 03:56:18 -06:00
|
|
|
md_flush_request(mddev, bio);
|
2017-06-05 00:49:39 -06:00
|
|
|
return true;
|
2005-09-09 17:23:41 -06:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
mp_bh = mempool_alloc(conf->pool, GFP_NOIO);
|
|
|
|
|
|
|
|
mp_bh->master_bio = bio;
|
|
|
|
mp_bh->mddev = mddev;
|
|
|
|
|
|
|
|
mp_bh->path = multipath_map(conf);
|
|
|
|
if (mp_bh->path < 0) {
|
2015-07-20 07:29:37 -06:00
|
|
|
bio_io_error(bio);
|
2005-04-16 16:20:36 -06:00
|
|
|
mempool_free(mp_bh, conf->pool);
|
2017-06-05 00:49:39 -06:00
|
|
|
return true;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
multipath = conf->multipaths + mp_bh->path;
|
|
|
|
|
2016-11-22 08:57:21 -07:00
|
|
|
bio_init(&mp_bh->bio, NULL, 0);
|
2016-03-11 18:29:40 -07:00
|
|
|
__bio_clone_fast(&mp_bh->bio, bio);
|
|
|
|
|
2013-10-11 16:44:27 -06:00
|
|
|
mp_bh->bio.bi_iter.bi_sector += multipath->rdev->data_offset;
|
2017-08-23 11:10:32 -06:00
|
|
|
bio_set_dev(&mp_bh->bio, multipath->rdev->bdev);
|
2016-08-05 15:35:16 -06:00
|
|
|
mp_bh->bio.bi_opf |= REQ_FAILFAST_TRANSPORT;
|
2005-04-16 16:20:36 -06:00
|
|
|
mp_bh->bio.bi_end_io = multipath_end_request;
|
|
|
|
mp_bh->bio.bi_private = mp_bh;
|
2017-02-13 17:21:49 -07:00
|
|
|
mddev_check_writesame(mddev, &mp_bh->bio);
|
2017-04-05 11:21:03 -06:00
|
|
|
mddev_check_write_zeroes(mddev, &mp_bh->bio);
|
2005-04-16 16:20:36 -06:00
|
|
|
generic_make_request(&mp_bh->bio);
|
2017-06-05 00:49:39 -06:00
|
|
|
return true;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2016-06-02 00:19:52 -06:00
|
|
|
static void multipath_status(struct seq_file *seq, struct mddev *mddev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mddev->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
int i;
|
2014-09-29 22:23:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf (seq, " [%d/%d] [", conf->raid_disks,
|
2011-05-10 22:38:02 -06:00
|
|
|
conf->raid_disks - mddev->degraded);
|
2016-06-02 00:19:52 -06:00
|
|
|
rcu_read_lock();
|
|
|
|
for (i = 0; i < conf->raid_disks; i++) {
|
|
|
|
struct md_rdev *rdev = rcu_dereference(conf->multipaths[i].rdev);
|
|
|
|
seq_printf (seq, "%s", rdev && test_bit(In_sync, &rdev->flags) ? "U" : "_");
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
2018-01-13 01:49:03 -07:00
|
|
|
seq_putc(seq, ']');
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2014-12-14 18:56:56 -07:00
|
|
|
static int multipath_congested(struct mddev *mddev, int bits)
|
2006-10-03 02:15:54 -06:00
|
|
|
{
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mddev->private;
|
2006-10-03 02:15:54 -06:00
|
|
|
int i, ret = 0;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
for (i = 0; i < mddev->raid_disks ; i++) {
|
2011-10-10 23:45:26 -06:00
|
|
|
struct md_rdev *rdev = rcu_dereference(conf->multipaths[i].rdev);
|
2006-10-03 02:15:54 -06:00
|
|
|
if (rdev && !test_bit(Faulty, &rdev->flags)) {
|
2007-07-24 01:28:11 -06:00
|
|
|
struct request_queue *q = bdev_get_queue(rdev->bdev);
|
2006-10-03 02:15:54 -06:00
|
|
|
|
2017-02-02 07:56:50 -07:00
|
|
|
ret |= bdi_congested(q->backing_dev_info, bits);
|
2006-10-03 02:15:54 -06:00
|
|
|
/* Just like multipath_map, we just check the
|
|
|
|
* first available device
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Careful, this can execute in IRQ contexts as well!
|
|
|
|
*/
|
2011-10-10 23:47:53 -06:00
|
|
|
static void multipath_error (struct mddev *mddev, struct md_rdev *rdev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mddev->private;
|
2011-05-10 22:38:44 -06:00
|
|
|
char b[BDEVNAME_SIZE];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-05-10 22:38:02 -06:00
|
|
|
if (conf->raid_disks - mddev->degraded <= 1) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Uh oh, we can do nothing if this is our last path, but
|
|
|
|
* first check if this is a queued request for a device
|
|
|
|
* which has just failed.
|
|
|
|
*/
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_warn("multipath: only one IO path left and IO error.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
/* leave it active... it's all we have */
|
2011-05-10 22:38:44 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Mark disk as unusable
|
|
|
|
*/
|
|
|
|
if (test_and_clear_bit(In_sync, &rdev->flags)) {
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&conf->device_lock, flags);
|
|
|
|
mddev->degraded++;
|
|
|
|
spin_unlock_irqrestore(&conf->device_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-05-10 22:38:44 -06:00
|
|
|
set_bit(Faulty, &rdev->flags);
|
2016-12-08 16:48:19 -07:00
|
|
|
set_bit(MD_SB_CHANGE_DEVS, &mddev->sb_flags);
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_err("multipath: IO failure on %s, disabling IO path.\n"
|
|
|
|
"multipath: Operation continuing on %d IO paths.\n",
|
2011-05-10 22:38:44 -06:00
|
|
|
bdevname(rdev->bdev, b),
|
|
|
|
conf->raid_disks - mddev->degraded);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-10-10 23:48:57 -06:00
|
|
|
static void print_multipath_conf (struct mpconf *conf)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct multipath_info *tmp;
|
|
|
|
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_debug("MULTIPATH conf printout:\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!conf) {
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_debug("(conf==NULL)\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_debug(" --- wd:%d rd:%d\n", conf->raid_disks - conf->mddev->degraded,
|
|
|
|
conf->raid_disks);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for (i = 0; i < conf->raid_disks; i++) {
|
|
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
tmp = conf->multipaths + i;
|
|
|
|
if (tmp->rdev)
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_debug(" disk%d, o:%d, dev:%s\n",
|
|
|
|
i,!test_bit(Faulty, &tmp->rdev->flags),
|
|
|
|
bdevname(tmp->rdev->bdev,b));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-10 23:47:53 -06:00
|
|
|
static int multipath_add_disk(struct mddev *mddev, struct md_rdev *rdev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mddev->private;
|
2008-06-27 16:31:33 -06:00
|
|
|
int err = -EEXIST;
|
2005-04-16 16:20:36 -06:00
|
|
|
int path;
|
|
|
|
struct multipath_info *p;
|
2008-06-27 16:31:31 -06:00
|
|
|
int first = 0;
|
|
|
|
int last = mddev->raid_disks - 1;
|
|
|
|
|
|
|
|
if (rdev->raid_disk >= 0)
|
|
|
|
first = last = rdev->raid_disk;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
print_multipath_conf(conf);
|
|
|
|
|
2008-06-27 16:31:31 -06:00
|
|
|
for (path = first; path <= last; path++)
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((p=conf->multipaths+path)->rdev == NULL) {
|
2009-06-30 19:13:45 -06:00
|
|
|
disk_stack_limits(mddev->gendisk, rdev->bdev,
|
|
|
|
rdev->data_offset << 9);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-01-13 17:00:07 -07:00
|
|
|
err = md_integrity_add_rdev(rdev, mddev);
|
|
|
|
if (err)
|
|
|
|
break;
|
2011-05-10 22:38:44 -06:00
|
|
|
spin_lock_irq(&conf->device_lock);
|
2006-10-28 11:38:31 -06:00
|
|
|
mddev->degraded--;
|
2005-04-16 16:20:36 -06:00
|
|
|
rdev->raid_disk = path;
|
2005-11-08 22:39:31 -07:00
|
|
|
set_bit(In_sync, &rdev->flags);
|
2011-05-10 22:38:44 -06:00
|
|
|
spin_unlock_irq(&conf->device_lock);
|
2005-11-08 22:39:27 -07:00
|
|
|
rcu_assign_pointer(p->rdev, rdev);
|
2008-06-27 16:31:33 -06:00
|
|
|
err = 0;
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
print_multipath_conf(conf);
|
2008-06-27 16:31:33 -06:00
|
|
|
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-12-22 16:17:51 -07:00
|
|
|
static int multipath_remove_disk(struct mddev *mddev, struct md_rdev *rdev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mddev->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err = 0;
|
2011-12-22 16:17:51 -07:00
|
|
|
int number = rdev->raid_disk;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct multipath_info *p = conf->multipaths + number;
|
|
|
|
|
|
|
|
print_multipath_conf(conf);
|
|
|
|
|
2011-12-22 16:17:51 -07:00
|
|
|
if (rdev == p->rdev) {
|
2005-11-08 22:39:31 -07:00
|
|
|
if (test_bit(In_sync, &rdev->flags) ||
|
2005-04-16 16:20:36 -06:00
|
|
|
atomic_read(&rdev->nr_pending)) {
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_warn("hot-remove-disk, slot %d is identified but is still operational!\n", number);
|
2005-04-16 16:20:36 -06:00
|
|
|
err = -EBUSY;
|
|
|
|
goto abort;
|
|
|
|
}
|
|
|
|
p->rdev = NULL;
|
2016-06-02 00:19:53 -06:00
|
|
|
if (!test_bit(RemoveSynchronized, &rdev->flags)) {
|
|
|
|
synchronize_rcu();
|
|
|
|
if (atomic_read(&rdev->nr_pending)) {
|
|
|
|
/* lost the race, try later */
|
|
|
|
err = -EBUSY;
|
|
|
|
p->rdev = rdev;
|
|
|
|
goto abort;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2011-03-17 04:11:05 -06:00
|
|
|
err = md_integrity_register(mddev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
abort:
|
|
|
|
|
|
|
|
print_multipath_conf(conf);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a kernel thread which:
|
|
|
|
*
|
|
|
|
* 1. Retries failed read operations on working multipaths.
|
|
|
|
* 2. Updates the raid superblock when problems encounter.
|
|
|
|
* 3. Performs writes following reads for array syncronising.
|
|
|
|
*/
|
|
|
|
|
2012-10-10 20:34:00 -06:00
|
|
|
static void multipathd(struct md_thread *thread)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2012-10-10 20:34:00 -06:00
|
|
|
struct mddev *mddev = thread->mddev;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct multipath_bh *mp_bh;
|
|
|
|
struct bio *bio;
|
|
|
|
unsigned long flags;
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf = mddev->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct list_head *head = &conf->retry_list;
|
|
|
|
|
|
|
|
md_check_recovery(mddev);
|
|
|
|
for (;;) {
|
|
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
spin_lock_irqsave(&conf->device_lock, flags);
|
|
|
|
if (list_empty(head))
|
|
|
|
break;
|
|
|
|
mp_bh = list_entry(head->prev, struct multipath_bh, retry_list);
|
|
|
|
list_del(head->prev);
|
|
|
|
spin_unlock_irqrestore(&conf->device_lock, flags);
|
|
|
|
|
|
|
|
bio = &mp_bh->bio;
|
2013-10-11 16:44:27 -06:00
|
|
|
bio->bi_iter.bi_sector = mp_bh->master_bio->bi_iter.bi_sector;
|
2014-09-29 22:23:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if ((mp_bh->path = multipath_map (conf))<0) {
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_err("multipath: %s: unrecoverable IO read error for block %llu\n",
|
2017-08-23 11:10:32 -06:00
|
|
|
bio_devname(bio, b),
|
2016-11-01 21:16:49 -06:00
|
|
|
(unsigned long long)bio->bi_iter.bi_sector);
|
2017-06-03 01:38:06 -06:00
|
|
|
multipath_end_bh_io(mp_bh, BLK_STS_IOERR);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_err("multipath: %s: redirecting sector %llu to another IO path\n",
|
2017-08-23 11:10:32 -06:00
|
|
|
bio_devname(bio, b),
|
2016-11-01 21:16:49 -06:00
|
|
|
(unsigned long long)bio->bi_iter.bi_sector);
|
2005-04-16 16:20:36 -06:00
|
|
|
*bio = *(mp_bh->master_bio);
|
2013-10-11 16:44:27 -06:00
|
|
|
bio->bi_iter.bi_sector +=
|
|
|
|
conf->multipaths[mp_bh->path].rdev->data_offset;
|
2017-08-23 11:10:32 -06:00
|
|
|
bio_set_dev(bio, conf->multipaths[mp_bh->path].rdev->bdev);
|
2016-08-05 15:35:16 -06:00
|
|
|
bio->bi_opf |= REQ_FAILFAST_TRANSPORT;
|
2005-04-16 16:20:36 -06:00
|
|
|
bio->bi_end_io = multipath_end_request;
|
|
|
|
bio->bi_private = mp_bh;
|
|
|
|
generic_make_request(bio);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&conf->device_lock, flags);
|
|
|
|
}
|
|
|
|
|
2011-10-10 23:47:53 -06:00
|
|
|
static sector_t multipath_size(struct mddev *mddev, sector_t sectors, int raid_disks)
|
2009-03-17 19:10:40 -06:00
|
|
|
{
|
|
|
|
WARN_ONCE(sectors || raid_disks,
|
|
|
|
"%s does not support generic reshape\n", __func__);
|
|
|
|
|
|
|
|
return mddev->dev_sectors;
|
|
|
|
}
|
|
|
|
|
2011-10-10 23:47:53 -06:00
|
|
|
static int multipath_run (struct mddev *mddev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2011-10-10 23:48:57 -06:00
|
|
|
struct mpconf *conf;
|
2005-04-16 16:20:36 -06:00
|
|
|
int disk_idx;
|
|
|
|
struct multipath_info *disk;
|
2011-10-10 23:45:26 -06:00
|
|
|
struct md_rdev *rdev;
|
2011-05-10 22:38:02 -06:00
|
|
|
int working_disks;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-17 16:49:23 -06:00
|
|
|
if (md_check_no_bitmap(mddev))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (mddev->level != LEVEL_MULTIPATH) {
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_warn("multipath: %s: raid level not set to multipath IO (%d)\n",
|
|
|
|
mdname(mddev), mddev->level);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* copy the already verified devices into our private MULTIPATH
|
|
|
|
* bookkeeping area. [whatever we allocate in multipath_run(),
|
2014-12-14 18:56:58 -07:00
|
|
|
* should be freed in multipath_free()]
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2011-10-10 23:48:57 -06:00
|
|
|
conf = kzalloc(sizeof(struct mpconf), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
mddev->private = conf;
|
2016-11-01 21:16:49 -06:00
|
|
|
if (!conf)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
|
2006-01-06 01:20:32 -07:00
|
|
|
conf->multipaths = kzalloc(sizeof(struct multipath_info)*mddev->raid_disks,
|
2005-04-16 16:20:36 -06:00
|
|
|
GFP_KERNEL);
|
2016-11-01 21:16:49 -06:00
|
|
|
if (!conf->multipaths)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_free_conf;
|
|
|
|
|
2011-05-10 22:38:02 -06:00
|
|
|
working_disks = 0;
|
2012-03-18 19:46:39 -06:00
|
|
|
rdev_for_each(rdev, mddev) {
|
2005-04-16 16:20:36 -06:00
|
|
|
disk_idx = rdev->raid_disk;
|
|
|
|
if (disk_idx < 0 ||
|
|
|
|
disk_idx >= mddev->raid_disks)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
disk = conf->multipaths + disk_idx;
|
|
|
|
disk->rdev = rdev;
|
2009-06-30 19:13:45 -06:00
|
|
|
disk_stack_limits(mddev->gendisk, rdev->bdev,
|
|
|
|
rdev->data_offset << 9);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-08 22:39:31 -07:00
|
|
|
if (!test_bit(Faulty, &rdev->flags))
|
2011-05-10 22:38:02 -06:00
|
|
|
working_disks++;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
conf->raid_disks = mddev->raid_disks;
|
|
|
|
conf->mddev = mddev;
|
|
|
|
spin_lock_init(&conf->device_lock);
|
|
|
|
INIT_LIST_HEAD(&conf->retry_list);
|
|
|
|
|
2011-05-10 22:38:02 -06:00
|
|
|
if (!working_disks) {
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_warn("multipath: no operational IO paths for %s\n",
|
2005-04-16 16:20:36 -06:00
|
|
|
mdname(mddev));
|
|
|
|
goto out_free_conf;
|
|
|
|
}
|
2011-05-10 22:38:02 -06:00
|
|
|
mddev->degraded = conf->raid_disks - working_disks;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-21 18:02:55 -06:00
|
|
|
conf->pool = mempool_create_kmalloc_pool(NR_RESERVED_BUFS,
|
2006-03-26 02:37:48 -07:00
|
|
|
sizeof(struct multipath_bh));
|
2016-11-01 21:16:49 -06:00
|
|
|
if (conf->pool == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_free_conf;
|
|
|
|
|
2016-11-01 21:16:49 -06:00
|
|
|
mddev->thread = md_register_thread(multipathd, mddev,
|
|
|
|
"multipath");
|
|
|
|
if (!mddev->thread)
|
|
|
|
goto out_free_conf;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-11-01 21:16:49 -06:00
|
|
|
pr_info("multipath: array %s active with %d out of %d IO paths\n",
|
2011-05-10 22:38:02 -06:00
|
|
|
mdname(mddev), conf->raid_disks - mddev->degraded,
|
2016-11-01 21:16:49 -06:00
|
|
|
mddev->raid_disks);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Ok, everything is just fine now
|
|
|
|
*/
|
2009-03-30 21:59:03 -06:00
|
|
|
md_set_array_sectors(mddev, multipath_size(mddev, 0, 0));
|
2005-05-16 22:53:16 -06:00
|
|
|
|
2011-03-17 04:11:05 -06:00
|
|
|
if (md_integrity_register(mddev))
|
|
|
|
goto out_free_conf;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
out_free_conf:
|
2015-09-13 06:15:10 -06:00
|
|
|
mempool_destroy(conf->pool);
|
2005-06-21 18:17:30 -06:00
|
|
|
kfree(conf->multipaths);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(conf);
|
|
|
|
mddev->private = NULL;
|
|
|
|
out:
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2014-12-14 18:56:58 -07:00
|
|
|
static void multipath_free(struct mddev *mddev, void *priv)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2014-12-14 18:56:58 -07:00
|
|
|
struct mpconf *conf = priv;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mempool_destroy(conf->pool);
|
|
|
|
kfree(conf->multipaths);
|
|
|
|
kfree(conf);
|
|
|
|
}
|
|
|
|
|
2011-10-10 23:49:58 -06:00
|
|
|
static struct md_personality multipath_personality =
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
.name = "multipath",
|
2006-01-06 01:20:36 -07:00
|
|
|
.level = LEVEL_MULTIPATH,
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.make_request = multipath_make_request,
|
|
|
|
.run = multipath_run,
|
2014-12-14 18:56:58 -07:00
|
|
|
.free = multipath_free,
|
2005-04-16 16:20:36 -06:00
|
|
|
.status = multipath_status,
|
|
|
|
.error_handler = multipath_error,
|
|
|
|
.hot_add_disk = multipath_add_disk,
|
|
|
|
.hot_remove_disk= multipath_remove_disk,
|
2009-03-17 19:10:40 -06:00
|
|
|
.size = multipath_size,
|
2014-12-14 18:56:56 -07:00
|
|
|
.congested = multipath_congested,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static int __init multipath_init (void)
|
|
|
|
{
|
2006-01-06 01:20:36 -07:00
|
|
|
return register_md_personality (&multipath_personality);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __exit multipath_exit (void)
|
|
|
|
{
|
2006-01-06 01:20:36 -07:00
|
|
|
unregister_md_personality (&multipath_personality);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(multipath_init);
|
|
|
|
module_exit(multipath_exit);
|
|
|
|
MODULE_LICENSE("GPL");
|
2009-12-13 18:49:58 -07:00
|
|
|
MODULE_DESCRIPTION("simple multi-path personality for MD");
|
2005-04-16 16:20:36 -06:00
|
|
|
MODULE_ALIAS("md-personality-7"); /* MULTIPATH */
|
2006-01-06 01:20:51 -07:00
|
|
|
MODULE_ALIAS("md-multipath");
|
2006-01-06 01:20:36 -07:00
|
|
|
MODULE_ALIAS("md-level--4");
|