From 766b77d70276eef4a6ae92217d1ffbcde819a88b Mon Sep 17 00:00:00 2001 From: Douglas Gilbert Date: Wed, 20 Dec 2017 03:53:14 +0000 Subject: sg_write_x: almost finished; lots of nvme infrastructure git-svn-id: https://svn.bingwo.ca/repos/sg3_utils/trunk@737 6180dd3e-e324-4e3e-922d-17de1ae2f315 --- lib/sg_pt_freebsd.c | 725 +++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 722 insertions(+), 3 deletions(-) (limited to 'lib/sg_pt_freebsd.c') diff --git a/lib/sg_pt_freebsd.c b/lib/sg_pt_freebsd.c index 08716bb8..6fa3f310 100644 --- a/lib/sg_pt_freebsd.c +++ b/lib/sg_pt_freebsd.c @@ -5,7 +5,7 @@ * license that can be found in the BSD_LICENSE file. */ -/* sg_pt_freebsd version 1.18 20171114 */ +/* sg_pt_freebsd version 1.19 20171218 */ #include #include @@ -31,6 +31,8 @@ #include "sg_pt.h" #include "sg_lib.h" +#include "sg_unaligned.h" +#include "sg_pt_nvme.h" #include "freebsd_nvme_ioctl.h" #ifdef HAVE_CONFIG_H @@ -76,6 +78,7 @@ struct sg_pt_freebsd_scsi { uint32_t dxfer_olen; uint32_t mdxfer_len; bool mdxfer_out; + bool scsi_dsense; int scsi_status; int resid; int sense_resid; @@ -112,6 +115,42 @@ pr2ws(const char * fmt, ...) return n; } +static inline bool is_aligned(const void * pointer, size_t byte_count) +{ + return (sg_uintptr_t)pointer % byte_count == 0; +} + +/* The web claims that all NVMe commands are 64 bytes long. Believe it until + * contradicted. The only SCSI commands that can be longer than 16 bytes are + * the Variable Length Commands (opcode 0x7f) and the XCDB wrapped commands + * (opcode 0x7e). Both have an inbuilt length field which can be cross + * checked with clen. */ +static bool +is_scsi_command(const uint8_t * cdbp, int clen) +{ + int ilen, sa; + + if (clen <= 16) + return true; + if (0 == (clen % 4)) { + if (0x7f == cdbp[0]) { + ilen = 8 + cdbp[7]; + sa = sg_get_unaligned_be16(cdbp + 8); + if ((ilen == clen) && sa) + return true; + } else if (0x7e == cdbp[0]) { + ilen = 4 + sg_get_unaligned_be16(cdbp + 2); + if (ilen == clen) + return true; + } + } + if ((clen >= 64) && (clen <= 72)) + return false; + pr2ws("%s: irregular command, assume NVMe:\n", __func__); + dStrHexErr((const char *)cdbp, clen, 1); + return false; +} + /* Returns >= 0 if successful. If error in Unix returns negated errno. */ int @@ -124,7 +163,7 @@ scsi_pt_open_device(const char * device_name, bool read_only, int verbose) } /* Similar to scsi_pt_open_device() but takes Unix style open flags OR-ed - * together. The 'flags' is only used on NVMe devices. It is ignored on + * together. The 'oflags' is only used on NVMe devices. It is ignored on * SCSI and ATA devices in FreeBSD. * Returns >= 0 if successful, otherwise returns negated errno. */ int @@ -859,7 +898,7 @@ get_pt_nvme_nsid(const struct sg_pt_base * vp) fdchan = devicetable[han]; if (NULL == fdchan) return 0; - return fdchan->nsid ; + return fdchan->nsid; } return 0; } @@ -876,3 +915,683 @@ get_scsi_pt_os_err_str(const struct sg_pt_base * vp, int max_b_len, char * b) b[max_b_len - 1] = '\0'; return b; } + + +#define SCSI_INQUIRY_OPC 0x12 +#define SCSI_REPORT_LUNS_OPC 0xa0 +#define SCSI_TEST_UNIT_READY_OPC 0x0 +#define SCSI_REQUEST_SENSE_OPC 0x3 +#define SCSI_SEND_DIAGNOSTIC_OPC 0x1d +#define SCSI_RECEIVE_DIAGNOSTIC_OPC 0x1c + +/* Additional Sense Code (ASC) */ +#define NO_ADDITIONAL_SENSE 0x0 +#define LOGICAL_UNIT_NOT_READY 0x4 +#define LOGICAL_UNIT_COMMUNICATION_FAILURE 0x8 +#define UNRECOVERED_READ_ERR 0x11 +#define PARAMETER_LIST_LENGTH_ERR 0x1a +#define INVALID_OPCODE 0x20 +#define LBA_OUT_OF_RANGE 0x21 +#define INVALID_FIELD_IN_CDB 0x24 +#define INVALID_FIELD_IN_PARAM_LIST 0x26 +#define UA_RESET_ASC 0x29 +#define UA_CHANGED_ASC 0x2a +#define TARGET_CHANGED_ASC 0x3f +#define LUNS_CHANGED_ASCQ 0x0e +#define INSUFF_RES_ASC 0x55 +#define INSUFF_RES_ASCQ 0x3 +#define LOW_POWER_COND_ON_ASC 0x5e /* ASCQ=0 */ +#define POWER_ON_RESET_ASCQ 0x0 +#define BUS_RESET_ASCQ 0x2 /* scsi bus reset occurred */ +#define MODE_CHANGED_ASCQ 0x1 /* mode parameters changed */ +#define CAPACITY_CHANGED_ASCQ 0x9 +#define SAVING_PARAMS_UNSUP 0x39 +#define TRANSPORT_PROBLEM 0x4b +#define THRESHOLD_EXCEEDED 0x5d +#define LOW_POWER_COND_ON 0x5e +#define MISCOMPARE_VERIFY_ASC 0x1d +#define MICROCODE_CHANGED_ASCQ 0x1 /* with TARGET_CHANGED_ASC */ +#define MICROCODE_CHANGED_WO_RESET_ASCQ 0x16 + + +static void +build_sense_buffer(bool desc, uint8_t *buf, uint8_t skey, uint8_t asc, + uint8_t ascq) +{ + if (desc) { + buf[0] = 0x72; /* descriptor, current */ + buf[1] = skey; + buf[2] = asc; + buf[3] = ascq; + buf[7] = 0; + } else { + buf[0] = 0x70; /* fixed, current */ + buf[2] = skey; + buf[7] = 0xa; /* Assumes length is 18 bytes */ + buf[12] = asc; + buf[13] = ascq; + } +} + +/* Set in_bit to -1 to indicate no bit position of invalid field */ +static void +mk_sense_asc_ascq(struct sg_pt_freebsd_scsi * ptp, int sk, int asc, int ascq, + int vb) +{ + bool dsense = ptp->scsi_dsense; + int n; + uint8_t * sbp = ptp->sense; + + ptp->scsi_status = SAM_STAT_CHECK_CONDITION; + n = ptp->sense_len; + if ((n < 8) || ((! dsense) && (n < 14))) { + pr2ws("%s: sense_len=%d too short, want 14 or more\n", __func__, n); + return; + } else + ptp->sense_resid = ptp->sense_len - + (dsense ? 8 : ((n < 18) ? n : 18)); + memset(sbp, 0, n); + build_sense_buffer(dsense, sbp, sk, asc, ascq); + if (vb > 3) + pr2ws("%s: [sense_key,asc,ascq]: [0x5,0x%x,0x%x]\n", __func__, asc, + ascq); +} + +/* Set in_bit to -1 to indicate no bit position of invalid field */ +static void +mk_sense_invalid_fld(struct sg_pt_freebsd_scsi * ptp, bool in_cdb, + int in_byte, int in_bit, int vb) +{ + bool ds = ptp->scsi_dsense; + int sl, asc, n; + uint8_t * sbp = (uint8_t *)ptp->sense; + uint8_t sks[4]; + + ptp->scsi_status = SAM_STAT_CHECK_CONDITION; + asc = in_cdb ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST; + n = ptp->sense_len; + if ((n < 8) || ((! ds) && (n < 14))) { + pr2ws("%s: max_response_len=%d too short, want 14 or more\n", + __func__, n); + return; + } else + ptp->sense_resid = ptp->sense_len - (ds ? 8 : ((n < 18) ? n : 18)); + memset(sbp, 0, n); + build_sense_buffer(ds, sbp, SPC_SK_ILLEGAL_REQUEST, asc, 0); + memset(sks, 0, sizeof(sks)); + sks[0] = 0x80; + if (in_cdb) + sks[0] |= 0x40; + if (in_bit >= 0) { + sks[0] |= 0x8; + sks[0] |= (0x7 & in_bit); + } + sg_put_unaligned_be16(in_byte, sks + 1); + if (ds) { + sl = sbp[7] + 8; + sbp[7] = sl; + sbp[sl] = 0x2; + sbp[sl + 1] = 0x6; + memcpy(sbp + sl + 4, sks, 3); + } else + memcpy(sbp + 15, sks, 3); + if (vb > 3) + pr2ws("%s: [sense_key,asc,ascq]: [0x5,0x%x,0x0] %c byte=%d, bit=%d\n", + __func__, asc, in_cdb ? 'C' : 'D', in_byte, in_bit); +} + +#if 0 +static int +do_nvme_admin_cmd(struct sg_pt_linux_scsi * ptp, + struct sg_nvme_passthru_cmd *cmdp, int time_secs, + bool cp_cmd_out2resp, int vb) +{ + const uint32_t cmd_len = sizeof(struct sg_nvme_passthru_cmd); + uint32_t n; + + cmdp->timeout_ms = (time_secs < 0) ? 0 : (1000 * time_secs); + if (vb > 2) { + pr2ws("NVMe command:\n"); + dStrHex((const char *)cmdp, cmd_len, 1); + } + if (ioctl(ptp->dev_fd, NVME_IOCTL_ADMIN_CMD, cmdp) < 0) { + ptp->os_err = errno; + if (vb > 2) + pr2ws("%s: ioctl(NVME_IOCTL_ADMIN_CMD) failed: %s (errno=%d)\n", + __func__, strerror(ptp->os_err), ptp->os_err); + return -ptp->os_err; + } else + ptp->os_err = 0; + ptp->nvme_result = cmdp->result; + if (cp_cmd_out2resp) { + n = ptp->io_hdr.max_response_len; + if ((n > 0) && ptp->io_hdr.response) { + n = (n < cmd_len) ? n : cmd_len; + memcpy((uint8_t *)ptp->io_hdr.response, cmdp, n); + ptp->io_hdr.response_len = n; + } else + ptp->io_hdr.response_len = 0; + } else + ptp->io_hdr.response_len = 0; + + if (vb > 2) + pr2ws("%s: timeout_ms=%u, result=%u\n", __func__, cmdp->timeout_ms, + cmdp->result); + return 0; +} +#endif + +static int +sntl_cache_identity(struct sg_pt_freebsd_scsi * ptp, int time_secs, int vb) +{ + int err; + struct sg_nvme_passthru_cmd cmd; + uint32_t pg_sz = sg_get_page_size(); + + ptp->nvme_id_ctlp = sg_memalign(pg_sz, pg_sz, &ptp->free_nvme_id_ctlp, + vb > 3); + if (NULL == ptp->nvme_id_ctlp) { + pr2ws("%s: sg_memalign() failed to get memory\n", __func__); + return SG_LIB_OS_BASE_ERR + ENOMEM; + } + memset(&cmd, 0, sizeof(cmd)); + cmd.opcode = 0x6; /* Identify */ + cmd.cdw10 = 0x1; /* CNS=0x1 Identify controller */ + cmd.addr = (uint64_t)(sg_uintptr_t)ptp->nvme_id_ctlp; + cmd.data_len = pg_sz; + cmd.timeout_ms = (time_secs < 0) ? 0 : (1000 * time_secs); + if (ioctl(ptp->dev_fd, NVME_IOCTL_ADMIN_CMD, &cmd) < 0) { + err = errno; + if (vb > 2) + pr2ws("%s: ioctl(NVME_IOCTL_ADMIN_CMD) failed: %s (errno=%d)" + "\n", __func__, strerror(err), err); + ptp->os_err = err; + return -err; + } + return 0; +} + +static const char * nvme_scsi_vendor_str = "NVMe "; +static const uint16_t inq_resp_len = 36; + +static int +sntl_inq(struct sg_pt_freebsd_scsi * ptp, const uint8_t * cdbp, int time_secs, + int vb) +{ + bool evpd; + int res; + uint16_t k, n, alloc_len, pg_cd; + uint8_t inq_dout[128]; + + if (vb > 3) + pr2ws("%s: time_secs=%d\n", __func__, time_secs); + + if (0x2 & cdbp[1]) { + mk_sense_invalid_fld(ptp, true, 1, 1, vb); + return 0; + } + if (NULL == ptp->nvme_id_ctlp) { + res = sntl_cache_identity(ptp, time_secs, vb); + if (res) + return res; + } + memset(inq_dout, 0, sizeof(inq_dout)); + alloc_len = sg_get_unaligned_be16(cdbp + 3); + evpd = !!(0x1 & cdbp[1]); + pg_cd = cdbp[2]; + if (evpd) { /* VPD page responses */ + switch (pg_cd) { + case 0: + /* inq_dout[0] = (PQ=0)<<5 | (PDT=0); prefer pdt=0xd --> SES */ + inq_dout[1] = pg_cd; + sg_put_unaligned_be16(3, inq_dout + 2); + inq_dout[4] = 0x0; + inq_dout[5] = 0x80; + inq_dout[6] = 0x83; + n = 7; + break; + case 0x80: + /* inq_dout[0] = (PQ=0)<<5 | (PDT=0); prefer pdt=0xd --> SES */ + inq_dout[1] = pg_cd; + sg_put_unaligned_be16(20, inq_dout + 2); + memcpy(inq_dout + 4, ptp->nvme_id_ctlp + 4, 20); /* SN */ + n = 24; + break; + case 0x83: + /* inq_dout[0] = (PQ=0)<<5 | (PDT=0); prefer pdt=0xd --> SES */ + inq_dout[1] = pg_cd; + inq_dout[4] = 0x2; /* Prococol id=0, code_set=2 (ASCII) */ + inq_dout[5] = 0x1; /* PIV=0, ASSOC=0 (LU ??), desig_id=1 */ + /* Building T10 Vendor ID base designator, SNTL document 1.5 + * dated 20150624 confuses this with SCSI name string + * descriptor, desig_id=8 */ + memcpy(inq_dout + 8, nvme_scsi_vendor_str, 8); + memcpy(inq_dout + 16, ptp->nvme_id_ctlp + 24, 40); /* MN */ + for (k = 40; k > 0; --k) { + if (' ' == inq_dout[16 + k - 1]) + inq_dout[16 + k - 1] = '_'; /* convert trailing spaces */ + else + break; + } + memcpy(inq_dout + 16 + k + 1, ptp->nvme_id_ctlp + 4, 20); /* SN */ + n = 16 + k + 1 + 20; + inq_dout[7] = 8 + k + 1 + 20; + sg_put_unaligned_be16(n - 4, inq_dout + 2); + break; + default: /* Point to page_code field in cdb */ + mk_sense_invalid_fld(ptp, true, 2, 7, vb); + return 0; + } + if (alloc_len > 0) { + n = (alloc_len < n) ? alloc_len : n; + n = (n < ptp->io_hdr.din_xfer_len) ? n : ptp->io_hdr.din_xfer_len; + if (n > 0) + memcpy((uint8_t *)ptp->io_hdr.din_xferp, inq_dout, n); + } + } else { /* Standard INQUIRY response */ + /* inq_dout[0] = (PQ=0)<<5 | (PDT=0); pdt=0 --> SBC; 0xd --> SES */ + inq_dout[2] = 6; /* version: SPC-4 */ + inq_dout[3] = 2; /* NORMACA=0, HISUP=0, response data format: 2 */ + inq_dout[4] = 31; /* so response length is (or could be) 36 bytes */ + inq_dout[6] = 0x40; /* ENCSERV=1 */ + inq_dout[7] = 0x2; /* CMDQUE=1 */ + memcpy(inq_dout + 8, nvme_scsi_vendor_str, 8); /* NVMe not Intel */ + memcpy(inq_dout + 16, ptp->nvme_id_ctlp + 24, 16); /* Prod <-- MN */ + memcpy(inq_dout + 32, ptp->nvme_id_ctlp + 64, 4); /* Rev <-- FR */ + if (alloc_len > 0) { + n = (alloc_len < inq_resp_len) ? alloc_len : inq_resp_len; + n = (n < ptp->io_hdr.din_xfer_len) ? n : ptp->io_hdr.din_xfer_len; + if (n > 0) + memcpy((uint8_t *)ptp->io_hdr.din_xferp, inq_dout, n); + } + } + return 0; +} + +static int +sntl_rluns(struct sg_pt_linux_scsi * ptp, const uint8_t * cdbp, int time_secs, + int vb) +{ + int res; + uint16_t sel_report; + uint32_t alloc_len, k, n, num, max_nsid; + uint8_t * rl_doutp; + uint8_t * up; + + if (vb > 3) + pr2ws("%s: time_secs=%d\n", __func__, time_secs); + + sel_report = cdbp[2]; + alloc_len = sg_get_unaligned_be32(cdbp + 6); + if (NULL == ptp->nvme_id_ctlp) { + res = sntl_cache_identity(ptp, time_secs, vb); + if (res) + return res; + } + max_nsid = sg_get_unaligned_le32(ptp->nvme_id_ctlp + 516); + switch (sel_report) { + case 0: + case 2: + num = max_nsid; + break; + case 1: + case 0x10: + case 0x12: + num = 0; + break; + case 0x11: + num = (1 == ptp->nvme_nsid) ? max_nsid : 0; + break; + default: + if (vb > 1) + pr2ws("%s: bad select_report value: 0x%x\n", __func__, + sel_report); + mk_sense_invalid_fld(ptp, true, 2, 7, vb); + return 0; + } + rl_doutp = (uint8_t *)calloc(num + 1, 8); + if (NULL == rl_doutp) { + pr2ws("%s: calloc() failed to get memory\n", __func__); + return SG_LIB_OS_BASE_ERR + ENOMEM; + } + for (k = 0, up = rl_doutp + 8; k < num; ++k, up += 8) + sg_put_unaligned_be16(k, up); + n = num * 8; + sg_put_unaligned_be32(n, rl_doutp); + n+= 8; + if (alloc_len > 0) { + n = (alloc_len < n) ? alloc_len : n; + n = (n < ptp->io_hdr.din_xfer_len) ? n : ptp->io_hdr.din_xfer_len; + if (n > 0) { + memcpy((uint8_t *)ptp->io_hdr.din_xferp, rl_doutp, n); + ptp->io_hdr.din_resid = ptp->io_hdr.din_xfer_len - n; + } + } + res = 0; + free(rl_doutp); + return res; +} + +static int +sntl_tur(struct sg_pt_linux_scsi * ptp, int time_secs, int vb) +{ + int res, err; + uint32_t pow_state; + struct sg_nvme_passthru_cmd cmd; + + if (vb > 3) + pr2ws("%s: time_secs=%d\n", __func__, time_secs); + if (NULL == ptp->nvme_id_ctlp) { + res = sntl_cache_identity(ptp, time_secs, vb); + if (res) + return res; + } + memset(&cmd, 0, sizeof(cmd)); + cmd.opcode = 0xa; /* Get feature */ + cmd.nsid = SG_NVME_BROADCAST_NSID; + cmd.cdw10 = 0x2; /* SEL=0 (current), Feature=2 Power Management */ + cmd.timeout_ms = (time_secs < 0) ? 0 : (1000 * time_secs); + if (ioctl(ptp->dev_fd, NVME_IOCTL_ADMIN_CMD, &cmd) < 0) { + err = errno; + if (vb > 2) + pr2ws("%s: ioctl(NVME_ADMIN(Get feature)) failed: %s (errno=%d)" + "\n", __func__, strerror(err), err); + ptp->os_err = err; + return -err; + } + pow_state = (0x1f & cmd.result); + if (vb > 3) + pr2ws("%s: pow_state=%u\n", __func__, pow_state); +#if 0 /* pow_state bounces around too much on laptop */ + if (pow_state) + mk_sense_asc_ascq(ptp, SPC_SK_NOT_READY, LOW_POWER_COND_ON_ASC, 0, + vb); +#endif + return 0; +} + +static int +sntl_req_sense(struct sg_pt_linux_scsi * ptp, const uint8_t * cdbp, + int time_secs, int vb) +{ + bool desc; + int res, err; + uint32_t pow_state, alloc_len, n; + struct sg_nvme_passthru_cmd cmd; + uint8_t rs_dout[64]; + + if (vb > 3) + pr2ws("%s: time_secs=%d\n", __func__, time_secs); + if (NULL == ptp->nvme_id_ctlp) { + res = sntl_cache_identity(ptp, time_secs, vb); + if (res) + return res; + } + desc = !!(0x1 & cdbp[1]); + alloc_len = cdbp[4]; + memset(&cmd, 0, sizeof(cmd)); + cmd.opcode = 0xa; /* Get feature */ + cmd.nsid = SG_NVME_BROADCAST_NSID; + cmd.cdw10 = 0x2; /* SEL=0 (current), Feature=2 Power Management */ + cmd.timeout_ms = (time_secs < 0) ? 0 : (1000 * time_secs); + if (ioctl(ptp->dev_fd, NVME_IOCTL_ADMIN_CMD, &cmd) < 0) { + err = errno; + if (vb > 2) + pr2ws("%s: ioctl(NVME_ADMIN(Get feature)) failed: %s (errno=%d)" + "\n", __func__, strerror(err), err); + ptp->os_err = err; + return -err; + } + pow_state = (0x1f & cmd.result); + if (vb > 3) + pr2ws("%s: pow_state=%u\n", __func__, pow_state); + memset(rs_dout, 0, sizeof(rs_dout)); + if (pow_state) + build_sense_buffer(desc, rs_dout, SPC_SK_NO_SENSE, + LOW_POWER_COND_ON_ASC, 0); + else + build_sense_buffer(desc, rs_dout, SPC_SK_NO_SENSE, + NO_ADDITIONAL_SENSE, 0); + n = desc ? 8 : 18; + n = (n < alloc_len) ? n : alloc_len; + n = (n < ptp->io_hdr.din_xfer_len) ? n : ptp->io_hdr.din_xfer_len; + if (n > 0) { + memcpy((uint8_t *)ptp->io_hdr.din_xferp, rs_dout, n); + ptp->io_hdr.din_resid = ptp->io_hdr.din_xfer_len - n; + } + return 0; +} + +/* This is not really a SNTL. For SCSI SEND DIAGNOSTIC(PF=1) NVMe-MI + * has a special command (SES Send) to tunnel through pages to an + * enclosure. The NVMe enclosure is meant to understand the SES + * (SCSI Enclosure Services) use of diagnostics pages that are + * related to SES. */ +static int +sntl_senddiag(struct sg_pt_linux_scsi * ptp, const uint8_t * cdbp, + int time_secs, int vb) +{ + bool pf, self_test; + uint8_t st_cd, dpg_cd; + uint32_t alloc_len, n, dout_len, dpg_len; + uint32_t pg_sz = sg_get_page_size(); + const uint8_t * dop; + struct sg_nvme_passthru_cmd cmd; + + st_cd = 0x7 & (cdbp[1] >> 5); + pf = !! (0x4 & cdbp[1]); + self_test = !! (0x10 & cdbp[1]); + if (vb > 3) + pr2ws("%s: pf=%d, self_test=%d (st_code=%d)\n", __func__, (int)pf, + (int)self_test, (int)st_cd); + if (self_test) + return 0; /* NVMe has no self-test, just say OK */ + alloc_len = sg_get_unaligned_be16(cdbp + 3); /* parameter list length */ + dout_len = ptp->io_hdr.dout_xfer_len; + if (pf) { + if (0 == alloc_len) { + mk_sense_invalid_fld(ptp, true, 3, 7, vb); + if (vb) + pr2ws("%s: PF bit set bit param_list_len=0\n", __func__); + return 0; + } + } else { /* PF bit clear */ + if (alloc_len) { + mk_sense_invalid_fld(ptp, true, 3, 7, vb); + if (vb) + pr2ws("%s: param_list_len>0 but PF clear\n", __func__); + return 0; + } else + return 0; /* nothing to do */ + if (dout_len > 0) { + if (vb) + pr2ws("%s: dout given but PF clear\n", __func__); + return SCSI_PT_DO_BAD_PARAMS; + } + } + if (dout_len < 4) { + if (vb) + pr2ws("%s: dout length (%u bytes) too short\n", __func__, + dout_len); + return SCSI_PT_DO_BAD_PARAMS; + } + n = dout_len; + n = (n < alloc_len) ? n : alloc_len; + dop = (const uint8_t *)ptp->io_hdr.dout_xferp; + if (! is_aligned(dop, pg_sz)) { /* caller best use sg_memalign(,pg_sz) */ + if (vb) + pr2ws("%s: dout [0x%" PRIx64 "] not page aligned\n", __func__, + (uint64_t)ptp->io_hdr.dout_xferp); + return SCSI_PT_DO_BAD_PARAMS; + } + dpg_cd = dop[0]; + dpg_len = sg_get_unaligned_be16(dop + 2) + 4; + /* should we allow for more than one D_PG is dout ?? */ + n = (n < dpg_len) ? n : dpg_len; /* not yet ... */ + + if (vb) + pr2ws("%s: passing through d_pg=0x%x, len=%u to NVME_MI SES send\n", + __func__, dpg_cd, dpg_len); + memset(&cmd, 0, sizeof(cmd)); + cmd.opcode = 0x1d; /* MI send; hmmm same opcode as SEND DIAG */ + cmd.addr = (uint64_t)(sg_uintptr_t)ptp->io_hdr.dout_xferp; + cmd.data_len = 0x1000; /* NVMe 4k page size. Maybe determine this? */ + /* dout_len > 0x1000, is this a problem?? */ + cmd.cdw10 = 0x0804; /* NVMe Message Header */ + cmd.cdw11 = 0x9; /* nvme_mi_ses_send; (0x8 -> mi_ses_recv) */ + cmd.cdw13 = n; + return do_nvme_admin_cmd(ptp, &cmd, time_secs, false, vb); +} + +/* This is not really a SNTL. For SCSI RECEIVE DIAGNOSTIC RESULTS(PCV=1) + * NVMe-MI has a special command (SES Receive) to read pages through a + * tunnel from an enclosure. The NVMe enclosure is meant to understand the + * SES (SCSI Enclosure Services) use of diagnostics pages that are + * related to SES. */ +static int +sntl_recvdiag(struct sg_pt_linux_scsi * ptp, const uint8_t * cdbp, + int time_secs, int vb) +{ + bool pcv; + int res; + uint8_t dpg_cd; + uint32_t alloc_len, n, din_len; + uint32_t pg_sz = sg_get_page_size(); + const uint8_t * dip; + struct sg_nvme_passthru_cmd cmd; + + pcv = !! (0x1 & cdbp[1]); + dpg_cd = cdbp[2]; + alloc_len = sg_get_unaligned_be16(cdbp + 3); /* parameter list length */ + if (vb > 3) + pr2ws("%s: dpg_cd=0x%x, pcv=%d, alloc_len=0x%x\n", __func__, + dpg_cd, (int)pcv, alloc_len); + din_len = ptp->io_hdr.din_xfer_len; + if (pcv) { + if (0 == alloc_len) { + /* T10 says not an error, hmmm */ + mk_sense_invalid_fld(ptp, true, 3, 7, vb); + if (vb) + pr2ws("%s: PCV bit set bit but alloc_len=0\n", __func__); + return 0; + } + } else { /* PCV bit clear */ + if (alloc_len) { + mk_sense_invalid_fld(ptp, true, 3, 7, vb); + if (vb) + pr2ws("%s: alloc_len>0 but PCV clear\n", __func__); + return 0; + } else + return 0; /* nothing to do */ + if (din_len > 0) { + if (vb) + pr2ws("%s: din given but PCV clear\n", __func__); + return SCSI_PT_DO_BAD_PARAMS; + } + } + n = din_len; + n = (n < alloc_len) ? n : alloc_len; + dip = (const uint8_t *)ptp->io_hdr.din_xferp; + if (! is_aligned(dip, pg_sz)) { /* caller best use sg_memalign(,pg_sz) */ + if (vb) + pr2ws("%s: din [0x%" PRIx64 "] not page aligned\n", __func__, + (uint64_t)ptp->io_hdr.din_xferp); + return SCSI_PT_DO_BAD_PARAMS; + } + + if (vb) + pr2ws("%s: expecting d_pg=0x%x from NVME_MI SES receive\n", __func__, + dpg_cd); + memset(&cmd, 0, sizeof(cmd)); + cmd.opcode = 0x1e; /* MI receive */ + cmd.addr = (uint64_t)(sg_uintptr_t)ptp->io_hdr.din_xferp; + cmd.data_len = 0x1000; /* NVMe 4k page size. Maybe determine this? */ + /* din_len > 0x1000, is this a problem?? */ + cmd.cdw10 = 0x0804; /* NVMe Message Header */ + cmd.cdw11 = 0x8; /* nvme_mi_ses_receive */ + cmd.cdw12 = dpg_cd; + cmd.cdw13 = n; + res = do_nvme_admin_cmd(ptp, &cmd, time_secs, false, vb); + ptp->io_hdr.din_resid = din_len - n; + return res; +} + +/* Executes NVMe Admin command (or at least forwards it to lower layers). + * Returns 0 for success, negative numbers are negated 'errno' values from + * OS system calls. Positive return values are errors from this package. + * When time_secs is 0 the Linux NVMe Admin command default of 60 seconds + * is used. */ +int +sg_do_nvme_pt(struct sg_pt_base * vp, int fd, int time_secs, int vb) +{ + bool scsi_cmd; + int n, len; + struct sg_pt_linux_scsi * ptp = &vp->impl; + struct sg_nvme_passthru_cmd cmd; + const uint8_t * cdbp; + + if (! ptp->io_hdr.request) { + if (vb) + pr2ws("No NVMe command given (set_scsi_pt_cdb())\n"); + return SCSI_PT_DO_BAD_PARAMS; + } + if (fd >= 0) { + if ((ptp->dev_fd >= 0) && (fd != ptp->dev_fd)) { + if (vb) + pr2ws("%s: file descriptor given to create() and here " + "differ\n", __func__); + return SCSI_PT_DO_BAD_PARAMS; + } + ptp->dev_fd = fd; + } else if (ptp->dev_fd < 0) { + if (vb) + pr2ws("%s: invalid file descriptors\n", __func__); + return SCSI_PT_DO_BAD_PARAMS; + } + n = ptp->io_hdr.request_len; + cdbp = (const uint8_t *)ptp->io_hdr.request; + if (vb > 3) + pr2ws("%s: opcode=0x%x, fd=%d, time_secs=%d\n", __func__, cdbp[0], + fd, time_secs); + scsi_cmd = is_scsi_command(cdbp, n); + if (scsi_cmd) { + switch (cdbp[0]) { + case SCSI_INQUIRY_OPC: + return sntl_inq(ptp, cdbp, time_secs, vb); + case SCSI_REPORT_LUNS_OPC: + return sntl_rluns(ptp, cdbp, time_secs, vb); + case SCSI_TEST_UNIT_READY_OPC: + return sntl_tur(ptp, time_secs, vb); + case SCSI_REQUEST_SENSE_OPC: + return sntl_req_sense(ptp, cdbp, time_secs, vb); + case SCSI_SEND_DIAGNOSTIC_OPC: + return sntl_senddiag(ptp, cdbp, time_secs, vb); + case SCSI_RECEIVE_DIAGNOSTIC_OPC: + return sntl_recvdiag(ptp, cdbp, time_secs, vb); +// xxxxxxxxxx + default: + mk_sense_asc_ascq(ptp, SPC_SK_ILLEGAL_REQUEST, INVALID_OPCODE, + 0, vb); + return 0; + } + } + len = (int)sizeof(cmd); + n = (n < len) ? n : len; + if (n < 64) { + if (vb) + pr2ws("%s: command length of %d bytes is too short\n", __func__, + n); + return SCSI_PT_DO_BAD_PARAMS; + } + memcpy(&cmd, (const uint8_t *)ptp->io_hdr.request, n); + if (n < len) /* zero out rest of 'cmd' */ + memset((unsigned char *)&cmd + n, 0, len - n); + if (ptp->io_hdr.din_xfer_len > 0) { + cmd.data_len = ptp->io_hdr.din_xfer_len; + cmd.addr = (uint64_t)(sg_uintptr_t)ptp->io_hdr.din_xferp; + } else if (ptp->io_hdr.dout_xfer_len > 0) { + cmd.data_len = ptp->io_hdr.dout_xfer_len; + cmd.addr = (uint64_t)(sg_uintptr_t)ptp->io_hdr.dout_xferp; + } + return do_nvme_admin_cmd(ptp, &cmd, time_secs, true, vb); +} -- cgit v1.2.3