hw/block/nvme: support scatter gather lists
cover hw/block/nvme: support scatter gather lists
From: Klaus Jensen <[email protected]>
This adds support for scatter gather lists (SGLs). The full flexibility of SGLs require the device to be a bit more strict about CMB access, hence the "hw/block/nvme: harden cmb access" patch.
Based-on: <[email protected]> ("[PATCH 0/2] hw/block/nvme: handle transient dma errors")
Gollu Appalanaidu (1):
hw/block/nvme: add support for sgl bit bucket descriptor
Klaus Jensen (2):
hw/block/nvme: harden cmb access hw/block/nvme: add support for scatter gather lists
hw/block/nvme.c | 359 +++++++++++++++++++++++++++++++++++------- hw/block/trace-events | 4 + include/block/nvme.h | 6 +- 3 files changed, 308 insertions(+), 61 deletions(-)
Signature · 1 line
2.27.0
PATCH 1/3 hw/block/nvme: harden cmb access
From: Klaus Jensen <[email protected]>
Since the controller has only supported PRPs so far it has not been required to check the ending address (addr + len - 1) of the CMB access for validity since it has been guaranteed to be in range of the CMB.
This changes when the controller adds support for SGLs (next patch), so add that check.
--- hw/block/nvme.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
hw/block/nvme.c +6 -1
@@ -91,7 +91,12 @@ static bool nvme_addr_is_cmb(NvmeCtrl *n, hwaddr addr)static int nvme_addr_read (NvmeCtrl *n,hwaddr addr,void *buf,int size) { -if (n->bar.cmbsz &&nvme_addr_is_cmb (n, addr)) { +hwaddr hi = addr + size -1 ; +if (hi < addr) { +return 1 ; + } + +if (n->bar.cmbsz &&nvme_addr_is_cmb (n, addr) &&nvme_addr_is_cmb (n, hi)) {memcpy (buf,nvme_addr_to_cmb (n, addr), size);return 0 ; }
Signature · 1 line
2.27.0
PATCH 2/3 hw/block/nvme: add support for scatter gather lists
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
For now, support the Data Block, Segment and Last Segment descriptor types.
See NVM Express 1.3d, Section 4.4 ("Scatter Gather List (SGL)").
--- hw/block/nvme.c | 331 ++++++++++++++++++++++++++++++++++-------- hw/block/trace-events | 4 + include/block/nvme.h | 6 +- 3 files changed, 281 insertions(+), 60 deletions(-)
hw/block/nvme.c +274 -57
@@ -360,13 +360,263 @@ static uint16_t nvme_map_prp(NvmeCtrl *n, QEMUSGList *qsg, QEMUIOVector *iov,return NVME_SUCCESS ; } -static uint16_t nvme_dma_prp (NvmeCtrl *n,uint8_t *ptr,uint32_t len, -uint64_t prp1,uint64_t prp2,DMADirection dir, +/* +* Map 'nsgld' data descriptors from 'segment'. The function will subtract the +* number of bytes mapped in len. +*/ +static uint16_t nvme_map_sgl_data (NvmeCtrl *n,QEMUSGList *qsg, +QEMUIOVector *iov, +NvmeSglDescriptor *segment,uint64_t nsgld, +size_t *len,NvmeRequest *req) +{ +dma_addr_t addr, trans_len; +uint32_t dlen; +uint16_t status; + +for (int i =0 ; i < nsgld; i++) { +uint8_t type =NVME_SGL_TYPE (segment[i].type); + +switch (type) { +case NVME_SGL_DESCR_TYPE_DATA_BLOCK : +break ; +case NVME_SGL_DESCR_TYPE_SEGMENT : +case NVME_SGL_DESCR_TYPE_LAST_SEGMENT : +return NVME_INVALID_NUM_SGL_DESCRS |NVME_DNR ; +default : +return NVME_SGL_DESCR_TYPE_INVALID |NVME_DNR ; + } + + dlen =le32_to_cpu (segment[i].len); +if (!dlen) { +continue ; + } + +if (*len ==0 ) { +/* +* All data has been mapped, but the SGL contains additional +* segments and/or descriptors. The controller might accept +* ignoring the rest of the SGL. +*/ +uint16_t sgls =le16_to_cpu (n->id_ctrl.sgls); +if (sgls &NVME_CTRL_SGLS_EXCESS_LENGTH ) { +break ; + } + +trace_pci_nvme_err_invalid_sgl_excess_length (nvme_cid (req)); +return NVME_DATA_SGL_LEN_INVALID |NVME_DNR ; + } + + trans_len =MIN (*len, dlen); + addr =le64_to_cpu (segment[i].addr); + +if (UINT64_MAX - addr < dlen) { +return NVME_DATA_SGL_LEN_INVALID |NVME_DNR ; + } + + status =nvme_map_addr (n, qsg, iov, addr, trans_len); +if (status) { +return status; + } + + *len -= trans_len; + } + +return NVME_SUCCESS ; +} + +static uint16_t nvme_map_sgl (NvmeCtrl *n,QEMUSGList *qsg,QEMUIOVector *iov, +NvmeSglDescriptor sgl,size_t len,NvmeRequest *req) +{ +/* +* Read the segment in chunks of 256 descriptors (one 4k page) to avoid +* dynamically allocating a potentially huge SGL. The spec allows the SGL +* to be larger (as in number of bytes required to describe the SGL +* descriptors and segment chain) than the command transfer size, so it is +* not bounded by MDTS. +*/ +const int SEG_CHUNK_SIZE =256 ; + +NvmeSglDescriptor segment[SEG_CHUNK_SIZE ], *sgld, *last_sgld; +uint64_t nsgld; +uint32_t seg_len; +uint16_t status; +bool sgl_in_cmb = false; +hwaddr addr; +int ret; + + sgld = &sgl; + addr =le64_to_cpu (sgl.addr); + +trace_pci_nvme_map_sgl (nvme_cid (req),NVME_SGL_TYPE (sgl.type), req->nlb, + len); + +/* +* If the entire transfer can be described with a single data block it can +* be mapped directly. +*/ +if (NVME_SGL_TYPE (sgl.type) ==NVME_SGL_DESCR_TYPE_DATA_BLOCK ) { + status =nvme_map_sgl_data (n, qsg, iov, sgld,1 , &len, req); +if (status) { + goto unmap; + } + + goto out; + } + +/* +* If the segment is located in the CMB, the submission queue of the +* request must also reside there. +*/ +if (nvme_addr_is_cmb (n, addr)) { +if (!nvme_addr_is_cmb (n, req->sq->dma_addr)) { +return NVME_INVALID_USE_OF_CMB |NVME_DNR ; + } + + sgl_in_cmb = true; + } + +for (;;) { +switch (NVME_SGL_TYPE (sgld->type)) { +case NVME_SGL_DESCR_TYPE_SEGMENT : +case NVME_SGL_DESCR_TYPE_LAST_SEGMENT : +break ; +default : +return NVME_INVALID_SGL_SEG_DESCR |NVME_DNR ; + } + + seg_len =le32_to_cpu (sgld->len); + +/* check the length of the (Last) Segment descriptor */ +if (!seg_len || seg_len &0xf ) { +return NVME_INVALID_SGL_SEG_DESCR |NVME_DNR ; + } + +if (UINT64_MAX - addr < seg_len) { +return NVME_DATA_SGL_LEN_INVALID |NVME_DNR ; + } + + nsgld = seg_len /sizeof (NvmeSglDescriptor); + +while (nsgld >SEG_CHUNK_SIZE ) { +if (nvme_addr_read (n, addr, segment,sizeof (segment))) { +trace_pci_nvme_err_addr_read (addr); + status =NVME_DATA_TRANSFER_ERROR ; + goto unmap; + } + + status =nvme_map_sgl_data (n, qsg, iov, segment,SEG_CHUNK_SIZE , + &len, req); +if (status) { + goto unmap; + } + + nsgld -=SEG_CHUNK_SIZE ; + addr +=SEG_CHUNK_SIZE *sizeof (NvmeSglDescriptor); + } + + ret =nvme_addr_read (n, addr, segment, nsgld * +sizeof (NvmeSglDescriptor)); +if (ret) { +trace_pci_nvme_err_addr_read (addr); + status =NVME_DATA_TRANSFER_ERROR ; + goto unmap; + } + + last_sgld = &segment[nsgld -1 ]; + +/* if the segment ends with a Data Block, then we are done */ +if (NVME_SGL_TYPE (last_sgld->type) ==NVME_SGL_DESCR_TYPE_DATA_BLOCK ) { + status =nvme_map_sgl_data (n, qsg, iov, segment, nsgld, &len, req); +if (status) { + goto unmap; + } + + goto out; + } + +/* +* If the last descriptor was not a Data Block, then the current +* segment must not be a Last Segment. +*/ +if (NVME_SGL_TYPE (sgld->type) ==NVME_SGL_DESCR_TYPE_LAST_SEGMENT ) { + status =NVME_INVALID_SGL_SEG_DESCR |NVME_DNR ; + goto unmap; + } + + sgld = last_sgld; + addr =le64_to_cpu (sgld->addr); + +/* +* Do not map the last descriptor; it will be a Segment or Last Segment +* descriptor and is handled by the next iteration. +*/ + status =nvme_map_sgl_data (n, qsg, iov, segment, nsgld -1 , &len, req); +if (status) { + goto unmap; + } + +/* +* If the next segment is in the CMB, make sure that the sgl was +* already located there. +*/ +if (sgl_in_cmb !=nvme_addr_is_cmb (n, addr)) { + status =NVME_INVALID_USE_OF_CMB |NVME_DNR ; + goto unmap; + } + } + +out: +/* if there is any residual left in len, the SGL was too short */ +if (len) { + status =NVME_DATA_SGL_LEN_INVALID |NVME_DNR ; + goto unmap; + } + +return NVME_SUCCESS ; + +unmap: +if (iov->iov) { +qemu_iovec_destroy (iov); + } + +if (qsg->sg) { +qemu_sglist_destroy (qsg); + } + +return status; +} + +static uint16_t nvme_map (NvmeCtrl *n,size_t len,NvmeRequest *req) +{ +uint64_t prp1, prp2; + +switch (NVME_CMD_FLAGS_PSDT (req->cmd.flags)) { +case NVME_PSDT_PRP : + prp1 =le64_to_cpu (req->cmd.dptr.prp1); + prp2 =le64_to_cpu (req->cmd.dptr.prp2); + +return nvme_map_prp (n, &req->qsg, &req->iov, prp1, prp2, len, req); +case NVME_PSDT_SGL_MPTR_CONTIGUOUS : +case NVME_PSDT_SGL_MPTR_SGL : +/* SGLs shall not be used for Admin commands in NVMe over PCIe */ +if (!req->sq->sqid) { +return NVME_INVALID_FIELD |NVME_DNR ; + } + +return nvme_map_sgl (n, &req->qsg, &req->iov, req->cmd.dptr.sgl, len, + req); +default : +return NVME_INVALID_FIELD ; + } +} + +static uint16_t nvme_dma (NvmeCtrl *n,uint8_t *ptr,uint32_t len, +DMADirection dir,NvmeRequest *req) {uint16_t status =NVME_SUCCESS ; - status =nvme_map_prp (n, &req->qsg, &req->iov, prp1, prp2, len, req); + status =nvme_map (n, len, req);if (status) {return status; }
@@ -402,15 +652,6 @@ static uint16_t nvme_dma_prp(NvmeCtrl *n, uint8_t *ptr, uint32_t len,return status; } -static uint16_t nvme_map (NvmeCtrl *n,size_t len,NvmeRequest *req) -{ -NvmeCmd *cmd = &req->cmd; -uint64_t prp1 =le64_to_cpu (cmd->dptr.prp1); -uint64_t prp2 =le64_to_cpu (cmd->dptr.prp2); - -return nvme_map_prp (n, &req->qsg, &req->iov, prp1, prp2, len, req); -} -static void nvme_aio_destroy (NvmeAIO *aio) {g_free (aio);
@@ -1029,10 +1270,7 @@ static uint16_t nvme_create_sq(NvmeCtrl *n, NvmeRequest *req)static uint16_t nvme_smart_info (NvmeCtrl *n,uint8_t rae,uint32_t buf_len,uint64_t off,NvmeRequest *req) { -NvmeCmd *cmd = &req->cmd; -uint64_t prp1 =le64_to_cpu (cmd->dptr.prp1); -uint64_t prp2 =le64_to_cpu (cmd->dptr.prp2); -uint32_t nsid =le32_to_cpu (cmd->nsid); +uint32_t nsid =le32_to_cpu (req->cmd.nsid);uint32_t trans_len;time_t current_ms;
@@ -1081,17 +1319,14 @@ static uint16_t nvme_smart_info(NvmeCtrl *n, uint8_t rae, uint32_t buf_len,nvme_clear_events (n,NVME_AER_TYPE_SMART ); } -return nvme_dma_prp (n, (uint8_t *) &smart + off, trans_len, prp1, prp2, -DMA_DIRECTION_FROM_DEVICE , req); +return nvme_dma (n, (uint8_t *) &smart + off, trans_len, +DMA_DIRECTION_FROM_DEVICE , req); }static uint16_t nvme_fw_log_info (NvmeCtrl *n,uint32_t buf_len,uint64_t off,NvmeRequest *req) {uint32_t trans_len; -NvmeCmd *cmd = &req->cmd; -uint64_t prp1 =le64_to_cpu (cmd->dptr.prp1); -uint64_t prp2 =le64_to_cpu (cmd->dptr.prp2);NvmeFwSlotInfoLog fw_log = { .afi =0x1 , };
@@ -1104,17 +1339,14 @@ static uint16_t nvme_fw_log_info(NvmeCtrl *n, uint32_t buf_len, uint64_t off, trans_len =MIN (sizeof (fw_log) - off, buf_len); -return nvme_dma_prp (n, (uint8_t *) &fw_log + off, trans_len, prp1, prp2, -DMA_DIRECTION_FROM_DEVICE , req); +return nvme_dma (n, (uint8_t *) &fw_log + off, trans_len, +DMA_DIRECTION_FROM_DEVICE , req); }static uint16_t nvme_error_info (NvmeCtrl *n,uint8_t rae,uint32_t buf_len,uint64_t off,NvmeRequest *req) {uint32_t trans_len; -NvmeCmd *cmd = &req->cmd; -uint64_t prp1 =le64_to_cpu (cmd->dptr.prp1); -uint64_t prp2 =le64_to_cpu (cmd->dptr.prp2);NvmeErrorLog errlog;if (!rae) {
@@ -1129,8 +1361,8 @@ static uint16_t nvme_error_info(NvmeCtrl *n, uint8_t rae, uint32_t buf_len, trans_len =MIN (sizeof (errlog) - off, buf_len); -return nvme_dma_prp (n, (uint8_t *)&errlog, trans_len, prp1, prp2, -DMA_DIRECTION_FROM_DEVICE , req); +return nvme_dma (n, (uint8_t *)&errlog, trans_len, +DMA_DIRECTION_FROM_DEVICE , req); }static uint16_t nvme_get_log (NvmeCtrl *n,NvmeRequest *req)
@@ -1289,14 +1521,10 @@ static uint16_t nvme_create_cq(NvmeCtrl *n, NvmeRequest *req)static uint16_t nvme_identify_ctrl (NvmeCtrl *n,NvmeRequest *req) { -NvmeIdentify *c = (NvmeIdentify *)&req->cmd; -uint64_t prp1 =le64_to_cpu (c->prp1); -uint64_t prp2 =le64_to_cpu (c->prp2); -trace_pci_nvme_identify_ctrl (); -return nvme_dma_prp (n, (uint8_t *)&n->id_ctrl,sizeof (n->id_ctrl), prp1, - prp2,DMA_DIRECTION_FROM_DEVICE , req); +return nvme_dma (n, (uint8_t *)&n->id_ctrl,sizeof (n->id_ctrl), +DMA_DIRECTION_FROM_DEVICE , req); }static uint16_t nvme_identify_ns (NvmeCtrl *n,NvmeRequest *req)
@@ -1304,8 +1532,6 @@ static uint16_t nvme_identify_ns(NvmeCtrl *n, NvmeRequest *req)NvmeNamespace *ns;NvmeIdentify *c = (NvmeIdentify *)&req->cmd;uint32_t nsid =le32_to_cpu (c->nsid); -uint64_t prp1 =le64_to_cpu (c->prp1); -uint64_t prp2 =le64_to_cpu (c->prp2);trace_pci_nvme_identify_ns (nsid);
@@ -1316,8 +1542,8 @@ static uint16_t nvme_identify_ns(NvmeCtrl *n, NvmeRequest *req) ns = &n->namespaces[nsid -1 ]; -return nvme_dma_prp (n, (uint8_t *)&ns->id_ns,sizeof (ns->id_ns), prp1, - prp2,DMA_DIRECTION_FROM_DEVICE , req); +return nvme_dma (n, (uint8_t *)&ns->id_ns,sizeof (ns->id_ns), +DMA_DIRECTION_FROM_DEVICE , req); }static uint16_t nvme_identify_nslist (NvmeCtrl *n,NvmeRequest *req)
@@ -1325,8 +1551,6 @@ static uint16_t nvme_identify_nslist(NvmeCtrl *n, NvmeRequest *req)NvmeIdentify *c = (NvmeIdentify *)&req->cmd;static const int data_len =NVME_IDENTIFY_DATA_SIZE ;uint32_t min_nsid =le32_to_cpu (c->nsid); -uint64_t prp1 =le64_to_cpu (c->prp1); -uint64_t prp2 =le64_to_cpu (c->prp2);uint32_t *list;uint16_t ret;int i, j =0 ;
@@ -1343,8 +1567,8 @@ static uint16_t nvme_identify_nslist(NvmeCtrl *n, NvmeRequest *req)break ; } } - ret =nvme_dma_prp (n, (uint8_t *)list, data_len, prp1, prp2, -DMA_DIRECTION_FROM_DEVICE , req); + ret =nvme_dma (n, (uint8_t *)list, data_len,DMA_DIRECTION_FROM_DEVICE , + req);g_free (list);return ret; }
@@ -1353,8 +1577,6 @@ static uint16_t nvme_identify_ns_descr_list(NvmeCtrl *n, NvmeRequest *req) {NvmeIdentify *c = (NvmeIdentify *)&req->cmd;uint32_t nsid =le32_to_cpu (c->nsid); -uint64_t prp1 =le64_to_cpu (c->prp1); -uint64_t prp2 =le64_to_cpu (c->prp2);uint8_t list[NVME_IDENTIFY_DATA_SIZE ];
@@ -1386,8 +1608,8 @@ static uint16_t nvme_identify_ns_descr_list(NvmeCtrl *n, NvmeRequest *req) ns_descrs->uuid.hdr.nidl =NVME_NIDT_UUID_LEN ;stl_be_p (&ns_descrs->uuid.v, nsid); -return nvme_dma_prp (n, list,NVME_IDENTIFY_DATA_SIZE , prp1, prp2, -DMA_DIRECTION_FROM_DEVICE , req); +return nvme_dma (n, list,NVME_IDENTIFY_DATA_SIZE , +DMA_DIRECTION_FROM_DEVICE , req); }static uint16_t nvme_identify (NvmeCtrl *n,NvmeRequest *req)
@@ -1463,14 +1685,10 @@ static inline uint64_t nvme_get_timestamp(const NvmeCtrl *n)static uint16_t nvme_get_feature_timestamp (NvmeCtrl *n,NvmeRequest *req) { -NvmeCmd *cmd = &req->cmd; -uint64_t prp1 =le64_to_cpu (cmd->dptr.prp1); -uint64_t prp2 =le64_to_cpu (cmd->dptr.prp2); -uint64_t timestamp =nvme_get_timestamp (n); -return nvme_dma_prp (n, (uint8_t *)×tamp,sizeof (timestamp), prp1, - prp2,DMA_DIRECTION_FROM_DEVICE , req); +return nvme_dma (n, (uint8_t *)×tamp,sizeof (timestamp), +DMA_DIRECTION_FROM_DEVICE , req); }static uint16_t nvme_get_feature (NvmeCtrl *n,NvmeRequest *req)
@@ -1596,12 +1814,9 @@ static uint16_t nvme_set_feature_timestamp(NvmeCtrl *n, NvmeRequest *req) {uint16_t ret;uint64_t timestamp; -NvmeCmd *cmd = &req->cmd; -uint64_t prp1 =le64_to_cpu (cmd->dptr.prp1); -uint64_t prp2 =le64_to_cpu (cmd->dptr.prp2); - ret =nvme_dma_prp (n, (uint8_t *)×tamp,sizeof (timestamp), prp1, - prp2,DMA_DIRECTION_TO_DEVICE , req); + ret =nvme_dma (n, (uint8_t *)×tamp,sizeof (timestamp), +DMA_DIRECTION_TO_DEVICE , req);if (ret !=NVME_SUCCESS ) {return ret; }
@@ -2514,6 +2729,8 @@ static void nvme_init_ctrl(NvmeCtrl *n, PCIDevice *pci_dev) id->oncs =cpu_to_le16 (NVME_ONCS_WRITE_ZEROES |NVME_ONCS_TIMESTAMP |NVME_ONCS_FEATURES ); + id->sgls =cpu_to_le32 (NVME_CTRL_SGLS_SUPPORTED_NO_ALIGNMENT ); +pstrcpy ((char *) id->subnqn,sizeof (id->subnqn),"nqn.2019-08.org.qemu:" );pstrcat ((char *) id->subnqn,sizeof (id->subnqn), n->params.serial);
hw/block/trace-events +4 -0
@@ -36,6 +36,7 @@ pci_nvme_dma_read(uint64_t prp1, uint64_t prp2) "DMA read, prp1=0x%"PRIx64" prp2 pci_nvme_map_addr(uint64_t addr, uint64_t len) "addr 0x%"PRIx64" len %"PRIu64"" pci_nvme_map_addr_cmb(uint64_t addr, uint64_t len) "addr 0x%"PRIx64" len %"PRIu64"" pci_nvme_map_prp(uint16_t cid, uint64_t trans_len, uint32_t len, uint64_t prp1, uint64_t prp2, int num_prps) "cid %"PRIu16" trans_len %"PRIu64" len %"PRIu32" prp1 0x%"PRIx64" prp2 0x%"PRIx64" num_prps %d" +pci_nvme_map_sgl(uint16_t cid, uint8_t typ, uint32_t nlb, uint64_t len) "cid %"PRIu16" type 0x%"PRIx8" nlb %"PRIu32" len %"PRIu64"" pci_nvme_req_add_aio(uint16_t cid, void *aio, const char *blkname, uint64_t offset, uint64_t count, const char *opc, void *req) "cid %"PRIu16" aio %p blk \"%s\" offset %"PRIu64" count %"PRIu64" opc \"%s\" req %p" pci_nvme_aio_cb(uint16_t cid, void *aio, const char *blkname, uint64_t offset, const char *opc, void *req) "cid %"PRIu16" aio %p blk \"%s\" offset %"PRIu64" opc \"%s\" req %p" pci_nvme_io_cmd(uint16_t cid, uint32_t nsid, uint16_t sqid, uint8_t opcode) "cid %"PRIu16" nsid %"PRIu32" sqid %"PRIu16" opc 0x%"PRIx8""
@@ -91,6 +92,9 @@ pci_nvme_err_mdts(uint16_t cid, size_t len) "cid %"PRIu16" len %"PRIu64"" pci_nvme_err_aio(uint16_t cid, void *aio, const char *blkname, uint64_t offset, const char *opc, void *req, uint16_t status) "cid %"PRIu16" aio %p blk \"%s\" offset %"PRIu64" opc \"%s\" req %p status 0x%"PRIx16"" pci_nvme_err_addr_read(uint64_t addr) "addr 0x%"PRIx64"" pci_nvme_err_addr_write(uint64_t addr) "addr 0x%"PRIx64"" +pci_nvme_err_invalid_sgld(uint16_t cid, uint8_t typ) "cid %"PRIu16" type 0x%"PRIx8"" +pci_nvme_err_invalid_num_sgld(uint16_t cid, uint8_t typ) "cid %"PRIu16" type 0x%"PRIx8"" +pci_nvme_err_invalid_sgl_excess_length(uint16_t cid) "cid %"PRIu16"" pci_nvme_err_invalid_dma(void) "PRP/SGL is too small for transfer size" pci_nvme_err_invalid_prplist_ent(uint64_t prplist) "PRP list entry is null or not page aligned: 0x%"PRIx64"" pci_nvme_err_invalid_prp2_align(uint64_t prp2) "PRP2 is not page aligned: 0x%"PRIx64""
include/block/nvme.h +3 -3
@@ -411,9 +411,9 @@ typedef union NvmeCmdDptr { } NvmeCmdDptr;enum NvmePsdt { -PSDT_PRP =0x0 , -PSDT_SGL_MPTR_CONTIGUOUS =0x1 , -PSDT_SGL_MPTR_SGL =0x2 , +NVME_PSDT_PRP =0x0 , +NVME_PSDT_SGL_MPTR_CONTIGUOUS =0x1 , +NVME_PSDT_SGL_MPTR_SGL =0x2 , }; typedef struct NvmeCmd {
Signature · 1 line
2.27.0
PATCH 3/3 hw/block/nvme: add support for sgl bit bucket descriptor
In reply to Klaus JensenFrom: Gollu Appalanaidu <[email protected]>
This adds support for SGL descriptor type 0x1 (bit bucket descriptor). See the NVM Express v1.3d specification, Section 4.4 ("Scatter Gather List (SGL)").
--- hw/block/nvme.c | 33 +++++++++++++++++++++++++++------ 1 file changed, 27 insertions(+), 6 deletions(-)
hw/block/nvme.c +27 -6
@@ -377,6 +377,10 @@ static uint16_t nvme_map_sgl_data(NvmeCtrl *n, QEMUSGList *qsg,uint8_t type =NVME_SGL_TYPE (segment[i].type);switch (type) { +case NVME_SGL_DESCR_TYPE_BIT_BUCKET : +if (nvme_req_is_write (req)) { +continue ; + }case NVME_SGL_DESCR_TYPE_DATA_BLOCK :break ;case NVME_SGL_DESCR_TYPE_SEGMENT :
@@ -387,6 +391,7 @@ static uint16_t nvme_map_sgl_data(NvmeCtrl *n, QEMUSGList *qsg, } dlen =le32_to_cpu (segment[i].len); +if (!dlen) {continue ; }
@@ -407,6 +412,11 @@ static uint16_t nvme_map_sgl_data(NvmeCtrl *n, QEMUSGList *qsg, } trans_len =MIN (*len, dlen); + +if (type ==NVME_SGL_DESCR_TYPE_BIT_BUCKET ) { + goto next; + } + addr =le64_to_cpu (segment[i].addr);if (UINT64_MAX - addr < dlen) {
@@ -418,6 +428,7 @@ static uint16_t nvme_map_sgl_data(NvmeCtrl *n, QEMUSGList *qsg,return status; } +next: *len -= trans_len; }
@@ -488,7 +499,8 @@ static uint16_t nvme_map_sgl(NvmeCtrl *n, QEMUSGList *qsg, QEMUIOVector *iov, seg_len =le32_to_cpu (sgld->len);/* check the length of the (Last) Segment descriptor */ -if (!seg_len || seg_len &0xf ) { +if ((!seg_len || seg_len &0xf ) && + (NVME_SGL_TYPE (sgld->type) !=NVME_SGL_DESCR_TYPE_BIT_BUCKET )) {return NVME_INVALID_SGL_SEG_DESCR |NVME_DNR ; }
@@ -525,19 +537,27 @@ static uint16_t nvme_map_sgl(NvmeCtrl *n, QEMUSGList *qsg, QEMUIOVector *iov, last_sgld = &segment[nsgld -1 ]; -/* if the segment ends with a Data Block, then we are done */ -if (NVME_SGL_TYPE (last_sgld->type) ==NVME_SGL_DESCR_TYPE_DATA_BLOCK ) { +/* +* If the segment ends with a Data Block or Bit Bucket Descriptor Type, +* then we are done. +*/ +switch (NVME_SGL_TYPE (last_sgld->type)) { +case NVME_SGL_DESCR_TYPE_DATA_BLOCK : +case NVME_SGL_DESCR_TYPE_BIT_BUCKET : status =nvme_map_sgl_data (n, qsg, iov, segment, nsgld, &len, req);if (status) { goto unmap; } goto out; + +default : +break ; }/* -* If the last descriptor was not a Data Block, then the current -* segment must not be a Last Segment. +* If the last descriptor was not a Data Block or Bit Bucket, then the +* current segment must not be a Last Segment. */ if (NVME_SGL_TYPE (sgld->type) ==NVME_SGL_DESCR_TYPE_LAST_SEGMENT ) { status =NVME_INVALID_SGL_SEG_DESCR |NVME_DNR ;
@@ -2729,7 +2749,8 @@ static void nvme_init_ctrl(NvmeCtrl *n, PCIDevice *pci_dev) id->oncs =cpu_to_le16 (NVME_ONCS_WRITE_ZEROES |NVME_ONCS_TIMESTAMP |NVME_ONCS_FEATURES ); - id->sgls =cpu_to_le32 (NVME_CTRL_SGLS_SUPPORTED_NO_ALIGNMENT ); + id->sgls =cpu_to_le32 (NVME_CTRL_SGLS_SUPPORTED_NO_ALIGNMENT | +NVME_CTRL_SGLS_BITBUCKET );pstrcpy ((char *) id->subnqn,sizeof (id->subnqn),"nqn.2019-08.org.qemu:" );pstrcat ((char *) id->subnqn,sizeof (id->subnqn), n->params.serial);
Signature · 1 line
2.27.0