Skip to content

L
linux
Commit ca9f0089 authored by Hannes Reinecke's avatar Hannes Reinecke Committed by James Bottomley
Browse files
Options

[SCSI] scsi_dh: Update RDAC device handler 

This patch updates the RDAC device handler to
refuse to attach to devices not supporting the
RDAC vpd pages.
Signed-off-by: default avatarHannes Reinecke <hare@suse.de>
Signed-off-by: default avatarChandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@HansenPartnership.com>
parent 2aef6d5c
Show whitespace changes
Inline Side-by-side
Showing with 94 additions and 69 deletions
drivers/scsi/device_handler/scsi_dh_rdac.c
View file @ ca9f0089
...@@ -173,6 +173,11 @@ struct rdac_dh_data { ...@@ -173,6 +173,11 @@ struct rdac_dh_data {
#define RDAC_STATE_ACTIVE 0 #define RDAC_STATE_ACTIVE 0
#define RDAC_STATE_PASSIVE 1 #define RDAC_STATE_PASSIVE 1
unsigned char state; unsigned char state;
#define RDAC_LUN_UNOWNED 0
#define RDAC_LUN_OWNED 1
#define RDAC_LUN_AVT 2
char lun_state;
unsigned char sense[SCSI_SENSE_BUFFERSIZE]; unsigned char sense[SCSI_SENSE_BUFFERSIZE];
union { union {
struct c2_inquiry c2; struct c2_inquiry c2;
...@@ -182,6 +187,13 @@ struct rdac_dh_data { ...@@ -182,6 +187,13 @@ struct rdac_dh_data {
} inq; } inq;
}; };
static const char *lun_state[] =
{
"unowned",
"owned",
"owned (AVT mode)",
};
static LIST_HEAD(ctlr_list); static LIST_HEAD(ctlr_list);
static DEFINE_SPINLOCK(list_lock); static DEFINE_SPINLOCK(list_lock);
...@@ -197,9 +209,8 @@ static struct request *get_rdac_req(struct scsi_device *sdev, ...@@ -197,9 +209,8 @@ static struct request *get_rdac_req(struct scsi_device *sdev,
{ {
struct request *rq; struct request *rq;
struct request_queue *q = sdev->request_queue; struct request_queue *q = sdev->request_queue;
struct rdac_dh_data *h = get_rdac_data(sdev);
rq = blk_get_request(q, rw, GFP_KERNEL); rq = blk_get_request(q, rw, GFP_NOIO);
if (!rq) { if (!rq) {
sdev_printk(KERN_INFO, sdev, sdev_printk(KERN_INFO, sdev,
...@@ -207,17 +218,14 @@ static struct request *get_rdac_req(struct scsi_device *sdev, ...@@ -207,17 +218,14 @@ static struct request *get_rdac_req(struct scsi_device *sdev,
return NULL; return NULL;
} }
if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_KERNEL)) { if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
blk_put_request(rq); blk_put_request(rq);
sdev_printk(KERN_INFO, sdev, sdev_printk(KERN_INFO, sdev,
"get_rdac_req: blk_rq_map_kern failed.\n"); "get_rdac_req: blk_rq_map_kern failed.\n");
return NULL; return NULL;
} }
memset(&rq->cmd, 0, BLK_MAX_CDB); memset(rq->cmd, 0, BLK_MAX_CDB);
rq->sense = h->sense;
memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
rq->sense_len = 0;
rq->cmd_type = REQ_TYPE_BLOCK_PC; rq->cmd_type = REQ_TYPE_BLOCK_PC;
rq->cmd_flags |= REQ_FAILFAST | REQ_NOMERGE; rq->cmd_flags |= REQ_FAILFAST | REQ_NOMERGE;
...@@ -227,12 +235,12 @@ static struct request *get_rdac_req(struct scsi_device *sdev, ...@@ -227,12 +235,12 @@ static struct request *get_rdac_req(struct scsi_device *sdev,
return rq; return rq;
} }
static struct request *rdac_failover_get(struct scsi_device *sdev) static struct request *rdac_failover_get(struct scsi_device *sdev,
struct rdac_dh_data *h)
{ {
struct request *rq; struct request *rq;
struct rdac_mode_common *common; struct rdac_mode_common *common;
unsigned data_size; unsigned data_size;
struct rdac_dh_data *h = get_rdac_data(sdev);
if (h->ctlr->use_ms10) { if (h->ctlr->use_ms10) {
struct rdac_pg_expanded *rdac_pg; struct rdac_pg_expanded *rdac_pg;
...@@ -277,6 +285,10 @@ static struct request *rdac_failover_get(struct scsi_device *sdev) ...@@ -277,6 +285,10 @@ static struct request *rdac_failover_get(struct scsi_device *sdev)
} }
rq->cmd_len = COMMAND_SIZE(rq->cmd[0]); rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);
rq->sense = h->sense;
memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
rq->sense_len = 0;
return rq; return rq;
} }
...@@ -321,11 +333,10 @@ static struct rdac_controller *get_controller(u8 *subsys_id, u8 *slot_id) ...@@ -321,11 +333,10 @@ static struct rdac_controller *get_controller(u8 *subsys_id, u8 *slot_id)
} }
static int submit_inquiry(struct scsi_device *sdev, int page_code, static int submit_inquiry(struct scsi_device *sdev, int page_code,
unsigned int len) unsigned int len, struct rdac_dh_data *h)
{ {
struct request *rq; struct request *rq;
struct request_queue *q = sdev->request_queue; struct request_queue *q = sdev->request_queue;
struct rdac_dh_data *h = get_rdac_data(sdev);
int err = SCSI_DH_RES_TEMP_UNAVAIL; int err = SCSI_DH_RES_TEMP_UNAVAIL;
rq = get_rdac_req(sdev, &h->inq, len, READ); rq = get_rdac_req(sdev, &h->inq, len, READ);
...@@ -338,59 +349,68 @@ static int submit_inquiry(struct scsi_device *sdev, int page_code, ...@@ -338,59 +349,68 @@ static int submit_inquiry(struct scsi_device *sdev, int page_code,
rq->cmd[2] = page_code; rq->cmd[2] = page_code;
rq->cmd[4] = len; rq->cmd[4] = len;
rq->cmd_len = COMMAND_SIZE(INQUIRY); rq->cmd_len = COMMAND_SIZE(INQUIRY);
rq->sense = h->sense;
memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
rq->sense_len = 0;
err = blk_execute_rq(q, NULL, rq, 1); err = blk_execute_rq(q, NULL, rq, 1);
if (err == -EIO) if (err == -EIO)
err = SCSI_DH_IO; err = SCSI_DH_IO;
blk_put_request(rq);
done: done:
return err; return err;
} }
static int get_lun(struct scsi_device *sdev) static int get_lun(struct scsi_device *sdev, struct rdac_dh_data *h)
{ {
int err; int err;
struct c8_inquiry *inqp; struct c8_inquiry *inqp;
struct rdac_dh_data *h = get_rdac_data(sdev);
err = submit_inquiry(sdev, 0xC8, sizeof(struct c8_inquiry)); err = submit_inquiry(sdev, 0xC8, sizeof(struct c8_inquiry), h);
if (err == SCSI_DH_OK) { if (err == SCSI_DH_OK) {
inqp = &h->inq.c8; inqp = &h->inq.c8;
h->lun = inqp->lun[7]; /* currently it uses only one byte */ if (inqp->page_code != 0xc8)
return SCSI_DH_NOSYS;
if (inqp->page_id[0] != 'e' || inqp->page_id[1] != 'd' ||
inqp->page_id[2] != 'i' || inqp->page_id[3] != 'd')
return SCSI_DH_NOSYS;
h->lun = scsilun_to_int((struct scsi_lun *)inqp->lun);
} }
return err; return err;
} }
#define RDAC_OWNED 0 static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
#define RDAC_UNOWNED 1
#define RDAC_FAILED 2
static int check_ownership(struct scsi_device *sdev)
{ {
int err; int err;
struct c9_inquiry *inqp; struct c9_inquiry *inqp;
struct rdac_dh_data *h = get_rdac_data(sdev);
err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry)); err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry), h);
if (err == SCSI_DH_OK) { if (err == SCSI_DH_OK) {
err = RDAC_UNOWNED;
inqp = &h->inq.c9; inqp = &h->inq.c9;
/* if ((inqp->avte_cvp >> 7) == 0x1) {
* If in AVT mode or if the path already owns the LUN, /* LUN in AVT mode */
* return RDAC_OWNED; sdev_printk(KERN_NOTICE, sdev,
*/ "%s: AVT mode detected\n",
if (((inqp->avte_cvp >> 7) == 0x1) || RDAC_NAME);
((inqp->avte_cvp & 0x1) != 0)) h->lun_state = RDAC_LUN_AVT;
err = RDAC_OWNED; } else if ((inqp->avte_cvp & 0x1) != 0) {
} else /* LUN was owned by the controller */
err = RDAC_FAILED; h->lun_state = RDAC_LUN_OWNED;
}
}
return err; return err;
} }
static int initialize_controller(struct scsi_device *sdev) static int initialize_controller(struct scsi_device *sdev,
struct rdac_dh_data *h)
{ {
int err; int err;
struct c4_inquiry *inqp; struct c4_inquiry *inqp;
struct rdac_dh_data *h = get_rdac_data(sdev);
err = submit_inquiry(sdev, 0xC4, sizeof(struct c4_inquiry)); err = submit_inquiry(sdev, 0xC4, sizeof(struct c4_inquiry), h);
if (err == SCSI_DH_OK) { if (err == SCSI_DH_OK) {
inqp = &h->inq.c4; inqp = &h->inq.c4;
h->ctlr = get_controller(inqp->subsys_id, inqp->slot_id); h->ctlr = get_controller(inqp->subsys_id, inqp->slot_id);
...@@ -400,13 +420,12 @@ static int initialize_controller(struct scsi_device *sdev) ...@@ -400,13 +420,12 @@ static int initialize_controller(struct scsi_device *sdev)
return err; return err;
} }
static int set_mode_select(struct scsi_device *sdev) static int set_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
{ {
int err; int err;
struct c2_inquiry *inqp; struct c2_inquiry *inqp;
struct rdac_dh_data *h = get_rdac_data(sdev);
err = submit_inquiry(sdev, 0xC2, sizeof(struct c2_inquiry)); err = submit_inquiry(sdev, 0xC2, sizeof(struct c2_inquiry), h);
if (err == SCSI_DH_OK) { if (err == SCSI_DH_OK) {
inqp = &h->inq.c2; inqp = &h->inq.c2;
/* /*
...@@ -421,13 +440,13 @@ static int set_mode_select(struct scsi_device *sdev) ...@@ -421,13 +440,13 @@ static int set_mode_select(struct scsi_device *sdev)
return err; return err;
} }
static int mode_select_handle_sense(struct scsi_device *sdev) static int mode_select_handle_sense(struct scsi_device *sdev,
unsigned char *sensebuf)
{ {
struct scsi_sense_hdr sense_hdr; struct scsi_sense_hdr sense_hdr;
struct rdac_dh_data *h = get_rdac_data(sdev);
int sense, err = SCSI_DH_IO, ret; int sense, err = SCSI_DH_IO, ret;
ret = scsi_normalize_sense(h->sense, SCSI_SENSE_BUFFERSIZE, &sense_hdr); ret = scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE, &sense_hdr);
if (!ret) if (!ret)
goto done; goto done;
...@@ -451,14 +470,13 @@ static int mode_select_handle_sense(struct scsi_device *sdev) ...@@ -451,14 +470,13 @@ static int mode_select_handle_sense(struct scsi_device *sdev)
return err; return err;
} }
static int send_mode_select(struct scsi_device *sdev) static int send_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
{ {
struct request *rq; struct request *rq;
struct request_queue *q = sdev->request_queue; struct request_queue *q = sdev->request_queue;
struct rdac_dh_data *h = get_rdac_data(sdev);
int err = SCSI_DH_RES_TEMP_UNAVAIL; int err = SCSI_DH_RES_TEMP_UNAVAIL;
rq = rdac_failover_get(sdev); rq = rdac_failover_get(sdev, h);
if (!rq) if (!rq)
goto done; goto done;
...@@ -466,9 +484,11 @@ static int send_mode_select(struct scsi_device *sdev) ...@@ -466,9 +484,11 @@ static int send_mode_select(struct scsi_device *sdev)
err = blk_execute_rq(q, NULL, rq, 1); err = blk_execute_rq(q, NULL, rq, 1);
if (err != SCSI_DH_OK) if (err != SCSI_DH_OK)
err = mode_select_handle_sense(sdev); err = mode_select_handle_sense(sdev, h->sense);
if (err == SCSI_DH_OK) if (err == SCSI_DH_OK)
h->state = RDAC_STATE_ACTIVE; h->state = RDAC_STATE_ACTIVE;
blk_put_request(rq);
done: done:
return err; return err;
} }
...@@ -478,38 +498,23 @@ static int rdac_activate(struct scsi_device *sdev) ...@@ -478,38 +498,23 @@ static int rdac_activate(struct scsi_device *sdev)
struct rdac_dh_data *h = get_rdac_data(sdev); struct rdac_dh_data *h = get_rdac_data(sdev);
int err = SCSI_DH_OK; int err = SCSI_DH_OK;
if (h->lun == UNINITIALIZED_LUN) { err = check_ownership(sdev, h);
err = get_lun(sdev);
if (err != SCSI_DH_OK) if (err != SCSI_DH_OK)
goto done; goto done;
}
err = check_ownership(sdev);
switch (err) {
case RDAC_UNOWNED:
break;
case RDAC_OWNED:
err = SCSI_DH_OK;
goto done;
case RDAC_FAILED:
default:
err = SCSI_DH_IO;
goto done;
}
if (!h->ctlr) { if (!h->ctlr) {
err = initialize_controller(sdev); err = initialize_controller(sdev, h);
if (err != SCSI_DH_OK) if (err != SCSI_DH_OK)
goto done; goto done;
} }
if (h->ctlr->use_ms10 == -1) { if (h->ctlr->use_ms10 == -1) {
err = set_mode_select(sdev); err = set_mode_select(sdev, h);
if (err != SCSI_DH_OK) if (err != SCSI_DH_OK)
goto done; goto done;
} }
if (h->lun_state == RDAC_LUN_UNOWNED)
err = send_mode_select(sdev); err = send_mode_select(sdev, h);
done: done:
return err; return err;
} }
...@@ -606,11 +611,12 @@ static int rdac_bus_attach(struct scsi_device *sdev) ...@@ -606,11 +611,12 @@ static int rdac_bus_attach(struct scsi_device *sdev)
struct scsi_dh_data *scsi_dh_data; struct scsi_dh_data *scsi_dh_data;
struct rdac_dh_data *h; struct rdac_dh_data *h;
unsigned long flags; unsigned long flags;
int err;
scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *) scsi_dh_data = kzalloc(sizeof(struct scsi_device_handler *)
+ sizeof(*h) , GFP_KERNEL); + sizeof(*h) , GFP_KERNEL);
if (!scsi_dh_data) { if (!scsi_dh_data) {
sdev_printk(KERN_ERR, sdev, "Attach failed %s.\n", sdev_printk(KERN_ERR, sdev, "%s: Attach failed\n",
RDAC_NAME); RDAC_NAME);
return 0; return 0;
} }
...@@ -619,14 +625,33 @@ static int rdac_bus_attach(struct scsi_device *sdev) ...@@ -619,14 +625,33 @@ static int rdac_bus_attach(struct scsi_device *sdev)
h = (struct rdac_dh_data *) scsi_dh_data->buf; h = (struct rdac_dh_data *) scsi_dh_data->buf;
h->lun = UNINITIALIZED_LUN; h->lun = UNINITIALIZED_LUN;
h->state = RDAC_STATE_ACTIVE; h->state = RDAC_STATE_ACTIVE;
err = get_lun(sdev, h);
if (err != SCSI_DH_OK)
goto failed;
err = check_ownership(sdev, h);
if (err != SCSI_DH_OK)
goto failed;
if (!try_module_get(THIS_MODULE))
goto failed;
spin_lock_irqsave(sdev->request_queue->queue_lock, flags); spin_lock_irqsave(sdev->request_queue->queue_lock, flags);
sdev->scsi_dh_data = scsi_dh_data; sdev->scsi_dh_data = scsi_dh_data;
spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags); spin_unlock_irqrestore(sdev->request_queue->queue_lock, flags);
try_module_get(THIS_MODULE);
sdev_printk(KERN_NOTICE, sdev, "Attached %s\n", RDAC_NAME); sdev_printk(KERN_NOTICE, sdev,
"%s: LUN %d (%s)\n",
RDAC_NAME, h->lun, lun_state[(int)h->lun_state]);
return 0; return 0;
failed:
kfree(scsi_dh_data);
sdev_printk(KERN_ERR, sdev, "%s: not attached\n",
RDAC_NAME);
return -EINVAL;
} }
static void rdac_bus_detach( struct scsi_device *sdev ) static void rdac_bus_detach( struct scsi_device *sdev )
...@@ -645,7 +670,7 @@ static void rdac_bus_detach( struct scsi_device *sdev ) ...@@ -645,7 +670,7 @@ static void rdac_bus_detach( struct scsi_device *sdev )
kref_put(&h->ctlr->kref, release_controller); kref_put(&h->ctlr->kref, release_controller);
kfree(scsi_dh_data); kfree(scsi_dh_data);
module_put(THIS_MODULE); module_put(THIS_MODULE);
sdev_printk(KERN_NOTICE, sdev, "Detached %s\n", RDAC_NAME); sdev_printk(KERN_NOTICE, sdev, "%s: Detached\n", RDAC_NAME);
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7