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"
|
2009-03-30 21:27:03 -06:00
|
|
|
#include "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;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Later we do read balancing on the read side
|
|
|
|
* 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);
|
2005-11-08 22:39:31 -07:00
|
|
|
if (rdev && test_bit(In_sync, &rdev->flags)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
atomic_inc(&rdev->nr_pending);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
printk(KERN_ERR "multipath_map(): no more operational IO paths?\n");
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
static void multipath_end_bh_io (struct multipath_bh *mp_bh, int err)
|
|
|
|
{
|
|
|
|
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
|
|
|
|
2007-09-27 04:47:43 -06:00
|
|
|
bio_endio(bio, err);
|
2005-04-16 16:20:36 -06:00
|
|
|
mempool_free(mp_bh, conf->pool);
|
|
|
|
}
|
|
|
|
|
2007-09-27 04:47:43 -06:00
|
|
|
static void multipath_end_request(struct bio *bio, int error)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
|
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
|
|
|
|
|
|
|
if (uptodate)
|
|
|
|
multipath_end_bh_io(mp_bh, 0);
|
2010-08-07 10:20:39 -06:00
|
|
|
else if (!(bio->bi_rw & REQ_RAHEAD)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* oops, IO error:
|
|
|
|
*/
|
|
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
md_error (mp_bh->mddev, rdev);
|
|
|
|
printk(KERN_ERR "multipath: %s: rescheduling sector %llu\n",
|
|
|
|
bdevname(rdev->bdev,b),
|
|
|
|
(unsigned long long)bio->bi_sector);
|
|
|
|
multipath_reschedule_retry(mp_bh);
|
|
|
|
} else
|
|
|
|
multipath_end_bh_io(mp_bh, error);
|
|
|
|
rdev_dec_pending(rdev, conf->mddev);
|
|
|
|
}
|
|
|
|
|
2011-11-04 18:06:58 -06:00
|
|
|
static void 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;
|
|
|
|
|
2010-09-03 03:56:18 -06:00
|
|
|
if (unlikely(bio->bi_rw & REQ_FLUSH)) {
|
|
|
|
md_flush_request(mddev, bio);
|
2011-09-12 04:12:01 -06:00
|
|
|
return;
|
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) {
|
2007-09-27 04:47:43 -06:00
|
|
|
bio_endio(bio, -EIO);
|
2005-04-16 16:20:36 -06:00
|
|
|
mempool_free(mp_bh, conf->pool);
|
2011-09-12 04:12:01 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
multipath = conf->multipaths + mp_bh->path;
|
|
|
|
|
|
|
|
mp_bh->bio = *bio;
|
|
|
|
mp_bh->bio.bi_sector += multipath->rdev->data_offset;
|
|
|
|
mp_bh->bio.bi_bdev = multipath->rdev->bdev;
|
2010-08-07 10:20:39 -06:00
|
|
|
mp_bh->bio.bi_rw |= 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;
|
|
|
|
generic_make_request(&mp_bh->bio);
|
2011-09-12 04:12:01 -06:00
|
|
|
return;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2011-10-10 23:47:53 -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;
|
|
|
|
|
|
|
|
seq_printf (seq, " [%d/%d] [", conf->raid_disks,
|
2011-05-10 22:38:02 -06:00
|
|
|
conf->raid_disks - mddev->degraded);
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = 0; i < conf->raid_disks; i++)
|
|
|
|
seq_printf (seq, "%s",
|
|
|
|
conf->multipaths[i].rdev &&
|
2005-11-08 22:39:31 -07:00
|
|
|
test_bit(In_sync, &conf->multipaths[i].rdev->flags) ? "U" : "_");
|
2005-04-16 16:20:36 -06:00
|
|
|
seq_printf (seq, "]");
|
|
|
|
}
|
|
|
|
|
2006-10-03 02:15:54 -06:00
|
|
|
static int multipath_congested(void *data, int bits)
|
|
|
|
{
|
2011-10-10 23:47:53 -06:00
|
|
|
struct mddev *mddev = data;
|
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;
|
|
|
|
|
2009-09-23 02:10:29 -06:00
|
|
|
if (mddev_congested(mddev, bits))
|
|
|
|
return 1;
|
|
|
|
|
2006-10-03 02:15:54 -06:00
|
|
|
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
|
|
|
|
|
|
|
ret |= bdi_congested(&q->backing_dev_info, bits);
|
|
|
|
/* 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.
|
|
|
|
*/
|
|
|
|
printk(KERN_ALERT
|
2011-05-10 22:38:44 -06:00
|
|
|
"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);
|
|
|
|
set_bit(MD_CHANGE_DEVS, &mddev->flags);
|
|
|
|
printk(KERN_ALERT "multipath: IO failure on %s,"
|
|
|
|
" disabling IO path.\n"
|
|
|
|
"multipath: Operation continuing"
|
|
|
|
" on %d IO paths.\n",
|
|
|
|
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;
|
|
|
|
|
|
|
|
printk("MULTIPATH conf printout:\n");
|
|
|
|
if (!conf) {
|
|
|
|
printk("(conf==NULL)\n");
|
|
|
|
return;
|
|
|
|
}
|
2011-05-10 22:38:02 -06:00
|
|
|
printk(" --- wd:%d rd:%d\n", conf->raid_disks - conf->mddev->degraded,
|
2005-04-16 16:20:36 -06:00
|
|
|
conf->raid_disks);
|
|
|
|
|
|
|
|
for (i = 0; i < conf->raid_disks; i++) {
|
|
|
|
char b[BDEVNAME_SIZE];
|
|
|
|
tmp = conf->multipaths + i;
|
|
|
|
if (tmp->rdev)
|
|
|
|
printk(" disk%d, o:%d, dev:%s\n",
|
2005-11-08 22:39:31 -07:00
|
|
|
i,!test_bit(Faulty, &tmp->rdev->flags),
|
2005-04-16 16:20:36 -06:00
|
|
|
bdevname(tmp->rdev->bdev,b));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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;
|
2006-01-09 21:54:44 -07:00
|
|
|
struct request_queue *q;
|
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) {
|
2006-01-09 21:54:44 -07:00
|
|
|
q = rdev->bdev->bd_disk->queue;
|
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
|
|
|
|
|
|
|
/* as we don't honour merge_bvec_fn, we must never risk
|
2010-03-07 22:44:38 -07:00
|
|
|
* violating it, so limit ->max_segments to one, lying
|
|
|
|
* within a single page.
|
2005-04-16 16:20:36 -06:00
|
|
|
* (Note: it is very unlikely that a device with
|
|
|
|
* merge_bvec_fn will be involved in multipath.)
|
|
|
|
*/
|
2010-03-07 22:44:38 -07:00
|
|
|
if (q->merge_bvec_fn) {
|
|
|
|
blk_queue_max_segments(mddev->queue, 1);
|
|
|
|
blk_queue_segment_boundary(mddev->queue,
|
|
|
|
PAGE_CACHE_SIZE - 1);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
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;
|
2009-08-02 18:59:47 -06:00
|
|
|
md_integrity_add_rdev(rdev, mddev);
|
2008-06-27 16:31:33 -06:00
|
|
|
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)) {
|
md: restart recovery cleanly after device failure.
When we get any IO error during a recovery (rebuilding a spare), we abort
the recovery and restart it.
For RAID6 (and multi-drive RAID1) it may not be best to restart at the
beginning: when multiple failures can be tolerated, the recovery may be
able to continue and re-doing all that has already been done doesn't make
sense.
We already have the infrastructure to record where a recovery is up to
and restart from there, but it is not being used properly.
This is because:
- We sometimes abort with MD_RECOVERY_ERR rather than just MD_RECOVERY_INTR,
which causes the recovery not be be checkpointed.
- We remove spares and then re-added them which loses important state
information.
The distinction between MD_RECOVERY_ERR and MD_RECOVERY_INTR really isn't
needed. If there is an error, the relevant drive will be marked as
Faulty, and that is enough to ensure correct handling of the error. So we
first remove MD_RECOVERY_ERR, changing some of the uses of it to
MD_RECOVERY_INTR.
Then we cause the attempt to remove a non-faulty device from an array to
fail (unless recovery is impossible as the array is too degraded). Then
when remove_and_add_spares attempts to remove the devices on which
recovery can continue, it will fail, they will remain in place, and
recovery will continue on them as desired.
Issue: If we are halfway through rebuilding a spare and another drive
fails, and a new spare is immediately available, do we want to:
1/ complete the current rebuild, then go back and rebuild the new spare or
2/ restart the rebuild from the start and rebuild both devices in
parallel.
Both options can be argued for. The code currently takes option 2 as
a/ this requires least code change
b/ this results in a minimally-degraded array in minimal time.
Cc: "Eivind Sarto" <ivan@kasenna.com>
Signed-off-by: Neil Brown <neilb@suse.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-05-23 14:04:39 -06:00
|
|
|
printk(KERN_ERR "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;
|
2005-05-01 09:59:04 -06:00
|
|
|
synchronize_rcu();
|
2005-04-16 16:20:36 -06:00
|
|
|
if (atomic_read(&rdev->nr_pending)) {
|
|
|
|
/* lost the race, try later */
|
|
|
|
err = -EBUSY;
|
|
|
|
p->rdev = rdev;
|
2009-08-02 18:59:47 -06:00
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2011-10-10 23:47:53 -06:00
|
|
|
static void multipathd (struct mddev *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;
|
|
|
|
bio->bi_sector = mp_bh->master_bio->bi_sector;
|
|
|
|
|
|
|
|
if ((mp_bh->path = multipath_map (conf))<0) {
|
|
|
|
printk(KERN_ALERT "multipath: %s: unrecoverable IO read"
|
|
|
|
" error for block %llu\n",
|
|
|
|
bdevname(bio->bi_bdev,b),
|
|
|
|
(unsigned long long)bio->bi_sector);
|
|
|
|
multipath_end_bh_io(mp_bh, -EIO);
|
|
|
|
} else {
|
|
|
|
printk(KERN_ERR "multipath: %s: redirecting sector %llu"
|
|
|
|
" to another IO path\n",
|
|
|
|
bdevname(bio->bi_bdev,b),
|
|
|
|
(unsigned long long)bio->bi_sector);
|
|
|
|
*bio = *(mp_bh->master_bio);
|
|
|
|
bio->bi_sector += conf->multipaths[mp_bh->path].rdev->data_offset;
|
|
|
|
bio->bi_bdev = conf->multipaths[mp_bh->path].rdev->bdev;
|
2010-08-07 10:20:39 -06:00
|
|
|
bio->bi_rw |= 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) {
|
|
|
|
printk("multipath: %s: raid level not set to multipath IO (%d)\n",
|
|
|
|
mdname(mddev), mddev->level);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* copy the already verified devices into our private MULTIPATH
|
|
|
|
* bookkeeping area. [whatever we allocate in multipath_run(),
|
|
|
|
* should be freed in multipath_stop()]
|
|
|
|
*/
|
|
|
|
|
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;
|
|
|
|
if (!conf) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"multipath: couldn't allocate memory for %s\n",
|
|
|
|
mdname(mddev));
|
|
|
|
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);
|
|
|
|
if (!conf->multipaths) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"multipath: couldn't allocate memory for %s\n",
|
|
|
|
mdname(mddev));
|
|
|
|
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
|
|
|
|
|
|
|
/* as we don't honour merge_bvec_fn, we must never risk
|
|
|
|
* violating it, not that we ever expect a device with
|
|
|
|
* a merge_bvec_fn to be involved in multipath */
|
2010-03-07 22:44:38 -07:00
|
|
|
if (rdev->bdev->bd_disk->queue->merge_bvec_fn) {
|
|
|
|
blk_queue_max_segments(mddev->queue, 1);
|
|
|
|
blk_queue_segment_boundary(mddev->queue,
|
|
|
|
PAGE_CACHE_SIZE - 1);
|
|
|
|
}
|
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) {
|
2005-04-16 16:20:36 -06:00
|
|
|
printk(KERN_ERR "multipath: no operational IO paths for %s\n",
|
|
|
|
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));
|
2005-04-16 16:20:36 -06:00
|
|
|
if (conf->pool == NULL) {
|
|
|
|
printk(KERN_ERR
|
|
|
|
"multipath: couldn't allocate memory for %s\n",
|
|
|
|
mdname(mddev));
|
|
|
|
goto out_free_conf;
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
2009-09-23 02:09:45 -06:00
|
|
|
mddev->thread = md_register_thread(multipathd, mddev, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!mddev->thread) {
|
|
|
|
printk(KERN_ERR "multipath: couldn't allocate thread"
|
|
|
|
" for %s\n", mdname(mddev));
|
|
|
|
goto out_free_conf;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
printk(KERN_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,
|
|
|
|
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
|
|
|
|
2006-10-03 02:15:54 -06:00
|
|
|
mddev->queue->backing_dev_info.congested_fn = multipath_congested;
|
|
|
|
mddev->queue->backing_dev_info.congested_data = mddev;
|
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:
|
|
|
|
if (conf->pool)
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-10 23:47:53 -06:00
|
|
|
static int multipath_stop (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
|
|
|
|
2011-09-20 23:30:20 -06:00
|
|
|
md_unregister_thread(&mddev->thread);
|
2005-04-16 16:20:36 -06:00
|
|
|
blk_sync_queue(mddev->queue); /* the unplug fn references 'conf'*/
|
|
|
|
mempool_destroy(conf->pool);
|
|
|
|
kfree(conf->multipaths);
|
|
|
|
kfree(conf);
|
|
|
|
mddev->private = NULL;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
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,
|
|
|
|
.stop = multipath_stop,
|
|
|
|
.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,
|
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");
|