diff --git a/sys/cam/ctl/ctl.c b/sys/cam/ctl/ctl.c index 9b3629f60bf6..16fd9c0093f7 100644 --- a/sys/cam/ctl/ctl.c +++ b/sys/cam/ctl/ctl.c @@ -320,10 +320,10 @@ SYSCTL_INT(_kern_cam_ctl, OID_AUTO, verbose, CTLFLAG_RWTUN, /* * Supported pages (0x00), Serial number (0x80), Device ID (0x83), - * SCSI Ports (0x88), Block limits (0xB0) and + * SCSI Ports (0x88), Third-party Copy (0x8F), Block limits (0xB0) and * Logical Block Provisioning (0xB2) */ -#define SCSI_EVPD_NUM_SUPPORTED_PAGES 6 +#define SCSI_EVPD_NUM_SUPPORTED_PAGES 7 static void ctl_isc_event_handler(ctl_ha_channel chanel, ctl_ha_event event, int param); @@ -349,8 +349,6 @@ static int ctl_ioctl_fill_ooa(struct ctl_lun *lun, uint32_t *cur_fill_num, struct ctl_ooa_entry *kern_entries); static int ctl_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, struct thread *td); -uint32_t ctl_get_resindex(struct ctl_nexus *nexus); -uint32_t ctl_port_idx(int port_num); static uint32_t ctl_map_lun(int port_num, uint32_t lun); static uint32_t ctl_map_lun_back(int port_num, uint32_t lun); #ifdef unused @@ -4598,6 +4596,7 @@ ctl_alloc_lun(struct ctl_softc *ctl_softc, struct ctl_lun *ctl_lun, TAILQ_INIT(&lun->ooa_queue); TAILQ_INIT(&lun->blocked_queue); STAILQ_INIT(&lun->error_list); + ctl_tpc_init(lun); /* * Initialize the mode page index. @@ -4749,6 +4748,7 @@ ctl_free_lun(struct ctl_lun *lun) atomic_subtract_int(&lun->be_lun->be->num_luns, 1); lun->be_lun->lun_shutdown(lun->be_lun->be_lun); + ctl_tpc_shutdown(lun); mtx_destroy(&lun->lun_lock); free(lun->lun_devid, M_CTL); if (lun->flags & CTL_LUN_MALLOCED) @@ -9821,10 +9821,12 @@ ctl_inquiry_evpd_supported(struct ctl_scsiio *ctsio, int alloc_len) pages->page_list[2] = SVPD_DEVICE_ID; /* SCSI Ports */ pages->page_list[3] = SVPD_SCSI_PORTS; + /* Third-party Copy */ + pages->page_list[4] = SVPD_SCSI_TPC; /* Block limits */ - pages->page_list[4] = SVPD_BLOCK_LIMITS; + pages->page_list[5] = SVPD_BLOCK_LIMITS; /* Logical Block Provisioning */ - pages->page_list[5] = SVPD_LBP; + pages->page_list[6] = SVPD_LBP; ctsio->scsi_status = SCSI_STATUS_OK; @@ -10023,7 +10025,7 @@ ctl_inquiry_evpd_scsi_ports(struct ctl_scsiio *ctsio, int alloc_len) struct scsi_vpd_port_designation_cont *pdc; struct ctl_lun *lun; struct ctl_port *port; - int data_len, num_target_ports, id_len, g, pg, p; + int data_len, num_target_ports, iid_len, id_len, g, pg, p; int num_target_port_groups, single; lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; @@ -10034,6 +10036,7 @@ ctl_inquiry_evpd_scsi_ports(struct ctl_scsiio *ctsio, int alloc_len) else num_target_port_groups = NUM_TARGET_PORT_GROUPS; num_target_ports = 0; + iid_len = 0; id_len = 0; mtx_lock(&softc->ctl_lock); STAILQ_FOREACH(port, &softc->port_list, links) { @@ -10043,6 +10046,8 @@ ctl_inquiry_evpd_scsi_ports(struct ctl_scsiio *ctsio, int alloc_len) CTL_MAX_LUNS) continue; num_target_ports++; + if (port->init_devid) + iid_len += port->init_devid->len; if (port->port_devid) id_len += port->port_devid->len; } @@ -10050,7 +10055,7 @@ ctl_inquiry_evpd_scsi_ports(struct ctl_scsiio *ctsio, int alloc_len) data_len = sizeof(struct scsi_vpd_scsi_ports) + num_target_port_groups * num_target_ports * (sizeof(struct scsi_vpd_port_designation) + - sizeof(struct scsi_vpd_port_designation_cont)) + id_len; + sizeof(struct scsi_vpd_port_designation_cont)) + iid_len + id_len; ctsio->kern_data_ptr = malloc(data_len, M_CTL, M_WAITOK | M_ZERO); sp = (struct scsi_vpd_scsi_ports *)ctsio->kern_data_ptr; ctsio->kern_sg_entries = 0; @@ -10098,19 +10103,22 @@ ctl_inquiry_evpd_scsi_ports(struct ctl_scsiio *ctsio, int alloc_len) continue; p = port->targ_port % CTL_MAX_PORTS + g * CTL_MAX_PORTS; scsi_ulto2b(p, pd->relative_port_id); - scsi_ulto2b(0, pd->initiator_transportid_length); + if (port->init_devid && g == pg) { + iid_len = port->init_devid->len; + memcpy(pd->initiator_transportid, + port->init_devid->data, port->init_devid->len); + } else + iid_len = 0; + scsi_ulto2b(iid_len, pd->initiator_transportid_length); pdc = (struct scsi_vpd_port_designation_cont *) - &pd->initiator_transportid[0]; + (&pd->initiator_transportid[iid_len]); if (port->port_devid && g == pg) { id_len = port->port_devid->len; - scsi_ulto2b(port->port_devid->len, - pdc->target_port_descriptors_length); memcpy(pdc->target_port_descriptors, port->port_devid->data, port->port_devid->len); - } else { + } else id_len = 0; - scsi_ulto2b(0, pdc->target_port_descriptors_length); - } + scsi_ulto2b(id_len, pdc->target_port_descriptors_length); pd = (struct scsi_vpd_port_designation *) ((uint8_t *)pdc->target_port_descriptors + id_len); } @@ -10259,6 +10267,9 @@ ctl_inquiry_evpd(struct ctl_scsiio *ctsio) case SVPD_SCSI_PORTS: retval = ctl_inquiry_evpd_scsi_ports(ctsio, alloc_len); break; + case SVPD_SCSI_TPC: + retval = ctl_inquiry_evpd_tpc(ctsio, alloc_len); + break; case SVPD_BLOCK_LIMITS: retval = ctl_inquiry_evpd_block_limits(ctsio, alloc_len); break; @@ -10289,7 +10300,7 @@ ctl_inquiry_std(struct ctl_scsiio *ctsio) struct ctl_lun *lun; char *val; uint32_t alloc_len; - int is_fc; + ctl_port_type port_type; ctl_softc = control_softc; @@ -10298,11 +10309,10 @@ ctl_inquiry_std(struct ctl_scsiio *ctsio) * We treat the ioctl front end, and any SCSI adapters, as packetized * SCSI front ends. */ - if (ctl_softc->ctl_ports[ctl_port_idx(ctsio->io_hdr.nexus.targ_port)]->port_type != - CTL_PORT_FC) - is_fc = 0; - else - is_fc = 1; + port_type = ctl_softc->ctl_ports[ + ctl_port_idx(ctsio->io_hdr.nexus.targ_port)]->port_type; + if (port_type == CTL_PORT_IOCTL || port_type == CTL_PORT_INTERNAL) + port_type = CTL_PORT_SCSI; lun = ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; cdb = (struct scsi_inquiry *)ctsio->cdb; @@ -10381,7 +10391,7 @@ ctl_inquiry_std(struct ctl_scsiio *ctsio) inq_ptr->device = (SID_QUAL_BAD_LU << 5) | T_NODEVICE; /* RMB in byte 2 is 0 */ - inq_ptr->version = SCSI_REV_SPC3; + inq_ptr->version = SCSI_REV_SPC4; /* * According to SAM-3, even if a device only supports a single @@ -10406,17 +10416,18 @@ ctl_inquiry_std(struct ctl_scsiio *ctsio) CTL_DEBUG_PRINT(("additional_length = %d\n", inq_ptr->additional_length)); - inq_ptr->spc3_flags = SPC3_SID_TPGS_IMPLICIT; + inq_ptr->spc3_flags = SPC3_SID_3PC; + if (!ctl_is_single) + inq_ptr->spc3_flags |= SPC3_SID_TPGS_IMPLICIT; /* 16 bit addressing */ - if (is_fc == 0) + if (port_type == CTL_PORT_SCSI) inq_ptr->spc2_flags = SPC2_SID_ADDR16; /* XXX set the SID_MultiP bit here if we're actually going to respond on multiple ports */ inq_ptr->spc2_flags |= SPC2_SID_MultiP; /* 16 bit data bus, synchronous transfers */ - /* XXX these flags don't apply for FC */ - if (is_fc == 0) + if (port_type == CTL_PORT_SCSI) inq_ptr->flags = SID_WBus16 | SID_Sync; /* * XXX KDM do we want to support tagged queueing on the control @@ -10477,33 +10488,36 @@ ctl_inquiry_std(struct ctl_scsiio *ctsio) * and Selection) and Information Unit transfers on both the * control and array devices. */ - if (is_fc == 0) + if (port_type == CTL_PORT_SCSI) inq_ptr->spi3data = SID_SPI_CLOCK_DT_ST | SID_SPI_QAS | SID_SPI_IUS; - /* SAM-3 */ - scsi_ulto2b(0x0060, inq_ptr->version1); - /* SPC-3 (no version claimed) XXX should we claim a version? */ - scsi_ulto2b(0x0300, inq_ptr->version2); - if (is_fc) { + /* SAM-5 (no version claimed) */ + scsi_ulto2b(0x00A0, inq_ptr->version1); + /* SPC-4 (no version claimed) */ + scsi_ulto2b(0x0460, inq_ptr->version2); + if (port_type == CTL_PORT_FC) { /* FCP-2 ANSI INCITS.350:2003 */ scsi_ulto2b(0x0917, inq_ptr->version3); - } else { + } else if (port_type == CTL_PORT_SCSI) { /* SPI-4 ANSI INCITS.362:200x */ scsi_ulto2b(0x0B56, inq_ptr->version3); + } else if (port_type == CTL_PORT_ISCSI) { + /* iSCSI (no version claimed) */ + scsi_ulto2b(0x0960, inq_ptr->version3); + } else if (port_type == CTL_PORT_SAS) { + /* SAS (no version claimed) */ + scsi_ulto2b(0x0BE0, inq_ptr->version3); } if (lun == NULL) { - /* SBC-2 (no version claimed) XXX should we claim a version? */ - scsi_ulto2b(0x0320, inq_ptr->version4); + /* SBC-3 (no version claimed) */ + scsi_ulto2b(0x04C0, inq_ptr->version4); } else { switch (lun->be_lun->lun_type) { case T_DIRECT: - /* - * SBC-2 (no version claimed) XXX should we claim a - * version? - */ - scsi_ulto2b(0x0320, inq_ptr->version4); + /* SBC-3 (no version claimed) */ + scsi_ulto2b(0x04C0, inq_ptr->version4); break; case T_PROCESSOR: default: diff --git a/sys/cam/ctl/ctl_cmd_table.c b/sys/cam/ctl/ctl_cmd_table.c index a11ff721f5f0..1240f2a88a3b 100644 --- a/sys/cam/ctl/ctl_cmd_table.c +++ b/sys/cam/ctl/ctl_cmd_table.c @@ -190,6 +190,156 @@ const struct ctl_cmd_entry ctl_cmd_table_5f[32] = /* 08-1f */ }; +/* 83 EXTENDED COPY */ +const struct ctl_cmd_entry ctl_cmd_table_83[32] = +{ +/* 00 EXTENDED COPY (LID1) */ +{ctl_extended_copy_lid1, CTL_SERIDX_RD_CAP, CTL_CMD_FLAG_OK_ON_BOTH | + CTL_FLAG_DATA_OUT, + CTL_LUN_PAT_NONE, + 16, { 0x00, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0x07}}, + +/* 01 EXTENDED COPY (LID4) */ +{ctl_extended_copy_lid4, CTL_SERIDX_RD_CAP, CTL_CMD_FLAG_OK_ON_BOTH | + CTL_FLAG_DATA_OUT, + CTL_LUN_PAT_NONE, + 16, { 0x01, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0x07}}, + +/* 02 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 03 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 04 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 05 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 06 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 07 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 08 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 09 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 0A */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 0B */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 0C */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 0D */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 0E */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 0F */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 10 POPULATE TOKEN */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 11 WRITE USING TOKEN */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 12 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 13 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 14 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 15 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 16 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 17 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 18 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 19 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 1A */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 1B */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 1C COPY OPERATION ABORT */ +{ctl_copy_operation_abort, CTL_SERIDX_RD_CAP, CTL_CMD_FLAG_OK_ON_BOTH | + CTL_FLAG_DATA_NONE, + CTL_LUN_PAT_NONE, + 16, { 0x1c, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x07}}, +}; + +/* 84 RECEIVE COPY STATUS */ +const struct ctl_cmd_entry ctl_cmd_table_84[32] = +{ +/* 00 RECEIVE COPY STATUS (LID1) */ +{ctl_receive_copy_status_lid1, CTL_SERIDX_RD_CAP, + CTL_CMD_FLAG_OK_ON_BOTH | + CTL_FLAG_DATA_IN, + CTL_LUN_PAT_NONE, + 16, {0x00, 0xff, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0x07}}, + +/* 01 RECEIVE COPY DATA (LID1) */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 02 */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 03 RECEIVE COPY OPERATING PARAMETERS */ +{ctl_receive_copy_operating_parameters, CTL_SERIDX_RD_CAP, + CTL_CMD_FLAG_OK_ON_BOTH | + CTL_CMD_FLAG_OK_ON_STOPPED | + CTL_CMD_FLAG_OK_ON_INOPERABLE | + CTL_CMD_FLAG_OK_ON_SECONDARY | + CTL_FLAG_DATA_IN, + CTL_LUN_PAT_NONE, + 16, {0x03, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0x07}}, + +/* 04 RECEIVE COPY FAILURE DETAILS (LID1) */ +{ctl_receive_copy_failure_details, CTL_SERIDX_RD_CAP, + CTL_CMD_FLAG_OK_ON_BOTH | + CTL_FLAG_DATA_IN, + CTL_LUN_PAT_NONE, + 16, {0x04, 0xff, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0x07}}, + +/* 05 RECEIVE COPY STATUS (LID4) */ +{ctl_receive_copy_status_lid4, CTL_SERIDX_RD_CAP, + CTL_CMD_FLAG_OK_ON_BOTH | + CTL_FLAG_DATA_IN, + CTL_LUN_PAT_NONE, + 16, {0x05, 0xff, 0xff, 0xff, 0xff, 0, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0x07}}, + +/* 06 RECEIVE COPY DATA (LID4)*/ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 07 RECEIVE ROD TOKEN INFORMATION */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, + +/* 08 REPORT ALL ROD TOKENS */ +{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, +}; + /* 9E SERVICE ACTION IN(16) */ const struct ctl_cmd_entry ctl_cmd_table_9e[32] = { @@ -844,10 +994,12 @@ const struct ctl_cmd_entry ctl_cmd_table[256] = {NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, /* 83 EXTENDED COPY */ -{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, +{__DECONST(ctl_opfunc *, ctl_cmd_table_83), CTL_SERIDX_INVLD, CTL_CMD_FLAG_SA5, + CTL_LUN_PAT_NONE}, /* 84 RECEIVE COPY RESULTS */ -{NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, +{__DECONST(ctl_opfunc *, ctl_cmd_table_84), CTL_SERIDX_INVLD, CTL_CMD_FLAG_SA5, + CTL_LUN_PAT_NONE}, /* 85 */ {NULL, CTL_SERIDX_INVLD, CTL_CMD_FLAG_NONE, CTL_LUN_PAT_NONE}, diff --git a/sys/cam/ctl/ctl_frontend.c b/sys/cam/ctl/ctl_frontend.c index ecd5cbafedae..34b4a9ef5875 100644 --- a/sys/cam/ctl/ctl_frontend.c +++ b/sys/cam/ctl/ctl_frontend.c @@ -234,6 +234,8 @@ ctl_port_deregister(struct ctl_port *port) port->port_devid = NULL; free(port->target_devid, M_CTL); port->target_devid = NULL; + free(port->init_devid, M_CTL); + port->init_devid = NULL; for (i = 0; i < port->max_initiators; i++) free(port->wwpn_iid[i].name, M_CTL); free(port->wwpn_iid, M_CTL); diff --git a/sys/cam/ctl/ctl_frontend.h b/sys/cam/ctl/ctl_frontend.h index f252678cadf1..825ff50a0bca 100644 --- a/sys/cam/ctl/ctl_frontend.h +++ b/sys/cam/ctl/ctl_frontend.h @@ -242,6 +242,7 @@ struct ctl_port { ctl_options_t options; /* passed to CTL */ struct ctl_devid *port_devid; /* passed to CTL */ struct ctl_devid *target_devid; /* passed to CTL */ + struct ctl_devid *init_devid; /* passed to CTL */ STAILQ_ENTRY(ctl_port) fe_links; /* used by CTL */ STAILQ_ENTRY(ctl_port) links; /* used by CTL */ }; diff --git a/sys/cam/ctl/ctl_frontend_iscsi.c b/sys/cam/ctl/ctl_frontend_iscsi.c index beecdd98a580..2c4f4ddd6eb5 100644 --- a/sys/cam/ctl/ctl_frontend_iscsi.c +++ b/sys/cam/ctl/ctl_frontend_iscsi.c @@ -2702,7 +2702,7 @@ cfiscsi_scsi_command_done(union ctl_io *io) * Do not return status for aborted commands. * There are exceptions, but none supported by CTL yet. */ - if (io->io_hdr.status == CTL_CMD_ABORTED && + if ((io->io_hdr.flags & CTL_FLAG_ABORT) && (io->io_hdr.flags & CTL_FLAG_ABORT_STATUS) == 0) { ctl_free_io(io); icl_pdu_free(request); diff --git a/sys/cam/ctl/ctl_private.h b/sys/cam/ctl/ctl_private.h index a05f994cc925..33a1515481b3 100644 --- a/sys/cam/ctl/ctl_private.h +++ b/sys/cam/ctl/ctl_private.h @@ -373,6 +373,7 @@ struct ctl_devid { */ #define NUM_TARGET_PORT_GROUPS 2 +struct tpc_list; struct ctl_lun { struct mtx lun_lock; struct ctl_id target; @@ -403,6 +404,7 @@ struct ctl_lun { uint8_t res_type; uint8_t write_buffer[524288]; struct ctl_devid *lun_devid; + TAILQ_HEAD(tpc_lists, tpc_list) tpc_lists; }; typedef enum { @@ -467,6 +469,8 @@ struct ctl_softc { extern const struct ctl_cmd_entry ctl_cmd_table[256]; uint32_t ctl_get_initindex(struct ctl_nexus *nexus); +uint32_t ctl_get_resindex(struct ctl_nexus *nexus); +uint32_t ctl_port_idx(int port_num); int ctl_pool_create(struct ctl_softc *ctl_softc, ctl_pool_type pool_type, uint32_t total_ctl_io, struct ctl_io_pool **npool); void ctl_pool_free(struct ctl_io_pool *pool); @@ -498,6 +502,17 @@ int ctl_report_supported_tmf(struct ctl_scsiio *ctsio); int ctl_report_timestamp(struct ctl_scsiio *ctsio); int ctl_isc(struct ctl_scsiio *ctsio); +void ctl_tpc_init(struct ctl_lun *lun); +void ctl_tpc_shutdown(struct ctl_lun *lun); +int ctl_inquiry_evpd_tpc(struct ctl_scsiio *ctsio, int alloc_len); +int ctl_receive_copy_status_lid1(struct ctl_scsiio *ctsio); +int ctl_receive_copy_failure_details(struct ctl_scsiio *ctsio); +int ctl_receive_copy_status_lid4(struct ctl_scsiio *ctsio); +int ctl_receive_copy_operating_parameters(struct ctl_scsiio *ctsio); +int ctl_extended_copy_lid1(struct ctl_scsiio *ctsio); +int ctl_extended_copy_lid4(struct ctl_scsiio *ctsio); +int ctl_copy_operation_abort(struct ctl_scsiio *ctsio); + #endif /* _KERNEL */ #endif /* _CTL_PRIVATE_H_ */ diff --git a/sys/cam/ctl/ctl_ser_table.c b/sys/cam/ctl/ctl_ser_table.c index 6628ea80ae46..c680fb530f69 100644 --- a/sys/cam/ctl/ctl_ser_table.c +++ b/sys/cam/ctl/ctl_ser_table.c @@ -69,7 +69,7 @@ ctl_serialize_table[CTL_SERIDX_COUNT][CTL_SERIDX_COUNT] = { /*MD_SEL */{ bK, bK, bK, bK, bK, bK, bK, pS, pS, bK, pS, bK, bK}, /*RQ_SNS */{ pS, pS, pS, pS, pS, pS, bK, pS, pS, bK, pS, bK, bK}, /*INQ */{ pS, pS, pS, pS, pS, pS, bK, pS, pS, pS, pS, bK, bK}, -/*RD_CAP */{ pS, pS, pS, pS, pS, pS, bK, pS, pS, bK, pS, bK, bK}, +/*RD_CAP */{ pS, pS, pS, pS, pS, pS, bK, pS, pS, pS, pS, bK, bK}, /*RES */{ bK, bK, bK, bK, bK, bK, bK, pS, bK, bK, bK, bK, bK}, /*LOG_SNS */{ pS, pS, pS, pS, pS, bK, bK, pS, pS, bK, pS, bK, bK}, /*FORMAT */{ pS, bK, bK, bK, bK, bK, pS, pS, bK, bK, bK, bK, bK}, diff --git a/sys/cam/ctl/ctl_tpc.c b/sys/cam/ctl/ctl_tpc.c new file mode 100644 index 000000000000..d5baa01a008c --- /dev/null +++ b/sys/cam/ctl/ctl_tpc.c @@ -0,0 +1,1370 @@ +/*- + * Copyright (c) 2014 Alexander Motin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer, + * without modification, immediately at the beginning of the file. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define TPC_MAX_CSCDS 64 +#define TPC_MAX_SEGS 64 +#define TPC_MAX_SEG 0 +#define TPC_MAX_LIST 8192 +#define TPC_MAX_INLINE 0 +#define TPC_MAX_LISTS 255 +#define TPC_MAX_IO_SIZE (1024 * 1024) + +MALLOC_DEFINE(M_CTL_TPC, "ctltpc", "CTL TPC"); + +typedef enum { + TPC_ERR_RETRY = 0x000, + TPC_ERR_FAIL = 0x001, + TPC_ERR_MASK = 0x0ff, + TPC_ERR_NO_DECREMENT = 0x100 +} tpc_error_action; + +struct tpc_list; +TAILQ_HEAD(runl, tpc_io); +struct tpc_io { + union ctl_io *io; + uint64_t lun; + struct tpc_list *list; + struct runl run; + TAILQ_ENTRY(tpc_io) rlinks; + TAILQ_ENTRY(tpc_io) links; +}; + +struct tpc_list { + uint8_t service_action; + int init_port; + uint16_t init_idx; + uint32_t list_id; + uint8_t flags; + uint8_t *params; + struct scsi_ec_cscd *cscd; + struct scsi_ec_segment *seg[TPC_MAX_SEGS]; + uint8_t *inl; + int ncscd; + int nseg; + int leninl; + int curseg; + off_t curbytes; + int curops; + int stage; + uint8_t *buf; + int segbytes; + int tbdio; + int error; + int abort; + int completed; + TAILQ_HEAD(, tpc_io) allio; + struct scsi_sense_data sense_data; + uint8_t sense_len; + uint8_t scsi_status; + struct ctl_scsiio *ctsio; + struct ctl_lun *lun; + TAILQ_ENTRY(tpc_list) links; +}; + +void +ctl_tpc_init(struct ctl_lun *lun) +{ + + TAILQ_INIT(&lun->tpc_lists); +} + +void +ctl_tpc_shutdown(struct ctl_lun *lun) +{ + struct tpc_list *list; + + while ((list = TAILQ_FIRST(&lun->tpc_lists)) != NULL) { + TAILQ_REMOVE(&lun->tpc_lists, list, links); + KASSERT(list->completed, + ("Not completed TPC (%p) on shutdown", list)); + free(list, M_CTL); + } +} + +int +ctl_inquiry_evpd_tpc(struct ctl_scsiio *ctsio, int alloc_len) +{ + struct scsi_vpd_tpc *tpc_ptr; + struct scsi_vpd_tpc_descriptor *d_ptr; + struct scsi_vpd_tpc_descriptor_sc *sc_ptr; + struct scsi_vpd_tpc_descriptor_sc_descr *scd_ptr; + struct scsi_vpd_tpc_descriptor_pd *pd_ptr; + struct scsi_vpd_tpc_descriptor_sd *sd_ptr; + struct scsi_vpd_tpc_descriptor_sdid *sdid_ptr; + struct scsi_vpd_tpc_descriptor_gco *gco_ptr; + struct ctl_lun *lun; + int data_len; + + lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; + + data_len = sizeof(struct scsi_vpd_tpc) + + roundup2(sizeof(struct scsi_vpd_tpc_descriptor_sc) + + 2 * sizeof(struct scsi_vpd_tpc_descriptor_sc_descr) + 7, 4) + + sizeof(struct scsi_vpd_tpc_descriptor_pd) + + roundup2(sizeof(struct scsi_vpd_tpc_descriptor_sd) + 4, 4) + + roundup2(sizeof(struct scsi_vpd_tpc_descriptor_sdid) + 2, 4) + + sizeof(struct scsi_vpd_tpc_descriptor_gco); + + ctsio->kern_data_ptr = malloc(data_len, M_CTL, M_WAITOK | M_ZERO); + tpc_ptr = (struct scsi_vpd_tpc *)ctsio->kern_data_ptr; + ctsio->kern_sg_entries = 0; + + if (data_len < alloc_len) { + ctsio->residual = alloc_len - data_len; + ctsio->kern_data_len = data_len; + ctsio->kern_total_len = data_len; + } else { + ctsio->residual = 0; + ctsio->kern_data_len = alloc_len; + ctsio->kern_total_len = alloc_len; + } + ctsio->kern_data_resid = 0; + ctsio->kern_rel_offset = 0; + ctsio->kern_sg_entries = 0; + + /* + * The control device is always connected. The disk device, on the + * other hand, may not be online all the time. + */ + if (lun != NULL) + tpc_ptr->device = (SID_QUAL_LU_CONNECTED << 5) | + lun->be_lun->lun_type; + else + tpc_ptr->device = (SID_QUAL_LU_OFFLINE << 5) | T_DIRECT; + tpc_ptr->page_code = SVPD_SCSI_TPC; + scsi_ulto2b(data_len - 4, tpc_ptr->page_length); + + /* Supported commands */ + d_ptr = (struct scsi_vpd_tpc_descriptor *)&tpc_ptr->descr[0]; + sc_ptr = (struct scsi_vpd_tpc_descriptor_sc *)d_ptr; + scsi_ulto2b(SVPD_TPC_SC, sc_ptr->desc_type); + sc_ptr->list_length = 2 * sizeof(*scd_ptr) + 7; + scsi_ulto2b(roundup2(1 + sc_ptr->list_length, 4), sc_ptr->desc_length); + scd_ptr = &sc_ptr->descr[0]; + scd_ptr->opcode = EXTENDED_COPY; + scd_ptr->sa_length = 3; + scd_ptr->supported_service_actions[0] = EC_EC_LID1; + scd_ptr->supported_service_actions[1] = EC_EC_LID4; + scd_ptr->supported_service_actions[2] = EC_COA; + scd_ptr = (struct scsi_vpd_tpc_descriptor_sc_descr *) + &scd_ptr->supported_service_actions[scd_ptr->sa_length]; + scd_ptr->opcode = RECEIVE_COPY_STATUS; + scd_ptr->sa_length = 4; + scd_ptr->supported_service_actions[0] = RCS_RCS_LID1; + scd_ptr->supported_service_actions[1] = RCS_RCFD; + scd_ptr->supported_service_actions[2] = RCS_RCS_LID4; + scd_ptr->supported_service_actions[3] = RCS_RCOP; + + /* Parameter data. */ + d_ptr = (struct scsi_vpd_tpc_descriptor *) + (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length)); + pd_ptr = (struct scsi_vpd_tpc_descriptor_pd *)d_ptr; + scsi_ulto2b(SVPD_TPC_PD, pd_ptr->desc_type); + scsi_ulto2b(sizeof(*pd_ptr) - 4, pd_ptr->desc_length); + scsi_ulto2b(TPC_MAX_CSCDS, pd_ptr->maximum_cscd_descriptor_count); + scsi_ulto2b(TPC_MAX_SEGS, pd_ptr->maximum_segment_descriptor_count); + scsi_ulto4b(TPC_MAX_LIST, pd_ptr->maximum_descriptor_list_length); + scsi_ulto4b(TPC_MAX_INLINE, pd_ptr->maximum_inline_data_length); + + /* Supported Descriptors */ + d_ptr = (struct scsi_vpd_tpc_descriptor *) + (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length)); + sd_ptr = (struct scsi_vpd_tpc_descriptor_sd *)d_ptr; + scsi_ulto2b(SVPD_TPC_SD, sd_ptr->desc_type); + scsi_ulto2b(roundup2(sizeof(*sd_ptr) - 4 + 4, 4), sd_ptr->desc_length); + sd_ptr->list_length = 4; + sd_ptr->supported_descriptor_codes[0] = EC_SEG_B2B; + sd_ptr->supported_descriptor_codes[1] = EC_SEG_VERIFY; + sd_ptr->supported_descriptor_codes[2] = EC_SEG_REGISTER_KEY; + sd_ptr->supported_descriptor_codes[3] = EC_CSCD_ID; + + /* Supported CSCD Descriptor IDs */ + d_ptr = (struct scsi_vpd_tpc_descriptor *) + (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length)); + sdid_ptr = (struct scsi_vpd_tpc_descriptor_sdid *)d_ptr; + scsi_ulto2b(SVPD_TPC_SDID, sdid_ptr->desc_type); + scsi_ulto2b(roundup2(sizeof(*sdid_ptr) - 4 + 2, 4), sdid_ptr->desc_length); + scsi_ulto2b(2, sdid_ptr->list_length); + scsi_ulto2b(0xffff, &sdid_ptr->supported_descriptor_ids[0]); + + /* General Copy Operations */ + d_ptr = (struct scsi_vpd_tpc_descriptor *) + (&d_ptr->parameters[0] + scsi_2btoul(d_ptr->desc_length)); + gco_ptr = (struct scsi_vpd_tpc_descriptor_gco *)d_ptr; + scsi_ulto2b(SVPD_TPC_GCO, gco_ptr->desc_type); + scsi_ulto2b(sizeof(*gco_ptr) - 4, gco_ptr->desc_length); + scsi_ulto4b(TPC_MAX_LISTS, gco_ptr->total_concurrent_copies); + scsi_ulto4b(TPC_MAX_LISTS, gco_ptr->maximum_identified_concurrent_copies); + scsi_ulto4b(TPC_MAX_SEG, gco_ptr->maximum_segment_length); + gco_ptr->data_segment_granularity = 0; + gco_ptr->inline_data_granularity = 0; + + ctsio->scsi_status = SCSI_STATUS_OK; + ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED; + ctsio->be_move_done = ctl_config_move_done; + ctl_datamove((union ctl_io *)ctsio); + + return (CTL_RETVAL_COMPLETE); +} + +int +ctl_receive_copy_operating_parameters(struct ctl_scsiio *ctsio) +{ + struct ctl_lun *lun; + struct scsi_receive_copy_operating_parameters *cdb; + struct scsi_receive_copy_operating_parameters_data *data; + int retval; + int alloc_len, total_len; + + CTL_DEBUG_PRINT(("ctl_report_supported_tmf\n")); + + cdb = (struct scsi_receive_copy_operating_parameters *)ctsio->cdb; + lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; + + retval = CTL_RETVAL_COMPLETE; + + total_len = sizeof(*data) + 4; + alloc_len = scsi_4btoul(cdb->length); + + ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO); + + ctsio->kern_sg_entries = 0; + + if (total_len < alloc_len) { + ctsio->residual = alloc_len - total_len; + ctsio->kern_data_len = total_len; + ctsio->kern_total_len = total_len; + } else { + ctsio->residual = 0; + ctsio->kern_data_len = alloc_len; + ctsio->kern_total_len = alloc_len; + } + ctsio->kern_data_resid = 0; + ctsio->kern_rel_offset = 0; + + data = (struct scsi_receive_copy_operating_parameters_data *)ctsio->kern_data_ptr; + scsi_ulto4b(sizeof(*data) - 4 + 4, data->length); + data->snlid = RCOP_SNLID; + scsi_ulto2b(TPC_MAX_CSCDS, data->maximum_cscd_descriptor_count); + scsi_ulto2b(TPC_MAX_SEGS, data->maximum_segment_descriptor_count); + scsi_ulto4b(TPC_MAX_LIST, data->maximum_descriptor_list_length); + scsi_ulto4b(TPC_MAX_SEG, data->maximum_segment_length); + scsi_ulto4b(TPC_MAX_INLINE, data->maximum_inline_data_length); + scsi_ulto4b(0, data->held_data_limit); + scsi_ulto4b(0, data->maximum_stream_device_transfer_size); + scsi_ulto2b(TPC_MAX_LISTS, data->total_concurrent_copies); + data->maximum_concurrent_copies = TPC_MAX_LISTS; + data->data_segment_granularity = 0; + data->inline_data_granularity = 0; + data->held_data_granularity = 0; + data->implemented_descriptor_list_length = 4; + data->list_of_implemented_descriptor_type_codes[0] = EC_SEG_B2B; + data->list_of_implemented_descriptor_type_codes[1] = EC_SEG_VERIFY; + data->list_of_implemented_descriptor_type_codes[2] = EC_SEG_REGISTER_KEY; + data->list_of_implemented_descriptor_type_codes[3] = EC_CSCD_ID; + + ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED; + ctsio->be_move_done = ctl_config_move_done; + + ctl_datamove((union ctl_io *)ctsio); + return (retval); +} + +int +ctl_receive_copy_status_lid1(struct ctl_scsiio *ctsio) +{ + struct ctl_lun *lun; + struct scsi_receive_copy_status_lid1 *cdb; + struct scsi_receive_copy_status_lid1_data *data; + struct tpc_list *list; + struct tpc_list list_copy; + int retval; + int alloc_len, total_len; + uint32_t list_id; + + CTL_DEBUG_PRINT(("ctl_receive_copy_status_lid1\n")); + + cdb = (struct scsi_receive_copy_status_lid1 *)ctsio->cdb; + lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; + + retval = CTL_RETVAL_COMPLETE; + + list_id = cdb->list_identifier; + mtx_lock(&lun->lun_lock); + TAILQ_FOREACH(list, &lun->tpc_lists, links) { + if ((list->flags & EC_LIST_ID_USAGE_MASK) != + EC_LIST_ID_USAGE_NONE && list->list_id == list_id) + break; + } + if (list == NULL) { + mtx_unlock(&lun->lun_lock); + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, + /*command*/ 1, /*field*/ 2, /*bit_valid*/ 0, + /*bit*/ 0); + ctl_done((union ctl_io *)ctsio); + return (retval); + } + list_copy = *list; + if (list->completed) { + TAILQ_REMOVE(&lun->tpc_lists, list, links); + free(list, M_CTL); + } + mtx_unlock(&lun->lun_lock); + + total_len = sizeof(*data); + alloc_len = scsi_4btoul(cdb->length); + + ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO); + + ctsio->kern_sg_entries = 0; + + if (total_len < alloc_len) { + ctsio->residual = alloc_len - total_len; + ctsio->kern_data_len = total_len; + ctsio->kern_total_len = total_len; + } else { + ctsio->residual = 0; + ctsio->kern_data_len = alloc_len; + ctsio->kern_total_len = alloc_len; + } + ctsio->kern_data_resid = 0; + ctsio->kern_rel_offset = 0; + + data = (struct scsi_receive_copy_status_lid1_data *)ctsio->kern_data_ptr; + scsi_ulto4b(sizeof(*data) - 4, data->available_data); + if (list_copy.completed) { + if (list_copy.error || list_copy.abort) + data->copy_command_status = RCS_CCS_ERROR; + else + data->copy_command_status = RCS_CCS_COMPLETED; + } else + data->copy_command_status = RCS_CCS_INPROG; + scsi_ulto2b(list_copy.curseg, data->segments_processed); + if (list_copy.curbytes <= UINT32_MAX) { + data->transfer_count_units = RCS_TC_BYTES; + scsi_ulto4b(list_copy.curbytes, data->transfer_count); + } else { + data->transfer_count_units = RCS_TC_MBYTES; + scsi_ulto4b(list_copy.curbytes >> 20, data->transfer_count); + } + + ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED; + ctsio->be_move_done = ctl_config_move_done; + + ctl_datamove((union ctl_io *)ctsio); + return (retval); +} + +int +ctl_receive_copy_failure_details(struct ctl_scsiio *ctsio) +{ + struct ctl_lun *lun; + struct scsi_receive_copy_failure_details *cdb; + struct scsi_receive_copy_failure_details_data *data; + struct tpc_list *list; + struct tpc_list list_copy; + int retval; + int alloc_len, total_len; + uint32_t list_id; + + CTL_DEBUG_PRINT(("ctl_receive_copy_failure_details\n")); + + cdb = (struct scsi_receive_copy_failure_details *)ctsio->cdb; + lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; + + retval = CTL_RETVAL_COMPLETE; + + list_id = cdb->list_identifier; + mtx_lock(&lun->lun_lock); + TAILQ_FOREACH(list, &lun->tpc_lists, links) { + if (list->completed && (list->flags & EC_LIST_ID_USAGE_MASK) != + EC_LIST_ID_USAGE_NONE && list->list_id == list_id) + break; + } + if (list == NULL) { + mtx_unlock(&lun->lun_lock); + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, + /*command*/ 1, /*field*/ 2, /*bit_valid*/ 0, + /*bit*/ 0); + ctl_done((union ctl_io *)ctsio); + return (retval); + } + list_copy = *list; + TAILQ_REMOVE(&lun->tpc_lists, list, links); + free(list, M_CTL); + mtx_unlock(&lun->lun_lock); + + total_len = sizeof(*data) + list_copy.sense_len; + alloc_len = scsi_4btoul(cdb->length); + + ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO); + + ctsio->kern_sg_entries = 0; + + if (total_len < alloc_len) { + ctsio->residual = alloc_len - total_len; + ctsio->kern_data_len = total_len; + ctsio->kern_total_len = total_len; + } else { + ctsio->residual = 0; + ctsio->kern_data_len = alloc_len; + ctsio->kern_total_len = alloc_len; + } + ctsio->kern_data_resid = 0; + ctsio->kern_rel_offset = 0; + + data = (struct scsi_receive_copy_failure_details_data *)ctsio->kern_data_ptr; + if (list_copy.completed && (list_copy.error || list_copy.abort)) { + scsi_ulto4b(sizeof(*data) - 4, data->available_data); + data->copy_command_status = RCS_CCS_ERROR; + } else + scsi_ulto4b(0, data->available_data); + scsi_ulto2b(list_copy.sense_len, data->sense_data_length); + memcpy(data->sense_data, &list_copy.sense_data, list_copy.sense_len); + + ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED; + ctsio->be_move_done = ctl_config_move_done; + + ctl_datamove((union ctl_io *)ctsio); + return (retval); +} + +int +ctl_receive_copy_status_lid4(struct ctl_scsiio *ctsio) +{ + struct ctl_lun *lun; + struct scsi_receive_copy_status_lid4 *cdb; + struct scsi_receive_copy_status_lid4_data *data; + struct tpc_list *list; + struct tpc_list list_copy; + int retval; + int alloc_len, total_len; + uint32_t list_id; + + CTL_DEBUG_PRINT(("ctl_receive_copy_status_lid4\n")); + + cdb = (struct scsi_receive_copy_status_lid4 *)ctsio->cdb; + lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; + + retval = CTL_RETVAL_COMPLETE; + + list_id = scsi_4btoul(cdb->list_identifier); + mtx_lock(&lun->lun_lock); + TAILQ_FOREACH(list, &lun->tpc_lists, links) { + if ((list->flags & EC_LIST_ID_USAGE_MASK) != + EC_LIST_ID_USAGE_NONE && list->list_id == list_id) + break; + } + if (list == NULL) { + mtx_unlock(&lun->lun_lock); + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, + /*command*/ 1, /*field*/ 2, /*bit_valid*/ 0, + /*bit*/ 0); + ctl_done((union ctl_io *)ctsio); + return (retval); + } + list_copy = *list; + if (list->completed) { + TAILQ_REMOVE(&lun->tpc_lists, list, links); + free(list, M_CTL); + } + mtx_unlock(&lun->lun_lock); + + total_len = sizeof(*data) + list_copy.sense_len; + alloc_len = scsi_4btoul(cdb->length); + + ctsio->kern_data_ptr = malloc(total_len, M_CTL, M_WAITOK | M_ZERO); + + ctsio->kern_sg_entries = 0; + + if (total_len < alloc_len) { + ctsio->residual = alloc_len - total_len; + ctsio->kern_data_len = total_len; + ctsio->kern_total_len = total_len; + } else { + ctsio->residual = 0; + ctsio->kern_data_len = alloc_len; + ctsio->kern_total_len = alloc_len; + } + ctsio->kern_data_resid = 0; + ctsio->kern_rel_offset = 0; + + data = (struct scsi_receive_copy_status_lid4_data *)ctsio->kern_data_ptr; + scsi_ulto4b(sizeof(*data) - 4, data->available_data); + data->response_to_service_action = list_copy.service_action; + if (list_copy.completed) { + if (list_copy.error) + data->copy_command_status = RCS_CCS_ERROR; + else if (list_copy.abort) + data->copy_command_status = RCS_CCS_ABORTED; + else + data->copy_command_status = RCS_CCS_COMPLETED; + } else + data->copy_command_status = RCS_CCS_INPROG_FG; + scsi_ulto2b(list_copy.curops, data->operation_counter); + scsi_ulto4b(UINT32_MAX, data->estimated_status_update_delay); + if (list_copy.curbytes <= UINT32_MAX) { + data->transfer_count_units = RCS_TC_BYTES; + scsi_ulto4b(list_copy.curbytes, data->transfer_count); + } else { + data->transfer_count_units = RCS_TC_MBYTES; + scsi_ulto4b(list_copy.curbytes >> 20, data->transfer_count); + } + scsi_ulto2b(list_copy.curseg, data->segments_processed); + data->sense_data_length = list_copy.sense_len; + memcpy(data->sense_data, &list_copy.sense_data, list_copy.sense_len); + + ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED; + ctsio->be_move_done = ctl_config_move_done; + + ctl_datamove((union ctl_io *)ctsio); + return (retval); +} + +int +ctl_copy_operation_abort(struct ctl_scsiio *ctsio) +{ + struct ctl_lun *lun; + struct scsi_copy_operation_abort *cdb; + struct tpc_list *list; + int retval; + uint32_t list_id; + + CTL_DEBUG_PRINT(("ctl_copy_operation_abort\n")); + + cdb = (struct scsi_copy_operation_abort *)ctsio->cdb; + lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; + + retval = CTL_RETVAL_COMPLETE; + + list_id = scsi_4btoul(cdb->list_identifier); + mtx_lock(&lun->lun_lock); + TAILQ_FOREACH(list, &lun->tpc_lists, links) { + if ((list->flags & EC_LIST_ID_USAGE_MASK) != + EC_LIST_ID_USAGE_NONE && list->list_id == list_id) + break; + } + if (list == NULL) { + mtx_unlock(&lun->lun_lock); + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, + /*command*/ 1, /*field*/ 2, /*bit_valid*/ 0, + /*bit*/ 0); + ctl_done((union ctl_io *)ctsio); + return (retval); + } + list->abort = 1; + mtx_unlock(&lun->lun_lock); + + ctl_set_success(ctsio); + ctl_done((union ctl_io *)ctsio); + return (retval); +} + +static uint64_t +tpc_resolve(struct tpc_list *list, uint16_t idx, uint32_t *ss) +{ + + if (idx == 0xffff) { + if (ss && list->lun->be_lun) + *ss = list->lun->be_lun->blocksize; + return (list->lun->lun); + } + if (idx >= list->ncscd) + return (UINT64_MAX); + return (tpcl_resolve(list->init_port, &list->cscd[idx], ss)); +} + +static int +tpc_process_b2b(struct tpc_list *list) +{ + struct scsi_ec_segment_b2b *seg; + struct scsi_ec_cscd_dtsp *sdstp, *ddstp; + struct tpc_io *tior, *tiow; + struct runl run, *prun; + uint64_t sl, dl; + off_t srclba, dstlba, numbytes, donebytes, roundbytes; + int numlba; + uint32_t srcblock, dstblock; + + if (list->stage == 1) { +complete: + while ((tior = TAILQ_FIRST(&list->allio)) != NULL) { + TAILQ_REMOVE(&list->allio, tior, links); + ctl_free_io(tior->io); + free(tior, M_CTL); + } + free(list->buf, M_CTL); + if (list->abort) { + ctl_set_task_aborted(list->ctsio); + return (CTL_RETVAL_ERROR); + } else if (list->error) { + ctl_set_sense(list->ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_COPY_ABORTED, + /*asc*/ 0x0d, /*ascq*/ 0x01, SSD_ELEM_NONE); + return (CTL_RETVAL_ERROR); + } else { + list->curbytes += list->segbytes; + return (CTL_RETVAL_COMPLETE); + } + } + + TAILQ_INIT(&list->allio); + seg = (struct scsi_ec_segment_b2b *)list->seg[list->curseg]; + sl = tpc_resolve(list, scsi_2btoul(seg->src_cscd), &srcblock); + dl = tpc_resolve(list, scsi_2btoul(seg->dst_cscd), &dstblock); + if (sl >= CTL_MAX_LUNS || dl >= CTL_MAX_LUNS) { + ctl_set_sense(list->ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_COPY_ABORTED, + /*asc*/ 0x08, /*ascq*/ 0x04, SSD_ELEM_NONE); + return (CTL_RETVAL_ERROR); + } + sdstp = &list->cscd[scsi_2btoul(seg->src_cscd)].dtsp; + if (scsi_3btoul(sdstp->block_length) != 0) + srcblock = scsi_3btoul(sdstp->block_length); + ddstp = &list->cscd[scsi_2btoul(seg->dst_cscd)].dtsp; + if (scsi_3btoul(ddstp->block_length) != 0) + dstblock = scsi_3btoul(ddstp->block_length); + numlba = scsi_2btoul(seg->number_of_blocks); + if (seg->flags & EC_SEG_DC) + numbytes = (off_t)numlba * dstblock; + else + numbytes = (off_t)numlba * srcblock; + srclba = scsi_8btou64(seg->src_lba); + dstlba = scsi_8btou64(seg->dst_lba); + +// printf("Copy %ju bytes from %ju @ %ju to %ju @ %ju\n", +// (uintmax_t)numbytes, sl, scsi_8btou64(seg->src_lba), +// dl, scsi_8btou64(seg->dst_lba)); + + if (numbytes == 0) + return (CTL_RETVAL_COMPLETE); + + if (numbytes % srcblock != 0 || numbytes % dstblock != 0) { + ctl_set_sense(list->ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_COPY_ABORTED, + /*asc*/ 0x26, /*ascq*/ 0x0A, SSD_ELEM_NONE); + return (CTL_RETVAL_ERROR); + } + + list->buf = malloc(numbytes, M_CTL, M_WAITOK); + list->segbytes = numbytes; + donebytes = 0; + TAILQ_INIT(&run); + prun = &run; + list->tbdio = 1; + while (donebytes < numbytes) { + roundbytes = MIN(numbytes - donebytes, TPC_MAX_IO_SIZE); + + tior = malloc(sizeof(*tior), M_CTL, M_WAITOK | M_ZERO); + TAILQ_INIT(&tior->run); + tior->list = list; + TAILQ_INSERT_TAIL(&list->allio, tior, links); + tior->io = tpcl_alloc_io(); + if (tior->io == NULL) { + list->error = 1; + goto complete; + } + ctl_scsi_read_write(tior->io, + /*data_ptr*/ &list->buf[donebytes], + /*data_len*/ roundbytes, + /*read_op*/ 1, + /*byte2*/ 0, + /*minimum_cdb_size*/ 0, + /*lba*/ srclba + donebytes / srcblock, + /*num_blocks*/ roundbytes / srcblock, + /*tag_type*/ CTL_TAG_SIMPLE, + /*control*/ 0); + tior->io->io_hdr.retries = 3; + tior->lun = sl; + tior->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tior; + + tiow = malloc(sizeof(*tior), M_CTL, M_WAITOK | M_ZERO); + TAILQ_INIT(&tiow->run); + tiow->list = list; + TAILQ_INSERT_TAIL(&list->allio, tiow, links); + tiow->io = tpcl_alloc_io(); + if (tiow->io == NULL) { + list->error = 1; + goto complete; + } + ctl_scsi_read_write(tiow->io, + /*data_ptr*/ &list->buf[donebytes], + /*data_len*/ roundbytes, + /*read_op*/ 0, + /*byte2*/ 0, + /*minimum_cdb_size*/ 0, + /*lba*/ dstlba + donebytes / dstblock, + /*num_blocks*/ roundbytes / dstblock, + /*tag_type*/ CTL_TAG_SIMPLE, + /*control*/ 0); + tiow->io->io_hdr.retries = 3; + tiow->lun = dl; + tiow->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tior; + + TAILQ_INSERT_TAIL(&tior->run, tiow, rlinks); + TAILQ_INSERT_TAIL(prun, tior, rlinks); + prun = &tior->run; + donebytes += roundbytes; + } + + while ((tior = TAILQ_FIRST(&run)) != NULL) { + TAILQ_REMOVE(&run, tior, rlinks); + if (tpcl_queue(tior->io, tior->lun) != CTL_RETVAL_COMPLETE) + panic("tpcl_queue() error"); + } + + list->stage++; + return (CTL_RETVAL_QUEUED); +} + +static int +tpc_process_verify(struct tpc_list *list) +{ + struct scsi_ec_segment_verify *seg; + struct tpc_io *tio; + uint64_t sl; + + if (list->stage == 1) { +complete: + while ((tio = TAILQ_FIRST(&list->allio)) != NULL) { + TAILQ_REMOVE(&list->allio, tio, links); + ctl_free_io(tio->io); + free(tio, M_CTL); + } + if (list->abort) { + ctl_set_task_aborted(list->ctsio); + return (CTL_RETVAL_ERROR); + } else if (list->error) { + ctl_set_sense(list->ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_COPY_ABORTED, + /*asc*/ 0x0d, /*ascq*/ 0x01, SSD_ELEM_NONE); + return (CTL_RETVAL_ERROR); + } else + return (CTL_RETVAL_COMPLETE); + } + + TAILQ_INIT(&list->allio); + seg = (struct scsi_ec_segment_verify *)list->seg[list->curseg]; + sl = tpc_resolve(list, scsi_2btoul(seg->src_cscd), NULL); + if (sl >= CTL_MAX_LUNS) { + ctl_set_sense(list->ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_COPY_ABORTED, + /*asc*/ 0x08, /*ascq*/ 0x04, SSD_ELEM_NONE); + return (CTL_RETVAL_ERROR); + } + +// printf("Verify %ju\n", sl); + + if ((seg->tur & 0x01) == 0) + return (CTL_RETVAL_COMPLETE); + + list->tbdio = 1; + tio = malloc(sizeof(*tio), M_CTL, M_WAITOK | M_ZERO); + TAILQ_INIT(&tio->run); + tio->list = list; + TAILQ_INSERT_TAIL(&list->allio, tio, links); + tio->io = tpcl_alloc_io(); + if (tio->io == NULL) { + list->error = 1; + goto complete; + } + ctl_scsi_tur(tio->io, /*tag_type*/ CTL_TAG_SIMPLE, /*control*/ 0); + tio->io->io_hdr.retries = 3; + tio->lun = sl; + tio->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tio; + list->stage++; + if (tpcl_queue(tio->io, tio->lun) != CTL_RETVAL_COMPLETE) + panic("tpcl_queue() error"); + return (CTL_RETVAL_QUEUED); +} + +static int +tpc_process_register_key(struct tpc_list *list) +{ + struct scsi_ec_segment_register_key *seg; + struct tpc_io *tio; + uint64_t dl; + int datalen; + + if (list->stage == 1) { +complete: + while ((tio = TAILQ_FIRST(&list->allio)) != NULL) { + TAILQ_REMOVE(&list->allio, tio, links); + ctl_free_io(tio->io); + free(tio, M_CTL); + } + free(list->buf, M_CTL); + if (list->abort) { + ctl_set_task_aborted(list->ctsio); + return (CTL_RETVAL_ERROR); + } else if (list->error) { + ctl_set_sense(list->ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_COPY_ABORTED, + /*asc*/ 0x0d, /*ascq*/ 0x01, SSD_ELEM_NONE); + return (CTL_RETVAL_ERROR); + } else + return (CTL_RETVAL_COMPLETE); + } + + TAILQ_INIT(&list->allio); + seg = (struct scsi_ec_segment_register_key *)list->seg[list->curseg]; + dl = tpc_resolve(list, scsi_2btoul(seg->dst_cscd), NULL); + if (dl >= CTL_MAX_LUNS) { + ctl_set_sense(list->ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_COPY_ABORTED, + /*asc*/ 0x08, /*ascq*/ 0x04, SSD_ELEM_NONE); + return (CTL_RETVAL_ERROR); + } + +// printf("Register Key %ju\n", dl); + + list->tbdio = 1; + tio = malloc(sizeof(*tio), M_CTL, M_WAITOK | M_ZERO); + TAILQ_INIT(&tio->run); + tio->list = list; + TAILQ_INSERT_TAIL(&list->allio, tio, links); + tio->io = tpcl_alloc_io(); + if (tio->io == NULL) { + list->error = 1; + goto complete; + } + datalen = sizeof(struct scsi_per_res_out_parms); + list->buf = malloc(datalen, M_CTL, M_WAITOK); + ctl_scsi_persistent_res_out(tio->io, + list->buf, datalen, SPRO_REGISTER, -1, + scsi_8btou64(seg->res_key), scsi_8btou64(seg->sa_res_key), + /*tag_type*/ CTL_TAG_SIMPLE, /*control*/ 0); + tio->io->io_hdr.retries = 3; + tio->lun = dl; + tio->io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr = tio; + list->stage++; + if (tpcl_queue(tio->io, tio->lun) != CTL_RETVAL_COMPLETE) + panic("tpcl_queue() error"); + return (CTL_RETVAL_QUEUED); +} + +static void +tpc_process(struct tpc_list *list) +{ + struct ctl_lun *lun = list->lun; + struct scsi_ec_segment *seg; + struct ctl_scsiio *ctsio = list->ctsio; + int retval = CTL_RETVAL_COMPLETE; + +//printf("ZZZ %d cscd, %d segs\n", list->ncscd, list->nseg); + while (list->curseg < list->nseg) { + seg = list->seg[list->curseg]; + switch (seg->type_code) { + case EC_SEG_B2B: + retval = tpc_process_b2b(list); + break; + case EC_SEG_VERIFY: + retval = tpc_process_verify(list); + break; + case EC_SEG_REGISTER_KEY: + retval = tpc_process_register_key(list); + break; + default: + ctl_set_sense(ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_COPY_ABORTED, + /*asc*/ 0x26, /*ascq*/ 0x09, SSD_ELEM_NONE); + goto done; + } + if (retval == CTL_RETVAL_QUEUED) + return; + if (retval == CTL_RETVAL_ERROR) { + list->error = 1; + goto done; + } + list->curseg++; + list->stage = 0; + } + + ctl_set_success(ctsio); + +done: +//printf("ZZZ done\n"); + mtx_lock(&lun->lun_lock); + if ((list->flags & EC_LIST_ID_USAGE_MASK) == EC_LIST_ID_USAGE_NONE) { + TAILQ_REMOVE(&lun->tpc_lists, list, links); + free(list, M_CTL); + } else { + list->completed = 1; + list->sense_data = ctsio->sense_data; + list->sense_len = ctsio->sense_len; + list->scsi_status = ctsio->scsi_status; + } + mtx_unlock(&lun->lun_lock); + + ctl_done((union ctl_io *)ctsio); +} + +/* + * For any sort of check condition, busy, etc., we just retry. We do not + * decrement the retry count for unit attention type errors. These are + * normal, and we want to save the retry count for "real" errors. Otherwise, + * we could end up with situations where a command will succeed in some + * situations and fail in others, depending on whether a unit attention is + * pending. Also, some of our error recovery actions, most notably the + * LUN reset action, will cause a unit attention. + * + * We can add more detail here later if necessary. + */ +static tpc_error_action +tpc_checkcond_parse(union ctl_io *io) +{ + tpc_error_action error_action; + int error_code, sense_key, asc, ascq; + + /* + * Default to retrying the command. + */ + error_action = TPC_ERR_RETRY; + + scsi_extract_sense_len(&io->scsiio.sense_data, + io->scsiio.sense_len, + &error_code, + &sense_key, + &asc, + &ascq, + /*show_errors*/ 1); + + switch (error_code) { + case SSD_DEFERRED_ERROR: + case SSD_DESC_DEFERRED_ERROR: + error_action |= TPC_ERR_NO_DECREMENT; + break; + case SSD_CURRENT_ERROR: + case SSD_DESC_CURRENT_ERROR: + default: + switch (sense_key) { + case SSD_KEY_UNIT_ATTENTION: + error_action |= TPC_ERR_NO_DECREMENT; + break; + case SSD_KEY_HARDWARE_ERROR: + /* + * This is our generic "something bad happened" + * error code. It often isn't recoverable. + */ + if ((asc == 0x44) && (ascq == 0x00)) + error_action = TPC_ERR_FAIL; + break; + case SSD_KEY_NOT_READY: + /* + * If the LUN is powered down, there likely isn't + * much point in retrying right now. + */ + if ((asc == 0x04) && (ascq == 0x02)) + error_action = TPC_ERR_FAIL; + /* + * If the LUN is offline, there probably isn't much + * point in retrying, either. + */ + if ((asc == 0x04) && (ascq == 0x03)) + error_action = TPC_ERR_FAIL; + break; + } + } + return (error_action); +} + +static tpc_error_action +tpc_error_parse(union ctl_io *io) +{ + tpc_error_action error_action = TPC_ERR_RETRY; + + switch (io->io_hdr.io_type) { + case CTL_IO_SCSI: + switch (io->io_hdr.status & CTL_STATUS_MASK) { + case CTL_SCSI_ERROR: + switch (io->scsiio.scsi_status) { + case SCSI_STATUS_CHECK_COND: + error_action = tpc_checkcond_parse(io); + break; + default: + break; + } + break; + default: + break; + } + break; + case CTL_IO_TASK: + break; + default: + panic("%s: invalid ctl_io type %d\n", __func__, + io->io_hdr.io_type); + break; + } + return (error_action); +} + +void +tpc_done(union ctl_io *io) +{ + struct tpc_io *tio, *tior; + + /* + * Very minimal retry logic. We basically retry if we got an error + * back, and the retry count is greater than 0. If we ever want + * more sophisticated initiator type behavior, the CAM error + * recovery code in ../common might be helpful. + */ +// if ((io->io_hdr.status & CTL_STATUS_MASK) != CTL_SUCCESS) +// ctl_io_error_print(io, NULL); + tio = io->io_hdr.ctl_private[CTL_PRIV_FRONTEND].ptr; + if (((io->io_hdr.status & CTL_STATUS_MASK) != CTL_SUCCESS) + && (io->io_hdr.retries > 0)) { + ctl_io_status old_status; + tpc_error_action error_action; + + error_action = tpc_error_parse(io); + switch (error_action & TPC_ERR_MASK) { + case TPC_ERR_FAIL: + break; + case TPC_ERR_RETRY: + default: + if ((error_action & TPC_ERR_NO_DECREMENT) == 0) + io->io_hdr.retries--; + old_status = io->io_hdr.status; + io->io_hdr.status = CTL_STATUS_NONE; + io->io_hdr.flags &= ~CTL_FLAG_ABORT; + io->io_hdr.flags &= ~CTL_FLAG_SENT_2OTHER_SC; + if (tpcl_queue(io, tio->lun) != CTL_RETVAL_COMPLETE) { + printf("%s: error returned from ctl_queue()!\n", + __func__); + io->io_hdr.status = old_status; + } else + return; + } + } + + if ((io->io_hdr.status & CTL_STATUS_MASK) != CTL_SUCCESS) + tio->list->error = 1; + else + atomic_add_int(&tio->list->curops, 1); + if (!tio->list->error && !tio->list->abort) { + while ((tior = TAILQ_FIRST(&tio->run)) != NULL) { + TAILQ_REMOVE(&tio->run, tior, rlinks); + atomic_add_int(&tio->list->tbdio, 1); + if (tpcl_queue(tior->io, tior->lun) != CTL_RETVAL_COMPLETE) + panic("tpcl_queue() error"); + } + } + if (atomic_fetchadd_int(&tio->list->tbdio, -1) == 1) + tpc_process(tio->list); +} + +int +ctl_extended_copy_lid1(struct ctl_scsiio *ctsio) +{ + struct scsi_extended_copy *cdb; + struct scsi_extended_copy_lid1_data *data; + struct ctl_lun *lun; + struct tpc_list *list, *tlist; + uint8_t *ptr; + char *value; + int len, off, lencscd, lenseg, leninl, nseg; + + CTL_DEBUG_PRINT(("ctl_extended_copy_lid1\n")); + + lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; + cdb = (struct scsi_extended_copy *)ctsio->cdb; + len = scsi_4btoul(cdb->length); + + if (len < sizeof(struct scsi_extended_copy_lid1_data) || + len > sizeof(struct scsi_extended_copy_lid1_data) + + TPC_MAX_LIST + TPC_MAX_INLINE) { + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1, + /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0); + goto done; + } + + /* + * If we've got a kernel request that hasn't been malloced yet, + * malloc it and tell the caller the data buffer is here. + */ + if ((ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED) == 0) { + ctsio->kern_data_ptr = malloc(len, M_CTL, M_WAITOK); + ctsio->kern_data_len = len; + ctsio->kern_total_len = len; + ctsio->kern_data_resid = 0; + ctsio->kern_rel_offset = 0; + ctsio->kern_sg_entries = 0; + ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED; + ctsio->be_move_done = ctl_config_move_done; + ctl_datamove((union ctl_io *)ctsio); + + return (CTL_RETVAL_COMPLETE); + } + + data = (struct scsi_extended_copy_lid1_data *)ctsio->kern_data_ptr; + lencscd = scsi_2btoul(data->cscd_list_length); + lenseg = scsi_4btoul(data->segment_list_length); + leninl = scsi_4btoul(data->inline_data_length); + if (len < sizeof(struct scsi_extended_copy_lid1_data) + + lencscd + lenseg + leninl || + leninl > TPC_MAX_INLINE) { + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 0, + /*field*/ 2, /*bit_valid*/ 0, /*bit*/ 0); + goto done; + } + if (lencscd > TPC_MAX_CSCDS * sizeof(struct scsi_ec_cscd)) { + ctl_set_sense(ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST, + /*asc*/ 0x26, /*ascq*/ 0x06, SSD_ELEM_NONE); + goto done; + } + if (lencscd + lenseg > TPC_MAX_LIST) { + ctl_set_param_len_error(ctsio); + goto done; + } + + list = malloc(sizeof(struct tpc_list), M_CTL, M_WAITOK | M_ZERO); + list->service_action = cdb->service_action; + value = ctl_get_opt(&lun->be_lun->options, "insecure_tpc"); + if (value != NULL && strcmp(value, "on") == 0) + list->init_port = -1; + else + list->init_port = ctsio->io_hdr.nexus.targ_port; + list->init_idx = ctl_get_resindex(&ctsio->io_hdr.nexus); + list->list_id = data->list_identifier; + list->flags = data->flags; + list->params = ctsio->kern_data_ptr; + list->cscd = (struct scsi_ec_cscd *)&data->data[0]; + ptr = &data->data[lencscd]; + for (nseg = 0, off = 0; off < lenseg; nseg++) { + if (nseg >= TPC_MAX_SEGS) { + free(list, M_CTL); + ctl_set_sense(ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST, + /*asc*/ 0x26, /*ascq*/ 0x08, SSD_ELEM_NONE); + goto done; + } + list->seg[nseg] = (struct scsi_ec_segment *)(ptr + off); + off += sizeof(struct scsi_ec_segment) + + scsi_2btoul(list->seg[nseg]->descr_length); + } + list->inl = &data->data[lencscd + lenseg]; + list->ncscd = lencscd / sizeof(struct scsi_ec_cscd); + list->nseg = nseg; + list->leninl = leninl; + list->ctsio = ctsio; + list->lun = lun; + mtx_lock(&lun->lun_lock); + if ((list->flags & EC_LIST_ID_USAGE_MASK) != EC_LIST_ID_USAGE_NONE) { + TAILQ_FOREACH(tlist, &lun->tpc_lists, links) { + if ((tlist->flags & EC_LIST_ID_USAGE_MASK) != + EC_LIST_ID_USAGE_NONE && + tlist->list_id == list->list_id) + break; + } + if (tlist != NULL && !tlist->completed) { + mtx_unlock(&lun->lun_lock); + free(list, M_CTL); + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, + /*command*/ 0, /*field*/ 0, /*bit_valid*/ 0, + /*bit*/ 0); + goto done; + } + if (tlist != NULL) { + TAILQ_REMOVE(&lun->tpc_lists, tlist, links); + free(tlist, M_CTL); + } + } + TAILQ_INSERT_TAIL(&lun->tpc_lists, list, links); + mtx_unlock(&lun->lun_lock); + + tpc_process(list); + return (CTL_RETVAL_COMPLETE); + +done: + ctl_done((union ctl_io *)ctsio); + return (CTL_RETVAL_COMPLETE); +} + +int +ctl_extended_copy_lid4(struct ctl_scsiio *ctsio) +{ + struct scsi_extended_copy *cdb; + struct scsi_extended_copy_lid4_data *data; + struct ctl_lun *lun; + struct tpc_list *list, *tlist; + uint8_t *ptr; + char *value; + int len, off, lencscd, lenseg, leninl, nseg; + + CTL_DEBUG_PRINT(("ctl_extended_copy_lid4\n")); + + lun = (struct ctl_lun *)ctsio->io_hdr.ctl_private[CTL_PRIV_LUN].ptr; + cdb = (struct scsi_extended_copy *)ctsio->cdb; + len = scsi_4btoul(cdb->length); + + if (len < sizeof(struct scsi_extended_copy_lid4_data) || + len > sizeof(struct scsi_extended_copy_lid4_data) + + TPC_MAX_LIST + TPC_MAX_INLINE) { + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 1, + /*field*/ 9, /*bit_valid*/ 0, /*bit*/ 0); + goto done; + } + + /* + * If we've got a kernel request that hasn't been malloced yet, + * malloc it and tell the caller the data buffer is here. + */ + if ((ctsio->io_hdr.flags & CTL_FLAG_ALLOCATED) == 0) { + ctsio->kern_data_ptr = malloc(len, M_CTL, M_WAITOK); + ctsio->kern_data_len = len; + ctsio->kern_total_len = len; + ctsio->kern_data_resid = 0; + ctsio->kern_rel_offset = 0; + ctsio->kern_sg_entries = 0; + ctsio->io_hdr.flags |= CTL_FLAG_ALLOCATED; + ctsio->be_move_done = ctl_config_move_done; + ctl_datamove((union ctl_io *)ctsio); + + return (CTL_RETVAL_COMPLETE); + } + + data = (struct scsi_extended_copy_lid4_data *)ctsio->kern_data_ptr; + lencscd = scsi_2btoul(data->cscd_list_length); + lenseg = scsi_2btoul(data->segment_list_length); + leninl = scsi_2btoul(data->inline_data_length); + if (len < sizeof(struct scsi_extended_copy_lid4_data) + + lencscd + lenseg + leninl || + leninl > TPC_MAX_INLINE) { + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, /*command*/ 0, + /*field*/ 2, /*bit_valid*/ 0, /*bit*/ 0); + goto done; + } + if (lencscd > TPC_MAX_CSCDS * sizeof(struct scsi_ec_cscd)) { + ctl_set_sense(ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST, + /*asc*/ 0x26, /*ascq*/ 0x06, SSD_ELEM_NONE); + goto done; + } + if (lencscd + lenseg > TPC_MAX_LIST) { + ctl_set_param_len_error(ctsio); + goto done; + } + + list = malloc(sizeof(struct tpc_list), M_CTL, M_WAITOK | M_ZERO); + list->service_action = cdb->service_action; + value = ctl_get_opt(&lun->be_lun->options, "insecure_tpc"); + if (value != NULL && strcmp(value, "on") == 0) + list->init_port = -1; + else + list->init_port = ctsio->io_hdr.nexus.targ_port; + list->init_idx = ctl_get_resindex(&ctsio->io_hdr.nexus); + list->list_id = scsi_4btoul(data->list_identifier); + list->flags = data->flags; + list->params = ctsio->kern_data_ptr; + list->cscd = (struct scsi_ec_cscd *)&data->data[0]; + ptr = &data->data[lencscd]; + for (nseg = 0, off = 0; off < lenseg; nseg++) { + if (nseg >= TPC_MAX_SEGS) { + free(list, M_CTL); + ctl_set_sense(ctsio, /*current_error*/ 1, + /*sense_key*/ SSD_KEY_ILLEGAL_REQUEST, + /*asc*/ 0x26, /*ascq*/ 0x08, SSD_ELEM_NONE); + goto done; + } + list->seg[nseg] = (struct scsi_ec_segment *)(ptr + off); + off += sizeof(struct scsi_ec_segment) + + scsi_2btoul(list->seg[nseg]->descr_length); + } + list->inl = &data->data[lencscd + lenseg]; + list->ncscd = lencscd / sizeof(struct scsi_ec_cscd); + list->nseg = nseg; + list->leninl = leninl; + list->ctsio = ctsio; + list->lun = lun; + mtx_lock(&lun->lun_lock); + if ((list->flags & EC_LIST_ID_USAGE_MASK) != EC_LIST_ID_USAGE_NONE) { + TAILQ_FOREACH(tlist, &lun->tpc_lists, links) { + if ((tlist->flags & EC_LIST_ID_USAGE_MASK) != + EC_LIST_ID_USAGE_NONE && + tlist->list_id == list->list_id) + break; + } + if (tlist != NULL && !tlist->completed) { + mtx_unlock(&lun->lun_lock); + free(list, M_CTL); + ctl_set_invalid_field(ctsio, /*sks_valid*/ 1, + /*command*/ 0, /*field*/ 0, /*bit_valid*/ 0, + /*bit*/ 0); + goto done; + } + if (tlist != NULL) { + TAILQ_REMOVE(&lun->tpc_lists, tlist, links); + free(tlist, M_CTL); + } + } + TAILQ_INSERT_TAIL(&lun->tpc_lists, list, links); + mtx_unlock(&lun->lun_lock); + + tpc_process(list); + return (CTL_RETVAL_COMPLETE); + +done: + ctl_done((union ctl_io *)ctsio); + return (CTL_RETVAL_COMPLETE); +} + diff --git a/sys/cam/ctl/ctl_tpc.h b/sys/cam/ctl/ctl_tpc.h new file mode 100644 index 000000000000..ecbaec105d30 --- /dev/null +++ b/sys/cam/ctl/ctl_tpc.h @@ -0,0 +1,38 @@ +/*- + * Copyright (c) 2014 Alexander Motin + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer, + * without modification, immediately at the beginning of the file. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * $FreeBSD$ + */ + +#ifndef _CTL_TPC_H +#define _CTL_TPC_H 1 + +void tpc_done(union ctl_io *io); + +uint64_t tpcl_resolve(int init_port, struct scsi_ec_cscd *cscd, uint32_t *ss); +union ctl_io * tpcl_alloc_io(void); +int tpcl_queue(union ctl_io *io, uint64_t lun); + +#endif /* _CTL_TPC_H */ diff --git a/sys/cam/ctl/ctl_tpc_local.c b/sys/cam/ctl/ctl_tpc_local.c new file mode 100644 index 000000000000..8fb797865ad2 --- /dev/null +++ b/sys/cam/ctl/ctl_tpc_local.c @@ -0,0 +1,387 @@ +/*- + * Copyright (c) 2014 Alexander Motin + * Copyright (c) 2004, 2005 Silicon Graphics International Corp. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer, + * without modification, immediately at the beginning of the file. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +__FBSDID("$FreeBSD$"); + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +struct tpcl_softc { + struct ctl_port port; + int cur_tag_num; +}; + +extern struct ctl_softc *control_softc; +static struct tpcl_softc tpcl_softc; + +static int tpcl_init(void); +static void tpcl_shutdown(void); +static void tpcl_online(void *arg); +static void tpcl_offline(void *arg); +static int tpcl_lun_enable(void *arg, struct ctl_id target_id, int lun_id); +static int tpcl_lun_disable(void *arg, struct ctl_id target_id, int lun_id); +static void tpcl_datamove(union ctl_io *io); +static void tpcl_done(union ctl_io *io); + + +static struct ctl_frontend tpcl_frontend = +{ + .name = "tpc", + .init = tpcl_init, + .shutdown = tpcl_shutdown, +}; +CTL_FRONTEND_DECLARE(ctltpc, tpcl_frontend); + +static int +tpcl_init(void) +{ + struct ctl_softc *softc = control_softc; + struct tpcl_softc *tsoftc = &tpcl_softc; + struct ctl_port *port; + struct scsi_transportid_spi *tid; + int len; + + memset(tsoftc, 0, sizeof(*tsoftc)); + + port = &tsoftc->port; + port->frontend = &tpcl_frontend; + port->port_type = CTL_PORT_INTERNAL; + port->num_requested_ctl_io = 100; + port->port_name = "tpc"; + port->port_online = tpcl_online; + port->port_offline = tpcl_offline; + port->onoff_arg = tsoftc; + port->lun_enable = tpcl_lun_enable; + port->lun_disable = tpcl_lun_disable; + port->targ_lun_arg = tsoftc; + port->fe_datamove = tpcl_datamove; + port->fe_done = tpcl_done; + port->max_targets = 1; + port->max_target_id = 0; + port->max_initiators = 1; + + if (ctl_port_register(port, (softc->flags & CTL_FLAG_MASTER_SHELF)) != 0) + { + printf("%s: tpc frontend registration failed\n", __func__); + return (0); + } + + len = sizeof(struct scsi_transportid_spi); + port->init_devid = malloc(sizeof(struct ctl_devid) + len, + M_CTL, M_WAITOK | M_ZERO); + port->init_devid->len = len; + tid = (struct scsi_transportid_spi *)port->init_devid->data; + tid->format_protocol = SCSI_TRN_SPI_FORMAT_DEFAULT | SCSI_PROTO_SPI; + scsi_ulto2b(0, tid->scsi_addr); + scsi_ulto2b(port->targ_port, tid->rel_trgt_port_id); + + ctl_port_online(port); + return (0); +} + +void +tpcl_shutdown(void) +{ + struct tpcl_softc *tsoftc = &tpcl_softc; + struct ctl_port *port; + + port = &tsoftc->port; + ctl_port_offline(port); + if (ctl_port_deregister(&tsoftc->port) != 0) + printf("%s: ctl_frontend_deregister() failed\n", __func__); +} + +static void +tpcl_online(void *arg) +{ +} + +static void +tpcl_offline(void *arg) +{ +} + +static int +tpcl_lun_enable(void *arg, struct ctl_id target_id, int lun_id) +{ + + return (0); +} + +static int +tpcl_lun_disable(void *arg, struct ctl_id target_id, int lun_id) +{ + + return (0); +} + +static void +tpcl_datamove(union ctl_io *io) +{ + struct ctl_sg_entry *ext_sglist, *kern_sglist; + struct ctl_sg_entry ext_entry, kern_entry; + int ext_sg_entries, kern_sg_entries; + int ext_sg_start, ext_offset; + int len_to_copy, len_copied; + int kern_watermark, ext_watermark; + struct ctl_scsiio *ctsio; + int i, j; + + ext_sg_start = 0; + ext_offset = 0; + ext_sglist = NULL; + + CTL_DEBUG_PRINT(("%s\n", __func__)); + + ctsio = &io->scsiio; + + /* + * If this is the case, we're probably doing a BBR read and don't + * actually need to transfer the data. This will effectively + * bit-bucket the data. + */ + if (ctsio->ext_data_ptr == NULL) + goto bailout; + + /* + * To simplify things here, if we have a single buffer, stick it in + * a S/G entry and just make it a single entry S/G list. + */ + if (ctsio->io_hdr.flags & CTL_FLAG_EDPTR_SGLIST) { + int len_seen; + + ext_sglist = (struct ctl_sg_entry *)ctsio->ext_data_ptr; + ext_sg_entries = ctsio->ext_sg_entries; + ext_sg_start = 0; + ext_offset = 0; + len_seen = 0; + for (i = 0; i < ext_sg_entries; i++) { + if ((len_seen + ext_sglist[i].len) >= + ctsio->ext_data_filled) { + ext_sg_start = i; + ext_offset = ctsio->ext_data_filled - len_seen; + break; + } + len_seen += ext_sglist[i].len; + } + } else { + ext_sglist = &ext_entry; + ext_sglist->addr = ctsio->ext_data_ptr; + ext_sglist->len = ctsio->ext_data_len; + ext_sg_entries = 1; + ext_sg_start = 0; + ext_offset = ctsio->ext_data_filled; + } + + if (ctsio->kern_sg_entries > 0) { + kern_sglist = (struct ctl_sg_entry *)ctsio->kern_data_ptr; + kern_sg_entries = ctsio->kern_sg_entries; + } else { + kern_sglist = &kern_entry; + kern_sglist->addr = ctsio->kern_data_ptr; + kern_sglist->len = ctsio->kern_data_len; + kern_sg_entries = 1; + } + + kern_watermark = 0; + ext_watermark = ext_offset; + len_copied = 0; + for (i = ext_sg_start, j = 0; + i < ext_sg_entries && j < kern_sg_entries;) { + uint8_t *ext_ptr, *kern_ptr; + + len_to_copy = min(ext_sglist[i].len - ext_watermark, + kern_sglist[j].len - kern_watermark); + + ext_ptr = (uint8_t *)ext_sglist[i].addr; + ext_ptr = ext_ptr + ext_watermark; + if (io->io_hdr.flags & CTL_FLAG_BUS_ADDR) { + /* + * XXX KDM fix this! + */ + panic("need to implement bus address support"); +#if 0 + kern_ptr = bus_to_virt(kern_sglist[j].addr); +#endif + } else + kern_ptr = (uint8_t *)kern_sglist[j].addr; + kern_ptr = kern_ptr + kern_watermark; + + kern_watermark += len_to_copy; + ext_watermark += len_to_copy; + + if ((ctsio->io_hdr.flags & CTL_FLAG_DATA_MASK) == + CTL_FLAG_DATA_IN) { + CTL_DEBUG_PRINT(("%s: copying %d bytes to user\n", + __func__, len_to_copy)); + CTL_DEBUG_PRINT(("%s: from %p to %p\n", __func__, + kern_ptr, ext_ptr)); + memcpy(ext_ptr, kern_ptr, len_to_copy); + } else { + CTL_DEBUG_PRINT(("%s: copying %d bytes from user\n", + __func__, len_to_copy)); + CTL_DEBUG_PRINT(("%s: from %p to %p\n", __func__, + ext_ptr, kern_ptr)); + memcpy(kern_ptr, ext_ptr, len_to_copy); + } + + len_copied += len_to_copy; + + if (ext_sglist[i].len == ext_watermark) { + i++; + ext_watermark = 0; + } + + if (kern_sglist[j].len == kern_watermark) { + j++; + kern_watermark = 0; + } + } + + ctsio->ext_data_filled += len_copied; + + CTL_DEBUG_PRINT(("%s: ext_sg_entries: %d, kern_sg_entries: %d\n", + __func__, ext_sg_entries, kern_sg_entries)); + CTL_DEBUG_PRINT(("%s: ext_data_len = %d, kern_data_len = %d\n", + __func__, ctsio->ext_data_len, ctsio->kern_data_len)); + + /* XXX KDM set residual?? */ +bailout: + io->scsiio.be_move_done(io); +} + +static void +tpcl_done(union ctl_io *io) +{ + + tpc_done(io); +} + +uint64_t +tpcl_resolve(int init_port, struct scsi_ec_cscd *cscd, uint32_t *ss) +{ + struct ctl_softc *softc = control_softc; + struct scsi_ec_cscd_id *cscdid; + struct ctl_port *port; + struct ctl_lun *lun; + uint64_t lunid = UINT64_MAX, l; + int i; + + if (cscd->type_code != EC_CSCD_ID) + return (lunid); + + cscdid = (struct scsi_ec_cscd_id *)cscd; + mtx_lock(&softc->ctl_lock); + if (init_port >= 0) { + port = softc->ctl_ports[ctl_port_idx(init_port)]; + if (port == NULL || port->lun_map == NULL) + init_port = -1; + } + if (init_port < 0) { + STAILQ_FOREACH(lun, &softc->lun_list, links) { + if (lun->lun_devid == NULL) + continue; + if (scsi_devid_match(lun->lun_devid->data, + lun->lun_devid->len, &cscdid->codeset, + cscdid->length + 4) == 0) { + lunid = lun->lun; + if (ss && lun->be_lun) + *ss = lun->be_lun->blocksize; + break; + } + } + } else { + for (i = 0; i < CTL_MAX_LUNS; i++) { + l = port->lun_map(port->targ_lun_arg, i); + if (l >= CTL_MAX_LUNS) + continue; + lun = softc->ctl_luns[l]; + if (lun == NULL || lun->lun_devid == NULL) + continue; + if (scsi_devid_match(lun->lun_devid->data, + lun->lun_devid->len, &cscdid->codeset, + cscdid->length + 4) == 0) { + lunid = lun->lun; + if (ss && lun->be_lun) + *ss = lun->be_lun->blocksize; + break; + } + } + } + mtx_unlock(&softc->ctl_lock); + return (lunid); +}; + +union ctl_io * +tpcl_alloc_io(void) +{ + struct tpcl_softc *tsoftc = &tpcl_softc; + + return (ctl_alloc_io(tsoftc->port.ctl_pool_ref)); +}; + +int +tpcl_queue(union ctl_io *io, uint64_t lun) +{ + struct tpcl_softc *tsoftc = &tpcl_softc; + + io->io_hdr.nexus.initid.id = 0; + io->io_hdr.nexus.targ_port = tsoftc->port.targ_port; + io->io_hdr.nexus.targ_target.id = 0; + io->io_hdr.nexus.targ_lun = lun; + io->scsiio.tag_num = atomic_fetchadd_int(&tsoftc->cur_tag_num, 1); + io->scsiio.ext_data_filled = 0; + return (ctl_queue(io)); +} diff --git a/sys/cam/ctl/scsi_ctl.c b/sys/cam/ctl/scsi_ctl.c index cd3524a57ada..3529683f6208 100644 --- a/sys/cam/ctl/scsi_ctl.c +++ b/sys/cam/ctl/scsi_ctl.c @@ -804,8 +804,7 @@ ctlfestart(struct cam_periph *periph, union ccb *start_ccb) if (io == NULL) { scsi_status = SCSI_STATUS_BUSY; csio->sense_len = 0; - } else if ((io->io_hdr.status & CTL_STATUS_MASK) == - CTL_CMD_ABORTED && + } else if ((io->io_hdr.flags & CTL_FLAG_ABORT) && (io->io_hdr.flags & CTL_FLAG_ABORT_STATUS) == 0) { io->io_hdr.flags &= ~CTL_FLAG_STATUS_QUEUED; diff --git a/sys/cam/scsi/scsi_all.h b/sys/cam/scsi/scsi_all.h index 8ffbd827eaec..6a4467e5b2c0 100644 --- a/sys/cam/scsi/scsi_all.h +++ b/sys/cam/scsi/scsi_all.h @@ -1266,6 +1266,273 @@ struct scsi_report_timestamp_data uint8_t reserve2[2]; }; +struct scsi_receive_copy_status_lid1 +{ + uint8_t opcode; + uint8_t service_action; +#define RCS_RCS_LID1 0x00 + uint8_t list_identifier; + uint8_t reserved[7]; + uint8_t length[4]; + uint8_t reserved1; + uint8_t control; +}; + +struct scsi_receive_copy_status_lid1_data +{ + uint8_t available_data[4]; + uint8_t copy_command_status; +#define RCS_CCS_INPROG 0x00 +#define RCS_CCS_COMPLETED 0x01 +#define RCS_CCS_ERROR 0x02 + uint8_t segments_processed[2]; + uint8_t transfer_count_units; +#define RCS_TC_BYTES 0x00 +#define RCS_TC_KBYTES 0x01 +#define RCS_TC_MBYTES 0x02 +#define RCS_TC_GBYTES 0x03 +#define RCS_TC_TBYTES 0x04 +#define RCS_TC_PBYTES 0x05 +#define RCS_TC_EBYTES 0x06 +#define RCS_TC_LBAS 0xf1 + uint8_t transfer_count[4]; +}; + +struct scsi_receive_copy_failure_details +{ + uint8_t opcode; + uint8_t service_action; +#define RCS_RCFD 0x04 + uint8_t list_identifier; + uint8_t reserved[7]; + uint8_t length[4]; + uint8_t reserved1; + uint8_t control; +}; + +struct scsi_receive_copy_failure_details_data +{ + uint8_t available_data[4]; + uint8_t reserved[52]; + uint8_t copy_command_status; + uint8_t reserved2; + uint8_t sense_data_length[2]; + uint8_t sense_data[]; +}; + +struct scsi_receive_copy_status_lid4 +{ + uint8_t opcode; + uint8_t service_action; +#define RCS_RCS_LID4 0x05 + uint8_t list_identifier[4]; + uint8_t reserved[4]; + uint8_t length[4]; + uint8_t reserved1; + uint8_t control; +}; + +struct scsi_receive_copy_status_lid4_data +{ + uint8_t available_data[4]; + uint8_t response_to_service_action; + uint8_t copy_command_status; +#define RCS_CCS_COMPLETED_PROD 0x03 +#define RCS_CCS_COMPLETED_RESID 0x04 +#define RCS_CCS_INPROG_FGBG 0x10 +#define RCS_CCS_INPROG_FG 0x11 +#define RCS_CCS_INPROG_BG 0x12 +#define RCS_CCS_ABORTED 0x60 + uint8_t operation_counter[2]; + uint8_t estimated_status_update_delay[4]; + uint8_t extended_copy_completion_status; + uint8_t length_of_the_sense_data_field; + uint8_t sense_data_length; + uint8_t transfer_count_units; + uint8_t transfer_count[8]; + uint8_t segments_processed[2]; + uint8_t reserved[2]; + uint8_t sense_data[]; +}; + +struct scsi_receive_copy_operating_parameters +{ + uint8_t opcode; + uint8_t service_action; +#define RCS_RCOP 0x03 + uint8_t reserved[8]; + uint8_t length[4]; + uint8_t reserved1; + uint8_t control; +}; + +struct scsi_receive_copy_operating_parameters_data +{ + uint8_t length[4]; + uint8_t snlid; +#define RCOP_SNLID 0x01 + uint8_t reserved[3]; + uint8_t maximum_cscd_descriptor_count[2]; + uint8_t maximum_segment_descriptor_count[2]; + uint8_t maximum_descriptor_list_length[4]; + uint8_t maximum_segment_length[4]; + uint8_t maximum_inline_data_length[4]; + uint8_t held_data_limit[4]; + uint8_t maximum_stream_device_transfer_size[4]; + uint8_t reserved2[2]; + uint8_t total_concurrent_copies[2]; + uint8_t maximum_concurrent_copies; + uint8_t data_segment_granularity; + uint8_t inline_data_granularity; + uint8_t held_data_granularity; + uint8_t reserved3[3]; + uint8_t implemented_descriptor_list_length; + uint8_t list_of_implemented_descriptor_type_codes[0]; +}; + +struct scsi_extended_copy +{ + uint8_t opcode; + uint8_t service_action; +#define EC_EC_LID1 0x00 +#define EC_EC_LID4 0x01 + uint8_t reserved[8]; + uint8_t length[4]; + uint8_t reserved1; + uint8_t control; +}; + +struct scsi_ec_cscd_dtsp +{ + uint8_t flags; +#define EC_CSCD_FIXED 0x01 +#define EC_CSCD_PAD 0x04 + uint8_t block_length[3]; +}; + +struct scsi_ec_cscd +{ + uint8_t type_code; +#define EC_CSCD_EXT 0xff + uint8_t luidt_pdt; +#define EC_LUIDT_MASK 0xc0 +#define EC_LUIDT_LUN 0x00 +#define EC_LUIDT_PROXY_TOKEN 0x40 + uint8_t relative_initiator_port[2]; + uint8_t cscd_params[24]; + struct scsi_ec_cscd_dtsp dtsp; +}; + +struct scsi_ec_cscd_id +{ + uint8_t type_code; +#define EC_CSCD_ID 0xe4 + uint8_t luidt_pdt; + uint8_t relative_initiator_port[2]; + uint8_t codeset; + uint8_t id_type; + uint8_t reserved; + uint8_t length; + uint8_t designator[20]; + struct scsi_ec_cscd_dtsp dtsp; +}; + +struct scsi_ec_segment +{ + uint8_t type_code; + uint8_t flags; +#define EC_SEG_DC 0x02 +#define EC_SEG_CAT 0x01 + uint8_t descr_length[2]; + uint8_t params[]; +}; + +struct scsi_ec_segment_b2b +{ + uint8_t type_code; +#define EC_SEG_B2B 0x02 + uint8_t flags; + uint8_t descr_length[2]; + uint8_t src_cscd[2]; + uint8_t dst_cscd[2]; + uint8_t reserved[2]; + uint8_t number_of_blocks[2]; + uint8_t src_lba[8]; + uint8_t dst_lba[8]; +}; + +struct scsi_ec_segment_verify +{ + uint8_t type_code; +#define EC_SEG_VERIFY 0x07 + uint8_t reserved; + uint8_t descr_length[2]; + uint8_t src_cscd[2]; + uint8_t reserved2[2]; + uint8_t tur; + uint8_t reserved3[3]; +}; + +struct scsi_ec_segment_register_key +{ + uint8_t type_code; +#define EC_SEG_REGISTER_KEY 0x14 + uint8_t reserved; + uint8_t descr_length[2]; + uint8_t reserved2[2]; + uint8_t dst_cscd[2]; + uint8_t res_key[8]; + uint8_t sa_res_key[8]; + uint8_t reserved3[4]; +}; + +struct scsi_extended_copy_lid1_data +{ + uint8_t list_identifier; + uint8_t flags; +#define EC_PRIORITY 0x07 +#define EC_LIST_ID_USAGE_MASK 0x18 +#define EC_LIST_ID_USAGE_FULL 0x08 +#define EC_LIST_ID_USAGE_NOHOLD 0x10 +#define EC_LIST_ID_USAGE_NONE 0x18 +#define EC_STR 0x20 + uint8_t cscd_list_length[2]; + uint8_t reserved[4]; + uint8_t segment_list_length[4]; + uint8_t inline_data_length[4]; + uint8_t data[]; +}; + +struct scsi_extended_copy_lid4_data +{ + uint8_t list_format; +#define EC_LIST_FORMAT 0x01 + uint8_t flags; + uint8_t header_cscd_list_length[2]; + uint8_t reserved[11]; + uint8_t flags2; +#define EC_IMMED 0x01 +#define EC_G_SENSE 0x02 + uint8_t header_cscd_type_code; + uint8_t reserved2[3]; + uint8_t list_identifier[4]; + uint8_t reserved3[18]; + uint8_t cscd_list_length[2]; + uint8_t segment_list_length[2]; + uint8_t inline_data_length[2]; + uint8_t data[]; +}; + +struct scsi_copy_operation_abort +{ + uint8_t opcode; + uint8_t service_action; +#define EC_COA 0x1c + uint8_t list_identifier[4]; + uint8_t reserved[9]; + uint8_t control; +}; + struct ata_pass_16 { u_int8_t opcode; u_int8_t protocol; @@ -1337,6 +1604,8 @@ struct ata_pass_16 { #define MODE_SENSE_10 0x5A #define PERSISTENT_RES_IN 0x5E #define PERSISTENT_RES_OUT 0x5F +#define EXTENDED_COPY 0x83 +#define RECEIVE_COPY_STATUS 0x84 #define ATA_PASS_16 0x85 #define READ_16 0x88 #define COMPARE_AND_WRITE 0x89 @@ -1450,7 +1719,9 @@ struct scsi_inquiry_data #define SID_QUAL_IS_VENDOR_UNIQUE(inq_data) ((SID_QUAL(inq_data) & 0x08) != 0) u_int8_t dev_qual2; #define SID_QUAL2 0x7F -#define SID_IS_REMOVABLE(inq_data) (((inq_data)->dev_qual2 & 0x80) != 0) +#define SID_LU_CONG 0x40 +#define SID_RMB 0x80 +#define SID_IS_REMOVABLE(inq_data) (((inq_data)->dev_qual2 & SID_RMB) != 0) u_int8_t version; #define SID_ANSI_REV(inq_data) ((inq_data)->version & 0x07) #define SCSI_REV_0 0 @@ -1773,6 +2044,83 @@ struct scsi_vpd_scsi_ports */ #define SVPD_ATA_INFORMATION 0x89 + +struct scsi_vpd_tpc_descriptor +{ + uint8_t desc_type[2]; + uint8_t desc_length[2]; + uint8_t parameters[]; +}; + +struct scsi_vpd_tpc_descriptor_sc_descr +{ + uint8_t opcode; + uint8_t sa_length; + uint8_t supported_service_actions[0]; +}; + +struct scsi_vpd_tpc_descriptor_sc +{ + uint8_t desc_type[2]; +#define SVPD_TPC_SC 0x0001 + uint8_t desc_length[2]; + uint8_t list_length; + struct scsi_vpd_tpc_descriptor_sc_descr descr[]; +}; + +struct scsi_vpd_tpc_descriptor_pd +{ + uint8_t desc_type[2]; +#define SVPD_TPC_PD 0x0004 + uint8_t desc_length[2]; + uint8_t reserved[4]; + uint8_t maximum_cscd_descriptor_count[2]; + uint8_t maximum_segment_descriptor_count[2]; + uint8_t maximum_descriptor_list_length[4]; + uint8_t maximum_inline_data_length[4]; + uint8_t reserved2[12]; +}; + +struct scsi_vpd_tpc_descriptor_sd +{ + uint8_t desc_type[2]; +#define SVPD_TPC_SD 0x0008 + uint8_t desc_length[2]; + uint8_t list_length; + uint8_t supported_descriptor_codes[]; +}; + +struct scsi_vpd_tpc_descriptor_sdid +{ + uint8_t desc_type[2]; +#define SVPD_TPC_SDID 0x000C + uint8_t desc_length[2]; + uint8_t list_length[2]; + uint8_t supported_descriptor_ids[]; +}; + +struct scsi_vpd_tpc_descriptor_gco +{ + uint8_t desc_type[2]; +#define SVPD_TPC_GCO 0x8001 + uint8_t desc_length[2]; + uint8_t total_concurrent_copies[4]; + uint8_t maximum_identified_concurrent_copies[4]; + uint8_t maximum_segment_length[4]; + uint8_t data_segment_granularity; + uint8_t inline_data_granularity; + uint8_t reserved[18]; +}; + +struct scsi_vpd_tpc +{ + uint8_t device; + uint8_t page_code; +#define SVPD_SCSI_TPC 0x8F + uint8_t page_length[2]; + struct scsi_vpd_tpc_descriptor descr[]; +}; + /* * Block Device Characteristics VPD Page based on * T10/1799-D Revision 31 diff --git a/sys/conf/files b/sys/conf/files index 64101d1c06c5..2b4ebfbc7901 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -86,6 +86,8 @@ cam/ctl/ctl_frontend_cam_sim.c optional ctl cam/ctl/ctl_frontend_internal.c optional ctl cam/ctl/ctl_frontend_iscsi.c optional ctl cam/ctl/ctl_scsi_all.c optional ctl +cam/ctl/ctl_tpc.c optional ctl +cam/ctl/ctl_tpc_local.c optional ctl cam/ctl/ctl_error.c optional ctl cam/ctl/ctl_util.c optional ctl cam/ctl/scsi_ctl.c optional ctl diff --git a/sys/modules/ctl/Makefile b/sys/modules/ctl/Makefile index c4fe6497ad2a..77dc4e12b382 100644 --- a/sys/modules/ctl/Makefile +++ b/sys/modules/ctl/Makefile @@ -14,6 +14,8 @@ SRCS+= ctl_frontend_cam_sim.c SRCS+= ctl_frontend_internal.c SRCS+= ctl_frontend_iscsi.c SRCS+= ctl_scsi_all.c +SRCS+= ctl_tpc.c +SRCS+= ctl_tpc_local.c SRCS+= ctl_error.c SRCS+= ctl_util.c SRCS+= scsi_ctl.c diff --git a/usr.sbin/ctladm/ctladm.8 b/usr.sbin/ctladm/ctladm.8 index dfa238239d91..f58a760f39d3 100644 --- a/usr.sbin/ctladm/ctladm.8 +++ b/usr.sbin/ctladm/ctladm.8 @@ -951,6 +951,14 @@ Specifies LUN SCSI name string. Specifies LUN EUI-64 identifier. .It Va naa Specifies LUN NAA identifier. +Either EUI or NAA identifier should be set to UNIQUE value to allow +EXTENDED COPY command access the LUN. +Non-unique LUN identifiers may lead to data corruption. +.It Va insecure_tpc +Setting to "on" allows EXTENDED COPY command sent to this LUN access +other LUNs on this host, not accessible otherwise. +This allows to offload copying between different iSCSI targets residing +on the same host in trusted environments. .It Va unmap Set to "on", enables UNMAP support for the LUN. .El