28 #include <linux/module.h>
30 #include <linux/kernel.h>
31 #include <linux/errno.h>
33 #include <linux/slab.h>
34 #include <linux/types.h>
35 #include <linux/string.h>
48 #include <asm/unaligned.h>
50 #include <scsi/scsi.h>
61 #define SCSI_DEBUG_VERSION "1.82"
62 static const char * scsi_debug_version_date =
"20100324";
65 #define NO_ADDITIONAL_SENSE 0x0
66 #define LOGICAL_UNIT_NOT_READY 0x4
67 #define UNRECOVERED_READ_ERR 0x11
68 #define PARAMETER_LIST_LENGTH_ERR 0x1a
69 #define INVALID_OPCODE 0x20
70 #define ADDR_OUT_OF_RANGE 0x21
71 #define INVALID_COMMAND_OPCODE 0x20
72 #define INVALID_FIELD_IN_CDB 0x24
73 #define INVALID_FIELD_IN_PARAM_LIST 0x26
74 #define POWERON_RESET 0x29
75 #define SAVING_PARAMS_UNSUP 0x39
76 #define TRANSPORT_PROBLEM 0x4b
77 #define THRESHOLD_EXCEEDED 0x5d
78 #define LOW_POWER_COND_ON 0x5e
81 #define ACK_NAK_TO 0x3
83 #define SDEBUG_TAGGED_QUEUING 0
86 #define DEF_NUM_HOST 1
87 #define DEF_NUM_TGTS 1
88 #define DEF_MAX_LUNS 1
94 #define DEF_DEV_SIZE_MB 8
98 #define DEF_EVERY_NTH 0
103 #define DEF_LBPWS10 0
105 #define DEF_LOWEST_ALIGNED 0
106 #define DEF_NO_LUN_0 0
107 #define DEF_NUM_PARTS 0
109 #define DEF_OPT_BLKS 64
110 #define DEF_PHYSBLK_EXP 0
112 #define DEF_REMOVABLE false
113 #define DEF_SCSI_LEVEL 5
114 #define DEF_SECTOR_SIZE 512
115 #define DEF_UNMAP_ALIGNMENT 0
116 #define DEF_UNMAP_GRANULARITY 1
117 #define DEF_UNMAP_MAX_BLOCKS 0xFFFFFFFF
118 #define DEF_UNMAP_MAX_DESC 256
119 #define DEF_VIRTUAL_GB 0
120 #define DEF_VPD_USE_HOSTNO 1
121 #define DEF_WRITESAME_LENGTH 0xFFFF
124 #define SCSI_DEBUG_OPT_NOISE 1
125 #define SCSI_DEBUG_OPT_MEDIUM_ERR 2
126 #define SCSI_DEBUG_OPT_TIMEOUT 4
127 #define SCSI_DEBUG_OPT_RECOVERED_ERR 8
128 #define SCSI_DEBUG_OPT_TRANSPORT_ERR 16
129 #define SCSI_DEBUG_OPT_DIF_ERR 32
130 #define SCSI_DEBUG_OPT_DIX_ERR 64
131 #define SCSI_DEBUG_OPT_MAC_TIMEOUT 128
151 #define OPT_MEDIUM_ERR_ADDR 0x1234
152 #define OPT_MEDIUM_ERR_NUM 10
156 #define SAM2_LUN_ADDRESS_METHOD 0
157 #define SAM2_WLUN_REPORT_LUNS 0xc101
161 #define SCSI_DEBUG_CANQUEUE 255
164 static int scsi_debug_ato =
DEF_ATO;
167 static int scsi_debug_dif =
DEF_DIF;
168 static int scsi_debug_dix =
DEF_DIX;
177 static int scsi_debug_no_uld = 0;
181 static int scsi_debug_opts =
DEF_OPTS;
188 static unsigned int scsi_debug_lbpu =
DEF_LBPU;
189 static unsigned int scsi_debug_lbpws =
DEF_LBPWS;
190 static unsigned int scsi_debug_lbpws10 =
DEF_LBPWS10;
191 static unsigned int scsi_debug_lbprz =
DEF_LBPRZ;
199 static int scsi_debug_cmnd_count = 0;
201 #define DEV_READONLY(TGT) (0)
203 static unsigned int sdebug_store_sectors;
208 static int sdebug_heads;
209 static int sdebug_cylinders_per;
210 static int sdebug_sectors_per;
212 #define SDEBUG_MAX_PARTS 4
214 #define SDEBUG_SENSE_LEN 32
216 #define SCSI_DEBUG_MAX_CMD_LEN 32
218 static unsigned int scsi_debug_lbp(
void)
220 return scsi_debug_lbpu | scsi_debug_lbpws | scsi_debug_lbpws10;
243 #define to_sdebug_host(d) \
244 container_of(d, struct sdebug_host_info, dev)
260 static unsigned char * fake_storep;
261 static unsigned char *dif_storep;
262 static void *map_storep;
264 static unsigned long map_size;
265 static int num_aborts = 0;
266 static int num_dev_resets = 0;
267 static int num_bus_resets = 0;
268 static int num_host_resets = 0;
269 static int dix_writes;
270 static int dix_reads;
271 static int dif_errors;
276 static char sdebug_proc_name[] =
"scsi_debug";
278 static struct bus_type pseudo_lld_bus;
286 .name = sdebug_proc_name,
287 .bus = &pseudo_lld_bus,
290 static const int check_condition_result =
293 static const int illegal_condition_result =
296 static unsigned char ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
298 static unsigned char iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
301 static int sdebug_add_adapter(
void);
302 static void sdebug_remove_adapter(
void);
304 static void sdebug_max_tgts_luns(
void)
309 spin_lock(&sdebug_host_list_lock);
311 hpnt = sdbg_host->
shost;
313 (scsi_debug_num_tgts > hpnt->
this_id))
314 hpnt->
max_id = scsi_debug_num_tgts + 1;
316 hpnt->
max_id = scsi_debug_num_tgts;
320 spin_unlock(&sdebug_host_list_lock);
326 unsigned char *
sbuff;
335 "[0x%x,0x%x,0x%x]\n", key, asc, asq);
338 static void get_data_transfer_info(
unsigned char *
cmd,
339 unsigned long long *
lba,
unsigned int *num,
346 *lba = (
u64)cmd[19] | (
u64)cmd[18] << 8 |
347 (
u64)cmd[17] << 16 | (
u64)cmd[16] << 24 |
348 (
u64)cmd[15] << 32 | (
u64)cmd[14] << 40 |
349 (
u64)cmd[13] << 48 | (
u64)cmd[12] << 56;
351 *ei_lba = (
u32)cmd[23] | (
u32)cmd[22] << 8 |
352 (
u32)cmd[21] << 16 | (
u32)cmd[20] << 24;
354 *num = (
u32)cmd[31] | (
u32)cmd[30] << 8 | (
u32)cmd[29] << 16 |
361 *lba = (
u64)cmd[9] | (
u64)cmd[8] << 8 |
362 (
u64)cmd[7] << 16 | (
u64)cmd[6] << 24 |
363 (
u64)cmd[5] << 32 | (
u64)cmd[4] << 40 |
364 (
u64)cmd[3] << 48 | (
u64)cmd[2] << 56;
366 *num = (
u32)cmd[13] | (
u32)cmd[12] << 8 | (
u32)cmd[11] << 16 |
371 *lba = (
u32)cmd[5] | (
u32)cmd[4] << 8 | (
u32)cmd[3] << 16 |
374 *num = (
u32)cmd[9] | (
u32)cmd[8] << 8 | (
u32)cmd[7] << 16 |
381 *lba = (
u32)cmd[5] | (
u32)cmd[4] << 8 | (
u32)cmd[3] << 16 |
384 *num = (
u32)cmd[8] | (
u32)cmd[7] << 8;
388 *lba = (
u32)cmd[3] | (
u32)cmd[2] << 8 |
389 (
u32)(cmd[1] & 0x1f) << 16;
390 *num = (0 == cmd[4]) ? 256 : cmd[4];
406 static int check_readiness(
struct scsi_cmnd * SCpnt,
int reset_only,
412 "attention: power on reset\n");
415 return check_condition_result;
417 if ((0 == reset_only) && devip->
stopped) {
420 "ready: initializing command required\n");
423 return check_condition_result;
429 static int fill_from_dev_buffer(
struct scsi_cmnd *
scp,
unsigned char *arr,
443 sdb->
resid -= act_len;
445 sdb->
resid = scsi_bufflen(scp) - act_len;
451 static int fetch_to_dev_buffer(
struct scsi_cmnd *scp,
unsigned char *arr,
454 if (!scsi_bufflen(scp))
459 return scsi_sg_copy_to_buffer(scp, arr, arr_len);
463 static const char * inq_vendor_id =
"Linux ";
464 static const char * inq_product_id =
"scsi_debug ";
465 static const char * inq_product_rev =
"0004";
467 static int inquiry_evpd_83(
unsigned char * arr,
int port_group_id,
468 int target_dev_id,
int dev_id_num,
469 const char * dev_id_str,
475 port_a = target_dev_id + 1;
480 memcpy(&arr[4], inq_vendor_id, 8);
481 memcpy(&arr[12], inq_product_id, 16);
482 memcpy(&arr[28], dev_id_str, dev_id_str_len);
483 num = 8 + 16 + dev_id_str_len;
486 if (dev_id_num >= 0) {
496 arr[num++] = (dev_id_num >> 24);
497 arr[num++] = (dev_id_num >> 16) & 0xff;
498 arr[num++] = (dev_id_num >> 8) & 0xff;
499 arr[num++] = dev_id_num & 0xff;
519 arr[num++] = (port_a >> 24);
520 arr[num++] = (port_a >> 16) & 0xff;
521 arr[num++] = (port_a >> 8) & 0xff;
522 arr[num++] = port_a & 0xff;
530 arr[num++] = (port_group_id >> 8) & 0xff;
531 arr[num++] = port_group_id & 0xff;
541 arr[num++] = (target_dev_id >> 24);
542 arr[num++] = (target_dev_id >> 16) & 0xff;
543 arr[num++] = (target_dev_id >> 8) & 0xff;
544 arr[num++] = target_dev_id & 0xff;
550 memcpy(arr + num,
"naa.52222220", 12);
552 snprintf(b,
sizeof(b),
"%08X", target_dev_id);
561 static unsigned char vpd84_data[] = {
562 0x22,0x22,0x22,0x0,0xbb,0x0,
563 0x22,0x22,0x22,0x0,0xbb,0x1,
564 0x22,0x22,0x22,0x0,0xbb,0x2,
567 static int inquiry_evpd_84(
unsigned char * arr)
569 memcpy(arr, vpd84_data,
sizeof(vpd84_data));
570 return sizeof(vpd84_data);
573 static int inquiry_evpd_85(
unsigned char * arr)
576 const char * na1 =
"https://www.kernel.org/config";
577 const char * na2 =
"http://www.kernel.org/log";
586 plen = ((plen / 4) + 1) * 4;
588 memcpy(arr + num, na1, olen);
589 memset(arr + num + olen, 0, plen - olen);
598 plen = ((plen / 4) + 1) * 4;
600 memcpy(arr + num, na2, olen);
601 memset(arr + num + olen, 0, plen - olen);
608 static int inquiry_evpd_88(
unsigned char * arr,
int target_dev_id)
613 port_a = target_dev_id + 1;
632 arr[num++] = (port_a >> 24);
633 arr[num++] = (port_a >> 16) & 0xff;
634 arr[num++] = (port_a >> 8) & 0xff;
635 arr[num++] = port_a & 0xff;
654 arr[num++] = (port_b >> 24);
655 arr[num++] = (port_b >> 16) & 0xff;
656 arr[num++] = (port_b >> 8) & 0xff;
657 arr[num++] = port_b & 0xff;
663 static unsigned char vpd89_data[] = {
665 'l',
'i',
'n',
'u',
'x',
' ',
' ',
' ',
666 'S',
'A',
'T',
' ',
's',
'c',
's',
'i',
'_',
'd',
'e',
'b',
'u',
'g',
' ',
' ',
668 0x34,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,
670 0x5a,0xc,0xff,0x3f,0x37,0xc8,0x10,0,0,0,0,0,0x3f,0,0,0,
671 0,0,0,0,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x58,0x20,0x20,0x20,0x20,
672 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0,0,0,0x40,0x4,0,0x2e,0x33,
673 0x38,0x31,0x20,0x20,0x20,0x20,0x54,0x53,0x38,0x33,0x30,0x30,0x33,0x31,
675 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
677 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
679 0,0,0,0x2f,0,0,0,0x2,0,0x2,0x7,0,0xff,0xff,0x1,0,
680 0x3f,0,0xc1,0xff,0x3e,0,0x10,0x1,0xb0,0xf8,0x50,0x9,0,0,0x7,0,
681 0x3,0,0x78,0,0x78,0,0xf0,0,0x78,0,0,0,0,0,0,0,
682 0,0,0,0,0,0,0,0,0x2,0,0,0,0,0,0,0,
683 0x7e,0,0x1b,0,0x6b,0x34,0x1,0x7d,0x3,0x40,0x69,0x34,0x1,0x3c,0x3,0x40,
684 0x7f,0x40,0,0,0,0,0xfe,0xfe,0,0,0,0,0,0xfe,0,0,
685 0,0,0,0,0,0,0,0,0xb0,0xf8,0x50,0x9,0,0,0,0,
686 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
687 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
688 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
689 0x1,0,0xb0,0xf8,0x50,0x9,0xb0,0xf8,0x50,0x9,0x20,0x20,0x2,0,0xb6,0x42,
690 0,0x80,0x8a,0,0x6,0x3c,0xa,0x3c,0xff,0xff,0xc6,0x7,0,0x1,0,0x8,
691 0xf0,0xf,0,0x10,0x2,0,0x30,0,0,0,0,0,0,0,0x6,0xfe,
692 0,0,0x2,0,0x50,0,0x8a,0,0x4f,0x95,0,0,0x21,0,0xb,0,
693 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
694 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
695 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
696 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
697 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
698 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
699 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
700 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
701 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
702 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
703 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
704 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0xa5,0x51,
707 static int inquiry_evpd_89(
unsigned char * arr)
709 memcpy(arr, vpd89_data,
sizeof(vpd89_data));
710 return sizeof(vpd89_data);
715 static unsigned char vpdb0_data[] = {
716 0,0,0,4, 0,0,0x4,0, 0,0,0,64,
717 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
718 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
719 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
722 static int inquiry_evpd_b0(
unsigned char * arr)
726 memcpy(arr, vpdb0_data,
sizeof(vpdb0_data));
729 gran = 1 << scsi_debug_physblk_exp;
730 arr[2] = (gran >> 8) & 0xff;
731 arr[3] = gran & 0xff;
734 if (sdebug_store_sectors > 0x400) {
735 arr[4] = (sdebug_store_sectors >> 24) & 0xff;
736 arr[5] = (sdebug_store_sectors >> 16) & 0xff;
737 arr[6] = (sdebug_store_sectors >> 8) & 0xff;
738 arr[7] = sdebug_store_sectors & 0xff;
744 if (scsi_debug_lbpu) {
753 if (scsi_debug_unmap_alignment) {
766 return sizeof(vpdb0_data);
770 static int inquiry_evpd_b1(
unsigned char *arr)
782 static int inquiry_evpd_b2(
unsigned char *arr)
790 if (scsi_debug_lbpws)
793 if (scsi_debug_lbpws10)
796 if (scsi_debug_lbprz)
802 #define SDEBUG_LONG_INQ_SZ 96
803 #define SDEBUG_MAX_INQ_ARR_SZ 584
808 unsigned char pq_pdt;
810 unsigned char *cmd = (
unsigned char *)scp->
cmnd;
811 int alloc_len,
n,
ret;
813 alloc_len = (cmd[3] << 8) + cmd[4];
819 else if (scsi_debug_no_lun_0 && (0 == devip->
lun))
822 pq_pdt = (scsi_debug_ptype & 0x1f);
828 return check_condition_result;
829 }
else if (0x1 & cmd[1]) {
830 int lu_id_num, port_group_id, target_dev_id,
len;
834 port_group_id = (((host_no + 1) & 0x7f) << 8) +
836 if (0 == scsi_debug_vpd_use_hostno)
838 lu_id_num = devip->
wlun ? -1 : (((host_no + 1) * 2000) +
840 target_dev_id = ((host_no + 1) * 2000) +
841 (devip->
target * 1000) - 3;
842 len =
scnprintf(lu_id_str, 6,
"%d", lu_id_num);
857 if (scsi_debug_lbp())
860 }
else if (0x80 == cmd[2]) {
863 memcpy(&arr[4], lu_id_str, len);
864 }
else if (0x83 == cmd[2]) {
866 arr[3] = inquiry_evpd_83(&arr[4], port_group_id,
867 target_dev_id, lu_id_num,
869 }
else if (0x84 == cmd[2]) {
871 arr[3] = inquiry_evpd_84(&arr[4]);
872 }
else if (0x85 == cmd[2]) {
874 arr[3] = inquiry_evpd_85(&arr[4]);
875 }
else if (0
x86 == cmd[2]) {
880 else if (scsi_debug_dif)
885 }
else if (0x87 == cmd[2]) {
892 }
else if (0x88 == cmd[2]) {
894 arr[3] = inquiry_evpd_88(&arr[4], target_dev_id);
895 }
else if (0x89 == cmd[2]) {
897 n = inquiry_evpd_89(&arr[4]);
900 }
else if (0xb0 == cmd[2]) {
902 arr[3] = inquiry_evpd_b0(&arr[4]);
903 }
else if (0xb1 == cmd[2]) {
905 arr[3] = inquiry_evpd_b1(&arr[4]);
906 }
else if (0xb2 == cmd[2]) {
908 arr[3] = inquiry_evpd_b2(&arr[4]);
914 return check_condition_result;
916 len =
min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
917 ret = fill_from_dev_buffer(scp, arr,
923 arr[1] = scsi_debug_removable ? 0x80 : 0;
924 arr[2] = scsi_debug_scsi_level;
927 arr[5] = scsi_debug_dif ? 1 : 0;
928 if (0 == scsi_debug_vpd_use_hostno)
933 memcpy(&arr[8], inq_vendor_id, 8);
934 memcpy(&arr[16], inq_product_id, 16);
935 memcpy(&arr[32], inq_product_rev, 4);
937 arr[58] = 0x0; arr[59] = 0x77;
938 arr[60] = 0x3; arr[61] = 0x14;
940 if (scsi_debug_ptype == 0) {
941 arr[
n++] = 0x3; arr[
n++] = 0x3d;
942 }
else if (scsi_debug_ptype == 1) {
943 arr[
n++] = 0x3; arr[
n++] = 0x60;
945 arr[
n++] = 0xc; arr[
n++] = 0xf;
946 ret = fill_from_dev_buffer(scp, arr,
952 static int resp_requests(
struct scsi_cmnd * scp,
955 unsigned char * sbuff;
956 unsigned char *cmd = (
unsigned char *)scp->
cmnd;
961 memset(arr, 0,
sizeof(arr));
962 if (devip->
reset == 1)
964 want_dsense = !!(cmd[1] & 1) || scsi_debug_dsense;
966 if ((iec_m_pg[2] & 0x4) && (6 == (iec_m_pg[3] & 0xf))) {
981 if ((cmd[1] & 1) && (! scsi_debug_dsense)) {
983 memset(arr, 0,
sizeof(arr));
992 return fill_from_dev_buffer(scp, arr, len);
995 static int resp_start_stop(
struct scsi_cmnd * scp,
998 unsigned char *cmd = (
unsigned char *)scp->
cmnd;
999 int power_cond, errsts,
start;
1001 if ((errsts = check_readiness(scp, 1, devip)))
1003 power_cond = (cmd[4] & 0xf0) >> 4;
1007 return check_condition_result;
1015 static sector_t get_sdebug_capacity(
void)
1017 if (scsi_debug_virtual_gb > 0)
1018 return (
sector_t)scsi_debug_virtual_gb *
1019 (1073741824 / scsi_debug_sector_size);
1021 return sdebug_store_sectors;
1024 #define SDEBUG_READCAP_ARR_SZ 8
1025 static int resp_readcap(
struct scsi_cmnd * scp,
1032 if ((errsts = check_readiness(scp, 1, devip)))
1035 sdebug_capacity = get_sdebug_capacity();
1037 if (sdebug_capacity < 0xffffffff) {
1038 capac = (
unsigned int)sdebug_capacity - 1;
1039 arr[0] = (capac >> 24);
1040 arr[1] = (capac >> 16) & 0xff;
1041 arr[2] = (capac >> 8) & 0xff;
1042 arr[3] = capac & 0xff;
1049 arr[6] = (scsi_debug_sector_size >> 8) & 0xff;
1050 arr[7] = scsi_debug_sector_size & 0xff;
1054 #define SDEBUG_READCAP16_ARR_SZ 32
1055 static int resp_readcap16(
struct scsi_cmnd * scp,
1058 unsigned char *cmd = (
unsigned char *)scp->
cmnd;
1060 unsigned long long capac;
1061 int errsts,
k, alloc_len;
1063 if ((errsts = check_readiness(scp, 1, devip)))
1065 alloc_len = ((cmd[10] << 24) + (cmd[11] << 16) + (cmd[12] << 8)
1068 sdebug_capacity = get_sdebug_capacity();
1070 capac = sdebug_capacity - 1;
1071 for (
k = 0; k < 8; ++k, capac >>= 8)
1072 arr[7 -
k] = capac & 0xff;
1073 arr[8] = (scsi_debug_sector_size >> 24) & 0xff;
1074 arr[9] = (scsi_debug_sector_size >> 16) & 0xff;
1075 arr[10] = (scsi_debug_sector_size >> 8) & 0xff;
1076 arr[11] = scsi_debug_sector_size & 0xff;
1077 arr[13] = scsi_debug_physblk_exp & 0xf;
1078 arr[14] = (scsi_debug_lowest_aligned >> 8) & 0x3f;
1080 if (scsi_debug_lbp()) {
1082 if (scsi_debug_lbprz)
1086 arr[15] = scsi_debug_lowest_aligned & 0xff;
1088 if (scsi_debug_dif) {
1089 arr[12] = (scsi_debug_dif - 1) << 1;
1093 return fill_from_dev_buffer(scp, arr,
1097 #define SDEBUG_MAX_TGTPGS_ARR_SZ 1412
1099 static int resp_report_tgtpgs(
struct scsi_cmnd * scp,
1102 unsigned char *cmd = (
unsigned char *)scp->
cmnd;
1103 unsigned char * arr;
1105 int n,
ret, alen, rlen;
1106 int port_group_a, port_group_b, port_a, port_b;
1108 alen = ((cmd[6] << 24) + (cmd[7] << 16) + (cmd[8] << 8)
1122 port_group_a = (((
host_no + 1) & 0x7f) << 8) +
1124 port_group_b = (((
host_no + 1) & 0x7f) << 8) +
1125 (devip->
channel & 0x7f) + 0x80;
1131 if (0 == scsi_debug_vpd_use_hostno) {
1138 arr[n++] = (port_group_a >> 8) & 0xff;
1139 arr[n++] = port_group_a & 0xff;
1146 arr[n++] = (port_a >> 8) & 0xff;
1147 arr[n++] = port_a & 0xff;
1150 arr[n++] = (port_group_b >> 8) & 0xff;
1151 arr[n++] = port_group_b & 0xff;
1158 arr[n++] = (port_b >> 8) & 0xff;
1159 arr[n++] = port_b & 0xff;
1162 arr[0] = (rlen >> 24) & 0xff;
1163 arr[1] = (rlen >> 16) & 0xff;
1164 arr[2] = (rlen >> 8) & 0xff;
1165 arr[3] = rlen & 0xff;
1174 ret = fill_from_dev_buffer(scp, arr,
1182 static int resp_err_recov_pg(
unsigned char *
p,
int pcontrol,
int target)
1184 unsigned char err_recov_pg[] = {0x1, 0xa, 0xc0, 11, 240, 0, 0, 0,
1187 memcpy(p, err_recov_pg,
sizeof(err_recov_pg));
1189 memset(p + 2, 0,
sizeof(err_recov_pg) - 2);
1190 return sizeof(err_recov_pg);
1193 static int resp_disconnect_pg(
unsigned char * p,
int pcontrol,
int target)
1195 unsigned char disconnect_pg[] = {0x2, 0xe, 128, 128, 0, 10, 0, 0,
1196 0, 0, 0, 0, 0, 0, 0, 0};
1198 memcpy(p, disconnect_pg,
sizeof(disconnect_pg));
1200 memset(p + 2, 0,
sizeof(disconnect_pg) - 2);
1201 return sizeof(disconnect_pg);
1204 static int resp_format_pg(
unsigned char * p,
int pcontrol,
int target)
1206 unsigned char format_pg[] = {0x3, 0x16, 0, 0, 0, 0, 0, 0,
1207 0, 0, 0, 0, 0, 0, 0, 0,
1208 0, 0, 0, 0, 0x40, 0, 0, 0};
1210 memcpy(p, format_pg,
sizeof(format_pg));
1211 p[10] = (sdebug_sectors_per >> 8) & 0xff;
1212 p[11] = sdebug_sectors_per & 0xff;
1213 p[12] = (scsi_debug_sector_size >> 8) & 0xff;
1214 p[13] = scsi_debug_sector_size & 0xff;
1215 if (scsi_debug_removable)
1218 memset(p + 2, 0,
sizeof(format_pg) - 2);
1219 return sizeof(format_pg);
1222 static int resp_caching_pg(
unsigned char * p,
int pcontrol,
int target)
1224 unsigned char caching_pg[] = {0x8, 18, 0x14, 0, 0xff, 0xff, 0, 0,
1225 0xff, 0xff, 0xff, 0xff, 0x80, 0x14, 0, 0, 0, 0, 0, 0};
1227 memcpy(p, caching_pg,
sizeof(caching_pg));
1229 memset(p + 2, 0,
sizeof(caching_pg) - 2);
1230 return sizeof(caching_pg);
1233 static int resp_ctrl_m_pg(
unsigned char * p,
int pcontrol,
int target)
1235 unsigned char ch_ctrl_m_pg[] = { 0x6, 0, 0, 0, 0, 0,
1237 unsigned char d_ctrl_m_pg[] = {0xa, 10, 2, 0, 0, 0, 0, 0,
1240 if (scsi_debug_dsense)
1241 ctrl_m_pg[2] |= 0x4;
1243 ctrl_m_pg[2] &= ~0x4;
1246 ctrl_m_pg[5] |= 0x80;
1248 memcpy(p, ctrl_m_pg,
sizeof(ctrl_m_pg));
1250 memcpy(p + 2, ch_ctrl_m_pg,
sizeof(ch_ctrl_m_pg));
1251 else if (2 == pcontrol)
1252 memcpy(p, d_ctrl_m_pg,
sizeof(d_ctrl_m_pg));
1253 return sizeof(ctrl_m_pg);
1257 static int resp_iec_m_pg(
unsigned char * p,
int pcontrol,
int target)
1259 unsigned char ch_iec_m_pg[] = { 0x4, 0xf, 0, 0, 0, 0,
1261 unsigned char d_iec_m_pg[] = {0x1c, 0xa, 0x08, 0, 0, 0, 0, 0,
1264 memcpy(p, iec_m_pg,
sizeof(iec_m_pg));
1266 memcpy(p + 2, ch_iec_m_pg,
sizeof(ch_iec_m_pg));
1267 else if (2 == pcontrol)
1268 memcpy(p, d_iec_m_pg,
sizeof(d_iec_m_pg));
1269 return sizeof(iec_m_pg);
1272 static int resp_sas_sf_m_pg(
unsigned char * p,
int pcontrol,
int target)
1274 unsigned char sas_sf_m_pg[] = {0x19, 0x6,
1275 0x6, 0x0, 0x7, 0xd0, 0x0, 0x0};
1277 memcpy(p, sas_sf_m_pg,
sizeof(sas_sf_m_pg));
1279 memset(p + 2, 0,
sizeof(sas_sf_m_pg) - 2);
1280 return sizeof(sas_sf_m_pg);
1284 static int resp_sas_pcd_m_spg(
unsigned char * p,
int pcontrol,
int target,
1287 unsigned char sas_pcd_m_pg[] = {0x59, 0x1, 0, 0x64, 0, 0x6, 0, 2,
1288 0, 0, 0, 0, 0x10, 0x9, 0x8, 0x0,
1289 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1290 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1291 0x2, 0, 0, 0, 0, 0, 0, 0,
1292 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1293 0, 0, 0, 0, 0, 0, 0, 0,
1294 0, 1, 0, 0, 0x10, 0x9, 0x8, 0x0,
1295 0x52, 0x22, 0x22, 0x20, 0x0, 0x0, 0x0, 0x0,
1296 0x51, 0x11, 0x11, 0x10, 0x0, 0x0, 0x0, 0x1,
1297 0x3, 0, 0, 0, 0, 0, 0, 0,
1298 0x88, 0x99, 0, 0, 0, 0, 0, 0,
1299 0, 0, 0, 0, 0, 0, 0, 0,
1303 port_a = target_dev_id + 1;
1304 port_b = port_a + 1;
1305 memcpy(p, sas_pcd_m_pg,
sizeof(sas_pcd_m_pg));
1306 p[20] = (port_a >> 24);
1307 p[21] = (port_a >> 16) & 0xff;
1308 p[22] = (port_a >> 8) & 0xff;
1309 p[23] = port_a & 0xff;
1310 p[48 + 20] = (port_b >> 24);
1311 p[48 + 21] = (port_b >> 16) & 0xff;
1312 p[48 + 22] = (port_b >> 8) & 0xff;
1313 p[48 + 23] = port_b & 0xff;
1315 memset(p + 4, 0,
sizeof(sas_pcd_m_pg) - 4);
1316 return sizeof(sas_pcd_m_pg);
1319 static int resp_sas_sha_m_spg(
unsigned char * p,
int pcontrol)
1321 unsigned char sas_sha_m_pg[] = {0x59, 0x2, 0, 0xc, 0, 0x6, 0x10, 0,
1322 0, 0, 0, 0, 0, 0, 0, 0,
1325 memcpy(p, sas_sha_m_pg,
sizeof(sas_sha_m_pg));
1327 memset(p + 4, 0,
sizeof(sas_sha_m_pg) - 4);
1328 return sizeof(sas_sha_m_pg);
1331 #define SDEBUG_MAX_MSENSE_SZ 256
1333 static int resp_mode_sense(
struct scsi_cmnd * scp,
int target,
1336 unsigned char dbd, llbaa;
1337 int pcontrol, pcode, subpcode, bd_len;
1338 unsigned char dev_spec;
1339 int k, alloc_len, msense_6,
offset,
len, errsts, target_dev_id;
1342 unsigned char *cmd = (
unsigned char *)scp->
cmnd;
1344 if ((errsts = check_readiness(scp, 1, devip)))
1346 dbd = !!(cmd[1] & 0x8);
1347 pcontrol = (cmd[2] & 0xc0) >> 6;
1348 pcode = cmd[2] & 0x3f;
1351 llbaa = msense_6 ? 0 : !!(cmd[1] & 0x10);
1352 if ((0 == scsi_debug_ptype) && (0 == dbd))
1353 bd_len = llbaa ? 16 : 8;
1356 alloc_len = msense_6 ? cmd[4] : ((cmd[7] << 8) | cmd[8]);
1358 if (0x3 == pcontrol) {
1361 return check_condition_result;
1363 target_dev_id = ((devip->
sdbg_host->shost->host_no + 1) * 2000) +
1364 (devip->
target * 1000) - 3;
1366 if (0 == scsi_debug_ptype)
1382 if ((bd_len > 0) && (!sdebug_capacity))
1383 sdebug_capacity = get_sdebug_capacity();
1386 if (sdebug_capacity > 0xfffffffe) {
1392 ap[0] = (sdebug_capacity >> 24) & 0xff;
1393 ap[1] = (sdebug_capacity >> 16) & 0xff;
1394 ap[2] = (sdebug_capacity >> 8) & 0xff;
1395 ap[3] = sdebug_capacity & 0xff;
1397 ap[6] = (scsi_debug_sector_size >> 8) & 0xff;
1398 ap[7] = scsi_debug_sector_size & 0xff;
1401 }
else if (16 == bd_len) {
1402 unsigned long long capac = sdebug_capacity;
1404 for (k = 0; k < 8; ++k, capac >>= 8)
1405 ap[7 - k] = capac & 0xff;
1406 ap[12] = (scsi_debug_sector_size >> 24) & 0xff;
1407 ap[13] = (scsi_debug_sector_size >> 16) & 0xff;
1408 ap[14] = (scsi_debug_sector_size >> 8) & 0xff;
1409 ap[15] = scsi_debug_sector_size & 0xff;
1414 if ((subpcode > 0x0) && (subpcode < 0xff) && (0x19 != pcode)) {
1418 return check_condition_result;
1422 len = resp_err_recov_pg(ap, pcontrol, target);
1426 len = resp_disconnect_pg(ap, pcontrol, target);
1430 len = resp_format_pg(ap, pcontrol, target);
1434 len = resp_caching_pg(ap, pcontrol, target);
1438 len = resp_ctrl_m_pg(ap, pcontrol, target);
1442 if ((subpcode > 0x2) && (subpcode < 0xff)) {
1445 return check_condition_result;
1448 if ((0x0 == subpcode) || (0xff == subpcode))
1449 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1450 if ((0x1 == subpcode) || (0xff == subpcode))
1451 len += resp_sas_pcd_m_spg(ap + len, pcontrol, target,
1453 if ((0x2 == subpcode) || (0xff == subpcode))
1454 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1458 len = resp_iec_m_pg(ap, pcontrol, target);
1462 if ((0 == subpcode) || (0xff == subpcode)) {
1463 len = resp_err_recov_pg(ap, pcontrol, target);
1464 len += resp_disconnect_pg(ap + len, pcontrol, target);
1465 len += resp_format_pg(ap + len, pcontrol, target);
1466 len += resp_caching_pg(ap + len, pcontrol, target);
1467 len += resp_ctrl_m_pg(ap + len, pcontrol, target);
1468 len += resp_sas_sf_m_pg(ap + len, pcontrol, target);
1469 if (0xff == subpcode) {
1470 len += resp_sas_pcd_m_spg(ap + len, pcontrol,
1471 target, target_dev_id);
1472 len += resp_sas_sha_m_spg(ap + len, pcontrol);
1474 len += resp_iec_m_pg(ap + len, pcontrol, target);
1478 return check_condition_result;
1485 return check_condition_result;
1488 arr[0] = offset - 1;
1490 arr[0] = ((offset - 2) >> 8) & 0xff;
1491 arr[1] = (offset - 2) & 0xff;
1493 return fill_from_dev_buffer(scp, arr,
min(alloc_len, offset));
1496 #define SDEBUG_MAX_MSELECT_SZ 512
1498 static int resp_mode_select(
struct scsi_cmnd * scp,
int mselect6,
1501 int pf,
sp,
ps, md_len, bd_len, off, spf, pg_len;
1502 int param_len,
res, errsts, mpage;
1504 unsigned char *cmd = (
unsigned char *)scp->
cmnd;
1506 if ((errsts = check_readiness(scp, 1, devip)))
1508 memset(arr, 0,
sizeof(arr));
1511 param_len = mselect6 ? cmd[4] : ((cmd[7] << 8) + cmd[8]);
1515 return check_condition_result;
1517 res = fetch_to_dev_buffer(scp, arr, param_len);
1520 else if ((res < param_len) &&
1523 " IO sent=%d bytes\n", param_len, res);
1524 md_len = mselect6 ? (arr[0] + 1) : ((arr[0] << 8) + arr[1] + 2);
1525 bd_len = mselect6 ? arr[3] : ((arr[6] << 8) + arr[7]);
1529 return check_condition_result;
1531 off = bd_len + (mselect6 ? 4 : 8);
1532 mpage = arr[off] & 0x3f;
1533 ps = !!(arr[off] & 0x80);
1537 return check_condition_result;
1539 spf = !!(arr[off] & 0x40);
1540 pg_len = spf ? ((arr[off + 2] << 8) + arr[off + 3] + 4) :
1542 if ((pg_len + off) > param_len) {
1545 return check_condition_result;
1549 if (ctrl_m_pg[1] == arr[off + 1]) {
1550 memcpy(ctrl_m_pg + 2, arr + off + 2,
1551 sizeof(ctrl_m_pg) - 2);
1552 scsi_debug_dsense = !!(ctrl_m_pg[2] & 0x4);
1557 if (iec_m_pg[1] == arr[off + 1]) {
1558 memcpy(iec_m_pg + 2, arr + off + 2,
1559 sizeof(iec_m_pg) - 2);
1568 return check_condition_result;
1571 static int resp_temp_l_pg(
unsigned char * arr)
1573 unsigned char temp_l_pg[] = {0x0, 0x0, 0x3, 0x2, 0x0, 38,
1574 0x0, 0x1, 0x3, 0x2, 0x0, 65,
1577 memcpy(arr, temp_l_pg,
sizeof(temp_l_pg));
1578 return sizeof(temp_l_pg);
1581 static int resp_ie_l_pg(
unsigned char * arr)
1583 unsigned char ie_l_pg[] = {0x0, 0x0, 0x3, 0x3, 0x0, 0x0, 38,
1586 memcpy(arr, ie_l_pg,
sizeof(ie_l_pg));
1587 if (iec_m_pg[2] & 0x4) {
1591 return sizeof(ie_l_pg);
1594 #define SDEBUG_MAX_LSENSE_SZ 512
1596 static int resp_log_sense(
struct scsi_cmnd * scp,
1599 int ppc,
sp, pcontrol, pcode, subpcode, alloc_len, errsts,
len,
n;
1601 unsigned char *cmd = (
unsigned char *)scp->
cmnd;
1603 if ((errsts = check_readiness(scp, 1, devip)))
1605 memset(arr, 0,
sizeof(arr));
1611 return check_condition_result;
1613 pcontrol = (cmd[2] & 0xc0) >> 6;
1614 pcode = cmd[2] & 0x3f;
1615 subpcode = cmd[3] & 0xff;
1616 alloc_len = (cmd[7] << 8) + cmd[8];
1618 if (0 == subpcode) {
1628 arr[3] = resp_temp_l_pg(arr + 4);
1631 arr[3] = resp_ie_l_pg(arr + 4);
1636 return check_condition_result;
1638 }
else if (0xff == subpcode) {
1669 return check_condition_result;
1674 return check_condition_result;
1676 len =
min(((arr[2] << 8) + arr[3]) + 4, alloc_len);
1677 return fill_from_dev_buffer(scp, arr,
1682 unsigned long long lba,
unsigned int num)
1684 if (lba + num > sdebug_capacity) {
1686 return check_condition_result;
1689 if (num > sdebug_store_sectors) {
1691 return check_condition_result;
1696 static int do_device_access(
struct scsi_cmnd *scmd,
1698 unsigned long long lba,
unsigned int num,
int write)
1704 func = write ? fetch_to_dev_buffer : fill_from_dev_buffer;
1706 block =
do_div(lba, sdebug_store_sectors);
1707 if (block + num > sdebug_store_sectors)
1708 rest = block + num - sdebug_store_sectors;
1710 ret =
func(scmd, fake_storep + (block * scsi_debug_sector_size),
1711 (num - rest) * scsi_debug_sector_size);
1713 ret =
func(scmd, fake_storep, rest * scsi_debug_sector_size);
1721 unsigned int i, resid;
1728 start_sec =
do_div(tmp_sec, sdebug_store_sectors);
1730 sdt = (
struct sd_dif_tuple *)(dif_storep + dif_offset(start_sec));
1732 for (i = 0 ; i <
sectors ; i++) {
1738 sector = start_sec +
i;
1740 switch (scsi_debug_guard) {
1743 sector * scsi_debug_sector_size,
1744 scsi_debug_sector_size);
1748 sector * scsi_debug_sector_size,
1749 scsi_debug_sector_size);
1758 " rcvd 0x%04x, data 0x%04x\n", __func__,
1759 (
unsigned long)sector,
1769 __func__, (
unsigned long)sector);
1777 __func__, (
unsigned long)sector);
1785 resid = sectors * 8;
1792 memcpy(paddr, dif_storep + dif_offset(sector), len);
1795 if (sector >= sdebug_store_sectors) {
1798 sector =
do_div(tmp_sec, sdebug_store_sectors);
1809 static int resp_read(
struct scsi_cmnd *SCpnt,
unsigned long long lba,
1813 unsigned long iflags;
1816 ret = check_device_access_params(devip, lba, num);
1835 scsi_set_resid(SCpnt, scsi_bufflen(SCpnt));
1836 return check_condition_result;
1840 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
1841 int prot_ret = prot_verify_read(SCpnt, lba, num, ei_lba);
1845 return illegal_condition_result;
1850 ret = do_device_access(SCpnt, devip, lba, num, 0);
1861 for (i = 0 ; i < len ; i += 16) {
1864 for (j = 0 ; j < 16 ; j++) {
1865 unsigned char c = buf[i+
j];
1866 if (c >= 0x20 && c < 0x7e)
1867 printk(
" %c ", buf[i+j]);
1869 printk(
"%02x ", buf[i+j]);
1877 unsigned int sectors,
u32 ei_lba)
1882 struct scatterlist *psgl = scsi_prot_sglist(SCpnt);
1887 unsigned short csum;
1889 sector =
do_div(tmp_sec, sdebug_store_sectors);
1891 BUG_ON(scsi_sg_count(SCpnt) == 0);
1892 BUG_ON(scsi_prot_sg_count(SCpnt) == 0);
1902 for (j = 0 ; j < dsgl->
length ; j += scsi_debug_sector_size) {
1907 if (ppage_offset >= psgl->
length) {
1916 sdt = paddr + ppage_offset;
1918 switch (scsi_debug_guard) {
1921 scsi_debug_sector_size);
1925 scsi_debug_sector_size));
1935 "%s: GUARD check failed on sector %lu " \
1936 "rcvd 0x%04x, calculated 0x%04x\n",
1937 __func__, (
unsigned long)sector,
1947 != (start_sec & 0xffffffff)) {
1949 "%s: REF check failed on sector %lu\n",
1950 __func__, (
unsigned long)sector);
1959 "%s: REF check failed on sector %lu\n",
1960 __func__, (
unsigned long)sector);
1971 memcpy(dif_storep + dif_offset(sector), sdt, 8);
1975 if (sector == sdebug_store_sectors)
1980 daddr += scsi_debug_sector_size;
2000 static unsigned int map_state(
sector_t lba,
unsigned int *num)
2005 granularity = scsi_debug_unmap_granularity;
2006 alignment = granularity - scsi_debug_unmap_alignment;
2008 do_div(block, granularity);
2010 mapped =
test_bit(block, map_storep);
2017 end = next * granularity - scsi_debug_unmap_alignment;
2028 granularity = scsi_debug_unmap_granularity;
2029 alignment = granularity - scsi_debug_unmap_alignment;
2035 rem =
do_div(block, granularity);
2037 if (block < map_size)
2040 lba += granularity - rem;
2044 static void unmap_region(
sector_t lba,
unsigned int len)
2049 granularity = scsi_debug_unmap_granularity;
2050 alignment = granularity - scsi_debug_unmap_alignment;
2056 rem =
do_div(block, granularity);
2058 if (rem == 0 && lba + granularity < end && block < map_size) {
2060 if (scsi_debug_lbprz)
2062 block * scsi_debug_sector_size, 0,
2063 scsi_debug_sector_size);
2065 lba += granularity - rem;
2069 static int resp_write(
struct scsi_cmnd *SCpnt,
unsigned long long lba,
2073 unsigned long iflags;
2076 ret = check_device_access_params(devip, lba, num);
2081 if (scsi_debug_dix && scsi_prot_sg_count(SCpnt)) {
2082 int prot_ret = prot_verify_write(SCpnt, lba, num, ei_lba);
2086 return illegal_condition_result;
2091 ret = do_device_access(SCpnt, devip, lba, num, 1);
2092 if (scsi_debug_unmap_granularity)
2097 else if ((ret < (num * scsi_debug_sector_size)) &&
2100 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
2105 static int resp_write_same(
struct scsi_cmnd *scmd,
unsigned long long lba,
2109 unsigned long iflags;
2110 unsigned long long i;
2113 ret = check_device_access_params(devip, lba, num);
2117 if (num > scsi_debug_write_same_length) {
2120 return check_condition_result;
2125 if (unmap && scsi_debug_unmap_granularity) {
2126 unmap_region(lba, num);
2131 ret = fetch_to_dev_buffer(scmd,
2132 fake_storep + (lba * scsi_debug_sector_size),
2133 scsi_debug_sector_size);
2138 }
else if ((ret < (num * scsi_debug_sector_size)) &&
2141 " IO sent=%d bytes\n", num * scsi_debug_sector_size, ret);
2144 for (i = 1 ; i < num ; i++)
2145 memcpy(fake_storep + ((lba + i) * scsi_debug_sector_size),
2146 fake_storep + (lba * scsi_debug_sector_size),
2147 scsi_debug_sector_size);
2149 if (scsi_debug_unmap_granularity)
2170 ret = check_readiness(scmd, 1, devip);
2174 payload_len = get_unaligned_be16(&scmd->
cmnd[7]);
2175 BUG_ON(scsi_bufflen(scmd) != payload_len);
2177 descriptors = (payload_len - 8) / 16;
2181 return check_condition_result;
2183 scsi_sg_copy_to_buffer(scmd, buf, scsi_bufflen(scmd));
2185 BUG_ON(get_unaligned_be16(&buf[0]) != payload_len - 2);
2186 BUG_ON(get_unaligned_be16(&buf[2]) != descriptors * 16);
2188 desc = (
void *)&buf[8];
2194 ret = check_device_access_params(devip, lba, num);
2198 unmap_region(lba, num);
2209 #define SDEBUG_GET_LBA_STATUS_LEN 32
2211 static int resp_get_lba_status(
struct scsi_cmnd * scmd,
2214 unsigned long long lba;
2215 unsigned int alloc_len,
mapped, num;
2219 ret = check_readiness(scmd, 1, devip);
2229 ret = check_device_access_params(devip, lba, 1);
2233 mapped = map_state(lba, &num);
2244 #define SDEBUG_RLUN_ARR_SZ 256
2246 static int resp_report_luns(
struct scsi_cmnd * scp,
2249 unsigned int alloc_len;
2250 int lun_cnt,
i, upper, num,
n, wlun,
lun;
2251 unsigned char *cmd = (
unsigned char *)scp->
cmnd;
2252 int select_report = (
int)cmd[2];
2255 unsigned char * max_addr;
2257 alloc_len = cmd[9] + (cmd[8] << 8) + (cmd[7] << 16) + (cmd[6] << 24);
2258 if ((alloc_len < 4) || (select_report > 2)) {
2261 return check_condition_result;
2265 lun_cnt = scsi_debug_max_luns;
2266 if (1 == select_report)
2268 else if (scsi_debug_no_lun_0 && (lun_cnt > 0))
2270 wlun = (select_report > 0) ? 1 : 0;
2271 num = lun_cnt + wlun;
2272 arr[2] = ((
sizeof(
struct scsi_lun) * num) >> 8) & 0xff;
2273 arr[3] = (
sizeof(
struct scsi_lun) * num) & 0xff;
2280 one_lun = (
struct scsi_lun *) &arr[8];
2282 for (i = 0, lun = (scsi_debug_no_lun_0 ? 1 : 0);
2283 ((i < lun_cnt) && ((
unsigned char *)(one_lun +
i) < max_addr));
2285 upper = (lun >> 8) & 0x3f;
2296 alloc_len = (
unsigned char *)(one_lun + i) - arr;
2297 return fill_from_dev_buffer(scp, arr,
2298 min((
int)alloc_len, SDEBUG_RLUN_ARR_SZ));
2301 static int resp_xdwriteread(
struct scsi_cmnd *scp,
unsigned long long lba,
2305 unsigned char *kaddr, *
buf;
2315 scsi_sg_copy_to_buffer(scp, buf, scsi_bufflen(scp));
2319 kaddr = (
unsigned char *)
kmap_atomic(sg_page(sg));
2323 for (j = 0; j < sg->
length; j++)
2324 *(kaddr + sg->
offset + j) ^= *(buf + offset +
j);
2337 static void timer_intr_handler(
unsigned long indx)
2340 unsigned long iflags;
2342 if (indx >= scsi_debug_max_queue) {
2348 sqcp = &queued_arr[(
int)indx];
2352 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2361 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2370 devip = kzalloc(
sizeof(*devip), flags);
2395 (devip->
lun == sdev->
lun))
2398 if ((!devip->
used) && (!open_devip))
2403 open_devip = sdebug_device_create(sdbg_host,
GFP_ATOMIC);
2406 __func__, __LINE__);
2413 open_devip->
lun = sdev->
lun;
2415 open_devip->
reset = 1;
2416 open_devip->
used = 1;
2418 if (scsi_debug_dsense)
2430 static int scsi_debug_slave_alloc(
struct scsi_device *sdp)
2435 queue_flag_set_unlocked(QUEUE_FLAG_BIDI, sdp->
request_queue);
2439 static int scsi_debug_slave_configure(
struct scsi_device *sdp)
2448 devip = devInfoReg(sdp);
2452 if (sdp->
host->cmd_per_lun)
2454 sdp->
host->cmd_per_lun);
2456 if (scsi_debug_no_uld)
2461 static void scsi_debug_slave_destroy(
struct scsi_device *sdp)
2477 static int stop_queued_cmnd(
struct scsi_cmnd *cmnd)
2479 unsigned long iflags;
2484 for (k = 0; k < scsi_debug_max_queue; ++
k) {
2485 sqcp = &queued_arr[
k];
2493 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2494 return (k < scsi_debug_max_queue) ? 1 : 0;
2498 static void stop_all_queued(
void)
2500 unsigned long iflags;
2505 for (k = 0; k < scsi_debug_max_queue; ++
k) {
2506 sqcp = &queued_arr[
k];
2513 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2516 static int scsi_debug_abort(
struct scsi_cmnd * SCpnt)
2521 stop_queued_cmnd(SCpnt);
2525 static int scsi_debug_biosparam(
struct scsi_device *sdev,
2536 &info[2], &info[0], &info[1]);
2541 info[0] = sdebug_heads;
2542 info[1] = sdebug_sectors_per;
2543 info[2] = sdebug_cylinders_per;
2547 static int scsi_debug_device_reset(
struct scsi_cmnd * SCpnt)
2555 devip = devInfoReg(SCpnt->
device);
2562 static int scsi_debug_bus_reset(
struct scsi_cmnd * SCpnt)
2572 if (SCpnt && ((sdp = SCpnt->
device)) && ((hp = sdp->
host))) {
2578 dev_info->reset = 1;
2592 spin_lock(&sdebug_host_list_lock);
2596 dev_info->reset = 1;
2598 spin_unlock(&sdebug_host_list_lock);
2604 static
void __init init_all_queued(
void)
2606 unsigned long iflags;
2611 for (k = 0; k < scsi_debug_max_queue; ++
k) {
2612 sqcp = &queued_arr[
k];
2617 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2620 static void __init sdebug_build_parts(
unsigned char *ramp,
2621 unsigned long store_size)
2625 int sectors_per_part, num_sectors,
k;
2626 int heads_by_sects, start_sec, end_sec;
2629 if ((scsi_debug_num_parts < 1) || (store_size < 1048576))
2636 num_sectors = (
int)sdebug_store_sectors;
2637 sectors_per_part = (num_sectors - sdebug_sectors_per)
2638 / scsi_debug_num_parts;
2639 heads_by_sects = sdebug_heads * sdebug_sectors_per;
2640 starts[0] = sdebug_sectors_per;
2641 for (k = 1; k < scsi_debug_num_parts; ++
k)
2642 starts[k] = ((k * sectors_per_part) / heads_by_sects)
2644 starts[scsi_debug_num_parts] = num_sectors;
2645 starts[scsi_debug_num_parts + 1] = 0;
2649 pp = (
struct partition *)(ramp + 0x1be);
2650 for (k = 0; starts[k + 1]; ++
k, ++
pp) {
2651 start_sec = starts[
k];
2652 end_sec = starts[k + 1] - 1;
2655 pp->cyl = start_sec / heads_by_sects;
2656 pp->head = (start_sec - (pp->cyl * heads_by_sects))
2657 / sdebug_sectors_per;
2658 pp->sector = (start_sec % sdebug_sectors_per) + 1;
2660 pp->end_cyl = end_sec / heads_by_sects;
2661 pp->end_head = (end_sec - (pp->end_cyl * heads_by_sects))
2662 / sdebug_sectors_per;
2663 pp->end_sector = (end_sec % sdebug_sectors_per) + 1;
2665 pp->start_sect = start_sec;
2666 pp->nr_sects = end_sec - start_sec + 1;
2671 static int schedule_resp(
struct scsi_cmnd * cmnd,
2680 "non-zero result=0x%x\n", sdp->
host->host_no,
2684 if (cmnd && devip) {
2691 if (delta_jiff <= 0) {
2693 cmnd->
result = scsi_result;
2698 unsigned long iflags;
2703 for (k = 0; k < scsi_debug_max_queue; ++
k) {
2704 sqcp = &queued_arr[
k];
2708 if (k >= scsi_debug_max_queue) {
2709 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2717 sqcp->
cmnd_timer.function = timer_intr_handler;
2721 spin_unlock_irqrestore(&queued_arr_lock, iflags);
2787 MODULE_PARM_DESC(lbpws,
"enable LBP, support WRITE SAME(16) with UNMAP bit (def=0)");
2788 MODULE_PARM_DESC(lbpws10,
"enable LBP, support WRITE SAME(10) with UNMAP bit (def=0)");
2791 MODULE_PARM_DESC(max_luns,
"number of LUNs per target to simulate(def=1)");
2792 MODULE_PARM_DESC(max_queue,
"max number of queued commands (1 to 255(def))");
2796 MODULE_PARM_DESC(num_tgts,
"number of targets per host to simulate(def=1)");
2804 MODULE_PARM_DESC(unmap_alignment,
"lowest aligned thin provisioning lba (def=0)");
2805 MODULE_PARM_DESC(unmap_granularity,
"thin provisioning granularity in blocks (def=1)");
2806 MODULE_PARM_DESC(unmap_max_blocks,
"max # of blocks can be unmapped in one cmd (def=0xffffffff)");
2807 MODULE_PARM_DESC(unmap_max_desc,
"max # of ranges that can be unmapped in one cmd (def=256)");
2808 MODULE_PARM_DESC(virtual_gb,
"virtual gigabyte size (def=0 -> use dev_size_mb)");
2809 MODULE_PARM_DESC(vpd_use_hostno,
"0 -> dev ids ignore hostno (def=1 -> unique dev ids)");
2810 MODULE_PARM_DESC(write_same_length,
"Maximum blocks per WRITE SAME cmd (def=0xffff)");
2812 static char sdebug_info[256];
2814 static const char * scsi_debug_info(
struct Scsi_Host * shp)
2816 sprintf(sdebug_info,
"scsi_debug, version %s [%s], "
2818 scsi_debug_version_date, scsi_debug_dev_size_mb,
2829 int len,
pos, begin;
2836 int minLen = length > 15 ? 15 :
length;
2840 memcpy(arr, buffer, minLen);
2842 if (1 !=
sscanf(arr,
"%d", &pos))
2844 scsi_debug_opts =
pos;
2845 if (scsi_debug_every_nth != 0)
2846 scsi_debug_cmnd_count = 0;
2850 pos = len =
sprintf(buffer,
"scsi_debug adapter driver, version "
2852 "num_tgts=%d, shared (ram) size=%d MB, opts=0x%x, "
2853 "every_nth=%d(curr:%d)\n"
2854 "delay=%d, max_luns=%d, scsi_level=%d\n"
2855 "sector_size=%d bytes, cylinders=%d, heads=%d, sectors=%d\n"
2856 "number of aborts=%d, device_reset=%d, bus_resets=%d, "
2857 "host_resets=%d\ndix_reads=%d dix_writes=%d dif_errors=%d\n",
2859 scsi_debug_dev_size_mb, scsi_debug_opts, scsi_debug_every_nth,
2860 scsi_debug_cmnd_count, scsi_debug_delay,
2861 scsi_debug_max_luns, scsi_debug_scsi_level,
2862 scsi_debug_sector_size, sdebug_cylinders_per, sdebug_heads,
2863 sdebug_sectors_per, num_aborts, num_dev_resets, num_bus_resets,
2864 num_host_resets, dix_reads, dix_writes, dif_errors);
2869 *start = buffer + (offset - begin);
2870 len -= (offset - begin);
2882 const char * buf,
size_t count)
2887 if (1 ==
sscanf(buf,
"%10s", work)) {
2888 if ((1 ==
sscanf(work,
"%d", &delay)) && (delay >= 0)) {
2889 scsi_debug_delay =
delay;
2896 sdebug_delay_store);
2904 const char * buf,
size_t count)
2909 if (1 ==
sscanf(buf,
"%10s", work)) {
2911 if (1 ==
sscanf(&work[2],
"%x", &opts))
2914 if (1 ==
sscanf(work,
"%d", &opts))
2920 scsi_debug_opts =
opts;
2921 scsi_debug_cmnd_count = 0;
2932 const char * buf,
size_t count)
2936 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n >= 0)) {
2937 scsi_debug_ptype =
n;
2949 const char * buf,
size_t count)
2953 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n >= 0)) {
2954 scsi_debug_dsense =
n;
2960 sdebug_dsense_store);
2967 const char * buf,
size_t count)
2971 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n >= 0)) {
2972 scsi_debug_fake_rw =
n;
2978 sdebug_fake_rw_store);
2985 const char * buf,
size_t count)
2989 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n >= 0)) {
2990 scsi_debug_no_lun_0 =
n;
2996 sdebug_no_lun_0_store);
3003 const char * buf,
size_t count)
3007 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n >= 0)) {
3008 scsi_debug_num_tgts =
n;
3009 sdebug_max_tgts_luns();
3015 sdebug_num_tgts_store);
3034 const char * buf,
size_t count)
3038 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &nth))) {
3039 scsi_debug_every_nth = nth;
3040 scsi_debug_cmnd_count = 0;
3046 sdebug_every_nth_store);
3053 const char * buf,
size_t count)
3057 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n >= 0)) {
3058 scsi_debug_max_luns =
n;
3059 sdebug_max_tgts_luns();
3065 sdebug_max_luns_store);
3072 const char * buf,
size_t count)
3076 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n > 0) &&
3078 scsi_debug_max_queue =
n;
3084 sdebug_max_queue_store);
3103 const char * buf,
size_t count)
3107 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n >= 0)) {
3108 scsi_debug_virtual_gb =
n;
3110 sdebug_capacity = get_sdebug_capacity();
3117 sdebug_virtual_gb_store);
3125 const char * buf,
size_t count)
3129 if (
sscanf(buf,
"%d", &delta_hosts) != 1)
3131 if (delta_hosts > 0) {
3133 sdebug_add_adapter();
3134 }
while (--delta_hosts);
3135 }
else if (delta_hosts < 0) {
3137 sdebug_remove_adapter();
3138 }
while (++delta_hosts);
3143 sdebug_add_host_store);
3151 const char * buf,
size_t count)
3155 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n >= 0)) {
3156 scsi_debug_vpd_use_hostno =
n;
3162 sdebug_vpd_use_hostno_store);
3198 if (!scsi_debug_lbp())
3200 sdebug_store_sectors);
3204 buf[count++] =
'\n';
3217 const char *buf,
size_t count)
3221 if ((count > 0) && (1 ==
sscanf(buf,
"%d", &n)) && (n >= 0)) {
3222 scsi_debug_removable = (n > 0);
3228 sdebug_removable_store);
3237 static int do_create_driverfs_files(
void)
3268 static void do_remove_driverfs_files(
void)
3298 static int __init scsi_debug_init(
void)
3305 switch (scsi_debug_sector_size) {
3313 scsi_debug_sector_size);
3317 switch (scsi_debug_dif) {
3330 if (scsi_debug_guard > 1) {
3335 if (scsi_debug_ato > 1) {
3340 if (scsi_debug_physblk_exp > 15) {
3342 scsi_debug_physblk_exp);
3346 if (scsi_debug_lowest_aligned > 0x3fff) {
3348 scsi_debug_lowest_aligned);
3352 if (scsi_debug_dev_size_mb < 1)
3353 scsi_debug_dev_size_mb = 1;
3354 sz = (
unsigned long)scsi_debug_dev_size_mb * 1048576;
3355 sdebug_store_sectors = sz / scsi_debug_sector_size;
3356 sdebug_capacity = get_sdebug_capacity();
3360 sdebug_sectors_per = 32;
3361 if (scsi_debug_dev_size_mb >= 16)
3363 else if (scsi_debug_dev_size_mb >= 256)
3365 sdebug_cylinders_per = (
unsigned long)sdebug_capacity /
3366 (sdebug_sectors_per * sdebug_heads);
3367 if (sdebug_cylinders_per >= 1024) {
3370 sdebug_sectors_per = 63;
3371 sdebug_cylinders_per = (
unsigned long)sdebug_capacity /
3372 (sdebug_sectors_per * sdebug_heads);
3376 if (
NULL == fake_storep) {
3380 memset(fake_storep, 0, sz);
3381 if (scsi_debug_num_parts > 0)
3382 sdebug_build_parts(fake_storep, sz);
3384 if (scsi_debug_dif) {
3387 dif_size = sdebug_store_sectors *
sizeof(
struct sd_dif_tuple);
3388 dif_storep =
vmalloc(dif_size);
3391 dif_size, dif_storep);
3393 if (dif_storep ==
NULL) {
3399 memset(dif_storep, 0xff, dif_size);
3403 if (scsi_debug_lbp()) {
3404 unsigned int map_bytes;
3406 scsi_debug_unmap_max_blocks =
3407 clamp(scsi_debug_unmap_max_blocks, 0
U, 0xffffffffU);
3409 scsi_debug_unmap_max_desc =
3410 clamp(scsi_debug_unmap_max_desc, 0
U, 256
U);
3412 scsi_debug_unmap_granularity =
3413 clamp(scsi_debug_unmap_granularity, 1
U, 0xffffffffU);
3415 if (scsi_debug_unmap_alignment &&
3416 scsi_debug_unmap_granularity < scsi_debug_unmap_alignment) {
3418 "%s: ERR: unmap_granularity < unmap_alignment\n",
3423 map_size = (sdebug_store_sectors / scsi_debug_unmap_granularity);
3424 map_bytes = map_size >> 3;
3425 map_storep =
vmalloc(map_bytes);
3430 if (map_storep ==
NULL) {
3436 memset(map_storep, 0x0, map_bytes);
3439 if (scsi_debug_num_parts)
3444 if (IS_ERR(pseudo_primary)) {
3446 ret = PTR_ERR(pseudo_primary);
3461 ret = do_create_driverfs_files();
3470 host_to_add = scsi_debug_add_host;
3471 scsi_debug_add_host = 0;
3473 for (k = 0; k < host_to_add; k++) {
3474 if (sdebug_add_adapter()) {
3476 "sdebug_add_adapter failed k=%d\n", k);
3483 scsi_debug_add_host);
3488 do_remove_driverfs_files();
3504 static void __exit scsi_debug_exit(
void)
3506 int k = scsi_debug_add_host;
3510 sdebug_remove_adapter();
3511 do_remove_driverfs_files();
3525 static void sdebug_release_adapter(
struct device * dev)
3533 static int sdebug_add_adapter(
void)
3535 int k, devs_per_host;
3540 sdbg_host = kzalloc(
sizeof(*sdbg_host),
GFP_KERNEL);
3541 if (
NULL == sdbg_host) {
3543 __func__, __LINE__);
3549 devs_per_host = scsi_debug_num_tgts * scsi_debug_max_luns;
3550 for (k = 0; k < devs_per_host; k++) {
3551 sdbg_devinfo = sdebug_device_create(sdbg_host,
GFP_KERNEL);
3552 if (!sdbg_devinfo) {
3554 __func__, __LINE__);
3560 spin_lock(&sdebug_host_list_lock);
3562 spin_unlock(&sdebug_host_list_lock);
3564 sdbg_host->
dev.bus = &pseudo_lld_bus;
3566 sdbg_host->
dev.release = &sdebug_release_adapter;
3574 ++scsi_debug_add_host;
3581 kfree(sdbg_devinfo);
3588 static void sdebug_remove_adapter(
void)
3592 spin_lock(&sdebug_host_list_lock);
3593 if (!list_empty(&sdebug_host_list)) {
3594 sdbg_host =
list_entry(sdebug_host_list.prev,
3598 spin_unlock(&sdebug_host_list_lock);
3604 --scsi_debug_add_host;
3610 unsigned char *cmd = (
unsigned char *) SCpnt->
cmnd;
3613 unsigned long long lba;
3616 int target = SCpnt->
device->id;
3618 int inj_recovered = 0;
3619 int inj_transport = 0;
3622 int delay_override = 0;
3625 scsi_set_resid(SCpnt, 0);
3628 for (k = 0, len = SCpnt->
cmd_len; k < len; ++k)
3629 printk(
"%02x ", (
int)cmd[k]);
3633 if (target == SCpnt->
device->host->hostt->this_id) {
3636 return schedule_resp(SCpnt,
NULL, done,
3640 if ((SCpnt->
device->lun >= scsi_debug_max_luns) &&
3642 return schedule_resp(SCpnt,
NULL, done,
3644 devip = devInfoReg(SCpnt->
device);
3646 return schedule_resp(SCpnt,
NULL, done,
3649 if ((scsi_debug_every_nth != 0) &&
3650 (++scsi_debug_cmnd_count >=
abs(scsi_debug_every_nth))) {
3651 scsi_debug_cmnd_count = 0;
3652 if (scsi_debug_every_nth < -1)
3653 scsi_debug_every_nth = -1;
3657 scsi_medium_access_command(SCpnt))
3679 "not supported for wlun\n", *cmd);
3682 errsts = check_condition_result;
3683 return schedule_resp(SCpnt, devip, done, errsts,
3691 errsts = resp_inquiry(SCpnt, target, devip);
3695 errsts = resp_requests(SCpnt, devip);
3699 errsts = resp_start_stop(SCpnt, devip);
3702 errsts = check_readiness(SCpnt, 1, devip);
3707 cmd[4] ?
"inhibited" :
"enabled");
3710 errsts = check_readiness(SCpnt, 1, devip);
3714 errsts = check_readiness(SCpnt, 0, devip);
3717 errsts = check_readiness(SCpnt, 1, devip);
3720 errsts = check_readiness(SCpnt, 1, devip);
3723 errsts = check_readiness(SCpnt, 1, devip);
3726 errsts = check_readiness(SCpnt, 1, devip);
3729 errsts = resp_readcap(SCpnt, devip);
3733 errsts = resp_readcap16(SCpnt, devip);
3736 if (scsi_debug_lbp() == 0) {
3739 errsts = check_condition_result;
3741 errsts = resp_get_lba_status(SCpnt, devip);
3745 errsts = check_condition_result;
3752 errsts = check_condition_result;
3755 errsts = resp_report_tgtpgs(SCpnt, devip);
3765 errsts = check_condition_result;
3771 (cmd[1] & 0xe0) == 0)
3777 errsts = check_readiness(SCpnt, 0, devip);
3780 if (scsi_debug_fake_rw)
3782 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3783 errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
3784 if (inj_recovered && (0 == errsts)) {
3787 errsts = check_condition_result;
3788 }
else if (inj_transport && (0 == errsts)) {
3791 errsts = check_condition_result;
3792 }
else if (inj_dif && (0 == errsts)) {
3794 errsts = illegal_condition_result;
3795 }
else if (inj_dix && (0 == errsts)) {
3797 errsts = illegal_condition_result;
3802 errsts = resp_report_luns(SCpnt, devip);
3805 errsts = check_readiness(SCpnt, 0, devip);
3815 errsts = check_condition_result;
3821 (cmd[1] & 0xe0) == 0)
3827 errsts = check_readiness(SCpnt, 0, devip);
3830 if (scsi_debug_fake_rw)
3832 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3833 errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
3834 if (inj_recovered && (0 == errsts)) {
3837 errsts = check_condition_result;
3838 }
else if (inj_dif && (0 == errsts)) {
3840 errsts = illegal_condition_result;
3841 }
else if (inj_dix && (0 == errsts)) {
3843 errsts = illegal_condition_result;
3850 (*cmd ==
WRITE_SAME && scsi_debug_lbpws10 == 0)) {
3853 errsts = check_condition_result;
3859 errsts = check_readiness(SCpnt, 0, devip);
3862 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3863 errsts = resp_write_same(SCpnt, lba, num, devip, ei_lba, unmap);
3866 errsts = check_readiness(SCpnt, 0, devip);
3870 if (scsi_debug_unmap_max_desc == 0 || scsi_debug_lbpu == 0) {
3873 errsts = check_condition_result;
3875 errsts = resp_unmap(SCpnt, devip);
3879 errsts = resp_mode_sense(SCpnt, target, devip);
3882 errsts = resp_mode_select(SCpnt, 1, devip);
3885 errsts = resp_mode_select(SCpnt, 0, devip);
3888 errsts = resp_log_sense(SCpnt, devip);
3892 errsts = check_readiness(SCpnt, 0, devip);
3895 errsts = check_readiness(SCpnt, 1, devip);
3898 if (!scsi_bidi_cmnd(SCpnt)) {
3901 errsts = check_condition_result;
3905 errsts = check_readiness(SCpnt, 0, devip);
3908 if (scsi_debug_fake_rw)
3910 get_data_transfer_info(cmd, &lba, &num, &ei_lba);
3911 errsts = resp_read(SCpnt, lba, num, devip, ei_lba);
3914 errsts = resp_write(SCpnt, lba, num, devip, ei_lba);
3917 errsts = resp_xdwriteread(SCpnt, lba, num, devip);
3922 if ((cmd[10] & 0xe0) == 0)
3924 "Unprotected RD/WR to DIF device\n");
3939 errsts = check_condition_result;
3945 "supported\n", *cmd);
3946 errsts = check_readiness(SCpnt, 1, devip);
3950 errsts = check_condition_result;
3953 return schedule_resp(SCpnt, devip, done, errsts,
3954 (delay_override ? 0 : scsi_debug_delay));
3961 .proc_name = sdebug_proc_name,
3962 .name =
"SCSI DEBUG",
3963 .info = scsi_debug_info,
3964 .slave_alloc = scsi_debug_slave_alloc,
3965 .slave_configure = scsi_debug_slave_configure,
3966 .slave_destroy = scsi_debug_slave_destroy,
3967 .ioctl = scsi_debug_ioctl,
3968 .queuecommand = scsi_debug_queuecommand,
3969 .eh_abort_handler = scsi_debug_abort,
3970 .eh_bus_reset_handler = scsi_debug_bus_reset,
3971 .eh_device_reset_handler = scsi_debug_device_reset,
3972 .eh_host_reset_handler = scsi_debug_host_reset,
3973 .bios_param = scsi_debug_biosparam,
3976 .sg_tablesize = 256,
3978 .max_sectors = 0xffff,
3983 static int sdebug_driver_probe(
struct device * dev)
3992 sdebug_driver_template.can_queue = scsi_debug_max_queue;
4000 sdbg_host->
shost = hpnt;
4002 if ((hpnt->
this_id >= 0) && (scsi_debug_num_tgts > hpnt->
this_id))
4003 hpnt->
max_id = scsi_debug_num_tgts + 1;
4005 hpnt->
max_id = scsi_debug_num_tgts;
4010 switch (scsi_debug_dif) {
4036 scsi_host_set_prot(hpnt, host_prot);
4047 if (scsi_debug_guard == 1)
4052 error = scsi_add_host(hpnt, &sdbg_host->
dev);
4064 static int sdebug_driver_remove(
struct device * dev)
4082 kfree(sdbg_devinfo);
4089 static int pseudo_lld_bus_match(
struct device *dev,
4095 static struct bus_type pseudo_lld_bus = {
4097 .match = pseudo_lld_bus_match,
4098 .probe = sdebug_driver_probe,
4099 .remove = sdebug_driver_remove,