Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi
Pull SCSI fixes from James Bottomley:
"This is a set of four bug fixes.
The isci one is an obvious thinko (using request buffer instead of
response buffer) which causes a command to fail.
The three others are DIF/DIX updates which are required because
they're part of a series of ten patches, the other seven of which went
into the block layer during the merge window meaning our current
DIF/DIX implementation is broken without these three.
Signed-off-by: James Bottomley <JBottomley@Parallels.com>"
* tag 'scsi-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/jejb/scsi:
[SCSI] sd: Implement support for WRITE SAME
[SCSI] sd: Permit merged discard requests
[SCSI] Add a report opcode helper
[SCSI] isci: copy fis 0x34 response into proper buffer
+263
-29
+2
drivers/ata/libata-scsi.c
+2
drivers/ata/libata-scsi.c
···
1052
1052
{
1053
1053
sdev->use_10_for_rw = 1;
1054
1054
sdev->use_10_for_ms = 1;
1055
+
sdev->no_report_opcodes = 1;
1056
+
sdev->no_write_same = 1;
1055
1057
1056
1058
/* Schedule policy is determined by ->qc_defer() callback and
1057
1059
* it needs to see every deferred qc. Set dev_blocked to 1 to
+2
drivers/firewire/sbp2.c
+2
drivers/firewire/sbp2.c
+1
-1
drivers/scsi/isci/request.c
+1
-1
drivers/scsi/isci/request.c
+45
drivers/scsi/scsi.c
+45
drivers/scsi/scsi.c
···
55
55
#include <linux/cpu.h>
56
56
#include <linux/mutex.h>
57
57
#include <linux/async.h>
58
+
#include <asm/unaligned.h>
58
59
59
60
#include <scsi/scsi.h>
60
61
#include <scsi/scsi_cmnd.h>
···
1061
1060
return -EINVAL;
1062
1061
}
1063
1062
EXPORT_SYMBOL_GPL(scsi_get_vpd_page);
1063
+
1064
+
/**
1065
+
* scsi_report_opcode - Find out if a given command opcode is supported
1066
+
* @sdev: scsi device to query
1067
+
* @buffer: scratch buffer (must be at least 20 bytes long)
1068
+
* @len: length of buffer
1069
+
* @opcode: opcode for command to look up
1070
+
*
1071
+
* Uses the REPORT SUPPORTED OPERATION CODES to look up the given
1072
+
* opcode. Returns 0 if RSOC fails or if the command opcode is
1073
+
* unsupported. Returns 1 if the device claims to support the command.
1074
+
*/
1075
+
int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
1076
+
unsigned int len, unsigned char opcode)
1077
+
{
1078
+
unsigned char cmd[16];
1079
+
struct scsi_sense_hdr sshdr;
1080
+
int result;
1081
+
1082
+
if (sdev->no_report_opcodes || sdev->scsi_level < SCSI_SPC_3)
1083
+
return 0;
1084
+
1085
+
memset(cmd, 0, 16);
1086
+
cmd[0] = MAINTENANCE_IN;
1087
+
cmd[1] = MI_REPORT_SUPPORTED_OPERATION_CODES;
1088
+
cmd[2] = 1; /* One command format */
1089
+
cmd[3] = opcode;
1090
+
put_unaligned_be32(len, &cmd[6]);
1091
+
memset(buffer, 0, len);
1092
+
1093
+
result = scsi_execute_req(sdev, cmd, DMA_FROM_DEVICE, buffer, len,
1094
+
&sshdr, 30 * HZ, 3, NULL);
1095
+
1096
+
if (result && scsi_sense_valid(&sshdr) &&
1097
+
sshdr.sense_key == ILLEGAL_REQUEST &&
1098
+
(sshdr.asc == 0x20 || sshdr.asc == 0x24) && sshdr.ascq == 0x00)
1099
+
return 0;
1100
+
1101
+
if ((buffer[1] & 3) == 3) /* Command supported */
1102
+
return 1;
1103
+
1104
+
return 0;
1105
+
}
1106
+
EXPORT_SYMBOL(scsi_report_opcode);
1064
1107
1065
1108
/**
1066
1109
* scsi_device_get - get an additional reference to a scsi_device
+17
-5
drivers/scsi/scsi_lib.c
+17
-5
drivers/scsi/scsi_lib.c
···
900
900
action = ACTION_FAIL;
901
901
error = -EILSEQ;
902
902
/* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
903
-
} else if ((sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
904
-
(cmd->cmnd[0] == UNMAP ||
905
-
cmd->cmnd[0] == WRITE_SAME_16 ||
906
-
cmd->cmnd[0] == WRITE_SAME)) {
907
-
description = "Discard failure";
903
+
} else if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
904
+
switch (cmd->cmnd[0]) {
905
+
case UNMAP:
906
+
description = "Discard failure";
907
+
break;
908
+
case WRITE_SAME:
909
+
case WRITE_SAME_16:
910
+
if (cmd->cmnd[1] & 0x8)
911
+
description = "Discard failure";
912
+
else
913
+
description =
914
+
"Write same failure";
915
+
break;
916
+
default:
917
+
description = "Invalid command failure";
918
+
break;
919
+
}
908
920
action = ACTION_FAIL;
909
921
error = -EREMOTEIO;
910
922
} else
+179
-23
drivers/scsi/sd.c
+179
-23
drivers/scsi/sd.c
···
99
99
#endif
100
100
101
101
static void sd_config_discard(struct scsi_disk *, unsigned int);
102
+
static void sd_config_write_same(struct scsi_disk *);
102
103
static int sd_revalidate_disk(struct gendisk *);
103
104
static void sd_unlock_native_capacity(struct gendisk *disk);
104
105
static int sd_probe(struct device *);
···
396
395
return err ? err : count;
397
396
}
398
397
398
+
static ssize_t
399
+
sd_show_write_same_blocks(struct device *dev, struct device_attribute *attr,
400
+
char *buf)
401
+
{
402
+
struct scsi_disk *sdkp = to_scsi_disk(dev);
403
+
404
+
return snprintf(buf, 20, "%u\n", sdkp->max_ws_blocks);
405
+
}
406
+
407
+
static ssize_t
408
+
sd_store_write_same_blocks(struct device *dev, struct device_attribute *attr,
409
+
const char *buf, size_t count)
410
+
{
411
+
struct scsi_disk *sdkp = to_scsi_disk(dev);
412
+
struct scsi_device *sdp = sdkp->device;
413
+
unsigned long max;
414
+
int err;
415
+
416
+
if (!capable(CAP_SYS_ADMIN))
417
+
return -EACCES;
418
+
419
+
if (sdp->type != TYPE_DISK)
420
+
return -EINVAL;
421
+
422
+
err = kstrtoul(buf, 10, &max);
423
+
424
+
if (err)
425
+
return err;
426
+
427
+
if (max == 0)
428
+
sdp->no_write_same = 1;
429
+
else if (max <= SD_MAX_WS16_BLOCKS)
430
+
sdkp->max_ws_blocks = max;
431
+
432
+
sd_config_write_same(sdkp);
433
+
434
+
return count;
435
+
}
436
+
399
437
static struct device_attribute sd_disk_attrs[] = {
400
438
__ATTR(cache_type, S_IRUGO|S_IWUSR, sd_show_cache_type,
401
439
sd_store_cache_type),
···
450
410
__ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL),
451
411
__ATTR(provisioning_mode, S_IRUGO|S_IWUSR, sd_show_provisioning_mode,
452
412
sd_store_provisioning_mode),
413
+
__ATTR(max_write_same_blocks, S_IRUGO|S_IWUSR,
414
+
sd_show_write_same_blocks, sd_store_write_same_blocks),
453
415
__ATTR(max_medium_access_timeouts, S_IRUGO|S_IWUSR,
454
416
sd_show_max_medium_access_timeouts,
455
417
sd_store_max_medium_access_timeouts),
···
603
561
return;
604
562
605
563
case SD_LBP_UNMAP:
606
-
max_blocks = min_not_zero(sdkp->max_unmap_blocks, 0xffffffff);
564
+
max_blocks = min_not_zero(sdkp->max_unmap_blocks,
565
+
(u32)SD_MAX_WS16_BLOCKS);
607
566
break;
608
567
609
568
case SD_LBP_WS16:
610
-
max_blocks = min_not_zero(sdkp->max_ws_blocks, 0xffffffff);
569
+
max_blocks = min_not_zero(sdkp->max_ws_blocks,
570
+
(u32)SD_MAX_WS16_BLOCKS);
611
571
break;
612
572
613
573
case SD_LBP_WS10:
614
-
max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff);
574
+
max_blocks = min_not_zero(sdkp->max_ws_blocks,
575
+
(u32)SD_MAX_WS10_BLOCKS);
615
576
break;
616
577
617
578
case SD_LBP_ZERO:
618
-
max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff);
579
+
max_blocks = min_not_zero(sdkp->max_ws_blocks,
580
+
(u32)SD_MAX_WS10_BLOCKS);
619
581
q->limits.discard_zeroes_data = 1;
620
582
break;
621
583
}
···
629
583
}
630
584
631
585
/**
632
-
* scsi_setup_discard_cmnd - unmap blocks on thinly provisioned device
586
+
* sd_setup_discard_cmnd - unmap blocks on thinly provisioned device
633
587
* @sdp: scsi device to operate one
634
588
* @rq: Request to prepare
635
589
*
636
590
* Will issue either UNMAP or WRITE SAME(16) depending on preference
637
591
* indicated by target device.
638
592
**/
639
-
static int scsi_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
593
+
static int sd_setup_discard_cmnd(struct scsi_device *sdp, struct request *rq)
640
594
{
641
595
struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
642
-
struct bio *bio = rq->bio;
643
-
sector_t sector = bio->bi_sector;
644
-
unsigned int nr_sectors = bio_sectors(bio);
596
+
sector_t sector = blk_rq_pos(rq);
597
+
unsigned int nr_sectors = blk_rq_sectors(rq);
598
+
unsigned int nr_bytes = blk_rq_bytes(rq);
645
599
unsigned int len;
646
600
int ret;
647
601
char *buf;
648
602
struct page *page;
649
603
650
-
if (sdkp->device->sector_size == 4096) {
651
-
sector >>= 3;
652
-
nr_sectors >>= 3;
653
-
}
654
-
604
+
sector >>= ilog2(sdp->sector_size) - 9;
605
+
nr_sectors >>= ilog2(sdp->sector_size) - 9;
655
606
rq->timeout = SD_TIMEOUT;
656
607
657
608
memset(rq->cmd, 0, rq->cmd_len);
···
703
660
blk_add_request_payload(rq, page, len);
704
661
ret = scsi_setup_blk_pc_cmnd(sdp, rq);
705
662
rq->buffer = page_address(page);
663
+
rq->__data_len = nr_bytes;
706
664
707
665
out:
708
666
if (ret != BLKPREP_OK) {
709
667
__free_page(page);
710
668
rq->buffer = NULL;
711
669
}
670
+
return ret;
671
+
}
672
+
673
+
static void sd_config_write_same(struct scsi_disk *sdkp)
674
+
{
675
+
struct request_queue *q = sdkp->disk->queue;
676
+
unsigned int logical_block_size = sdkp->device->sector_size;
677
+
unsigned int blocks = 0;
678
+
679
+
if (sdkp->device->no_write_same) {
680
+
sdkp->max_ws_blocks = 0;
681
+
goto out;
682
+
}
683
+
684
+
/* Some devices can not handle block counts above 0xffff despite
685
+
* supporting WRITE SAME(16). Consequently we default to 64k
686
+
* blocks per I/O unless the device explicitly advertises a
687
+
* bigger limit.
688
+
*/
689
+
if (sdkp->max_ws_blocks == 0)
690
+
sdkp->max_ws_blocks = SD_MAX_WS10_BLOCKS;
691
+
692
+
if (sdkp->ws16 || sdkp->max_ws_blocks > SD_MAX_WS10_BLOCKS)
693
+
blocks = min_not_zero(sdkp->max_ws_blocks,
694
+
(u32)SD_MAX_WS16_BLOCKS);
695
+
else
696
+
blocks = min_not_zero(sdkp->max_ws_blocks,
697
+
(u32)SD_MAX_WS10_BLOCKS);
698
+
699
+
out:
700
+
blk_queue_max_write_same_sectors(q, blocks * (logical_block_size >> 9));
701
+
}
702
+
703
+
/**
704
+
* sd_setup_write_same_cmnd - write the same data to multiple blocks
705
+
* @sdp: scsi device to operate one
706
+
* @rq: Request to prepare
707
+
*
708
+
* Will issue either WRITE SAME(10) or WRITE SAME(16) depending on
709
+
* preference indicated by target device.
710
+
**/
711
+
static int sd_setup_write_same_cmnd(struct scsi_device *sdp, struct request *rq)
712
+
{
713
+
struct scsi_disk *sdkp = scsi_disk(rq->rq_disk);
714
+
struct bio *bio = rq->bio;
715
+
sector_t sector = blk_rq_pos(rq);
716
+
unsigned int nr_sectors = blk_rq_sectors(rq);
717
+
unsigned int nr_bytes = blk_rq_bytes(rq);
718
+
int ret;
719
+
720
+
if (sdkp->device->no_write_same)
721
+
return BLKPREP_KILL;
722
+
723
+
BUG_ON(bio_offset(bio) || bio_iovec(bio)->bv_len != sdp->sector_size);
724
+
725
+
sector >>= ilog2(sdp->sector_size) - 9;
726
+
nr_sectors >>= ilog2(sdp->sector_size) - 9;
727
+
728
+
rq->__data_len = sdp->sector_size;
729
+
rq->timeout = SD_WRITE_SAME_TIMEOUT;
730
+
memset(rq->cmd, 0, rq->cmd_len);
731
+
732
+
if (sdkp->ws16 || sector > 0xffffffff || nr_sectors > 0xffff) {
733
+
rq->cmd_len = 16;
734
+
rq->cmd[0] = WRITE_SAME_16;
735
+
put_unaligned_be64(sector, &rq->cmd[2]);
736
+
put_unaligned_be32(nr_sectors, &rq->cmd[10]);
737
+
} else {
738
+
rq->cmd_len = 10;
739
+
rq->cmd[0] = WRITE_SAME;
740
+
put_unaligned_be32(sector, &rq->cmd[2]);
741
+
put_unaligned_be16(nr_sectors, &rq->cmd[7]);
742
+
}
743
+
744
+
ret = scsi_setup_blk_pc_cmnd(sdp, rq);
745
+
rq->__data_len = nr_bytes;
746
+
712
747
return ret;
713
748
}
714
749
···
833
712
* block PC requests to make life easier.
834
713
*/
835
714
if (rq->cmd_flags & REQ_DISCARD) {
836
-
ret = scsi_setup_discard_cmnd(sdp, rq);
715
+
ret = sd_setup_discard_cmnd(sdp, rq);
716
+
goto out;
717
+
} else if (rq->cmd_flags & REQ_WRITE_SAME) {
718
+
ret = sd_setup_write_same_cmnd(sdp, rq);
837
719
goto out;
838
720
} else if (rq->cmd_flags & REQ_FLUSH) {
839
721
ret = scsi_setup_flush_cmnd(sdp, rq);
···
1606
1482
unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt);
1607
1483
struct scsi_sense_hdr sshdr;
1608
1484
struct scsi_disk *sdkp = scsi_disk(SCpnt->request->rq_disk);
1485
+
struct request *req = SCpnt->request;
1609
1486
int sense_valid = 0;
1610
1487
int sense_deferred = 0;
1611
1488
unsigned char op = SCpnt->cmnd[0];
1489
+
unsigned char unmap = SCpnt->cmnd[1] & 8;
1612
1490
1613
-
if ((SCpnt->request->cmd_flags & REQ_DISCARD) && !result)
1614
-
scsi_set_resid(SCpnt, 0);
1491
+
if (req->cmd_flags & REQ_DISCARD || req->cmd_flags & REQ_WRITE_SAME) {
1492
+
if (!result) {
1493
+
good_bytes = blk_rq_bytes(req);
1494
+
scsi_set_resid(SCpnt, 0);
1495
+
} else {
1496
+
good_bytes = 0;
1497
+
scsi_set_resid(SCpnt, blk_rq_bytes(req));
1498
+
}
1499
+
}
1615
1500
1616
1501
if (result) {
1617
1502
sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr);
···
1669
1536
if (sshdr.asc == 0x10) /* DIX: Host detected corruption */
1670
1537
good_bytes = sd_completed_bytes(SCpnt);
1671
1538
/* INVALID COMMAND OPCODE or INVALID FIELD IN CDB */
1672
-
if ((sshdr.asc == 0x20 || sshdr.asc == 0x24) &&
1673
-
(op == UNMAP || op == WRITE_SAME_16 || op == WRITE_SAME))
1674
-
sd_config_discard(sdkp, SD_LBP_DISABLE);
1539
+
if (sshdr.asc == 0x20 || sshdr.asc == 0x24) {
1540
+
switch (op) {
1541
+
case UNMAP:
1542
+
sd_config_discard(sdkp, SD_LBP_DISABLE);
1543
+
break;
1544
+
case WRITE_SAME_16:
1545
+
case WRITE_SAME:
1546
+
if (unmap)
1547
+
sd_config_discard(sdkp, SD_LBP_DISABLE);
1548
+
else {
1549
+
sdkp->device->no_write_same = 1;
1550
+
sd_config_write_same(sdkp);
1551
+
1552
+
good_bytes = 0;
1553
+
req->__data_len = blk_rq_bytes(req);
1554
+
req->cmd_flags |= REQ_QUIET;
1555
+
}
1556
+
}
1557
+
}
1675
1558
break;
1676
1559
default:
1677
1560
break;
···
2523
2374
if (buffer[3] == 0x3c) {
2524
2375
unsigned int lba_count, desc_count;
2525
2376
2526
-
sdkp->max_ws_blocks =
2527
-
(u32) min_not_zero(get_unaligned_be64(&buffer[36]),
2528
-
(u64)0xffffffff);
2377
+
sdkp->max_ws_blocks = (u32)get_unaligned_be64(&buffer[36]);
2529
2378
2530
2379
if (!sdkp->lbpme)
2531
2380
goto out;
···
2616
2469
kfree(buffer);
2617
2470
}
2618
2471
2472
+
static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
2473
+
{
2474
+
if (scsi_report_opcode(sdkp->device, buffer, SD_BUF_SIZE,
2475
+
WRITE_SAME_16))
2476
+
sdkp->ws16 = 1;
2477
+
}
2478
+
2619
2479
static int sd_try_extended_inquiry(struct scsi_device *sdp)
2620
2480
{
2621
2481
/*
···
2682
2528
sd_read_write_protect_flag(sdkp, buffer);
2683
2529
sd_read_cache_type(sdkp, buffer);
2684
2530
sd_read_app_tag_own(sdkp, buffer);
2531
+
sd_read_write_same(sdkp, buffer);
2685
2532
}
2686
2533
2687
2534
sdkp->first_scan = 0;
···
2700
2545
blk_queue_flush(sdkp->disk->queue, flush);
2701
2546
2702
2547
set_capacity(disk, sdkp->capacity);
2548
+
sd_config_write_same(sdkp);
2703
2549
kfree(buffer);
2704
2550
2705
2551
out:
+7
drivers/scsi/sd.h
+7
drivers/scsi/sd.h
···
14
14
#define SD_TIMEOUT (30 * HZ)
15
15
#define SD_MOD_TIMEOUT (75 * HZ)
16
16
#define SD_FLUSH_TIMEOUT (60 * HZ)
17
+
#define SD_WRITE_SAME_TIMEOUT (120 * HZ)
17
18
18
19
/*
19
20
* Number of allowed retries
···
37
36
enum {
38
37
SD_EXT_CDB_SIZE = 32, /* Extended CDB size */
39
38
SD_MEMPOOL_SIZE = 2, /* CDB pool size */
39
+
};
40
+
41
+
enum {
42
+
SD_MAX_WS10_BLOCKS = 0xffff,
43
+
SD_MAX_WS16_BLOCKS = 0x7fffff,
40
44
};
41
45
42
46
enum {
···
83
77
unsigned lbpws : 1;
84
78
unsigned lbpws10 : 1;
85
79
unsigned lbpvpd : 1;
80
+
unsigned ws16 : 1;
86
81
};
87
82
#define to_scsi_disk(obj) container_of(obj,struct scsi_disk,dev)
88
83
+6
drivers/usb/storage/scsiglue.c
+6
drivers/usb/storage/scsiglue.c
···
186
186
/* Some devices don't handle VPD pages correctly */
187
187
sdev->skip_vpd_pages = 1;
188
188
189
+
/* Do not attempt to use REPORT SUPPORTED OPERATION CODES */
190
+
sdev->no_report_opcodes = 1;
191
+
192
+
/* Do not attempt to use WRITE SAME */
193
+
sdev->no_write_same = 1;
194
+
189
195
/* Some disks return the total number of blocks in response
190
196
* to READ CAPACITY rather than the highest block number.
191
197
* If this device makes that mistake, tell the sd driver. */
+4
include/scsi/scsi_device.h
+4
include/scsi/scsi_device.h
···
135
135
* because we did a bus reset. */
136
136
unsigned use_10_for_rw:1; /* first try 10-byte read / write */
137
137
unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
138
+
unsigned no_report_opcodes:1; /* no REPORT SUPPORTED OPERATION CODES */
139
+
unsigned no_write_same:1; /* no WRITE SAME command */
138
140
unsigned skip_ms_page_8:1; /* do not use MODE SENSE page 0x08 */
139
141
unsigned skip_ms_page_3f:1; /* do not use MODE SENSE page 0x3f */
140
142
unsigned skip_vpd_pages:1; /* do not read VPD pages */
···
364
362
int retries, struct scsi_sense_hdr *sshdr);
365
363
extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf,
366
364
int buf_len);
365
+
extern int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
366
+
unsigned int len, unsigned char opcode);
367
367
extern int scsi_device_set_state(struct scsi_device *sdev,
368
368
enum scsi_device_state state);
369
369
extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,