hw/block/nvme: multiple namespaces support
v3 cover hw/block/nvme: multiple namespaces support
From: Klaus Jensen <[email protected]>
This is the next round of my patches for the nvme device.
This includes a bit of cleanup and two new features:
* support for scatter/gather lists
* multiple namespaces support through a new nvme-ns device
Finally, the series wraps up with changing the PCI vendor and device ID to get rid of the internal Intel id and as a side-effect get rid of some Linux kernel quirks that no longer applies.
"pci: pass along the return value of dma_memory_rw" has already been posted by Philippe in another series, but since it is not applied yet, I am including it here.
Changes for v3
~~~~~~~~~~~~~~
* hw/block/nvme: handle dma errors
Do not retry DMA, just set Controller Fatal Status (CFS). This causes the Linux kernel to most likely disable the controller when running the blktests block/011 test case, which causes some havoc when running blktests, but I have submitted a patch for blktests to fix this. (Keith)
* hw/block/nvme: refactor aio submission
Dropped the unneeded nvme_req_is_write function. (Keith)
* Added R-b's from Keith and Philippe.
Changes for v2
~~~~~~~~~~~~~~
* Added a new patch ("hw/block/nvme: fix typo in trace event") that does what it says on the tin.
* Dropped the "hw/block/nvme: support multiple parallel aios per request" patch (Keith).
* hw/block/nvme: add symbolic command name to trace events Changed to single quote (Philippe)
* hw/block/nvme: default request status to success Commit message typo fixed (Philippe)
* hw/block/nvme: change controller pci id
Do NOT bump the device id for the legacy Intel id (David)
Gollu Appalanaidu (1):
hw/block/nvme: add support for sgl bit bucket descriptor
Klaus Jensen (16):
hw/block/nvme: fix typo in trace event
pci: pass along the return value of dma_memory_rw hw/block/nvme: handle dma errors
hw/block/nvme: commonize nvme_rw error handling hw/block/nvme: alignment style fixes hw/block/nvme: add a lba to bytes helper hw/block/nvme: fix endian conversion hw/block/nvme: add symbolic command name to trace events hw/block/nvme: refactor aio submission hw/block/nvme: default request status to success hw/block/nvme: harden cmb access
hw/block/nvme: add support for scatter gather lists hw/block/nvme: refactor identify active namespace id list hw/block/nvme: support multiple namespaces
pci: allocate pci id for nvme
hw/block/nvme: change controller pci id
docs/specs/nvme.txt | 23 ++ docs/specs/pci-ids.txt | 1 + hw/block/nvme-ns.h | 74 ++++ hw/block/nvme.h | 83 +++- include/block/nvme.h | 6 +- include/hw/pci/pci.h | 4 +- hw/block/nvme-ns.c | 167 ++++++++ hw/block/nvme.c | 848 ++++++++++++++++++++++++++++++----------- hw/core/machine.c | 1 + MAINTAINERS | 1 + hw/block/meson.build | 2 +- hw/block/trace-events | 23 +- 12 files changed, 978 insertions(+), 255 deletions(-) create mode 100644 docs/specs/nvme.txt create mode 100644 hw/block/nvme-ns.h create mode 100644 hw/block/nvme-ns.c
Signature · 1 line
2.28.0
PATCH v3 1/17 hw/block/nvme: fix typo in trace event
From: Klaus Jensen <[email protected]>
Fix a typo in the sq doorbell trace event.
--- hw/block/trace-events | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
hw/block/trace-events +1 -1
@@ -70,7 +70,7 @@ pci_nvme_enqueue_req_completion(uint16_t cid, uint16_t cqid, uint16_t status) "c pci_nvme_mmio_read(uint64_t addr) "addr 0x%"PRIx64"" pci_nvme_mmio_write(uint64_t addr, uint64_t data) "addr 0x%"PRIx64" data 0x%"PRIx64"" pci_nvme_mmio_doorbell_cq(uint16_t cqid, uint16_t new_head) "cqid %"PRIu16" new_head %"PRIu16"" -pci_nvme_mmio_doorbell_sq(uint16_t sqid, uint16_t new_tail) "cqid %"PRIu16" new_tail %"PRIu16"" +pci_nvme_mmio_doorbell_sq(uint16_t sqid, uint16_t new_tail) "sqid %"PRIu16" new_tail %"PRIu16"" pci_nvme_mmio_intm_set(uint64_t data, uint64_t new_mask) "wrote MMIO, interrupt mask set, data=0x%"PRIx64", new_mask=0x%"PRIx64"" pci_nvme_mmio_intm_clr(uint64_t data, uint64_t new_mask) "wrote MMIO, interrupt mask clr, data=0x%"PRIx64", new_mask=0x%"PRIx64"" pci_nvme_mmio_cfg(uint64_t data) "wrote MMIO, config controller config=0x%"PRIx64""
Signature · 1 line
2.28.0
PATCH v3 2/17 pci: pass along the return value of dma_memory_rw
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
Some devices might want to know the return value of dma_memory_rw, so pass it along instead of ignoring it.
There are no existing users of the return value, so this patch should be safe.
--- include/hw/pci/pci.h | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-)
include/hw/pci/pci.h +1 -2
@@ -785,8 +785,7 @@ static inline AddressSpace *pci_get_address_space(PCIDevice *dev)static inline int pci_dma_rw (PCIDevice *dev,dma_addr_t addr,void *buf,dma_addr_t len,DMADirection dir) { -dma_memory_rw (pci_get_address_space (dev), addr, buf, len, dir); -return 0 ; +return dma_memory_rw (pci_get_address_space (dev), addr, buf, len, dir); } static inline int pci_dma_read(PCIDevice *dev, dma_addr_t addr,
Signature · 1 line
2.28.0
PATCH v3 3/17 hw/block/nvme: handle dma errors
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
Handling DMA errors gracefully is required for the device to pass the block/011 test ("disable PCI device while doing I/O") in the blktests suite.
With this patch the device sets the Controller Fatal Status bit in the CSTS register when failing to read from a submission queue or writing to a completion queue; expecting the host to reset the controller.
If DMA errors occur at any other point in the execution of the command (say, while mapping the PRPs), the command is aborted with a Data Transfer Error status code.
--- hw/block/nvme.c | 41 +++++++++++++++++++++++++++++++---------- hw/block/trace-events | 3 +++ 2 files changed, 34 insertions(+), 10 deletions(-)
hw/block/nvme.c +31 -10
@@ -140,14 +140,14 @@ static inline void *nvme_addr_to_cmb(NvmeCtrl *n, hwaddr addr)return &n->cmbuf[addr - n->ctrl_mem.addr]; } -static void nvme_addr_read (NvmeCtrl *n,hwaddr addr,void *buf,int size) +static int nvme_addr_read (NvmeCtrl *n,hwaddr addr,void *buf,int size) {if (n->bar.cmbsz &&nvme_addr_is_cmb (n, addr)) {memcpy (buf,nvme_addr_to_cmb (n, addr), size); -return ; +return 0 ; } -pci_dma_read (&n->parent_obj, addr, buf, size); +return pci_dma_read (&n->parent_obj, addr, buf, size); }static int nvme_check_sqid (NvmeCtrl *n,uint16_t sqid)
@@ -307,6 +307,7 @@ static uint16_t nvme_map_prp(NvmeCtrl *n, uint64_t prp1, uint64_t prp2,int num_prps = (len >> n->page_bits) +1 ;uint16_t status;bool prp_list_in_cmb = false; +int ret;QEMUSGList *qsg = &req->qsg;QEMUIOVector *iov = &req->iov;
@@ -347,7 +348,11 @@ static uint16_t nvme_map_prp(NvmeCtrl *n, uint64_t prp1, uint64_t prp2, nents = (len + n->page_size -1 ) >> n->page_bits; prp_trans =MIN (n->max_prp_ents, nents) *sizeof (uint64_t ); -nvme_addr_read (n, prp2, (void *)prp_list, prp_trans); + ret =nvme_addr_read (n, prp2, (void *)prp_list, prp_trans); +if (ret) { +trace_pci_nvme_err_addr_read (prp2); +return NVME_DATA_TRAS_ERROR ; + }while (len !=0 ) {uint64_t prp_ent =le64_to_cpu (prp_list[i]);
@@ -364,8 +369,12 @@ static uint16_t nvme_map_prp(NvmeCtrl *n, uint64_t prp1, uint64_t prp2, i =0 ; nents = (len + n->page_size -1 ) >> n->page_bits; prp_trans =MIN (n->max_prp_ents, nents) *sizeof (uint64_t ); -nvme_addr_read (n, prp_ent, (void *)prp_list, - prp_trans); + ret =nvme_addr_read (n, prp_ent, (void *)prp_list, + prp_trans); +if (ret) { +trace_pci_nvme_err_addr_read (prp_ent); +return NVME_DATA_TRAS_ERROR ; + } prp_ent =le64_to_cpu (prp_list[i]); }
@@ -457,6 +466,7 @@ static void nvme_post_cqes(void *opaque)NvmeCQueue *cq = opaque;NvmeCtrl *n = cq->ctrl;NvmeRequest *req, *next; +int ret; QTAILQ_FOREACH_SAFE(req, &cq->req_list, entry, next) {NvmeSQueue *sq;
@@ -466,15 +476,21 @@ static void nvme_post_cqes(void *opaque)break ; } -QTAILQ_REMOVE (&cq->req_list, req, entry); sq = req->sq; req->cqe.status =cpu_to_le16 ((req->status <<1 ) | cq->phase); req->cqe.sq_id =cpu_to_le16 (sq->sqid); req->cqe.sq_head =cpu_to_le16 (sq->head); addr = cq->dma_addr + cq->tail * n->cqe_size; + ret =pci_dma_write (&n->parent_obj, addr, (void *)&req->cqe, +sizeof (req->cqe)); +if (ret) { +trace_pci_nvme_err_addr_write (addr); +trace_pci_nvme_err_cfs (); + n->bar.csts =NVME_CSTS_FAILED ; +break ; + } +QTAILQ_REMOVE (&cq->req_list, req, entry);nvme_inc_cq_tail (cq); -pci_dma_write (&n->parent_obj, addr, (void *)&req->cqe, -sizeof (req->cqe));nvme_req_exit (req);QTAILQ_INSERT_TAIL (&sq->req_list, req, entry); }
@@ -1611,7 +1627,12 @@ static void nvme_process_sq(void *opaque)while (!(nvme_sq_empty (sq) ||QTAILQ_EMPTY (&sq->req_list))) { addr = sq->dma_addr + sq->head * n->sqe_size; -nvme_addr_read (n, addr, (void *)&cmd,sizeof (cmd)); +if (nvme_addr_read (n, addr, (void *)&cmd,sizeof (cmd))) { +trace_pci_nvme_err_addr_read (addr); +trace_pci_nvme_err_cfs (); + n->bar.csts =NVME_CSTS_FAILED ; +break ; + }nvme_inc_sq_head (sq); req =QTAILQ_FIRST (&sq->req_list);
hw/block/trace-events +3 -0
@@ -86,6 +86,9 @@ pci_nvme_mmio_shutdown_cleared(void) "shutdown bit cleared" # nvme traces for error conditions pci_nvme_err_mdts(uint16_t cid, size_t len) "cid %"PRIu16" len %zu" +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_cfs(void) "controller fatal status" 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""
Signature · 1 line
2.28.0
PATCH v3 4/17 hw/block/nvme: commonize nvme_rw error handling
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
Move common error handling to a label.
--- hw/block/nvme.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)
hw/block/nvme.c +9 -7
@@ -687,20 +687,18 @@ static uint16_t nvme_rw(NvmeCtrl *n, NvmeRequest *req) status =nvme_check_mdts (n, data_size);if (status) {trace_pci_nvme_err_mdts (nvme_cid (req), data_size); -block_acct_invalid (blk_get_stats (n->conf.blk), acct); -return status; + goto invalid; } status =nvme_check_bounds (n, ns, slba, nlb);if (status) {trace_pci_nvme_err_invalid_lba_range (slba, nlb, ns->id_ns.nsze); -block_acct_invalid (blk_get_stats (n->conf.blk), acct); -return status; + goto invalid; } -if (nvme_map_dptr (n, data_size, req)) { -block_acct_invalid (blk_get_stats (n->conf.blk), acct); -return NVME_INVALID_FIELD |NVME_DNR ; + status =nvme_map_dptr (n, data_size, req); +if (status) { + goto invalid; }if (req->qsg.nsg >0 ) {
@@ -722,6 +720,10 @@ static uint16_t nvme_rw(NvmeCtrl *n, NvmeRequest *req) }return NVME_NO_COMPLETE ; + +invalid: +block_acct_invalid (blk_get_stats (n->conf.blk), acct); +return status; }static uint16_t nvme_io_cmd (NvmeCtrl *n,NvmeRequest *req)
Signature · 1 line
2.28.0
PATCH v3 5/17 hw/block/nvme: alignment style fixes
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
Style fixes.
--- hw/block/nvme.c | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-)
hw/block/nvme.c +13 -12
@@ -634,7 +634,7 @@ static void nvme_rw_cb(void *opaque, int ret)static uint16_t nvme_flush (NvmeCtrl *n,NvmeRequest *req) {block_acct_start (blk_get_stats (n->conf.blk), &req->acct,0 , -BLOCK_ACCT_FLUSH ); +BLOCK_ACCT_FLUSH ); req->aiocb =blk_aio_flush (n->conf.blk, nvme_rw_cb, req);return NVME_NO_COMPLETE ;
@@ -663,7 +663,7 @@ static uint16_t nvme_write_zeroes(NvmeCtrl *n, NvmeRequest *req)block_acct_start (blk_get_stats (n->conf.blk), &req->acct,0 ,BLOCK_ACCT_WRITE ); req->aiocb =blk_aio_pwrite_zeroes (n->conf.blk, offset, count, -BDRV_REQ_MAY_UNMAP , nvme_rw_cb, req); +BDRV_REQ_MAY_UNMAP , nvme_rw_cb, req);return NVME_NO_COMPLETE ; }
@@ -803,7 +803,7 @@ static uint16_t nvme_del_sq(NvmeCtrl *n, NvmeRequest *req) }static void nvme_init_sq (NvmeSQueue *sq,NvmeCtrl *n,uint64_t dma_addr, -uint16_t sqid,uint16_t cqid,uint16_t size) +uint16_t sqid,uint16_t cqid,uint16_t size) {int i;NvmeCQueue *cq;
@@ -1058,7 +1058,8 @@ static uint16_t nvme_del_cq(NvmeCtrl *n, NvmeRequest *req) }static void nvme_init_cq (NvmeCQueue *cq,NvmeCtrl *n,uint64_t dma_addr, -uint16_t cqid,uint16_t vector,uint16_t size,uint16_t irq_enabled) +uint16_t cqid,uint16_t vector,uint16_t size, +uint16_t irq_enabled) {int ret;
@@ -1118,7 +1119,7 @@ static uint16_t nvme_create_cq(NvmeCtrl *n, NvmeRequest *req) cq =g_malloc0 (sizeof (*cq));nvme_init_cq (cq, n, prp1, cqid, vector, qsize +1 , -NVME_CQ_FLAGS_IEN (qflags)); +NVME_CQ_FLAGS_IEN (qflags));/* * It is only required to set qs_created when creating a completion queue;
@@ -1520,7 +1521,7 @@ static uint16_t nvme_set_feature(NvmeCtrl *n, NvmeRequest *req) }if (((n->temperature >= n->features.temp_thresh_hi) || - (n->temperature <= n->features.temp_thresh_low)) && + (n->temperature <= n->features.temp_thresh_low)) &&NVME_AEC_SMART (n->features.async_config) &NVME_SMART_TEMPERATURE ) { nvme_enqueue_event(n, NVME_AER_TYPE_SMART, NVME_AER_INFO_SMART_TEMP_THRESH,
@@ -1770,9 +1771,9 @@ static int nvme_start_ctrl(NvmeCtrl *n) n->cqe_size =1 <<NVME_CC_IOCQES (n->bar.cc); n->sqe_size =1 <<NVME_CC_IOSQES (n->bar.cc);nvme_init_cq (&n->admin_cq, n, n->bar.acq,0 ,0 , -NVME_AQA_ACQS (n->bar.aqa) +1 ,1 ); +NVME_AQA_ACQS (n->bar.aqa) +1 ,1 );nvme_init_sq (&n->admin_sq, n, n->bar.asq,0 ,0 , -NVME_AQA_ASQS (n->bar.aqa) +1 ); +NVME_AQA_ASQS (n->bar.aqa) +1 );nvme_set_timestamp (n,0ULL );
@@ -1782,7 +1783,7 @@ static int nvme_start_ctrl(NvmeCtrl *n) }static void nvme_write_bar (NvmeCtrl *n,hwaddr offset,uint64_t data, -unsigned size) +unsigned size) {if (unlikely (offset & (sizeof (uint32_t ) -1 ))) { NVME_GUEST_ERR(pci_nvme_ub_mmiowr_misaligned32,
@@ -1925,7 +1926,7 @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data, "invalid write to PMRSWTP register, ignored");return ;case 0xE14 :/* TODO PMRMSC */ -break ; +break ;default :NVME_GUEST_ERR (pci_nvme_ub_mmiowr_invalid, "invalid MMIO write,"
@@ -2101,7 +2102,7 @@ static void nvme_process_db(NvmeCtrl *n, hwaddr addr, int val) }static void nvme_mmio_write (void *opaque,hwaddr addr,uint64_t data, -unsigned size) +unsigned size) {NvmeCtrl *n = (NvmeCtrl *)opaque;
@@ -2125,7 +2126,7 @@ static const MemoryRegionOps nvme_mmio_ops = { };static void nvme_cmb_write (void *opaque,hwaddr addr,uint64_t data, -unsigned size) +unsigned size) {NvmeCtrl *n = (NvmeCtrl *)opaque;stn_le_p (&n->cmbuf[addr], size, data);
Signature · 1 line
2.28.0
PATCH v3 6/17 hw/block/nvme: add a lba to bytes helper
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
Add the nvme_l2b helper and use it for converting NLB and SLBA to byte counts and offsets.
--- hw/block/nvme.h | 6 ++++++ hw/block/nvme.c | 12 ++++-------- 2 files changed, 10 insertions(+), 8 deletions(-)
hw/block/nvme.h +6 -0
@@ -77,6 +77,12 @@ static inline uint8_t nvme_ns_lbads(NvmeNamespace *ns)return nvme_ns_lbaf (ns)->ds; } +/* convert an LBA to the equivalent in bytes */ +static inline size_t nvme_l2b (NvmeNamespace *ns,uint64_t lba) +{ +return lba <<nvme_ns_lbads (ns); +} +#define TYPE_NVME "nvme"#define NVME (obj) \ OBJECT_CHECK(NvmeCtrl, (obj), TYPE_NVME)
hw/block/nvme.c +4 -8
@@ -644,12 +644,10 @@ static uint16_t nvme_write_zeroes(NvmeCtrl *n, NvmeRequest *req) {NvmeRwCmd *rw = (NvmeRwCmd *)&req->cmd;NvmeNamespace *ns = req->ns; -const uint8_t lba_index =NVME_ID_NS_FLBAS_INDEX (ns->id_ns.flbas); -const uint8_t data_shift = ns->id_ns.lbaf[lba_index].ds;uint64_t slba =le64_to_cpu (rw->slba);uint32_t nlb =le16_to_cpu (rw->nlb) +1 ; -uint64_t offset = slba << data_shift; -uint32_t count = nlb << data_shift; +uint64_t offset =nvme_l2b (ns, slba); +uint32_t count =nvme_l2b (ns, nlb);uint16_t status;trace_pci_nvme_write_zeroes (nvme_cid (req), slba, nlb);
@@ -674,10 +672,8 @@ static uint16_t nvme_rw(NvmeCtrl *n, NvmeRequest *req)uint32_t nlb =le32_to_cpu (rw->nlb) +1 ;uint64_t slba =le64_to_cpu (rw->slba); -uint8_t lba_index =NVME_ID_NS_FLBAS_INDEX (ns->id_ns.flbas); -uint8_t data_shift = ns->id_ns.lbaf[lba_index].ds; -uint64_t data_size = (uint64_t )nlb << data_shift; -uint64_t data_offset = slba << data_shift; +uint64_t data_size =nvme_l2b (ns, nlb); +uint64_t data_offset =nvme_l2b (ns, slba);int is_write = rw->opcode ==NVME_CMD_WRITE ?1 :0 ;enum BlockAcctType acct = is_write ?BLOCK_ACCT_WRITE :BLOCK_ACCT_READ ;uint16_t status;
Signature · 1 line
2.28.0
PATCH v3 7/17 hw/block/nvme: fix endian conversion
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
The raw NLB field is a 16 bit value, so use le16_to_cpu instead of le32_to_cpu and cast to uint32_t before incrementing the value to not wrap around.
--- hw/block/nvme.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
hw/block/nvme.c +2 -2
@@ -645,7 +645,7 @@ static uint16_t nvme_write_zeroes(NvmeCtrl *n, NvmeRequest *req)NvmeRwCmd *rw = (NvmeRwCmd *)&req->cmd;NvmeNamespace *ns = req->ns;uint64_t slba =le64_to_cpu (rw->slba); -uint32_t nlb =le16_to_cpu (rw->nlb) +1 ; +uint32_t nlb = (uint32_t )le16_to_cpu (rw->nlb) +1 ;uint64_t offset =nvme_l2b (ns, slba);uint32_t count =nvme_l2b (ns, nlb);uint16_t status;
@@ -669,7 +669,7 @@ static uint16_t nvme_rw(NvmeCtrl *n, NvmeRequest *req) {NvmeRwCmd *rw = (NvmeRwCmd *)&req->cmd;NvmeNamespace *ns = req->ns; -uint32_t nlb =le32_to_cpu (rw->nlb) +1 ; +uint32_t nlb = (uint32_t )le16_to_cpu (rw->nlb) +1 ;uint64_t slba =le64_to_cpu (rw->slba);uint64_t data_size =nvme_l2b (ns, nlb);
Signature · 1 line
2.28.0
PATCH v3 8/17 hw/block/nvme: add symbolic command name to trace events
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
Add the symbolic command name to the pci_nvme_{io,admin}_cmd and pci_nvme_rw trace events.
--- hw/block/nvme.h | 28 ++++++++++++++++++++++++++++ hw/block/nvme.c | 8 +++++--- hw/block/trace-events | 6 +++--- 3 files changed, 36 insertions(+), 6 deletions(-)
hw/block/nvme.h +28 -0
@@ -32,6 +32,34 @@ typedef struct NvmeRequest {QTAILQ_ENTRY (NvmeRequest)entry; } NvmeRequest; +static inline const char *nvme_adm_opc_str (uint8_t opc) +{ +switch (opc) { +case NVME_ADM_CMD_DELETE_SQ :return "NVME_ADM_CMD_DELETE_SQ" ; +case NVME_ADM_CMD_CREATE_SQ :return "NVME_ADM_CMD_CREATE_SQ" ; +case NVME_ADM_CMD_GET_LOG_PAGE :return "NVME_ADM_CMD_GET_LOG_PAGE" ; +case NVME_ADM_CMD_DELETE_CQ :return "NVME_ADM_CMD_DELETE_CQ" ; +case NVME_ADM_CMD_CREATE_CQ :return "NVME_ADM_CMD_CREATE_CQ" ; +case NVME_ADM_CMD_IDENTIFY :return "NVME_ADM_CMD_IDENTIFY" ; +case NVME_ADM_CMD_ABORT :return "NVME_ADM_CMD_ABORT" ; +case NVME_ADM_CMD_SET_FEATURES :return "NVME_ADM_CMD_SET_FEATURES" ; +case NVME_ADM_CMD_GET_FEATURES :return "NVME_ADM_CMD_GET_FEATURES" ; +case NVME_ADM_CMD_ASYNC_EV_REQ :return "NVME_ADM_CMD_ASYNC_EV_REQ" ; +default :return "NVME_ADM_CMD_UNKNOWN" ; + } +} + +static inline const char *nvme_io_opc_str (uint8_t opc) +{ +switch (opc) { +case NVME_CMD_FLUSH :return "NVME_NVM_CMD_FLUSH" ; +case NVME_CMD_WRITE :return "NVME_NVM_CMD_WRITE" ; +case NVME_CMD_READ :return "NVME_NVM_CMD_READ" ; +case NVME_CMD_WRITE_ZEROES :return "NVME_NVM_CMD_WRITE_ZEROES" ; +default :return "NVME_NVM_CMD_UNKNOWN" ; + } +} + typedef struct NvmeSQueue { struct NvmeCtrl *ctrl; uint16_t sqid;
hw/block/nvme.c +5 -3
@@ -678,7 +678,8 @@ static uint16_t nvme_rw(NvmeCtrl *n, NvmeRequest *req)enum BlockAcctType acct = is_write ?BLOCK_ACCT_WRITE :BLOCK_ACCT_READ ;uint16_t status; -trace_pci_nvme_rw (is_write ?"write" :"read" , nlb, data_size, slba); +trace_pci_nvme_rw (nvme_cid (req),nvme_io_opc_str (rw->opcode), nlb, + data_size, slba); status =nvme_check_mdts (n, data_size);if (status) {
@@ -727,7 +728,7 @@ static uint16_t nvme_io_cmd(NvmeCtrl *n, NvmeRequest *req)uint32_t nsid =le32_to_cpu (req->cmd.nsid);trace_pci_nvme_io_cmd (nvme_cid (req), nsid,nvme_sqid (req), - req->cmd.opcode); + req->cmd.opcode,nvme_io_opc_str (req->cmd.opcode));if (unlikely (nsid ==0 || nsid > n->num_namespaces)) {trace_pci_nvme_err_invalid_ns (nsid, n->num_namespaces);
@@ -1584,7 +1585,8 @@ static uint16_t nvme_aer(NvmeCtrl *n, NvmeRequest *req)static uint16_t nvme_admin_cmd (NvmeCtrl *n,NvmeRequest *req) { -trace_pci_nvme_admin_cmd (nvme_cid (req),nvme_sqid (req), req->cmd.opcode); +trace_pci_nvme_admin_cmd (nvme_cid (req),nvme_sqid (req), req->cmd.opcode, +nvme_adm_opc_str (req->cmd.opcode));switch (req->cmd.opcode) {case NVME_ADM_CMD_DELETE_SQ :
hw/block/trace-events +3 -3
@@ -36,9 +36,9 @@ 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(uint64_t trans_len, uint32_t len, uint64_t prp1, uint64_t prp2, int num_prps) "trans_len %"PRIu64" len %"PRIu32" prp1 0x%"PRIx64" prp2 0x%"PRIx64" num_prps %d" -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"" -pci_nvme_admin_cmd(uint16_t cid, uint16_t sqid, uint8_t opcode) "cid %"PRIu16" sqid %"PRIu16" opc 0x%"PRIx8"" -pci_nvme_rw(const char *verb, uint32_t blk_count, uint64_t byte_count, uint64_t lba) "%s %"PRIu32" blocks (%"PRIu64" bytes) from LBA %"PRIu64"" +pci_nvme_io_cmd(uint16_t cid, uint32_t nsid, uint16_t sqid, uint8_t opcode, const char *opname) "cid %"PRIu16" nsid %"PRIu32" sqid %"PRIu16" opc 0x%"PRIx8" opname '%s'" +pci_nvme_admin_cmd(uint16_t cid, uint16_t sqid, uint8_t opcode, const char *opname) "cid %"PRIu16" sqid %"PRIu16" opc 0x%"PRIx8" opname '%s'" +pci_nvme_rw(uint16_t cid, const char *verb, uint32_t nlb, uint64_t count, uint64_t lba) "cid %"PRIu16" '%s' nlb %"PRIu32" count %"PRIu64" lba 0x%"PRIx64"" pci_nvme_rw_cb(uint16_t cid) "cid %"PRIu16"" pci_nvme_write_zeroes(uint16_t cid, uint64_t slba, uint32_t nlb) "cid %"PRIu16" slba %"PRIu64" nlb %"PRIu32"" pci_nvme_create_sq(uint64_t addr, uint16_t sqid, uint16_t cqid, uint16_t qsize, uint16_t qflags) "create submission queue, addr=0x%"PRIx64", sqid=%"PRIu16", cqid=%"PRIu16", qsize=%"PRIu16", qflags=%"PRIu16""
Signature · 1 line
2.28.0
PATCH v3 9/17 hw/block/nvme: refactor aio submission
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
This pulls block layer aio submission/completion to common functions.
For completions, additionally map an AIO error to the Unrecovered Read and Write Fault status codes.
--- hw/block/nvme.h | 14 +++++ hw/block/nvme.c | 136 ++++++++++++++++++++++++++++++------------ hw/block/trace-events | 4 +- 3 files changed, 114 insertions(+), 40 deletions(-)
hw/block/nvme.h +14 -0
@@ -171,4 +171,18 @@ static inline uint64_t nvme_ns_nlbas(NvmeCtrl *n, NvmeNamespace *ns) return n->ns_size >> nvme_ns_lbads(ns); } +static inline NvmeCQueue *nvme_cq (NvmeRequest *req) +{ +NvmeSQueue *sq = req->sq; +NvmeCtrl *n = sq->ctrl; + +return n->cq[sq->cqid]; +} + +static inline NvmeCtrl *nvme_ctrl (NvmeRequest *req) +{ +NvmeSQueue *sq = req->sq; +return sq->ctrl; +} +#endif /* HW_NVME_H */
hw/block/nvme.c +97 -39
171 lines not on this page · raw message
hw/block/trace-events +3 -1
@@ -39,8 +39,9 @@ pci_nvme_map_prp(uint64_t trans_len, uint32_t len, uint64_t prp1, uint64_t prp2, pci_nvme_io_cmd(uint16_t cid, uint32_t nsid, uint16_t sqid, uint8_t opcode, const char *opname) "cid %"PRIu16" nsid %"PRIu32" sqid %"PRIu16" opc 0x%"PRIx8" opname '%s'" pci_nvme_admin_cmd(uint16_t cid, uint16_t sqid, uint8_t opcode, const char *opname) "cid %"PRIu16" sqid %"PRIu16" opc 0x%"PRIx8" opname '%s'" pci_nvme_rw(uint16_t cid, const char *verb, uint32_t nlb, uint64_t count, uint64_t lba) "cid %"PRIu16" '%s' nlb %"PRIu32" count %"PRIu64" lba 0x%"PRIx64"" -pci_nvme_rw_cb(uint16_t cid) "cid %"PRIu16"" +pci_nvme_rw_cb(uint16_t cid, const char *blkname) "cid %"PRIu16" blk '%s'" pci_nvme_write_zeroes(uint16_t cid, uint64_t slba, uint32_t nlb) "cid %"PRIu16" slba %"PRIu64" nlb %"PRIu32"" +pci_nvme_do_aio(uint16_t cid, uint8_t opc, const char *opname, const char *blkname, int64_t offset, size_t len) "cid %"PRIu16" opc 0x%"PRIx8" opname '%s' blk '%s' offset %"PRId64" len %zu" pci_nvme_create_sq(uint64_t addr, uint16_t sqid, uint16_t cqid, uint16_t qsize, uint16_t qflags) "create submission queue, addr=0x%"PRIx64", sqid=%"PRIu16", cqid=%"PRIu16", qsize=%"PRIu16", qflags=%"PRIu16"" pci_nvme_create_cq(uint64_t addr, uint16_t cqid, uint16_t vector, uint16_t size, uint16_t qflags, int ien) "create completion queue, addr=0x%"PRIx64", cqid=%"PRIu16", vector=%"PRIu16", qsize=%"PRIu16", qflags=%"PRIu16", ien=%d" pci_nvme_del_sq(uint16_t qid) "deleting submission queue sqid=%"PRIu16""
@@ -89,6 +90,7 @@ pci_nvme_err_mdts(uint16_t cid, size_t len) "cid %"PRIu16" len %zu" 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_cfs(void) "controller fatal status" +pci_nvme_err_aio(uint16_t cid, const char *errname, uint16_t status) "cid %"PRIu16" err '%s' status 0x%"PRIx16"" 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""
Signature · 1 line
2.28.0
PATCH v3 10/17 hw/block/nvme: default request status to success
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
Make the default request status NVME_SUCCESS so only error status codes have to be set.
--- hw/block/nvme.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
hw/block/nvme.c +1 -3
@@ -230,6 +230,7 @@ static void nvme_req_clear(NvmeRequest *req) { req->ns =NULL ;memset (&req->cqe,0x0 ,sizeof (req->cqe)); + req->status =NVME_SUCCESS ; }static void nvme_req_exit (NvmeRequest *req)
@@ -546,8 +547,6 @@ static void nvme_process_aers(void *opaque) result->log_page = event->result.log_page;g_free (event); - req->status =NVME_SUCCESS ; -trace_pci_nvme_aer_post_cqe (result->event_type, result->event_info, result->log_page);
@@ -626,7 +625,6 @@ static void nvme_rw_cb(void *opaque, int ret)if (!ret) {block_acct_done (stats, acct); - req->status =NVME_SUCCESS ; }else {uint16_t status;
Signature · 1 line
2.28.0
PATCH v3 11/17 hw/block/nvme: harden cmb access
In reply to Klaus JensenFrom: 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
@@ -142,7 +142,12 @@ static inline void *nvme_addr_to_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.28.0
PATCH v3 12/17 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)").
--- include/block/nvme.h | 6 +- hw/block/nvme.c | 329 ++++++++++++++++++++++++++++++++++-------- hw/block/trace-events | 4 + 3 files changed, 279 insertions(+), 60 deletions(-)
include/block/nvme.h +3 -3
@@ -412,9 +412,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 QEMU_PACKED NvmeCmd {
hw/block/nvme.c +272 -57
446 lines not on this page · raw message
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(uint64_t trans_len, uint32_t len, uint64_t prp1, uint64_t prp2, int num_prps) "trans_len %"PRIu64" len %"PRIu32" prp1 0x%"PRIx64" prp2 0x%"PRIx64" num_prps %d" +pci_nvme_map_sgl(uint16_t cid, uint8_t typ, uint64_t len) "cid %"PRIu16" type 0x%"PRIx8" len %"PRIu64"" pci_nvme_io_cmd(uint16_t cid, uint32_t nsid, uint16_t sqid, uint8_t opcode, const char *opname) "cid %"PRIu16" nsid %"PRIu32" sqid %"PRIu16" opc 0x%"PRIx8" opname '%s'" pci_nvme_admin_cmd(uint16_t cid, uint16_t sqid, uint8_t opcode, const char *opname) "cid %"PRIu16" sqid %"PRIu16" opc 0x%"PRIx8" opname '%s'" pci_nvme_rw(uint16_t cid, const char *verb, uint32_t nlb, uint64_t count, uint64_t lba) "cid %"PRIu16" '%s' nlb %"PRIu32" count %"PRIu64" lba 0x%"PRIx64""
@@ -91,6 +92,9 @@ 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_cfs(void) "controller fatal status" pci_nvme_err_aio(uint16_t cid, const char *errname, uint16_t status) "cid %"PRIu16" err '%s' status 0x%"PRIx16"" +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""
Signature · 1 line
2.28.0
Re: [PATCH v3 12/17] hw/block/nvme: add support for scatter gather lists
Quoted 283 lines · Klaus Jensen
From: 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)").
Signed-off-by Klaus Jensen <[email protected]>Reviewed-by Keith Busch <[email protected]>--- include/block/nvme.h | 6 +- hw/block/nvme.c | 329 ++++++++++++++++++++++++++++++++++-------- hw/block/trace-events | 4 + 3 files changed, 279 insertions(+), 60 deletions(-)include/block/nvme.h +3
-3@@ -412,9 +412,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 QEMU_PACKED NvmeCmd {hw/block/nvme.c +240
-2@@ -413,13 +413,262 @@ static uint16_t nvme_map_prp(NvmeCtrl *n, uint64_t prp1, uint64_t prp2,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), 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_TRAS_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_TRAS_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_dptr (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, 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 ;
hw/block/nvme.c static uint16_t nvme_map_prp(NvmeCtrl *n, uint64_t prp1, uint64_t prp2, · line 666
Quoted 10 lines
hw/block/nvme.c +10
-0+ } + +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,
Using a 'void *ptr' would simplify your API, avoiding the callers to cast.
Quoted 21 lines
hw/block/nvme.c +2
-9+ DMADirection dir, NvmeRequest *req) { uint16_t status = NVME_SUCCESS; - status =nvme_map_prp (n, prp1, prp2, len, req); + status =nvme_map_dptr (n, len, req);if (status) {return status; }@@ -458,15 +707,6 @@ static uint16_t nvme_dma_prp(NvmeCtrl *n, uint8_t *ptr, uint32_t len,return status; } -static uint16_t nvme_map_dptr (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, prp1, prp2, len, req); -}
Re: [PATCH v3 12/17] hw/block/nvme: add support for scatter gather lists
Quoted 6 lines · Philippe Mathieu-Daudé
Quoted 1 line · Klaus Jensen
+static
uint16_tnvme_dma(NvmeCtrl *n,uint8_t*ptr,uint32_tlen,Using a 'void *ptr' would simplify your API, avoiding the callers to cast.
You are correct, but there is a bunch of work being done on top of nvme-next right now - so even though it is not in master yet, I'd rather not make too many fixups that trickles down like this.
But I will queue something up for this.
PATCH v3 13/17 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
@@ -430,6 +430,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 (req->cmd.opcode ==NVME_CMD_WRITE ) { +continue ; + }case NVME_SGL_DESCR_TYPE_DATA_BLOCK :break ;case NVME_SGL_DESCR_TYPE_SEGMENT :
@@ -440,6 +444,7 @@ static uint16_t nvme_map_sgl_data(NvmeCtrl *n, QEMUSGList *qsg, } dlen =le32_to_cpu (segment[i].len); +if (!dlen) {continue ; }
@@ -460,6 +465,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) {
@@ -471,6 +481,7 @@ static uint16_t nvme_map_sgl_data(NvmeCtrl *n, QEMUSGList *qsg,return status; } +next: *len -= trans_len; }
@@ -540,7 +551,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 ; }
@@ -577,19 +589,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 ;
@@ -2656,7 +2676,8 @@ static void nvme_init_ctrl(NvmeCtrl *n, PCIDevice *pci_dev) id->nn =cpu_to_le32 (n->num_namespaces); id->oncs =cpu_to_le16 (NVME_ONCS_WRITE_ZEROES |NVME_ONCS_TIMESTAMP |NVME_ONCS_FEATURES ); - id->sgls =cpu_to_le32 (NVME_CTRL_SGLS_SUPPORT_NO_ALIGN ); + id->sgls =cpu_to_le32 (NVME_CTRL_SGLS_SUPPORT_NO_ALIGN | +NVME_CTRL_SGLS_BITBUCKET ); subnqn =g_strdup_printf ("nqn.2019-08.org.qemu:%s" , n->params.serial);strpadcpy ((char *)id->subnqn,sizeof (id->subnqn), subnqn,'\0' );
Signature · 1 line
2.28.0
PATCH v3 14/17 hw/block/nvme: refactor identify active namespace id list
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
Prepare to support inactive namespaces.
--- hw/block/nvme.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
hw/block/nvme.c +4 -4
@@ -1473,7 +1473,7 @@ static uint16_t nvme_identify_nslist(NvmeCtrl *n, NvmeRequest *req)uint32_t min_nsid =le32_to_cpu (c->nsid);uint32_t *list;uint16_t ret; -int i, j =0 ; +int j =0 ;trace_pci_nvme_identify_nslist (min_nsid);
@@ -1488,11 +1488,11 @@ static uint16_t nvme_identify_nslist(NvmeCtrl *n, NvmeRequest *req) } list =g_malloc0 (data_len); -for (i =0 ; i < n->num_namespaces; i++) { -if (i < min_nsid) { +for (int i =1 ; i <= n->num_namespaces; i++) { +if (i <= min_nsid) {continue ; } - list[j++] =cpu_to_le32 (i +1 ); + list[j++] =cpu_to_le32 (i);if (j == data_len /sizeof (uint32_t )) {break ; }
Signature · 1 line
2.28.0
PATCH v3 15/17 hw/block/nvme: support multiple namespaces
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
This adds support for multiple namespaces by introducing a new 'nvme-ns' device model. The nvme device creates a bus named from the device name ('id'). The nvme-ns devices then connect to this and registers themselves with the nvme device.
This changes how an nvme device is created. Example with two namespaces:
-drive file=nvme0n1.img,if=none,id=disk1
-drive file=nvme0n2.img,if=none,id=disk2
-device nvme,serial=deadbeef,id=nvme0
-device nvme-ns,drive=disk1,bus=nvme0,nsid=1
-device nvme-ns,drive=disk2,bus=nvme0,nsid=2
The drive property is kept on the nvme device to keep the change backward compatible, but the property is now optional. Specifying a drive for the nvme device will always create the namespace with nsid 1.
--- hw/block/nvme-ns.h | 74 +++++++++++++ hw/block/nvme.h | 46 ++++---- hw/block/nvme-ns.c | 167 ++++++++++++++++++++++++++++ hw/block/nvme.c | 249 +++++++++++++++++++++++++++--------------- hw/block/meson.build | 2 +- hw/block/trace-events | 6 +- 6 files changed, 428 insertions(+), 116 deletions(-) create mode 100644 hw/block/nvme-ns.h create mode 100644 hw/block/nvme-ns.c
hw/block/nvme-ns.h new file +74 -0
@@ -0,0 +1,74 @@ +/* +* QEMU NVM Express Virtual Namespace +* +* Copyright (c) 2019 CNEX Labs +* Copyright (c) 2020 Samsung Electronics +* +* Authors: +* Klaus Jensen <[email protected]> +* +* This work is licensed under the terms of the GNU GPL, version 2. See the +* COPYING file in the top-level directory. +* +*/ + +#ifndef NVME_NS_H +#define NVME_NS_H + +#define TYPE_NVME_NS "nvme-ns" +#define NVME_NS (obj) \ + OBJECT_CHECK(NvmeNamespace, (obj), TYPE_NVME_NS) + +typedef struct NvmeNamespaceParams { +uint32_t nsid; +}NvmeNamespaceParams ; + +typedef struct NvmeNamespace { +DeviceState parent_obj; +BlockConf blkconf; +int32_t bootindex; +int64_t size; +NvmeIdNs id_ns; + +NvmeNamespaceParams params; +}NvmeNamespace ; + +static inline uint32_t nvme_nsid (NvmeNamespace *ns) +{ +if (ns) { +return ns->params.nsid; + } + +return -1 ; +} + +static inline NvmeLBAF *nvme_ns_lbaf (NvmeNamespace *ns) +{ +NvmeIdNs *id_ns = &ns->id_ns; +return &id_ns->lbaf[NVME_ID_NS_FLBAS_INDEX (id_ns->flbas)]; +} + +static inline uint8_t nvme_ns_lbads (NvmeNamespace *ns) +{ +return nvme_ns_lbaf (ns)->ds; +} + +/* calculate the number of LBAs that the namespace can accomodate */ +static inline uint64_t nvme_ns_nlbas (NvmeNamespace *ns) +{ +return ns->size >>nvme_ns_lbads (ns); +} + +/* convert an LBA to the equivalent in bytes */ +static inline size_t nvme_l2b (NvmeNamespace *ns,uint64_t lba) +{ +return lba <<nvme_ns_lbads (ns); +} + +typedef struct NvmeCtrl NvmeCtrl ; + +int nvme_ns_setup (NvmeCtrl *n,NvmeNamespace *ns,Error **errp); +void nvme_ns_drain (NvmeNamespace *ns); +void nvme_ns_flush (NvmeNamespace *ns); + +#endif /* NVME_NS_H */
hw/block/nvme.h +21 -25
95 lines not on this page · raw message
hw/block/nvme-ns.c new file +167 -0
167 lines not on this page · raw message
hw/block/nvme.c +162 -87
516 lines not on this page · raw message
hw/block/meson.build +1 -1
@@ -13,7 +13,7 @@ softmmu_ss.add(when: 'CONFIG_SSI_M25P80', if_true: files('m25p80.c')) softmmu_ss.add(when: 'CONFIG_SWIM', if_true: files('swim.c')) softmmu_ss.add(when: 'CONFIG_XEN', if_true: files('xen-block.c')) softmmu_ss.add(when: 'CONFIG_SH4', if_true: files('tc58128.c')) -softmmu_ss.add(when: 'CONFIG_NVME_PCI', if_true: files('nvme.c')) +softmmu_ss.add(when: 'CONFIG_NVME_PCI', if_true: files('nvme.c', 'nvme-ns.c')) specific_ss.add(when: 'CONFIG_VIRTIO_BLK', if_true: files('virtio-blk.c')) specific_ss.add(when: 'CONFIG_VHOST_USER_BLK', if_true: files('vhost-user-blk.c'))
hw/block/trace-events +3 -3
@@ -29,6 +29,7 @@ hd_geometry_guess(void *blk, uint32_t cyls, uint32_t heads, uint32_t secs, int t # nvme.c # nvme traces for successful events +pci_nvme_register_namespace(uint32_t nsid) "nsid %"PRIu32"" pci_nvme_irq_msix(uint32_t vector) "raising MSI-X IRQ vector %u" pci_nvme_irq_pin(void) "pulsing IRQ pin" pci_nvme_irq_masked(void) "IRQ is masked"
@@ -39,9 +40,9 @@ pci_nvme_map_prp(uint64_t trans_len, uint32_t len, uint64_t prp1, uint64_t prp2, pci_nvme_map_sgl(uint16_t cid, uint8_t typ, uint64_t len) "cid %"PRIu16" type 0x%"PRIx8" len %"PRIu64"" pci_nvme_io_cmd(uint16_t cid, uint32_t nsid, uint16_t sqid, uint8_t opcode, const char *opname) "cid %"PRIu16" nsid %"PRIu32" sqid %"PRIu16" opc 0x%"PRIx8" opname '%s'" pci_nvme_admin_cmd(uint16_t cid, uint16_t sqid, uint8_t opcode, const char *opname) "cid %"PRIu16" sqid %"PRIu16" opc 0x%"PRIx8" opname '%s'" -pci_nvme_rw(uint16_t cid, const char *verb, uint32_t nlb, uint64_t count, uint64_t lba) "cid %"PRIu16" '%s' nlb %"PRIu32" count %"PRIu64" lba 0x%"PRIx64"" +pci_nvme_rw(uint16_t cid, const char *verb, uint32_t nsid, uint32_t nlb, uint64_t count, uint64_t lba) "cid %"PRIu16" opname '%s' nsid %"PRIu32" nlb %"PRIu32" count %"PRIu64" lba 0x%"PRIx64"" pci_nvme_rw_cb(uint16_t cid, const char *blkname) "cid %"PRIu16" blk '%s'" -pci_nvme_write_zeroes(uint16_t cid, uint64_t slba, uint32_t nlb) "cid %"PRIu16" slba %"PRIu64" nlb %"PRIu32"" +pci_nvme_write_zeroes(uint16_t cid, uint32_t nsid, uint64_t slba, uint32_t nlb) "cid %"PRIu16" nsid %"PRIu32" slba %"PRIu64" nlb %"PRIu32"" pci_nvme_do_aio(uint16_t cid, uint8_t opc, const char *opname, const char *blkname, int64_t offset, size_t len) "cid %"PRIu16" opc 0x%"PRIx8" opname '%s' blk '%s' offset %"PRId64" len %zu" pci_nvme_create_sq(uint64_t addr, uint16_t sqid, uint16_t cqid, uint16_t qsize, uint16_t qflags) "create submission queue, addr=0x%"PRIx64", sqid=%"PRIu16", cqid=%"PRIu16", qsize=%"PRIu16", qflags=%"PRIu16"" pci_nvme_create_cq(uint64_t addr, uint16_t cqid, uint16_t vector, uint16_t size, uint16_t qflags, int ien) "create completion queue, addr=0x%"PRIx64", cqid=%"PRIu16", vector=%"PRIu16", qsize=%"PRIu16", qflags=%"PRIu16", ien=%d"
@@ -100,7 +101,6 @@ pci_nvme_err_invalid_prplist_ent(uint64_t prplist) "PRP list entry is null or no pci_nvme_err_invalid_prp2_align(uint64_t prp2) "PRP2 is not page aligned: 0x%"PRIx64"" pci_nvme_err_invalid_prp2_missing(void) "PRP2 is null and more data to be transferred" pci_nvme_err_invalid_prp(void) "invalid PRP" -pci_nvme_err_invalid_ns(uint32_t ns, uint32_t limit) "invalid namespace %u not within 1-%u" pci_nvme_err_invalid_opc(uint8_t opc) "invalid opcode 0x%"PRIx8"" pci_nvme_err_invalid_admin_opc(uint8_t opc) "invalid admin opcode 0x%"PRIx8"" pci_nvme_err_invalid_lba_range(uint64_t start, uint64_t len, uint64_t limit) "Invalid LBA start=%"PRIu64" len=%"PRIu64" limit=%"PRIu64""
Signature · 1 line
2.28.0
PATCH v3 16/17 pci: allocate pci id for nvme
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
The emulated nvme device (hw/block/nvme.c) is currently using an internal Intel device id.
Prepare to change that by allocating a device id under the 1b36 (Red Hat, Inc.) vendor id.
--- docs/specs/nvme.txt | 23 +++++++++++++++++++++++ docs/specs/pci-ids.txt | 1 + include/hw/pci/pci.h | 1 + MAINTAINERS | 1 + 4 files changed, 26 insertions(+) create mode 100644 docs/specs/nvme.txt
docs/specs/nvme.txt new file +23 -0
@@ -0,0 +1,23 @@ +NVM Express Controller +====================== + +The nvme device (-device nvme) emulates an NVM Express Controller. + + +Reference Specifications +------------------------ + +The device currently implements most mandatory features of NVMe v1.3d, see + + https://nvmexpress.org/resources/specifications/ + +for the specification. + + +Known issues +------------ + +* The accounting numbers in the SMART/Health are reset across power cycles + +* Interrupt Coalescing is not supported and is disabled by default in volation + of the specification.
docs/specs/pci-ids.txt +1 -0
@@ -63,6 +63,7 @@ PCI devices (other than virtio): 1b36:000b PCIe Expander Bridge (-device pxb-pcie) 1b36:000d PCI xhci usb host adapter 1b36:000f mdpy (mdev sample device), linux/samples/vfio-mdev/mdpy.c +1b36:0010 PCIe NVMe device (-device nvme) All these devices are documented in docs/specs.
include/hw/pci/pci.h +1 -0
@@ -106,6 +106,7 @@ extern bool pci_available;#define PCI_DEVICE_ID_REDHAT_XHCI 0x000d#define PCI_DEVICE_ID_REDHAT_PCIE_BRIDGE 0x000e#define PCI_DEVICE_ID_REDHAT_MDPY 0x000f +#define PCI_DEVICE_ID_REDHAT_NVME 0x0010#define PCI_DEVICE_ID_REDHAT_QXL 0x0100#define FMT_PCIBUS PRIx64
MAINTAINERS +1 -0
@@ -1880,6 +1880,7 @@ L: [email protected] S: Supported F: hw/block/nvme* F: tests/qtest/nvme-test.c +F: docs/specs/nvme.txt T: git git://git.infradead.org/qemu-nvme.git nvme-next megasas
Signature · 1 line
2.28.0
PATCH v3 17/17 hw/block/nvme: change controller pci id
In reply to Klaus JensenFrom: Klaus Jensen <[email protected]>
There are two reasons for changing this:
1. The nvme device currently uses an internal Intel device id.
2. Since commits "nvme: fix write zeroes offset and count" and "nvme:
support multiple namespaces" the controller device no longer has the quirks that the Linux kernel think it has.
As the quirks are applied based on pci vendor and device id, change them to get rid of the quirks.
To keep backward compatibility, add a new 'use-intel-id' parameter to the nvme device to force use of the Intel vendor and device id. This is off by default but add a compat property to set this for 5.1 machines and older. If a 5.1 machine is booted (or the use-intel-id parameter is explicitly set to true), the Linux kernel will just apply these unnecessary quirks:
1. NVME_QUIRK_IDENTIFY_CNS which says that the device does not support anything else than values 0x0 and 0x1 for CNS (Identify Namespace and Identify Namespace). With multiple namespace support, this just means that the kernel will "scan" namespaces instead of using "Active Namespace ID list" (CNS 0x2).
2. NVME_QUIRK_DISABLE_WRITE_ZEROES. The nvme device started out with a broken Write Zeroes implementation which has since been fixed in commit 9d6459d21a6e ("nvme: fix write zeroes offset and count").
--- hw/block/nvme.h | 1 + hw/block/nvme.c | 12 ++++++++++-- hw/core/machine.c | 1 + 3 files changed, 12 insertions(+), 2 deletions(-)
hw/block/nvme.h +1 -0
@@ -15,6 +15,7 @@ typedef struct NvmeParams {uint8_t aerl;uint32_t aer_max_queued;uint8_t mdts; +bool use_intel_id; } NvmeParams; typedef struct NvmeAsyncEvent {
hw/block/nvme.c +10 -2
@@ -2683,6 +2683,15 @@ static void nvme_init_pci(NvmeCtrl *n, PCIDevice *pci_dev, Error **errp) pci_conf[PCI_INTERRUPT_PIN ] =1 ;pci_config_set_prog_interface (pci_conf,0x2 ); + +if (n->params.use_intel_id) { +pci_config_set_vendor_id (pci_conf,PCI_VENDOR_ID_INTEL ); +pci_config_set_device_id (pci_conf,0x5845 ); + }else { +pci_config_set_vendor_id (pci_conf,PCI_VENDOR_ID_REDHAT ); +pci_config_set_device_id (pci_conf,PCI_DEVICE_ID_REDHAT_NVME ); + } +pci_config_set_class (pci_conf,PCI_CLASS_STORAGE_EXPRESS );pcie_endpoint_cap_init (pci_dev,0x80 );
@@ -2836,6 +2845,7 @@ static Property nvme_props[] = {DEFINE_PROP_UINT8 ("aerl" , NvmeCtrl, params.aerl,3 ),DEFINE_PROP_UINT32 ("aer_max_queued" , NvmeCtrl, params.aer_max_queued,64 ),DEFINE_PROP_UINT8 ("mdts" , NvmeCtrl, params.mdts,7 ), +DEFINE_PROP_BOOL ("use-intel-id" , NvmeCtrl, params.use_intel_id, false), DEFINE_PROP_END_OF_LIST(), };
@@ -2852,8 +2862,6 @@ static void nvme_class_init(ObjectClass *oc, void *data) pc->realize = nvme_realize; pc->exit = nvme_exit; pc->class_id =PCI_CLASS_STORAGE_EXPRESS ; - pc->vendor_id =PCI_VENDOR_ID_INTEL ; - pc->device_id =0x5845 ; pc->revision =2 ;set_bit (DEVICE_CATEGORY_STORAGE , dc->categories);
hw/core/machine.c +1 -0
@@ -34,6 +34,7 @@ GlobalProperty hw_compat_5_1[] = { { "vhost-user-scsi", "num_queues", "1"}, { "virtio-blk-device", "num-queues", "1"}, { "virtio-scsi-device", "num_queues", "1"}, + { "nvme", "use-intel-id", "on"}, };const size_t hw_compat_5_1_len =G_N_ELEMENTS (hw_compat_5_1);
Signature · 1 line
2.28.0
Quoted 10 lines · Klaus Jensen
From: Klaus Jensen <[email protected]>
This is the next round of my patches for the nvme device.
This includes a bit of cleanup and two new features:
* support for scatter/gather lists
* multiple namespaces support through a new nvme-ns device
Quoted 7 lines
Finally, the series wraps up with changing the PCI vendor and device ID to get rid of the internal Intel id and as a side-effect get rid of some Linux kernel quirks that no longer applies.
"pci: pass along the return value of
dma_memory_rw" has already been posted by Philippe in another series, but since it is not applied yet, I am including it here.
For the rest of the patches I haven't individually commented:
Quoted 15 lines · Keith Busch
Quoted 14 lines · Klaus Jensen
From: Klaus Jensen <[email protected]>
This is the next round of my patches for the nvme device.
This includes a bit of cleanup and two new features:
* support for scatter/gather lists
* multiple namespaces support through a new nvme-ns device
Finally, the series wraps up with changing the PCI vendor and device ID to get rid of the internal Intel id and as a side-effect get rid of some Linux kernel quirks that no longer applies.
Quoted 7 lines
Quoted 3 lines
"pci: pass along the return value of
dma_memory_rw" has already been posted by Philippe in another series, but since it is not applied yet, I am including it here.For the rest of the patches I haven't individually commented:
Reviewed-by Keith Busch <[email protected]>
Sorry if I am being thick here Keith, but didn't you R-b all patches (except 3 and 9) in v2 yesterday?
I do not see any comments to any of the v3 patches, so I'm not sure how to interpret this ;)
Quoted 22 lines · Klaus Jensen
Quoted 21 lines · Keith Busch
Quoted 10 lines · Klaus Jensen
From: Klaus Jensen <[email protected]>
This is the next round of my patches for the nvme device.
This includes a bit of cleanup and two new features:
* support for scatter/gather lists
* multiple namespaces support through a new nvme-ns device
Quoted 7 lines
Finally, the series wraps up with changing the PCI vendor and device ID to get rid of the internal Intel id and as a side-effect get rid of some Linux kernel quirks that no longer applies.
"pci: pass along the return value of
dma_memory_rw" has already been posted by Philippe in another series, but since it is not applied yet, I am including it here.For the rest of the patches I haven't individually commented:
Quoted 7 lines
Quoted 1 line
Reviewed-by Keith Busch <[email protected]>Sorry if I am being thick here Keith, but didn't you R-b all patches (except 3 and 9) in v2 yesterday?
I do not see any comments to any of the v3 patches, so I'm not sure how to interpret this ;)
Ha, I thought I did yesterday too, but it's not showing in my "Sent" mail so I sent it again. But since it apparently did send, you can interpret the 2nd as "two thumbs up!". :)
Klaus Jensen
AppliedQuoted 71 lines · Klaus Jensen
From: Klaus Jensen <[email protected]>
This is the next round of my patches for the nvme device.
This includes a bit of cleanup and two new features:
* support for scatter/gather lists
* multiple namespaces support through a new nvme-ns device
Finally, the series wraps up with changing the PCI vendor and device ID to get rid of the internal Intel id and as a side-effect get rid of some Linux kernel quirks that no longer applies.
"pci: pass along the return value of
dma_memory_rw" has already been posted by Philippe in another series, but since it is not applied yet, I am including it here.Changes for v3
~~~~~~~~~~~~~~* hw/block/nvme: handle dma errors
Do not retry DMA, just set Controller Fatal Status (CFS). This causes the Linux kernel to most likely disable the controller when running the blktests block/011 test case, which causes some havoc when running blktests, but I have submitted a patch for blktests to fix this. (Keith)* hw/block/nvme: refactor aio submission
Dropped the unneedednvme_req_is_writefunction. (Keith)* Added R-b's from Keith and Philippe.
Changes for v2
~~~~~~~~~~~~~~* Added a new patch ("hw/block/nvme: fix typo in trace event") that does what it says on the tin.
* Dropped the "hw/block/nvme: support multiple parallel aios per request" patch (Keith).
* hw/block/nvme: add symbolic command name to trace events Changed to single quote (Philippe)
* hw/block/nvme: default request status to success Commit message typo fixed (Philippe)
* hw/block/nvme: change controller pci id
Do NOT bump the device id for the legacy Intel id (David)Gollu Appalanaidu (1):
hw/block/nvme: add support for sgl bit bucket descriptorKlaus Jensen (16):
hw/block/nvme: fix typo in trace event
pci: pass along the return value ofdma_memory_rwhw/block/nvme: handle dma errors
hw/block/nvme: commonizenvme_rwerror handling hw/block/nvme: alignment style fixes hw/block/nvme: add a lba to bytes helper hw/block/nvme: fix endian conversion hw/block/nvme: add symbolic command name to trace events hw/block/nvme: refactor aio submission hw/block/nvme: default request status to success hw/block/nvme: harden cmb access
hw/block/nvme: add support for scatter gather lists hw/block/nvme: refactor identify active namespace id list hw/block/nvme: support multiple namespaces
pci: allocate pci id for nvme
hw/block/nvme: change controller pci id
Quoted 20 lines
docs/specs/nvme.txt | 23 ++ docs/specs/pci-ids.txt | 1 + hw/block/nvme-ns.h | 74 ++++ hw/block/nvme.h | 83 +++- include/block/nvme.h | 6 +- include/hw/pci/pci.h | 4 +- hw/block/nvme-ns.c | 167 ++++++++ hw/block/nvme.c | 848 ++++++++++++++++++++++++++++++----------- hw/core/machine.c | 1 + MAINTAINERS | 1 + hw/block/meson.build | 2 +- hw/block/trace-events | 23 +- 12 files changed, 978 insertions(+), 255 deletions(-) create mode 100644 docs/specs/nvme.txt create mode 100644 hw/block/nvme-ns.h create mode 100644 hw/block/nvme-ns.cSignature · 1 line
2.28.0
Pushed to nvme-next.
Thanks for the reviews everyone. I think I posted the first version of this more than a year ago. This feels so good!