248 строки
6.2 KiB
C
248 строки
6.2 KiB
C
/*
|
|
* Copyright (C) 2005 Mike Christie, All rights reserved.
|
|
* Copyright (C) 2007 Red Hat, Inc. All rights reserved.
|
|
* Authors: Mike Christie
|
|
* Dave Wysochanski
|
|
*
|
|
* This file is released under the GPL.
|
|
*
|
|
* This module implements the specific path activation code for
|
|
* HP StorageWorks and FSC FibreCat Asymmetric (Active/Passive)
|
|
* storage arrays.
|
|
* These storage arrays have controller-based failover, not
|
|
* LUN-based failover. However, LUN-based failover is the design
|
|
* of dm-multipath. Thus, this module is written for LUN-based failover.
|
|
*/
|
|
#include <linux/blkdev.h>
|
|
#include <linux/list.h>
|
|
#include <linux/types.h>
|
|
#include <scsi/scsi.h>
|
|
#include <scsi/scsi_cmnd.h>
|
|
#include <scsi/scsi_dbg.h>
|
|
|
|
#include "dm.h"
|
|
#include "dm-hw-handler.h"
|
|
|
|
#define DM_MSG_PREFIX "multipath hp-sw"
|
|
#define DM_HP_HWH_NAME "hp-sw"
|
|
#define DM_HP_HWH_VER "1.0.0"
|
|
|
|
struct hp_sw_context {
|
|
unsigned char sense[SCSI_SENSE_BUFFERSIZE];
|
|
};
|
|
|
|
/*
|
|
* hp_sw_error_is_retryable - Is an HP-specific check condition retryable?
|
|
* @req: path activation request
|
|
*
|
|
* Examine error codes of request and determine whether the error is retryable.
|
|
* Some error codes are already retried by scsi-ml (see
|
|
* scsi_decide_disposition), but some HP specific codes are not.
|
|
* The intent of this routine is to supply the logic for the HP specific
|
|
* check conditions.
|
|
*
|
|
* Returns:
|
|
* 1 - command completed with retryable error
|
|
* 0 - command completed with non-retryable error
|
|
*
|
|
* Possible optimizations
|
|
* 1. More hardware-specific error codes
|
|
*/
|
|
static int hp_sw_error_is_retryable(struct request *req)
|
|
{
|
|
/*
|
|
* NOT_READY is known to be retryable
|
|
* For now we just dump out the sense data and call it retryable
|
|
*/
|
|
if (status_byte(req->errors) == CHECK_CONDITION)
|
|
__scsi_print_sense(DM_HP_HWH_NAME, req->sense, req->sense_len);
|
|
|
|
/*
|
|
* At this point we don't have complete information about all the error
|
|
* codes from this hardware, so we are just conservative and retry
|
|
* when in doubt.
|
|
*/
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* hp_sw_end_io - Completion handler for HP path activation.
|
|
* @req: path activation request
|
|
* @error: scsi-ml error
|
|
*
|
|
* Check sense data, free request structure, and notify dm that
|
|
* pg initialization has completed.
|
|
*
|
|
* Context: scsi-ml softirq
|
|
*
|
|
*/
|
|
static void hp_sw_end_io(struct request *req, int error)
|
|
{
|
|
struct dm_path *path = req->end_io_data;
|
|
unsigned err_flags = 0;
|
|
|
|
if (!error) {
|
|
DMDEBUG("%s path activation command - success",
|
|
path->dev->name);
|
|
goto out;
|
|
}
|
|
|
|
if (hp_sw_error_is_retryable(req)) {
|
|
DMDEBUG("%s path activation command - retry",
|
|
path->dev->name);
|
|
err_flags = MP_RETRY;
|
|
goto out;
|
|
}
|
|
|
|
DMWARN("%s path activation fail - error=0x%x",
|
|
path->dev->name, error);
|
|
err_flags = MP_FAIL_PATH;
|
|
|
|
out:
|
|
req->end_io_data = NULL;
|
|
__blk_put_request(req->q, req);
|
|
dm_pg_init_complete(path, err_flags);
|
|
}
|
|
|
|
/*
|
|
* hp_sw_get_request - Allocate an HP specific path activation request
|
|
* @path: path on which request will be sent (needed for request queue)
|
|
*
|
|
* The START command is used for path activation request.
|
|
* These arrays are controller-based failover, not LUN based.
|
|
* One START command issued to a single path will fail over all
|
|
* LUNs for the same controller.
|
|
*
|
|
* Possible optimizations
|
|
* 1. Make timeout configurable
|
|
* 2. Preallocate request
|
|
*/
|
|
static struct request *hp_sw_get_request(struct dm_path *path)
|
|
{
|
|
struct request *req;
|
|
struct block_device *bdev = path->dev->bdev;
|
|
struct request_queue *q = bdev_get_queue(bdev);
|
|
struct hp_sw_context *h = path->hwhcontext;
|
|
|
|
req = blk_get_request(q, WRITE, GFP_NOIO);
|
|
if (!req)
|
|
goto out;
|
|
|
|
req->timeout = 60 * HZ;
|
|
|
|
req->errors = 0;
|
|
req->cmd_type = REQ_TYPE_BLOCK_PC;
|
|
req->cmd_flags |= REQ_FAILFAST | REQ_NOMERGE;
|
|
req->end_io_data = path;
|
|
req->sense = h->sense;
|
|
memset(req->sense, 0, SCSI_SENSE_BUFFERSIZE);
|
|
|
|
req->cmd[0] = START_STOP;
|
|
req->cmd[4] = 1;
|
|
req->cmd_len = COMMAND_SIZE(req->cmd[0]);
|
|
|
|
out:
|
|
return req;
|
|
}
|
|
|
|
/*
|
|
* hp_sw_pg_init - HP path activation implementation.
|
|
* @hwh: hardware handler specific data
|
|
* @bypassed: unused; is the path group bypassed? (see dm-mpath.c)
|
|
* @path: path to send initialization command
|
|
*
|
|
* Send an HP-specific path activation command on 'path'.
|
|
* Do not try to optimize in any way, just send the activation command.
|
|
* More than one path activation command may be sent to the same controller.
|
|
* This seems to work fine for basic failover support.
|
|
*
|
|
* Possible optimizations
|
|
* 1. Detect an in-progress activation request and avoid submitting another one
|
|
* 2. Model the controller and only send a single activation request at a time
|
|
* 3. Determine the state of a path before sending an activation request
|
|
*
|
|
* Context: kmpathd (see process_queued_ios() in dm-mpath.c)
|
|
*/
|
|
static void hp_sw_pg_init(struct hw_handler *hwh, unsigned bypassed,
|
|
struct dm_path *path)
|
|
{
|
|
struct request *req;
|
|
struct hp_sw_context *h;
|
|
|
|
path->hwhcontext = hwh->context;
|
|
h = hwh->context;
|
|
|
|
req = hp_sw_get_request(path);
|
|
if (!req) {
|
|
DMERR("%s path activation command - allocation fail",
|
|
path->dev->name);
|
|
goto retry;
|
|
}
|
|
|
|
DMDEBUG("%s path activation command - sent", path->dev->name);
|
|
|
|
blk_execute_rq_nowait(req->q, NULL, req, 1, hp_sw_end_io);
|
|
return;
|
|
|
|
retry:
|
|
dm_pg_init_complete(path, MP_RETRY);
|
|
}
|
|
|
|
static int hp_sw_create(struct hw_handler *hwh, unsigned argc, char **argv)
|
|
{
|
|
struct hp_sw_context *h;
|
|
|
|
h = kmalloc(sizeof(*h), GFP_KERNEL);
|
|
if (!h)
|
|
return -ENOMEM;
|
|
|
|
hwh->context = h;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void hp_sw_destroy(struct hw_handler *hwh)
|
|
{
|
|
struct hp_sw_context *h = hwh->context;
|
|
|
|
kfree(h);
|
|
}
|
|
|
|
static struct hw_handler_type hp_sw_hwh = {
|
|
.name = DM_HP_HWH_NAME,
|
|
.module = THIS_MODULE,
|
|
.create = hp_sw_create,
|
|
.destroy = hp_sw_destroy,
|
|
.pg_init = hp_sw_pg_init,
|
|
};
|
|
|
|
static int __init hp_sw_init(void)
|
|
{
|
|
int r;
|
|
|
|
r = dm_register_hw_handler(&hp_sw_hwh);
|
|
if (r < 0)
|
|
DMERR("register failed %d", r);
|
|
else
|
|
DMINFO("version " DM_HP_HWH_VER " loaded");
|
|
|
|
return r;
|
|
}
|
|
|
|
static void __exit hp_sw_exit(void)
|
|
{
|
|
int r;
|
|
|
|
r = dm_unregister_hw_handler(&hp_sw_hwh);
|
|
if (r < 0)
|
|
DMERR("unregister failed %d", r);
|
|
}
|
|
|
|
module_init(hp_sw_init);
|
|
module_exit(hp_sw_exit);
|
|
|
|
MODULE_DESCRIPTION("DM Multipath HP StorageWorks / FSC FibreCat (A/P) support");
|
|
MODULE_AUTHOR("Mike Christie, Dave Wysochanski <dm-devel@redhat.com>");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_VERSION(DM_HP_HWH_VER);
|