/* * Copyright (c) 2017-2018 Douglas Gilbert. * All rights reserved. * Use of this source code is governed by a BSD-style * license that can be found in the BSD_LICENSE file. * * The code to use the NVMe Management Interface (MI) SES pass-through * was provided by WDC in November 2017. */ /* * Copyright 2017, Western Digital Corporation * * Written by Berck Nash * * Use of this source code is governed by a BSD-style * license that can be found in the BSD_LICENSE file. * * Based on the NVM-Express command line utility, which bore the following * notice: * * Copyright (c) 2014-2015, Intel Corporation. * * Written by Keith Busch * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version 2 * of the License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, * MA 02110-1301, USA. */ /* sg_pt_linux_nvme version 1.04 20180115 */ #include #include #include #include #include #include #include #include #include #define __STDC_FORMAT_MACROS 1 #include #include #include #include /* to define 'major' */ #ifndef major #include #endif #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include "sg_pt.h" #include "sg_lib.h" #include "sg_linux_inc.h" #include "sg_pt_linux.h" #include "sg_unaligned.h" #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 #define SCSI_MAINT_IN_OPC 0xa3 #define SCSI_REP_SUP_OPCS_OPC 0xc #define SCSI_REP_SUP_TMFS_OPC 0xd /* 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 inline bool is_aligned(const void * pointer, size_t byte_count) { return ((sg_uintptr_t)pointer % byte_count) == 0; } #if defined(__GNUC__) || defined(__clang__) static int pr2ws(const char * fmt, ...) __attribute__ ((format (printf, 1, 2))); #else static int pr2ws(const char * fmt, ...); #endif static int pr2ws(const char * fmt, ...) { va_list args; int n; va_start(args, fmt); n = vfprintf(sg_warnings_strm ? sg_warnings_strm : stderr, fmt, args); va_end(args); return n; } #if (HAVE_NVME && (! IGNORE_NVME)) /* This trims given NVMe block device name in Linux (e.g. /dev/nvme0n1p5) * to the name of its associated char device (e.g. /dev/nvme0). If this * occurs true is returned and the char device name is placed in 'b' (as * long as b_len is sufficient). Otherwise false is returned. */ bool sg_get_nvme_char_devname(const char * nvme_block_devname, uint32_t b_len, char * b) { uint32_t n, tlen; const char * cp; char buff[8]; if ((NULL == b) || (b_len < 5)) return false; /* degenerate cases */ cp = strstr(nvme_block_devname, "nvme"); if (NULL == cp) return false; /* expected to find "nvme" in given name */ if (1 != sscanf(cp, "nvme%u", &n)) return false; /* didn't find valid "nvme" */ snprintf(buff, sizeof(buff), "%u", n); tlen = (cp - nvme_block_devname) + 4 + strlen(buff); if ((tlen + 1) > b_len) return false; /* b isn't long enough to fit output */ memcpy(b, nvme_block_devname, tlen); b[tlen] = '\0'; return true; } 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_linux_scsi * ptp, int sk, int asc, int ascq, int vb) { bool dsense = ptp->scsi_dsense; int n; uint8_t * sbp = (uint8_t *)ptp->io_hdr.response; ptp->io_hdr.device_status = SAM_STAT_CHECK_CONDITION; n = ptp->io_hdr.max_response_len; if ((n < 8) || ((! dsense) && (n < 14))) { if (vb) pr2ws("%s: max_response_len=%d too short, want 14 or more\n", __func__, n); return; } else ptp->io_hdr.response_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]: [0x%x,0x%x,0x%x]\n", __func__, sk, asc, ascq); } static void mk_sense_from_nvme_status(struct sg_pt_linux_scsi * ptp, int vb) { bool ok; bool dsense = ptp->scsi_dsense; int n; uint8_t sstatus, sk, asc, ascq; uint8_t * sbp = (uint8_t *)ptp->io_hdr.response; ok = sg_nvme_status2scsi(ptp->nvme_status, &sstatus, &sk, &asc, &ascq); if (! ok) { /* can't find a mapping to a SCSI error, so ... */ sstatus = SAM_STAT_CHECK_CONDITION; sk = SPC_SK_ILLEGAL_REQUEST; asc = 0xb; ascq = 0x0; /* asc: "WARNING" purposely vague */ } ptp->io_hdr.device_status = sstatus; n = ptp->io_hdr.max_response_len; if ((n < 8) || ((! dsense) && (n < 14))) { pr2ws("%s: sense_len=%d too short, want 14 or more\n", __func__, n); return; } else ptp->io_hdr.response_len = (dsense ? 8 : ((n < 18) ? n : 18)); memset(sbp, 0, n); build_sense_buffer(dsense, sbp, sk, asc, ascq); if (vb > 3) pr2ws("%s: [status, sense_key,asc,ascq]: [0x%x, 0x%x,0x%x,0x%x]\n", __func__, sstatus, sk, asc, ascq); } /* Set in_bit to -1 to indicate no bit position of invalid field */ static void mk_sense_invalid_fld(struct sg_pt_linux_scsi * ptp, bool in_cdb, int in_byte, int in_bit, int vb) { bool dsense = ptp->scsi_dsense; int sl, asc, n; uint8_t * sbp = (uint8_t *)ptp->io_hdr.response; uint8_t sks[4]; ptp->io_hdr.device_status = SAM_STAT_CHECK_CONDITION; asc = in_cdb ? INVALID_FIELD_IN_CDB : INVALID_FIELD_IN_PARAM_LIST; n = ptp->io_hdr.max_response_len; if ((n < 8) || ((! dsense) && (n < 14))) { if (vb) pr2ws("%s: max_response_len=%d too short, want 14 or more\n", __func__, n); return; } else ptp->io_hdr.response_len = dsense ? 8 : ((n < 18) ? n : 18); memset(sbp, 0, n); build_sense_buffer(dsense, 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 (dsense) { 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); } /* Returns 0 for success. Returns SG_LIB_NVME_STATUS if there is non-zero * NVMe status (from the completion queue) with the value placed in * ptp->nvme_status. If Unix error from ioctl then return negated value * (equivalent -errno from basic Unix system functions like open()). * CDW0 from the completion queue is placed in ptp->nvme_result in the * absence of a Unix error. If time_secs is negative it is treated as * a timeout in milliseconds (of abs(time_secs) ). */ static int do_nvme_admin_cmd(struct sg_pt_linux_scsi * ptp, struct sg_nvme_passthru_cmd *cmdp, void * dp, bool is_read, int time_secs, int vb) { const uint32_t cmd_len = sizeof(struct sg_nvme_passthru_cmd); int res; uint32_t n; uint16_t sct_sc; const uint8_t * up = ((const uint8_t *)cmdp) + SG_NVME_PT_OPCODE; cmdp->timeout_ms = (time_secs < 0) ? (-time_secs) : (1000 * time_secs); ptp->os_err = 0; if (vb > 2) { pr2ws("NVMe command:\n"); hex2stderr((const uint8_t *)cmdp, cmd_len, 1); if ((vb > 3) && (! is_read) && dp) { uint32_t len = sg_get_unaligned_le32(up + SG_NVME_PT_DATA_LEN); if (len > 0) { n = len; if ((len < 512) || (vb > 5)) pr2ws("\nData-out buffer (%u bytes):\n", n); else { pr2ws("\nData-out buffer (first 512 of %u bytes):\n", n); n = 512; } hex2stderr((const uint8_t *)dp, n, 0); } } } res = ioctl(ptp->dev_fd, NVME_IOCTL_ADMIN_CMD, cmdp); if (res < 0) { /* OS error (errno negated) */ ptp->os_err = -res; if (vb > 1) { pr2ws("%s: ioctl opcode=0x%x failed: %s " "(errno=%d)\n", __func__, *up, strerror(-res), -res); } return res; } /* Now res contains NVMe completion queue CDW3 31:17 (15 bits) */ ptp->nvme_result = cmdp->result; if (ptp->nvme_direct && ptp->io_hdr.response && (ptp->io_hdr.max_response_len > 3)) { /* build 16 byte "sense" buffer */ uint8_t * sbp = (uint8_t *)ptp->io_hdr.response; uint16_t st = (uint16_t)res; n = ptp->io_hdr.max_response_len; n = (n < 16) ? n : 16; memset(sbp, 0 , n); ptp->io_hdr.response_len = n; sg_put_unaligned_le32(cmdp->result, sbp + SG_NVME_PT_CQ_RESULT); if (n > 15) /* LSBit will be 0 (Phase bit) after (st << 1) */ sg_put_unaligned_le16(st << 1, sbp + SG_NVME_PT_CQ_STATUS_P); } /* clear upper bits (DNR and More) leaving ((SCT << 8) | SC) */ sct_sc = 0x3ff & res; ptp->nvme_status = sct_sc; if (sct_sc) { /* when non-zero, treat as command error */ if (vb > 1) { char b[80]; pr2ws("%s: ioctl opcode=0x%x failed: NVMe status: %s [0x%x]\n", __func__, *up, sg_get_nvme_cmd_status_str(sct_sc, sizeof(b), b), sct_sc); } return SG_LIB_NVME_STATUS; /* == SCSI_PT_DO_NVME_STATUS */ } if ((vb > 3) && is_read && dp) { uint32_t len = sg_get_unaligned_le32(up + SG_NVME_PT_DATA_LEN); if (len > 0) { n = len; if ((len < 1024) || (vb > 5)) pr2ws("\nData-in buffer (%u bytes):\n", n); else { pr2ws("\nData-in buffer (first 1024 of %u bytes):\n", n); n = 1024; } hex2stderr((const uint8_t *)dp, n, 0); } } return 0; } /* Returns 0 on success; otherwise a positive value is returned */ static int sntl_cache_identity(struct sg_pt_linux_scsi * ptp, int time_secs, int vb) { struct sg_nvme_passthru_cmd cmd; uint32_t pg_sz = sg_get_page_size(); uint8_t * up; up = sg_memalign(pg_sz, pg_sz, &ptp->free_nvme_id_ctlp, vb > 3); ptp->nvme_id_ctlp = up; if (NULL == up) { pr2ws("%s: sg_memalign() failed to get memory\n", __func__); return -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; return do_nvme_admin_cmd(ptp, &cmd, up, true, time_secs, vb); } static const char * nvme_scsi_vendor_str = "NVMe "; static const uint16_t inq_resp_len = 36; static int sntl_inq(struct sg_pt_linux_scsi * ptp, const uint8_t * cdbp, int time_secs, int vb) { bool evpd; bool cp_id_ctl = false; int res; uint16_t n, alloc_len, pg_cd; uint32_t pg_sz = sg_get_page_size(); uint8_t * nvme_id_ns = NULL; uint8_t * free_nvme_id_ns = NULL; uint8_t inq_dout[256]; if (vb > 3) pr2ws("%s: time_secs=%d\n", __func__, time_secs); if (0x2 & cdbp[1]) { /* Reject CmdDt=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 (SG_LIB_NVME_STATUS == res) { mk_sense_from_nvme_status(ptp, vb); return 0; } else if (res) /* should be negative errno */ 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; n = 8; sg_put_unaligned_be16(n - 4, inq_dout + 2); inq_dout[4] = 0x0; inq_dout[5] = 0x80; inq_dout[6] = 0x83; inq_dout[n - 1] = 0xde; /* last VPD number */ 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: if ((ptp->nvme_nsid > 0) && (ptp->nvme_nsid < SG_NVME_BROADCAST_NSID)) { nvme_id_ns = sg_memalign(pg_sz, pg_sz, &free_nvme_id_ns, vb > 3); if (nvme_id_ns) { struct sg_nvme_passthru_cmd cmd; memset(&cmd, 0, sizeof(cmd)); cmd.opcode = 0x6; /* Identify */ cmd.nsid = ptp->nvme_nsid; cmd.cdw10 = 0x0; /* CNS=0x0 Identify namespace */ cmd.addr = (uint64_t)(sg_uintptr_t)nvme_id_ns; cmd.data_len = pg_sz; res = do_nvme_admin_cmd(ptp, &cmd, nvme_id_ns, true, time_secs, vb > 3); if (res) { free(free_nvme_id_ns); free_nvme_id_ns = NULL; nvme_id_ns = NULL; } } } n = sg_make_vpd_devid_for_nvme(ptp->nvme_id_ctlp, nvme_id_ns, 0 /* pdt */, -1 /*tproto */, inq_dout, sizeof(inq_dout)); if (n > 3) sg_put_unaligned_be16(n - 4, inq_dout + 2); if (free_nvme_id_ns) { free(free_nvme_id_ns); free_nvme_id_ns = NULL; nvme_id_ns = NULL; } break; case 0xde: inq_dout[1] = pg_cd; sg_put_unaligned_be16((16 + 4096) - 4, inq_dout + 2); n = 16 + 4096; cp_id_ctl = true; 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; ptp->io_hdr.din_resid = ptp->io_hdr.din_xfer_len - n; if (n > 0) { if (cp_id_ctl) { memcpy((uint8_t *)ptp->io_hdr.din_xferp, inq_dout, (n < 16 ? n : 16)); if (n > 16) memcpy((uint8_t *)ptp->io_hdr.din_xferp + 16, ptp->nvme_id_ctlp, n - 16); } else 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; ptp->io_hdr.din_resid = ptp->io_hdr.din_xfer_len - n; 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 (SG_LIB_NVME_STATUS == res) { mk_sense_from_nvme_status(ptp, vb); return 0; } else 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 -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; ptp->io_hdr.din_resid = ptp->io_hdr.din_xfer_len - n; if (n > 0) memcpy((uint8_t *)ptp->io_hdr.din_xferp, rl_doutp, 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; uint32_t pow_state; struct sg_nvme_passthru_cmd cmd; if (vb > 4) pr2ws("%s: time_secs=%d\n", __func__, time_secs); if (NULL == ptp->nvme_id_ctlp) { res = sntl_cache_identity(ptp, time_secs, vb); if (SG_LIB_NVME_STATUS == res) { mk_sense_from_nvme_status(ptp, vb); return 0; } else 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); res = do_nvme_admin_cmd(ptp, &cmd, NULL, false, time_secs, vb); if (0 != res) { if (SG_LIB_NVME_STATUS == res) { mk_sense_from_nvme_status(ptp, vb); return 0; } else return res; } else { ptp->os_err = 0; ptp->nvme_status = 0; } pow_state = (0x1f & ptp->nvme_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; 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 (SG_LIB_NVME_STATUS == res) { mk_sense_from_nvme_status(ptp, vb); return 0; } else 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); res = do_nvme_admin_cmd(ptp, &cmd, NULL, false, time_secs, vb); if (0 != res) { if (SG_LIB_NVME_STATUS == res) { mk_sense_from_nvme_status(ptp, vb); return 0; } else return res; } else { ptp->os_err = 0; ptp->nvme_status = 0; } ptp->io_hdr.response_len = 0; pow_state = (0x1f & ptp->nvme_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; ptp->io_hdr.din_resid = ptp->io_hdr.din_xfer_len - n; if (n > 0) memcpy((uint8_t *)ptp->io_hdr.din_xferp, rs_dout, 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; int res; uint8_t st_cd, dpg_cd; uint32_t alloc_len, n, dout_len, dpg_len, nvme_dst; uint32_t pg_sz = sg_get_page_size(); uint8_t * dop; struct sg_nvme_passthru_cmd cmd; uint8_t * cmd_up = (uint8_t *)&cmd; st_cd = 0x7 & (cdbp[1] >> 5); self_test = !! (0x4 & cdbp[1]); pf = !! (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 || st_cd) { memset(cmd_up, 0, sizeof(cmd)); cmd_up[SG_NVME_PT_OPCODE] = 0x14; /* Device self-test */ /* just this namespace (if there is one) and controller */ sg_put_unaligned_le32(ptp->nvme_nsid, cmd_up + SG_NVME_PT_NSID); switch (st_cd) { case 0: /* Here if self_test is set, do short self-test */ case 1: /* Background short */ case 5: /* Foreground short */ nvme_dst = 1; break; case 2: /* Background extended */ case 6: /* Foreground extended */ nvme_dst = 2; break; case 4: /* Abort self-test */ nvme_dst = 0xf; break; default: pr2ws("%s: bad self-test code [0x%x]\n", __func__, st_cd); mk_sense_invalid_fld(ptp, true, 1, 7, vb); return 0; } sg_put_unaligned_le32(nvme_dst, cmd_up + SG_NVME_PT_CDW10); res = do_nvme_admin_cmd(ptp, &cmd, NULL, false, time_secs, vb); if (0 != res) { if (SG_LIB_NVME_STATUS == res) { mk_sense_from_nvme_status(ptp, vb); return 0; } else return res; } } 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 = (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)dop; 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; res = do_nvme_admin_cmd(ptp, &cmd, dop, false, time_secs, vb); if (0 != res) { if (SG_LIB_NVME_STATUS == res) { mk_sense_from_nvme_status(ptp, vb); return 0; } } return res; } /* 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(); 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; n = din_len; n = (n < alloc_len) ? n : alloc_len; dip = (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)dip; 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, dip, true, time_secs, vb); if (0 != res) { if (SG_LIB_NVME_STATUS == res) { mk_sense_from_nvme_status(ptp, vb); return 0; } else return res; } ptp->io_hdr.din_resid = din_len - n; return res; } #define F_SA_LOW 0x80 /* cdb byte 1, bits 4 to 0 */ #define F_SA_HIGH 0x100 /* as used by variable length cdbs */ #define FF_SA (F_SA_HIGH | F_SA_LOW) #define F_INV_OP 0x200 static struct opcode_info_t { uint8_t opcode; uint16_t sa; /* service action, 0 for none */ uint32_t flags; /* OR-ed set of F_* flags */ uint8_t len_mask[16]; /* len=len_mask[0], then mask for cdb[1]... */ /* ignore cdb bytes after position 15 */ } opcode_info_arr[] = { {0x0, 0, 0, {6, /* TEST UNIT READY */ 0, 0, 0, 0, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }, {0x3, 0, 0, {6, /* REQUEST SENSE */ 0xe1, 0, 0, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }, {0x12, 0, 0, {6, /* INQUIRY */ 0xe3, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }, {0x1c, 0, 0, {6, /* RECEIVE DIAGNOSTIC RESULTS */ 0x1, 0xff, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }, {0x1d, 0, 0, {6, /* SEND DIAGNOSTIC */ 0xf7, 0x0, 0xff, 0xff, 0xc7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }, {0xa0, 0, 0, {12, /* REPORT LUNS */ 0xe3, 0xff, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0, 0, 0} }, {0xa3, 0xc, F_SA_LOW, {12, /* REPORT SUPPORTED OPERATION CODES */ 0xc, 0x87, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0, 0, 0} }, {0xa3, 0xd, F_SA_LOW, {12, /* REPORT SUPPORTED TASK MAN. FUNCTIONS */ 0xd, 0x80, 0, 0, 0, 0xff, 0xff, 0xff, 0xff, 0, 0xc7, 0, 0, 0, 0} }, {0xff, 0xffff, 0xffff, {0, /* Sentinel, keep as last element */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} }, }; static int sntl_rep_opcodes(struct sg_pt_linux_scsi * ptp, const uint8_t * cdbp, int time_secs, int vb) { bool rctd; uint8_t reporting_opts, req_opcode, supp; uint16_t req_sa, u; uint32_t alloc_len, offset, a_len; uint32_t pg_sz = sg_get_page_size(); int k, len, count, bump; const struct opcode_info_t *oip; uint8_t *arr; uint8_t *free_arr; if (vb > 3) pr2ws("%s: time_secs=%d\n", __func__, time_secs); rctd = !!(cdbp[2] & 0x80); /* report command timeout desc. */ reporting_opts = cdbp[2] & 0x7; req_opcode = cdbp[3]; req_sa = sg_get_unaligned_be16(cdbp + 4); alloc_len = sg_get_unaligned_be32(cdbp + 6); if (alloc_len < 4 || alloc_len > 0xffff) { mk_sense_invalid_fld(ptp, true, 6, -1, vb); return 0; } a_len = pg_sz - 72; arr = sg_memalign(pg_sz, pg_sz, &free_arr, vb > 3); if (NULL == arr) { pr2ws("%s: calloc() failed to get memory\n", __func__); return -ENOMEM; } switch (reporting_opts) { case 0: /* all commands */ count = 0; bump = rctd ? 20 : 8; for (offset = 4, oip = opcode_info_arr; (oip->flags != 0xffff) && (offset < a_len); ++oip) { if (F_INV_OP & oip->flags) continue; ++count; arr[offset] = oip->opcode; sg_put_unaligned_be16(oip->sa, arr + offset + 2); if (rctd) arr[offset + 5] |= 0x2; if (FF_SA & oip->flags) arr[offset + 5] |= 0x1; sg_put_unaligned_be16(oip->len_mask[0], arr + offset + 6); if (rctd) sg_put_unaligned_be16(0xa, arr + offset + 8); offset += bump; } sg_put_unaligned_be32(count * bump, arr + 0); break; case 1: /* one command: opcode only */ case 2: /* one command: opcode plus service action */ case 3: /* one command: if sa==0 then opcode only else opcode+sa */ for (oip = opcode_info_arr; oip->flags != 0xffff; ++oip) { if ((req_opcode == oip->opcode) && (req_sa == oip->sa)) break; } if ((0xffff == oip->flags) || (F_INV_OP & oip->flags)) { supp = 1; offset = 4; } else { if (1 == reporting_opts) { if (FF_SA & oip->flags) { mk_sense_invalid_fld(ptp, true, 2, 2, vb); free(free_arr); return 0; } req_sa = 0; } else if ((2 == reporting_opts) && 0 == (FF_SA & oip->flags)) { mk_sense_invalid_fld(ptp, true, 4, -1, vb); free(free_arr); return 0; } if ((0 == (FF_SA & oip->flags)) && (req_opcode == oip->opcode)) supp = 3; else if (0 == (FF_SA & oip->flags)) supp = 1; else if (req_sa != oip->sa) supp = 1; else supp = 3; if (3 == supp) { u = oip->len_mask[0]; sg_put_unaligned_be16(u, arr + 2); arr[4] = oip->opcode; for (k = 1; k < u; ++k) arr[4 + k] = (k < 16) ? oip->len_mask[k] : 0xff; offset = 4 + u; } else offset = 4; } arr[1] = (rctd ? 0x80 : 0) | supp; if (rctd) { sg_put_unaligned_be16(0xa, arr + offset); offset += 12; } break; default: mk_sense_invalid_fld(ptp, true, 2, 2, vb); free(free_arr); return 0; } offset = (offset < a_len) ? offset : a_len; len = (offset < alloc_len) ? offset : alloc_len; ptp->io_hdr.din_resid = ptp->io_hdr.din_xfer_len - len; if (len > 0) memcpy((uint8_t *)ptp->io_hdr.din_xferp, arr, len); free(free_arr); return 0; } static int sntl_rep_tmfs(struct sg_pt_linux_scsi * ptp, const uint8_t * cdbp, int time_secs, int vb) { bool repd; uint32_t alloc_len, len; uint8_t arr[16]; if (vb > 3) pr2ws("%s: time_secs=%d\n", __func__, time_secs); memset(arr, 0, sizeof(arr)); repd = !!(cdbp[2] & 0x80); alloc_len = sg_get_unaligned_be32(cdbp + 6); if (alloc_len < 4) { mk_sense_invalid_fld(ptp, true, 6, -1, vb); return 0; } arr[0] = 0xc8; /* ATS | ATSS | LURS */ arr[1] = 0x1; /* ITNRS */ if (repd) { arr[3] = 0xc; len = 16; } else len = 4; len = (len < alloc_len) ? len : alloc_len; ptp->io_hdr.din_resid = ptp->io_hdr.din_xfer_len - len; if (len > 0) memcpy((uint8_t *)ptp->io_hdr.din_xferp, arr, len); return 0; } /* 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_cdb; bool is_read = false; int n, len; uint16_t sa; struct sg_pt_linux_scsi * ptp = &vp->impl; struct sg_nvme_passthru_cmd cmd; const uint8_t * cdbp; void * dp = NULL; 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_cdb = sg_is_scsi_cdb(cdbp, n); /* direct NVMe command (i.e. 64 bytes long) or SNTL */ ptp->nvme_direct = ! scsi_cdb; if (scsi_cdb) { 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); case SCSI_MAINT_IN_OPC: sa = 0x1f & cdbp[1]; /* service action */ if (SCSI_REP_SUP_OPCS_OPC == sa) return sntl_rep_opcodes(ptp, cdbp, time_secs, vb); else if (SCSI_REP_SUP_TMFS_OPC == sa) return sntl_rep_tmfs(ptp, cdbp, time_secs, vb); /* fall through */ default: if (vb > 2) { char b[64]; sg_get_command_name(cdbp, -1, sizeof(b), b); pr2ws("%s: no translation to NVMe for SCSI %s command\n", __func__, b); } 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; dp = (void *)ptp->io_hdr.din_xferp; cmd.addr = (uint64_t)(sg_uintptr_t)ptp->io_hdr.din_xferp; is_read = true; } else if (ptp->io_hdr.dout_xfer_len > 0) { cmd.data_len = ptp->io_hdr.dout_xfer_len; dp = (void *)ptp->io_hdr.dout_xferp; cmd.addr = (uint64_t)(sg_uintptr_t)ptp->io_hdr.dout_xferp; is_read = false; } return do_nvme_admin_cmd(ptp, &cmd, dp, is_read, time_secs, vb); } #else /* (HAVE_NVME && (! IGNORE_NVME)) */ int sg_do_nvme_pt(struct sg_pt_base * vp, int fd, int time_secs, int vb) { if (vb) pr2ws("%s: not supported\n", __func__); if (vp) { ; } /* suppress warning */ if (fd) { ; } /* suppress warning */ if (time_secs) { ; } /* suppress warning */ return -ENOTTY; /* inappropriate ioctl error */ } #endif /* (HAVE_NVME && (! IGNORE_NVME)) */