aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/scsi/sd.c
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/scsi/sd.c')
-rw-r--r--drivers/scsi/sd.c121
1 files changed, 81 insertions, 40 deletions
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 56b9501d12f3..8e08d51a0f05 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -373,6 +373,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
373 struct scsi_cmnd *SCpnt; 373 struct scsi_cmnd *SCpnt;
374 struct scsi_device *sdp = q->queuedata; 374 struct scsi_device *sdp = q->queuedata;
375 struct gendisk *disk = rq->rq_disk; 375 struct gendisk *disk = rq->rq_disk;
376 struct scsi_disk *sdkp;
376 sector_t block = rq->sector; 377 sector_t block = rq->sector;
377 unsigned int this_count = rq->nr_sectors; 378 unsigned int this_count = rq->nr_sectors;
378 unsigned int timeout = sdp->timeout; 379 unsigned int timeout = sdp->timeout;
@@ -389,6 +390,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
389 if (ret != BLKPREP_OK) 390 if (ret != BLKPREP_OK)
390 goto out; 391 goto out;
391 SCpnt = rq->special; 392 SCpnt = rq->special;
393 sdkp = scsi_disk(disk);
392 394
393 /* from here on until we're complete, any goto out 395 /* from here on until we're complete, any goto out
394 * is used for a killable error condition */ 396 * is used for a killable error condition */
@@ -478,6 +480,11 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
478 } 480 }
479 SCpnt->cmnd[0] = WRITE_6; 481 SCpnt->cmnd[0] = WRITE_6;
480 SCpnt->sc_data_direction = DMA_TO_DEVICE; 482 SCpnt->sc_data_direction = DMA_TO_DEVICE;
483
484 if (blk_integrity_rq(rq) &&
485 sd_dif_prepare(rq, block, sdp->sector_size) == -EIO)
486 goto out;
487
481 } else if (rq_data_dir(rq) == READ) { 488 } else if (rq_data_dir(rq) == READ) {
482 SCpnt->cmnd[0] = READ_6; 489 SCpnt->cmnd[0] = READ_6;
483 SCpnt->sc_data_direction = DMA_FROM_DEVICE; 490 SCpnt->sc_data_direction = DMA_FROM_DEVICE;
@@ -492,8 +499,12 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
492 "writing" : "reading", this_count, 499 "writing" : "reading", this_count,
493 rq->nr_sectors)); 500 rq->nr_sectors));
494 501
495 SCpnt->cmnd[1] = 0; 502 /* Set RDPROTECT/WRPROTECT if disk is formatted with DIF */
496 503 if (scsi_host_dif_capable(sdp->host, sdkp->protection_type))
504 SCpnt->cmnd[1] = 1 << 5;
505 else
506 SCpnt->cmnd[1] = 0;
507
497 if (block > 0xffffffff) { 508 if (block > 0xffffffff) {
498 SCpnt->cmnd[0] += READ_16 - READ_6; 509 SCpnt->cmnd[0] += READ_16 - READ_6;
499 SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0; 510 SCpnt->cmnd[1] |= blk_fua_rq(rq) ? 0x8 : 0;
@@ -511,6 +522,7 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
511 SCpnt->cmnd[13] = (unsigned char) this_count & 0xff; 522 SCpnt->cmnd[13] = (unsigned char) this_count & 0xff;
512 SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0; 523 SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0;
513 } else if ((this_count > 0xff) || (block > 0x1fffff) || 524 } else if ((this_count > 0xff) || (block > 0x1fffff) ||
525 scsi_device_protection(SCpnt->device) ||
514 SCpnt->device->use_10_for_rw) { 526 SCpnt->device->use_10_for_rw) {
515 if (this_count > 0xffff) 527 if (this_count > 0xffff)
516 this_count = 0xffff; 528 this_count = 0xffff;
@@ -545,6 +557,10 @@ static int sd_prep_fn(struct request_queue *q, struct request *rq)
545 } 557 }
546 SCpnt->sdb.length = this_count * sdp->sector_size; 558 SCpnt->sdb.length = this_count * sdp->sector_size;
547 559
560 /* If DIF or DIX is enabled, tell HBA how to handle request */
561 if (sdkp->protection_type || scsi_prot_sg_count(SCpnt))
562 sd_dif_op(SCpnt, sdkp->protection_type, scsi_prot_sg_count(SCpnt));
563
548 /* 564 /*
549 * We shouldn't disconnect in the middle of a sector, so with a dumb 565 * We shouldn't disconnect in the middle of a sector, so with a dumb
550 * host adapter, it's safe to assume that we can at least transfer 566 * host adapter, it's safe to assume that we can at least transfer
@@ -939,6 +955,48 @@ static struct block_device_operations sd_fops = {
939 .revalidate_disk = sd_revalidate_disk, 955 .revalidate_disk = sd_revalidate_disk,
940}; 956};
941 957
958static unsigned int sd_completed_bytes(struct scsi_cmnd *scmd)
959{
960 u64 start_lba = scmd->request->sector;
961 u64 end_lba = scmd->request->sector + (scsi_bufflen(scmd) / 512);
962 u64 bad_lba;
963 int info_valid;
964
965 if (!blk_fs_request(scmd->request))
966 return 0;
967
968 info_valid = scsi_get_sense_info_fld(scmd->sense_buffer,
969 SCSI_SENSE_BUFFERSIZE,
970 &bad_lba);
971 if (!info_valid)
972 return 0;
973
974 if (scsi_bufflen(scmd) <= scmd->device->sector_size)
975 return 0;
976
977 if (scmd->device->sector_size < 512) {
978 /* only legitimate sector_size here is 256 */
979 start_lba <<= 1;
980 end_lba <<= 1;
981 } else {
982 /* be careful ... don't want any overflows */
983 u64 factor = scmd->device->sector_size / 512;
984 do_div(start_lba, factor);
985 do_div(end_lba, factor);
986 }
987
988 /* The bad lba was reported incorrectly, we have no idea where
989 * the error is.
990 */
991 if (bad_lba < start_lba || bad_lba >= end_lba)
992 return 0;
993
994 /* This computation should always be done in terms of
995 * the resolution of the device's medium.
996 */
997 return (bad_lba - start_lba) * scmd->device->sector_size;
998}
999
942/** 1000/**
943 * sd_done - bottom half handler: called when the lower level 1001 * sd_done - bottom half handler: called when the lower level
944 * driver has completed (successfully or otherwise) a scsi command. 1002 * driver has completed (successfully or otherwise) a scsi command.
@@ -949,15 +1007,10 @@ static struct block_device_operations sd_fops = {
949static int sd_done(struct scsi_cmnd *SCpnt) 1007static int sd_done(struct scsi_cmnd *SCpnt)
950{ 1008{
951 int result = SCpnt->result; 1009 int result = SCpnt->result;
952 unsigned int xfer_size = scsi_bufflen(SCpnt); 1010 unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
953 unsigned int good_bytes = result ? 0 : xfer_size;
954 u64 start_lba = SCpnt->request->sector;
955 u64 end_lba = SCpnt->request->sector + (xfer_size / 512);
956 u64 bad_lba;
957 struct scsi_sense_hdr sshdr; 1011 struct scsi_sense_hdr sshdr;
958 int sense_valid = 0; 1012 int sense_valid = 0;
959 int sense_deferred = 0; 1013 int sense_deferred = 0;
960 int info_valid;
961 1014
962 if (result) { 1015 if (result) {
963 sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr); 1016 sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
@@ -982,36 +1035,7 @@ static int sd_done(struct scsi_cmnd *SCpnt)
982 switch (sshdr.sense_key) { 1035 switch (sshdr.sense_key) {
983 case HARDWARE_ERROR: 1036 case HARDWARE_ERROR:
984 case MEDIUM_ERROR: 1037 case MEDIUM_ERROR:
985 if (!blk_fs_request(SCpnt->request)) 1038 good_bytes = sd_completed_bytes(SCpnt);
986 goto out;
987 info_valid = scsi_get_sense_info_fld(SCpnt->sense_buffer,
988 SCSI_SENSE_BUFFERSIZE,
989 &bad_lba);
990 if (!info_valid)
991 goto out;
992 if (xfer_size <= SCpnt->device->sector_size)
993 goto out;
994 if (SCpnt->device->sector_size < 512) {
995 /* only legitimate sector_size here is 256 */
996 start_lba <<= 1;
997 end_lba <<= 1;
998 } else {
999 /* be careful ... don't want any overflows */
1000 u64 factor = SCpnt->device->sector_size / 512;
1001 do_div(start_lba, factor);
1002 do_div(end_lba, factor);
1003 }
1004
1005 if (bad_lba < start_lba || bad_lba >= end_lba)
1006 /* the bad lba was reported incorrectly, we have
1007 * no idea where the error is
1008 */
1009 goto out;
1010
1011 /* This computation should always be done in terms of
1012 * the resolution of the device's medium.
1013 */
1014 good_bytes = (bad_lba - start_lba)*SCpnt->device->sector_size;
1015 break; 1039 break;
1016 case RECOVERED_ERROR: 1040 case RECOVERED_ERROR:
1017 case NO_SENSE: 1041 case NO_SENSE:
@@ -1021,10 +1045,23 @@ static int sd_done(struct scsi_cmnd *SCpnt)
1021 scsi_print_sense("sd", SCpnt); 1045 scsi_print_sense("sd", SCpnt);
1022 SCpnt->result = 0; 1046 SCpnt->result = 0;
1023 memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE); 1047 memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
1024 good_bytes = xfer_size; 1048 good_bytes = scsi_bufflen(SCpnt);
1049 break;
1050 case ABORTED_COMMAND:
1051 if (sshdr.asc == 0x10) { /* DIF: Disk detected corruption */
1052 scsi_print_result(SCpnt);
1053 scsi_print_sense("sd", SCpnt);
1054 good_bytes = sd_completed_bytes(SCpnt);
1055 }
1025 break; 1056 break;
1026 case ILLEGAL_REQUEST: 1057 case ILLEGAL_REQUEST:
1027 if (SCpnt->device->use_10_for_rw && 1058 if (sshdr.asc == 0x10) { /* DIX: HBA detected corruption */
1059 scsi_print_result(SCpnt);
1060 scsi_print_sense("sd", SCpnt);
1061 good_bytes = sd_completed_bytes(SCpnt);
1062 }
1063 if (!scsi_device_protection(SCpnt->device) &&
1064 SCpnt->device->use_10_for_rw &&
1028 (SCpnt->cmnd[0] == READ_10 || 1065 (SCpnt->cmnd[0] == READ_10 ||
1029 SCpnt->cmnd[0] == WRITE_10)) 1066 SCpnt->cmnd[0] == WRITE_10))
1030 SCpnt->device->use_10_for_rw = 0; 1067 SCpnt->device->use_10_for_rw = 0;
@@ -1037,6 +1074,9 @@ static int sd_done(struct scsi_cmnd *SCpnt)
1037 break; 1074 break;
1038 } 1075 }
1039 out: 1076 out:
1077 if (rq_data_dir(SCpnt->request) == READ && scsi_prot_sg_count(SCpnt))
1078 sd_dif_complete(SCpnt, good_bytes);
1079
1040 return good_bytes; 1080 return good_bytes;
1041} 1081}
1042 1082
@@ -1826,6 +1866,7 @@ static int sd_probe(struct device *dev)
1826 1866
1827 dev_set_drvdata(dev, sdkp); 1867 dev_set_drvdata(dev, sdkp);
1828 add_disk(gd); 1868 add_disk(gd);
1869 sd_dif_config_host(sdkp);
1829 1870
1830 sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n", 1871 sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n",
1831 sdp->removable ? "removable " : ""); 1872 sdp->removable ? "removable " : "");