Skip to content

Commit 3278255

Browse files
hreineckeaxboe
hreinecke
authored and
axboe
committed
scsi_dh_rdac: switch to scsi_execute_req_flags()
Switch to scsi_execute_req_flags() and scsi_get_vpd_page() instead of open-coding it. Using scsi_execute_req_flags() will set REQ_QUIET and REQ_PREEMPT, but this is okay as we're evaluating the errors anyway and should be able to send the command even if the device is quiesced. Signed-off-by: Hannes Reinecke <hare@suse.com> Signed-off-by: Christoph Hellwig <hch@lst.de> Acked-by: Martin K. Petersen <martin.petersen@oracle.com> Signed-off-by: Jens Axboe <axboe@fb.com>
1 parent eb8db83 commit 3278255

File tree

1 file changed

+51
-123
lines changed

1 file changed

+51
-123
lines changed

‎drivers/scsi/device_handler/scsi_dh_rdac.c

Lines changed: 51 additions & 123 deletions
Original file line numberDiff line numberDiff line change
@@ -205,7 +205,6 @@ struct rdac_dh_data {
205205
#define RDAC_NON_PREFERRED 1
206206
char preferred;
207207

208-
unsigned char sense[SCSI_SENSE_BUFFERSIZE];
209208
union {
210209
struct c2_inquiry c2;
211210
struct c4_inquiry c4;
@@ -262,40 +261,12 @@ do { \
262261
sdev_printk(KERN_INFO, sdev, RDAC_NAME ": " f "\n", ## arg); \
263262
} while (0);
264263

265-
static struct request *get_rdac_req(struct scsi_device *sdev,
266-
void *buffer, unsigned buflen, int rw)
264+
static unsigned int rdac_failover_get(struct rdac_controller *ctlr,
265+
struct list_head *list,
266+
unsigned char *cdb)
267267
{
268-
struct request *rq;
269-
struct request_queue *q = sdev->request_queue;
270-
271-
rq = blk_get_request(q, rw, GFP_NOIO);
272-
273-
if (IS_ERR(rq)) {
274-
sdev_printk(KERN_INFO, sdev,
275-
"get_rdac_req: blk_get_request failed.\n");
276-
return NULL;
277-
}
278-
blk_rq_set_block_pc(rq);
279-
280-
if (buflen && blk_rq_map_kern(q, rq, buffer, buflen, GFP_NOIO)) {
281-
blk_put_request(rq);
282-
sdev_printk(KERN_INFO, sdev,
283-
"get_rdac_req: blk_rq_map_kern failed.\n");
284-
return NULL;
285-
}
286-
287-
rq->cmd_flags |= REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
288-
REQ_FAILFAST_DRIVER;
289-
rq->retries = RDAC_RETRIES;
290-
rq->timeout = RDAC_TIMEOUT;
291-
292-
return rq;
293-
}
294-
295-
static struct request *rdac_failover_get(struct scsi_device *sdev,
296-
struct rdac_dh_data *h, struct list_head *list)
297-
{
298-
struct request *rq;
268+
struct scsi_device *sdev = ctlr->ms_sdev;
269+
struct rdac_dh_data *h = sdev->handler_data;
299270
struct rdac_mode_common *common;
300271
unsigned data_size;
301272
struct rdac_queue_data *qdata;
@@ -332,27 +303,17 @@ static struct request *rdac_failover_get(struct scsi_device *sdev,
332303
lun_table[qdata->h->lun] = 0x81;
333304
}
334305

335-
/* get request for block layer packet command */
336-
rq = get_rdac_req(sdev, &h->ctlr->mode_select, data_size, WRITE);
337-
if (!rq)
338-
return NULL;
339-
340306
/* Prepare the command. */
341307
if (h->ctlr->use_ms10) {
342-
rq->cmd[0] = MODE_SELECT_10;
343-
rq->cmd[7] = data_size >> 8;
344-
rq->cmd[8] = data_size & 0xff;
308+
cdb[0] = MODE_SELECT_10;
309+
cdb[7] = data_size >> 8;
310+
cdb[8] = data_size & 0xff;
345311
} else {
346-
rq->cmd[0] = MODE_SELECT;
347-
rq->cmd[4] = data_size;
312+
cdb[0] = MODE_SELECT;
313+
cdb[4] = data_size;
348314
}
349-
rq->cmd_len = COMMAND_SIZE(rq->cmd[0]);
350-
351-
rq->sense = h->sense;
352-
memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
353-
rq->sense_len = 0;
354315

355-
return rq;
316+
return data_size;
356317
}
357318

358319
static void release_controller(struct kref *kref)
@@ -400,46 +361,14 @@ static struct rdac_controller *get_controller(int index, char *array_name,
400361
return ctlr;
401362
}
402363

403-
static int submit_inquiry(struct scsi_device *sdev, int page_code,
404-
unsigned int len, struct rdac_dh_data *h)
405-
{
406-
struct request *rq;
407-
struct request_queue *q = sdev->request_queue;
408-
int err = SCSI_DH_RES_TEMP_UNAVAIL;
409-
410-
rq = get_rdac_req(sdev, &h->inq, len, READ);
411-
if (!rq)
412-
goto done;
413-
414-
/* Prepare the command. */
415-
rq->cmd[0] = INQUIRY;
416-
rq->cmd[1] = 1;
417-
rq->cmd[2] = page_code;
418-
rq->cmd[4] = len;
419-
rq->cmd_len = COMMAND_SIZE(INQUIRY);
420-
421-
rq->sense = h->sense;
422-
memset(rq->sense, 0, SCSI_SENSE_BUFFERSIZE);
423-
rq->sense_len = 0;
424-
425-
err = blk_execute_rq(q, NULL, rq, 1);
426-
if (err == -EIO)
427-
err = SCSI_DH_IO;
428-
429-
blk_put_request(rq);
430-
done:
431-
return err;
432-
}
433-
434364
static int get_lun_info(struct scsi_device *sdev, struct rdac_dh_data *h,
435365
char *array_name, u8 *array_id)
436366
{
437-
int err, i;
438-
struct c8_inquiry *inqp;
367+
int err = SCSI_DH_IO, i;
368+
struct c8_inquiry *inqp = &h->inq.c8;
439369

440-
err = submit_inquiry(sdev, 0xC8, sizeof(struct c8_inquiry), h);
441-
if (err == SCSI_DH_OK) {
442-
inqp = &h->inq.c8;
370+
if (!scsi_get_vpd_page(sdev, 0xC8, (unsigned char *)inqp,
371+
sizeof(struct c8_inquiry))) {
443372
if (inqp->page_code != 0xc8)
444373
return SCSI_DH_NOSYS;
445374
if (inqp->page_id[0] != 'e' || inqp->page_id[1] != 'd' ||
@@ -453,20 +382,20 @@ static int get_lun_info(struct scsi_device *sdev, struct rdac_dh_data *h,
453382
*(array_name+ARRAY_LABEL_LEN-1) = '\0';
454383
memset(array_id, 0, UNIQUE_ID_LEN);
455384
memcpy(array_id, inqp->array_unique_id, inqp->array_uniq_id_len);
385+
err = SCSI_DH_OK;
456386
}
457387
return err;
458388
}
459389

460390
static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
461391
{
462-
int err, access_state;
392+
int err = SCSI_DH_IO, access_state;
463393
struct rdac_dh_data *tmp;
464-
struct c9_inquiry *inqp;
394+
struct c9_inquiry *inqp = &h->inq.c9;
465395

466396
h->state = RDAC_STATE_ACTIVE;
467-
err = submit_inquiry(sdev, 0xC9, sizeof(struct c9_inquiry), h);
468-
if (err == SCSI_DH_OK) {
469-
inqp = &h->inq.c9;
397+
if (!scsi_get_vpd_page(sdev, 0xC9, (unsigned char *)inqp,
398+
sizeof(struct c9_inquiry))) {
470399
/* detect the operating mode */
471400
if ((inqp->avte_cvp >> 5) & 0x1)
472401
h->mode = RDAC_MODE_IOSHIP; /* LUN in IOSHIP mode */
@@ -501,6 +430,7 @@ static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
501430
tmp->sdev->access_state = access_state;
502431
}
503432
rcu_read_unlock();
433+
err = SCSI_DH_OK;
504434
}
505435

506436
return err;
@@ -509,12 +439,11 @@ static int check_ownership(struct scsi_device *sdev, struct rdac_dh_data *h)
509439
static int initialize_controller(struct scsi_device *sdev,
510440
struct rdac_dh_data *h, char *array_name, u8 *array_id)
511441
{
512-
int err, index;
513-
struct c4_inquiry *inqp;
442+
int err = SCSI_DH_IO, index;
443+
struct c4_inquiry *inqp = &h->inq.c4;
514444

515-
err = submit_inquiry(sdev, 0xC4, sizeof(struct c4_inquiry), h);
516-
if (err == SCSI_DH_OK) {
517-
inqp = &h->inq.c4;
445+
if (!scsi_get_vpd_page(sdev, 0xC4, (unsigned char *)inqp,
446+
sizeof(struct c4_inquiry))) {
518447
/* get the controller index */
519448
if (inqp->slot_id[1] == 0x31)
520449
index = 0;
@@ -530,18 +459,18 @@ static int initialize_controller(struct scsi_device *sdev,
530459
h->sdev = sdev;
531460
}
532461
spin_unlock(&list_lock);
462+
err = SCSI_DH_OK;
533463
}
534464
return err;
535465
}
536466

537467
static int set_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
538468
{
539-
int err;
540-
struct c2_inquiry *inqp;
469+
int err = SCSI_DH_IO;
470+
struct c2_inquiry *inqp = &h->inq.c2;
541471

542-
err = submit_inquiry(sdev, 0xC2, sizeof(struct c2_inquiry), h);
543-
if (err == SCSI_DH_OK) {
544-
inqp = &h->inq.c2;
472+
if (!scsi_get_vpd_page(sdev, 0xC2, (unsigned char *)inqp,
473+
sizeof(struct c2_inquiry))) {
545474
/*
546475
* If more than MODE6_MAX_LUN luns are supported, use
547476
* mode select 10
@@ -550,36 +479,35 @@ static int set_mode_select(struct scsi_device *sdev, struct rdac_dh_data *h)
550479
h->ctlr->use_ms10 = 1;
551480
else
552481
h->ctlr->use_ms10 = 0;
482+
err = SCSI_DH_OK;
553483
}
554484
return err;
555485
}
556486

557487
static int mode_select_handle_sense(struct scsi_device *sdev,
558-
unsigned char *sensebuf)
488+
struct scsi_sense_hdr *sense_hdr)
559489
{
560-
struct scsi_sense_hdr sense_hdr;
561-
int err = SCSI_DH_IO, ret;
490+
int err = SCSI_DH_IO;
562491
struct rdac_dh_data *h = sdev->handler_data;
563492

564-
ret = scsi_normalize_sense(sensebuf, SCSI_SENSE_BUFFERSIZE, &sense_hdr);
565-
if (!ret)
493+
if (!scsi_sense_valid(sense_hdr))
566494
goto done;
567495

568-
switch (sense_hdr.sense_key) {
496+
switch (sense_hdr->sense_key) {
569497
case NO_SENSE:
570498
case ABORTED_COMMAND:
571499
case UNIT_ATTENTION:
572500
err = SCSI_DH_RETRY;
573501
break;
574502
case NOT_READY:
575-
if (sense_hdr.asc == 0x04 && sense_hdr.ascq == 0x01)
503+
if (sense_hdr->asc == 0x04 && sense_hdr->ascq == 0x01)
576504
/* LUN Not Ready and is in the Process of Becoming
577505
* Ready
578506
*/
579507
err = SCSI_DH_RETRY;
580508
break;
581509
case ILLEGAL_REQUEST:
582-
if (sense_hdr.asc == 0x91 && sense_hdr.ascq == 0x36)
510+
if (sense_hdr->asc == 0x91 && sense_hdr->ascq == 0x36)
583511
/*
584512
* Command Lock contention
585513
*/
@@ -592,7 +520,7 @@ static int mode_select_handle_sense(struct scsi_device *sdev,
592520
RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
593521
"MODE_SELECT returned with sense %02x/%02x/%02x",
594522
(char *) h->ctlr->array_name, h->ctlr->index,
595-
sense_hdr.sense_key, sense_hdr.asc, sense_hdr.ascq);
523+
sense_hdr->sense_key, sense_hdr->asc, sense_hdr->ascq);
596524

597525
done:
598526
return err;
@@ -602,35 +530,36 @@ static void send_mode_select(struct work_struct *work)
602530
{
603531
struct rdac_controller *ctlr =
604532
container_of(work, struct rdac_controller, ms_work);
605-
struct request *rq;
606533
struct scsi_device *sdev = ctlr->ms_sdev;
607534
struct rdac_dh_data *h = sdev->handler_data;
608-
struct request_queue *q = sdev->request_queue;
609-
int err, retry_cnt = RDAC_RETRY_COUNT;
535+
int err = SCSI_DH_OK, retry_cnt = RDAC_RETRY_COUNT;
610536
struct rdac_queue_data *tmp, *qdata;
611537
LIST_HEAD(list);
538+
unsigned char cdb[COMMAND_SIZE(MODE_SELECT_10)];
539+
struct scsi_sense_hdr sshdr;
540+
unsigned int data_size;
541+
u64 req_flags = REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT |
542+
REQ_FAILFAST_DRIVER;
612543

613544
spin_lock(&ctlr->ms_lock);
614545
list_splice_init(&ctlr->ms_head, &list);
615546
ctlr->ms_queued = 0;
616547
ctlr->ms_sdev = NULL;
617548
spin_unlock(&ctlr->ms_lock);
618549

619-
retry:
620-
err = SCSI_DH_RES_TEMP_UNAVAIL;
621-
rq = rdac_failover_get(sdev, h, &list);
622-
if (!rq)
623-
goto done;
550+
retry:
551+
data_size = rdac_failover_get(ctlr, &list, cdb);
624552

625553
RDAC_LOG(RDAC_LOG_FAILOVER, sdev, "array %s, ctlr %d, "
626554
"%s MODE_SELECT command",
627555
(char *) h->ctlr->array_name, h->ctlr->index,
628556
(retry_cnt == RDAC_RETRY_COUNT) ? "queueing" : "retrying");
629557

630-
err = blk_execute_rq(q, NULL, rq, 1);
631-
blk_put_request(rq);
632-
if (err != SCSI_DH_OK) {
633-
err = mode_select_handle_sense(sdev, h->sense);
558+
if (scsi_execute_req_flags(sdev, cdb, DMA_TO_DEVICE,
559+
&h->ctlr->mode_select, data_size, &sshdr,
560+
RDAC_TIMEOUT * HZ,
561+
RDAC_RETRIES, NULL, req_flags, 0)) {
562+
err = mode_select_handle_sense(sdev, &sshdr);
634563
if (err == SCSI_DH_RETRY && retry_cnt--)
635564
goto retry;
636565
if (err == SCSI_DH_IMM_RETRY)
@@ -643,7 +572,6 @@ static void send_mode_select(struct work_struct *work)
643572
(char *) h->ctlr->array_name, h->ctlr->index);
644573
}
645574

646-
done:
647575
list_for_each_entry_safe(qdata, tmp, &list, entry) {
648576
list_del(&qdata->entry);
649577
if (err == SCSI_DH_OK)

0 commit comments

Comments
 (0)